From 8e4cec889803cce4ae8654117ab87b6efa669eb8 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Fri, 30 Oct 2026 13:21:12 +0800
Subject: [PATCH 01/17] feat(plsql): add Oracle PL/SQL language support
 (standalone ANTLR4 provider)

Adds SupportedLanguages.PlSql as an experimental standalone provider
following the COBOL precedent: a `plsql` phase (after structure, before
parse) parses PL/SQL with the grammars-v4 PlSql grammar on antlr4ng (pure
JS, no native binding) and writes the graph; the scope resolver runs in
callable-flow-only mode.

- package spec+body -> Module; procedure/function/nested/trigger -> Function
- CALLS for local, nested, pkg.proc and schema.pkg.proc calls; overloads
  narrowed by arity and named arguments, otherwise low-confidence fan-out
- table/view -> Record with ACCESSES reason plsql-<op> (select, insert,
  update, delete, merge, lock, trigger)
- SQL*Plus @@/@/START includes -> IMPORTS (exact paths only)
- .sql claimed via classifyFileContent only for Oracle sources
- line/column-preserving pre-pass (SQL*Plus commands, & substitution,
  nested conditional compilation), per-segment SLL->LL parse with a
  deadline, regex fallback for definitions lost to syntax errors
- rename: spec+body family, END labels, package qualifiers, cross-file
  calls; refuses on dynamic SQL, unparsed segments or unproven names
- shared plsql/resolve.ts decides both CALLS edges and rename bindings
- vendored grammar + scripts/generate-plsql-parser.mjs (reproducible)
- tests: resolver integration, unit, rename fixtures (success + refusal),
  new-language gate registrations; docs/languages/plsql-ingestion-gaps.md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .prettierignore                               |      2 +
 ARCHITECTURE.md                               |      5 +-
 README.md                                     |      4 +-
 docs/languages/README.md                      |      3 +-
 eslint.config.mjs                             |      2 +
 gitnexus-shared/src/language-detection.ts     |     14 +
 gitnexus-shared/src/languages.ts              |      2 +
 .../language-classification.ts                |      2 +
 gitnexus/package-lock.json                    |      7 +
 gitnexus/package.json                         |      1 +
 gitnexus/scripts/generate-plsql-parser.mjs    |     67 +
 .../src/core/ingestion/languages/index.ts     |      2 +
 .../src/core/ingestion/languages/plsql.ts     |     49 +
 .../ingestion/languages/plsql/captures.ts     |    153 +
 .../core/ingestion/languages/plsql/flow.ts    |     15 +
 .../core/ingestion/languages/plsql/index.ts   |     13 +
 .../ingestion/languages/plsql/interpret.ts    |     43 +
 .../core/ingestion/languages/plsql/rename.ts  |    185 +
 .../languages/plsql/scope-resolver.ts         |    157 +
 .../core/ingestion/pipeline-phases/index.ts   |      1 +
 .../core/ingestion/pipeline-phases/parse.ts   |      4 +-
 .../core/ingestion/pipeline-phases/plsql.ts   |     70 +
 gitnexus/src/core/ingestion/pipeline.ts       |      4 +-
 .../src/core/ingestion/plsql-processor.ts     |    361 +
 gitnexus/src/core/ingestion/plsql/extract.ts  |    650 +
 .../src/core/ingestion/plsql/file-types.ts    |     77 +
 .../ingestion/plsql/generated/PlSqlLexer.ts   |  17382 +
 .../plsql/generated/PlSqlLexerBase.ts         |     21 +
 .../ingestion/plsql/generated/PlSqlParser.ts  | 309538 +++++++++++++++
 .../plsql/generated/PlSqlParserBase.ts        |    117 +
 .../plsql/generated/PlSqlParserListener.ts    |  13489 +
 .../core/ingestion/plsql/generated/README.md  |     18 +
 .../ingestion/plsql/grammar/PlSqlLexer.g4     |   2593 +
 .../ingestion/plsql/grammar/PlSqlParser.g4    |  10147 +
 gitnexus/src/core/ingestion/plsql/parse.ts    |    167 +
 .../src/core/ingestion/plsql/preprocess.ts    |    254 +
 gitnexus/src/core/ingestion/plsql/resolve.ts  |    101 +
 .../core/ingestion/plsql/script-include.ts    |     43 +
 .../scope-resolution/pipeline/registry.ts     |      2 +
 .../src/core/ingestion/tree-sitter-queries.ts |      1 +
 gitnexus/src/core/parse-cache-identity.ts     |      1 +
 .../lang-resolution/plsql-app/db/install.sql  |     13 +
 .../plsql-app/db/packages/pkg_loan_settle.pkb |     68 +
 .../plsql-app/db/packages/pkg_loan_settle.pks |      5 +
 .../plsql-app/db/packages/pkg_log.pkb         |     21 +
 .../plsql-app/db/packages/pkg_log.pks         |      6 +
 .../plsql-app/db/postgres/fn_pg.sql           |      5 +
 .../plsql-app/db/procedures/prc_archive.prc   |      8 +
 .../db/triggers/trg_repay_plan_audit.sql      |      9 +
 .../after/pkg_log.pkb                         |     16 +
 .../after/pkg_log.pks                         |      5 +
 .../after/prc_settle.prc                      |      8 +
 .../before/pkg_log.pkb                        |     16 +
 .../before/pkg_log.pks                        |      5 +
 .../before/prc_settle.prc                     |      8 +
 .../package-procedure-cross-file/case.json    |     37 +
 .../refuse-dynamic-sql/after/pkg_fee.pkb      |     15 +
 .../refuse-dynamic-sql/before/pkg_fee.pkb     |     15 +
 .../plsql/refuse-dynamic-sql/case.json        |     16 +
 .../integration/rename-provider-plsql.test.ts |      3 +
 .../resolvers/callable-value-flow.test.ts     |      3 +
 .../test/integration/resolvers/plsql.test.ts  |    194 +
 .../ingestion/pipeline-phase-registry.test.ts |      1 +
 gitnexus/test/unit/plsql-extract.test.ts      |    172 +
 gitnexus/test/unit/plsql-preprocess.test.ts   |    106 +
 .../external-import-conformance.test.ts       |     15 +
 ...import-target-index-reuse.contract.test.ts |     16 +
 67 files changed, 356545 insertions(+), 8 deletions(-)
 create mode 100644 gitnexus/scripts/generate-plsql-parser.mjs
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql.ts
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql/captures.ts
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql/flow.ts
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql/index.ts
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql/interpret.ts
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql/rename.ts
 create mode 100644 gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
 create mode 100644 gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql-processor.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/extract.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/file-types.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/generated/PlSqlLexer.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/generated/PlSqlLexerBase.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/generated/PlSqlParser.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/generated/PlSqlParserBase.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/generated/PlSqlParserListener.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/generated/README.md
 create mode 100644 gitnexus/src/core/ingestion/plsql/grammar/PlSqlLexer.g4
 create mode 100644 gitnexus/src/core/ingestion/plsql/grammar/PlSqlParser.g4
 create mode 100644 gitnexus/src/core/ingestion/plsql/parse.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/preprocess.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/resolve.ts
 create mode 100644 gitnexus/src/core/ingestion/plsql/script-include.ts
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/install.sql
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pkb
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pks
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pkb
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pks
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/postgres/fn_pg.sql
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/procedures/prc_archive.prc
 create mode 100644 gitnexus/test/fixtures/lang-resolution/plsql-app/db/triggers/trg_repay_plan_audit.sql
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pks
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/prc_settle.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pks
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/prc_settle.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/case.json
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/after/pkg_fee.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/before/pkg_fee.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/case.json
 create mode 100644 gitnexus/test/integration/rename-provider-plsql.test.ts
 create mode 100644 gitnexus/test/integration/resolvers/plsql.test.ts
 create mode 100644 gitnexus/test/unit/plsql-extract.test.ts
 create mode 100644 gitnexus/test/unit/plsql-preprocess.test.ts

diff --git a/.prettierignore b/.prettierignore
index c85876d08..b067eb682 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -1,6 +1,8 @@
 dist/
 coverage/
 gitnexus/vendor/
+# ANTLR4-generated PL/SQL lexer/parser (regenerate, never hand-edit).
+gitnexus/src/core/ingestion/plsql/generated/
 gitnexus/test/fixtures/
 # Line/column-sensitive callable identity and taint regression.
 gitnexus/test/integration/cfg/fixtures/inline-taint-repo/
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 4635dbff8..f4b9be85b 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -85,7 +85,7 @@ Group-mode `trace` (`gitnexus/src/core/group/cross-trace.ts`) stitches a path th
 19 default phases are defined in `gitnexus/src/core/ingestion/pipeline-phases/`, each with explicit `deps` and typed output. `--pdg` adds `taintSummaries` and `callSummaries` (21 total).
 
 ```
-scan → structure → [springConfig, markdown, cobol] → parse → [routes, tools, orm]
+scan → structure → [springConfig, markdown, cobol, plsql] → parse → [routes, tools, orm]
   → crossFile → scopeResolution → [springAutoConfiguration, springAop]
   → pruneLocalSymbols → mro → springAopInheritance → di → communities → processes
 ```
@@ -97,7 +97,8 @@ scan → structure → [springConfig, markdown, cobol] → parse → [routes, to
 | `springConfig`            | `spring-config.ts`                     | `structure`                                                        | Spring configuration-property nodes and metadata                                                                                                                                            |
 | `markdown`                | `markdown.ts`                          | `structure`                                                        | Section nodes, cross-link edges from .md/.mdx                                                                                                                                               |
 | `cobol`                   | `cobol.ts`                             | `structure`                                                        | COBOL program/paragraph/section nodes (regex, no tree-sitter)                                                                                                                               |
-| `parse`                   | `parse.ts` + `parse-impl.ts`           | `structure`, `markdown`, `cobol`                                   | Symbol nodes, IMPORTS/CALLS/EXTENDS edges, extracted routes/tools/ORM queries                                                                                                               |
+| `plsql`                   | `plsql.ts`                             | `structure`                                                        | Oracle PL/SQL package/subprogram/trigger/table nodes; CALLS/ACCESSES/IMPORTS edges (ANTLR4)                                                                                                 |
+| `parse`                   | `parse.ts` + `parse-impl.ts`           | `structure`, `markdown`, `cobol`, `plsql`                          | Symbol nodes, IMPORTS/CALLS/EXTENDS edges, extracted routes/tools/ORM queries                                                                                                               |
 | `routes`                  | `routes.ts`                            | `parse`                                                            | Route nodes + HANDLES_ROUTE edges (Next.js, Expo, PHP, decorators, and JS/TS static route sources — see below)                                                                              |
 | `tools`                   | `tools.ts`                             | `parse`                                                            | Tool nodes + HANDLES_TOOL edges                                                                                                                                                             |
 | `orm`                     | `orm.ts`                               | `parse`                                                            | QUERIES edges (Prisma, Supabase)                                                                                                                                                            |
diff --git a/README.md b/README.md
index 9c0eb862f..ef982e70a 100644
--- a/README.md
+++ b/README.md
@@ -112,8 +112,8 @@ For Docker, hosted deployments, image verification, or a local frontend, see
 
 ## Supported languages
 
-C, C++, C#, COBOL, Dart, Go, Java, JavaScript, Kotlin, Objective-C, PHP, Python,
-Ruby, Rust, Swift, TypeScript, Vue and Zig have registered providers. Support
+C, C++, C#, COBOL, Dart, Go, Java, JavaScript, Kotlin, Objective-C, Oracle PL/SQL,
+PHP, Python, Ruby, Rust, Swift, TypeScript, Vue and Zig have registered providers. Support
 varies by construct; see the [language inventories](docs/languages/README.md)
 for measured behavior, exclusions and remaining gaps.
 
diff --git a/docs/languages/README.md b/docs/languages/README.md
index 23121f260..3d56f2f14 100644
--- a/docs/languages/README.md
+++ b/docs/languages/README.md
@@ -1,7 +1,7 @@
 # Language Ingestion Gap Inventories
 
 These inventories are the starting point for language-specific plans. There is one
-`<language>-ingestion-gaps.md` file for each of the 18 languages in
+`<language>-ingestion-gaps.md` file for each of the 19 languages in
 [SCOPE_RESOLVERS](../../gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts).
 Names match provider directories; `jvm` is shared infrastructure, not another language.
 
@@ -27,6 +27,7 @@ receiver examples do not establish whole-language, CFG/PDG or rename completenes
 | [JavaScript](javascript-ingestion-gaps.md)   | Preserve JSDoc container evidence for indexed receivers.                 |
 | [Kotlin](kotlin-ingestion-gaps.md)           | Inventory companion and inherited-receiver limits.                       |
 | [Objective-C](objective-c-ingestion-gaps.md) | Add receiver measurements without weakening dynamic-dispatch boundaries. |
+| [PL/SQL](plsql-ingestion-gaps.md)            | Measure call and table-access recall on real Oracle package corpora.     |
 | [PHP](php-ingestion-gaps.md)                 | Retain PHPDoc container types and establish namespace owners.            |
 | [Python](python-ingestion-gaps.md)           | Audit constructor-field and module ownership coverage.                   |
 | [Ruby](ruby-ingestion-gaps.md)               | Isolate YARD parameter bindings before adding recall.                    |
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 959560892..0c0ecea8b 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -55,6 +55,8 @@ export default [
       '**/.stryker-tmp/**',
       'gitnexus/reports/mutation/**',
       'gitnexus/vendor/**',
+      // ANTLR4-generated PL/SQL lexer/parser (regenerate, never hand-edit).
+      'gitnexus/src/core/ingestion/plsql/generated/**',
       'gitnexus-web/src/vendor/**',
       'gitnexus/test/fixtures/**',
       'gitnexus-web/test/fixtures/**',
diff --git a/gitnexus-shared/src/language-detection.ts b/gitnexus-shared/src/language-detection.ts
index 583a0fd5f..88c9a413a 100644
--- a/gitnexus-shared/src/language-detection.ts
+++ b/gitnexus-shared/src/language-detection.ts
@@ -55,6 +55,19 @@ const EXTENSION_MAP: Record<SupportedLanguages, readonly string[]> = {
   [SupportedLanguages.Vue]: ['.vue'],
   [SupportedLanguages.Cobol]: ['.cbl', '.cob', '.cpy', '.cobol'],
   [SupportedLanguages.Zig]: ['.zig'],
+  // `.sql` is claimed by content (provider.classifyFileContent), not by extension.
+  [SupportedLanguages.PlSql]: [
+    '.pks',
+    '.pkb',
+    '.pck',
+    '.pls',
+    '.plb',
+    '.prc',
+    '.fnc',
+    '.trg',
+    '.tps',
+    '.tpb',
+  ],
 } satisfies Record<SupportedLanguages, readonly string[]>; // Ensure exhaustiveness
 
 /** Pre-built reverse lookup: extension → language (built once at module load). */
@@ -129,6 +142,7 @@ const SYNTAX_MAP: Record<SupportedLanguages, string> = {
   [SupportedLanguages.Vue]: 'typescript',
   [SupportedLanguages.Cobol]: 'cobol',
   [SupportedLanguages.Zig]: 'zig',
+  [SupportedLanguages.PlSql]: 'plsql',
 } satisfies Record<SupportedLanguages, string>; // Ensure exhaustiveness
 
 /** Non-code file extensions → Prism-compatible syntax identifiers */
diff --git a/gitnexus-shared/src/languages.ts b/gitnexus-shared/src/languages.ts
index eec45e612..925859ff9 100644
--- a/gitnexus-shared/src/languages.ts
+++ b/gitnexus-shared/src/languages.ts
@@ -24,4 +24,6 @@ export enum SupportedLanguages {
   /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
   Cobol = 'cobol',
   Zig = 'zig',
+  /** Oracle PL/SQL — standalone ANTLR4 provider (no tree-sitter). */
+  PlSql = 'plsql',
 }
diff --git a/gitnexus-shared/src/scope-resolution/language-classification.ts b/gitnexus-shared/src/scope-resolution/language-classification.ts
index 2e635c8e2..df5d9a927 100644
--- a/gitnexus-shared/src/scope-resolution/language-classification.ts
+++ b/gitnexus-shared/src/scope-resolution/language-classification.ts
@@ -16,6 +16,7 @@
  *
  * Added after Ring 1: zig enters as `experimental` (new language
  * integration; promotion to `production` is a separate governance PR).
+ * plsql enters as `experimental` (standalone ANTLR4 provider path).
  */
 
 import { SupportedLanguages } from '../languages.js';
@@ -47,6 +48,7 @@ export const LanguageClassifications: Readonly<Record<SupportedLanguages, Langua
     [SupportedLanguages.Vue]: 'experimental',
     [SupportedLanguages.Cobol]: 'experimental',
     [SupportedLanguages.Zig]: 'experimental',
+    [SupportedLanguages.PlSql]: 'experimental',
   };
 
 /** Convenience predicate: is this language gating Ring 4 retirement? */
diff --git a/gitnexus/package-lock.json b/gitnexus/package-lock.json
index bdbf1d277..cc6467eae 100644
--- a/gitnexus/package-lock.json
+++ b/gitnexus/package-lock.json
@@ -26,6 +26,7 @@
         "@ladybugdb/core": "0.21.1",
         "@modelcontextprotocol/sdk": "^1.0.0",
         "@scarf/scarf": "^1.4.0",
+        "antlr4ng": "3.0.16",
         "busboy": "^1.6.0",
         "chokidar": "^5.0.0",
         "cli-progress": "^3.12.0",
@@ -3058,6 +3059,12 @@
         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
+    "node_modules/antlr4ng": {
+      "version": "3.0.16",
+      "resolved": "https://registry.npmjs.org/antlr4ng/-/antlr4ng-3.0.16.tgz",
+      "integrity": "sha512-DQuJkC7kX3xunfF4K2KsWTSvoxxslv+FQp/WHQZTJSsH2Ec3QfFmrxC3Nky2ok9yglXn6nHM4zUaVDxcN5f6kA==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/anynum": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
diff --git a/gitnexus/package.json b/gitnexus/package.json
index 2abadf380..c1aa86237 100644
--- a/gitnexus/package.json
+++ b/gitnexus/package.json
@@ -84,6 +84,7 @@
     "@ladybugdb/core": "0.21.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@scarf/scarf": "^1.4.0",
+    "antlr4ng": "3.0.16",
     "busboy": "^1.6.0",
     "chokidar": "^5.0.0",
     "cli-progress": "^3.12.0",
diff --git a/gitnexus/scripts/generate-plsql-parser.mjs b/gitnexus/scripts/generate-plsql-parser.mjs
new file mode 100644
index 000000000..1782e45cc
--- /dev/null
+++ b/gitnexus/scripts/generate-plsql-parser.mjs
@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * Regenerate the ANTLR4 PL/SQL lexer/parser under
+ * src/core/ingestion/plsql/generated/ from the vendored grammars-v4 sources in
+ * src/core/ingestion/plsql/grammar/.
+ *
+ *   npx --yes antlr-ng@1.0.10 is fetched on demand; it is not a runtime dependency.
+ *
+ * The grammar's C++ header placeholders are replaced with the antlr4ng base-class
+ * imports, exactly as grammars-v4's `Antlr4ng/transformGrammar.py` does.
+ */
+import { execFileSync } from 'node:child_process';
+import {
+  mkdtempSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  readdirSync,
+  copyFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const grammarDir = path.join(root, 'src/core/ingestion/plsql/grammar');
+const outDir = path.join(root, 'src/core/ingestion/plsql/generated');
+const work = mkdtempSync(path.join(tmpdir(), 'plsql-grammar-'));
+
+try {
+  for (const name of ['PlSqlLexer.g4', 'PlSqlParser.g4']) {
+    const text = readFileSync(path.join(grammarDir, name), 'utf8')
+      .replace(
+        '// Insert here @header for C++ lexer.',
+        '@header {import { PlSqlLexerBase } from "./PlSqlLexerBase.js"}',
+      )
+      .replace(
+        '// Insert here @header for C++ parser.',
+        '@header {import { PlSqlParserBase } from "./PlSqlParserBase.js"}',
+      );
+    writeFileSync(path.join(work, name), text);
+  }
+  execFileSync(
+    'npx',
+    [
+      '--yes',
+      'antlr-ng@1.0.10',
+      '-Dlanguage=TypeScript',
+      '-l',
+      'true',
+      '-v',
+      'false',
+      '-o',
+      work,
+      path.join(work, 'PlSqlLexer.g4'),
+      path.join(work, 'PlSqlParser.g4'),
+    ],
+    { stdio: 'inherit' },
+  );
+  for (const file of readdirSync(work)) {
+    if (/^PlSql(Lexer|Parser|ParserListener)\.ts$/.test(file))
+      copyFileSync(path.join(work, file), path.join(outDir, file));
+  }
+  console.log(`[plsql] regenerated parser into ${path.relative(root, outDir)}`);
+} finally {
+  rmSync(work, { recursive: true, force: true });
+}
diff --git a/gitnexus/src/core/ingestion/languages/index.ts b/gitnexus/src/core/ingestion/languages/index.ts
index b10822a6f..59331c5d5 100644
--- a/gitnexus/src/core/ingestion/languages/index.ts
+++ b/gitnexus/src/core/ingestion/languages/index.ts
@@ -31,6 +31,7 @@ import { dartProvider } from './dart.js';
 import { vueProvider } from './vue.js';
 import { cobolProvider } from './cobol.js';
 import { zigProvider } from './zig.js';
+import { plsqlProvider } from './plsql.js';
 
 export const providers = {
   [SupportedLanguages.JavaScript]: javascriptProvider,
@@ -51,6 +52,7 @@ export const providers = {
   [SupportedLanguages.Vue]: vueProvider,
   [SupportedLanguages.Cobol]: cobolProvider,
   [SupportedLanguages.Zig]: zigProvider,
+  [SupportedLanguages.PlSql]: plsqlProvider,
 } satisfies Record<SupportedLanguages, LanguageProvider>;
 
 /** Get provider by language enum (always succeeds for SupportedLanguages). */
diff --git a/gitnexus/src/core/ingestion/languages/plsql.ts b/gitnexus/src/core/ingestion/languages/plsql.ts
new file mode 100644
index 000000000..d7adc9aa6
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql.ts
@@ -0,0 +1,49 @@
+/**
+ * Oracle PL/SQL Language Provider
+ *
+ * Standalone ANTLR4 provider — no tree-sitter grammar. PL/SQL files are
+ * parsed with the grammars-v4 PlSql grammar (`../plsql/`) and mapped to the
+ * graph by `plsql-processor.ts` in the `plsql` pipeline phase, before parse.
+ *
+ * Dedicated extensions (.pks, .pkb, .pck, …) are always PL/SQL. `.sql` is
+ * claimed through `classifyFileContent` only when the file holds an Oracle
+ * PL/SQL unit, leaving other SQL dialects alone.
+ */
+import { SupportedLanguages } from 'gitnexus-shared';
+import { defineLanguage } from '../language-provider.js';
+import { PLSQL_EXTENSIONS, isSqlFile, looksLikeOraclePlSql } from '../plsql/file-types.js';
+import {
+  collectPlSqlSourceCfgs,
+  emitPlSqlScopeCaptures,
+  interpretPlSqlImport,
+  plsqlImportOwningScope,
+  plsqlReceiverBinding,
+  plsqlRenameProvider,
+} from './plsql/index.js';
+
+export const plsqlProvider = defineLanguage({
+  id: SupportedLanguages.PlSql,
+  parseStrategy: 'standalone',
+  extensions: [...PLSQL_EXTENSIONS],
+  // Check the extension first: classifiers run before extension lookup for every file.
+  shouldClassifyFileContent: isSqlFile,
+  classifyFileContent: (filePath, sourceText) =>
+    isSqlFile(filePath) && looksLikeOraclePlSql(sourceText),
+  entryPointPatterns: [],
+  astFrameworkPatterns: [],
+  treeSitterQueries: '',
+  typeConfig: {
+    declarationNodeTypes: new Set(),
+    extractDeclaration: () => null,
+    extractParameter: () => null,
+  },
+  exportChecker: () => false,
+  rename: plsqlRenameProvider,
+  collectSourceCfgs: collectPlSqlSourceCfgs,
+
+  // ── Scope-resolution hooks ───────────────────────────────────────
+  emitScopeCaptures: emitPlSqlScopeCaptures,
+  interpretImport: interpretPlSqlImport,
+  importOwningScope: plsqlImportOwningScope,
+  receiverBinding: plsqlReceiverBinding,
+});
diff --git a/gitnexus/src/core/ingestion/languages/plsql/captures.ts b/gitnexus/src/core/ingestion/languages/plsql/captures.ts
new file mode 100644
index 000000000..def840910
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql/captures.ts
@@ -0,0 +1,153 @@
+/**
+ * `emitScopeCaptures` for Oracle PL/SQL.
+ *
+ * Wraps the ANTLR fact extractor (`../../plsql/extract.ts`) and emits the
+ * parser-agnostic RFC §5.1 vocabulary consumed by the central ScopeExtractor:
+ *
+ *   package             → @scope.module   + @declaration.program  (→ Module)
+ *   procedure/function  → @scope.function + @declaration.function (→ Function)
+ *   trigger             → @scope.function + @declaration.function
+ *   spec declaration    → @declaration.function (no scope: it has no body)
+ *   call (last part)    → @reference.call  (+ @reference.arity)
+ *   call qualifier part → @reference.read  (the package name in `pkg.proc`)
+ *   END <label>         → @reference.read  (bound to the definition it closes)
+ *   @@script / START    → @import.statement / @import.name
+ *
+ * Every name capture uses the exact written token range, so rename and the
+ * source-binding pass can join captures back to source tokens by range.
+ */
+
+import type { Capture, CaptureMatch, Range } from 'gitnexus-shared';
+import {
+  extractPlSqlFacts,
+  type PlSqlDefinition,
+  type PlSqlFileFacts,
+  type PlSqlNameToken,
+} from '../../plsql/extract.js';
+
+function capture(name: string, range: Range, text: string): Capture {
+  return { name, range, text };
+}
+
+export function plsqlTokenRange(token: PlSqlNameToken): Range {
+  return {
+    startLine: token.line,
+    startCol: token.column,
+    endLine: token.line,
+    endCol: token.column + token.length,
+  };
+}
+
+export function plsqlNameRange(def: PlSqlDefinition): Range {
+  return {
+    startLine: def.nameLine,
+    startCol: def.nameColumn,
+    endLine: def.nameLine,
+    endCol: def.nameColumn + def.nameLength,
+  };
+}
+
+export function plsqlDefinitionRange(def: PlSqlDefinition): Range {
+  return {
+    startLine: def.startLine,
+    startCol: def.startColumn,
+    endLine: def.endLine,
+    endCol: Math.max(def.endColumn, def.startLine === def.endLine ? def.startColumn + 1 : 0),
+  };
+}
+
+export const plsqlRangeKey = (r: Range): string =>
+  `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
+
+/** Facts are recomputed per call site of the hook; memoise on the exact source text. */
+const factsCache = new Map<string, PlSqlFileFacts>();
+const FACTS_CACHE_LIMIT = 64;
+
+export function plsqlFactsFor(sourceText: string): PlSqlFileFacts {
+  const cached = factsCache.get(sourceText);
+  if (cached) return cached;
+  const facts = extractPlSqlFacts(sourceText);
+  if (factsCache.size >= FACTS_CACHE_LIMIT) factsCache.delete(factsCache.keys().next().value!);
+  factsCache.set(sourceText, facts);
+  return facts;
+}
+
+export function emitPlSqlScopeCaptures(
+  sourceText: string,
+  _filePath: string,
+  _cachedTree?: unknown,
+): readonly CaptureMatch[] {
+  const facts = plsqlFactsFor(sourceText);
+  const out: CaptureMatch[] = [];
+
+  for (const def of facts.definitions) {
+    const range = plsqlDefinitionRange(def);
+    const nameRange = plsqlNameRange(def);
+    const tag = def.kind === 'package' ? '@declaration.program' : '@declaration.function';
+    const required = def.parameters.filter((p) => !p.hasDefault).length;
+    const match: Record<string, Capture> = {
+      [tag]: capture(tag, range, def.name),
+      '@declaration.name': capture('@declaration.name', nameRange, def.name),
+      '@declaration.qualified_name': capture(
+        '@declaration.qualified_name',
+        nameRange,
+        [...def.ownerPath, def.name].join('.'),
+      ),
+    };
+    if (def.kind !== 'package' && !def.fromFallback) {
+      match['@declaration.parameter-count'] = capture(
+        '@declaration.parameter-count',
+        nameRange,
+        String(def.parameters.length),
+      );
+      match['@declaration.required-parameter-count'] = capture(
+        '@declaration.required-parameter-count',
+        nameRange,
+        String(required),
+      );
+    }
+    // A spec declaration has no body, so it opens no scope.
+    if (!def.isSpec || def.kind === 'package') {
+      const scope = def.kind === 'package' ? '@scope.module' : '@scope.function';
+      match[scope] = capture(scope, range, def.name);
+    }
+    out.push(match);
+    for (const label of def.endLabels) {
+      const r = plsqlTokenRange(label);
+      out.push({
+        '@reference.read': capture('@reference.read', r, label.name),
+        '@reference.name': capture('@reference.name', r, label.name),
+      });
+    }
+  }
+
+  for (const call of facts.calls) {
+    call.nameTokens.forEach((token, i) => {
+      const r = plsqlTokenRange(token);
+      const isCallee = i === call.nameTokens.length - 1;
+      const tag = isCallee ? '@reference.call' : '@reference.read';
+      out.push({
+        [tag]: capture(tag, r, token.name),
+        '@reference.name': capture('@reference.name', r, token.name),
+        ...(isCallee && call.arity !== undefined
+          ? { '@reference.arity': capture('@reference.arity', r, String(call.arity)) }
+          : {}),
+      });
+    });
+  }
+
+  for (const include of facts.scriptIncludes) {
+    const r: Range = {
+      startLine: include.line,
+      startCol: include.column,
+      endLine: include.line,
+      endCol: include.column + include.target.length,
+    };
+    out.push({
+      '@import.statement': capture('@import.statement', r, include.target),
+      '@import.name': capture('@import.name', r, include.target),
+    });
+  }
+
+  return out;
+}
diff --git a/gitnexus/src/core/ingestion/languages/plsql/flow.ts b/gitnexus/src/core/ingestion/languages/plsql/flow.ts
new file mode 100644
index 000000000..1774e375f
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql/flow.ts
@@ -0,0 +1,15 @@
+/**
+ * Control-flow graphs for PL/SQL are not built yet. The provider still
+ * implements `collectSourceCfgs` so the PDG layer treats PL/SQL as a known
+ * language that contributes no CFGs, rather than an unhandled one.
+ */
+
+import type { CollectedCfgs } from '../../cfg/collect.js';
+
+export function collectPlSqlSourceCfgs(
+  _sourceText: string,
+  _filePath: string,
+  _maxFunctionLines: number,
+): CollectedCfgs {
+  return { cfgs: [], skipped: { tooManyLines: 0, tooDeeplyNested: 0, buildError: 0 } };
+}
diff --git a/gitnexus/src/core/ingestion/languages/plsql/index.ts b/gitnexus/src/core/ingestion/languages/plsql/index.ts
new file mode 100644
index 000000000..1a62bfce3
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql/index.ts
@@ -0,0 +1,13 @@
+/**
+ * Oracle PL/SQL scope-resolution public API barrel.
+ *
+ *   - `captures.ts`  — `emitPlSqlScopeCaptures` (wraps the ANTLR fact extractor)
+ *   - `interpret.ts` — import / owning-scope / receiver hooks
+ *   - `rename.ts`    — rename provider
+ *   - `flow.ts`      — CFG hook (none yet)
+ */
+
+export { emitPlSqlScopeCaptures } from './captures.js';
+export { interpretPlSqlImport, plsqlImportOwningScope, plsqlReceiverBinding } from './interpret.js';
+export { plsqlRenameProvider } from './rename.js';
+export { collectPlSqlSourceCfgs } from './flow.js';
diff --git a/gitnexus/src/core/ingestion/languages/plsql/interpret.ts b/gitnexus/src/core/ingestion/languages/plsql/interpret.ts
new file mode 100644
index 000000000..812d7ae14
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql/interpret.ts
@@ -0,0 +1,43 @@
+/**
+ * PL/SQL scope-resolution interpret hooks.
+ *
+ * PL/SQL itself has no import statement — schema objects are global to the
+ * database. The one textual inclusion in PL/SQL source trees is SQL*Plus
+ * `@@script` / `@script` / `START script`, which install scripts use to load
+ * package specs and bodies in order. It is modelled as a `'named'` import of
+ * the script path.
+ */
+
+import type {
+  CaptureMatch,
+  ParsedImport,
+  Scope,
+  ScopeId,
+  ScopeTree,
+  TypeRef,
+} from 'gitnexus-shared';
+
+export function interpretPlSqlImport(match: CaptureMatch): ParsedImport | null {
+  const name = match['@import.name']?.text;
+  if (!name) return null;
+  return { kind: 'named', localName: name, importedName: name, targetRaw: name };
+}
+
+/** Script inclusion is file-level: it binds in the file's Module scope. */
+export function plsqlImportOwningScope(
+  _imp: ParsedImport,
+  innermost: Scope,
+  tree: ScopeTree,
+): ScopeId | null {
+  if (innermost.kind === 'Module') return innermost.id;
+  for (const id of tree.getAncestors(innermost.id)) {
+    const scope = tree.getScope(id);
+    if (scope?.kind === 'Module') return id;
+  }
+  return null;
+}
+
+/** PL/SQL subprograms have no implicit receiver (object-type `SELF` is out of scope). */
+export function plsqlReceiverBinding(_functionScope: Scope): TypeRef | null {
+  return null;
+}
diff --git a/gitnexus/src/core/ingestion/languages/plsql/rename.ts b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
new file mode 100644
index 000000000..199883a08
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
@@ -0,0 +1,185 @@
+/**
+ * Rename for PL/SQL packages and subprograms.
+ *
+ * Every identifier-like token of a file becomes an occurrence:
+ *   - declaration names (body, spec declaration) carry their definition id;
+ *   - call parts, package qualifiers and `END <label>`s carry the reference
+ *     site whose binding the scope resolver records;
+ *   - expression identifiers that are not recorded call sites (variables,
+ *     columns — or argument-less function calls the grammar cannot tell apart)
+ *     are left unproven, so a same-named one makes the engine refuse;
+ *   - everything else is `unrelated`.
+ *
+ * A spec declaration and its body (and a package spec and its body) form one
+ * symbol family and are renamed together. Rename is refused when the name
+ * appears in dynamic SQL text or in a segment the grammar could not parse.
+ */
+
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import type { Range, SymbolDefinition } from 'gitnexus-shared';
+import type {
+  RenameIssue,
+  RenameOccurrence,
+  RenameProvider,
+  RenameSource,
+} from '../../rename-provider.js';
+import { extractParsedFile } from '../../scope-extractor-bridge.js';
+import { PlSqlLexer } from '../../plsql/generated/PlSqlLexer.js';
+import { preprocessPlSql } from '../../plsql/preprocess.js';
+import {
+  normaliseIdentifier,
+  type PlSqlDefinition,
+  type PlSqlFileFacts,
+} from '../../plsql/extract.js';
+import { plsqlSignatureKey } from '../../plsql/resolve.js';
+import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
+
+const unsupported = (message: string): RenameIssue => ({
+  code: 'unsupported_occurrence',
+  message,
+  status: 'unsupported',
+});
+
+const evidence = new WeakMap<RenameSource, PlSqlFileFacts>();
+
+/** Reserved words that can never name a PL/SQL object (V$RESERVED_WORDS, reserved = 'Y'). */
+const PLSQL_RESERVED = new Set(
+  'ACCESS ADD ALL ALTER AND ANY AS ASC AUDIT BEGIN BETWEEN BY CASE CHAR CHECK CLUSTER COLUMN COMMENT COMPRESS CONNECT CREATE CURRENT DATE DECIMAL DECLARE DEFAULT DELETE DESC DISTINCT DROP ELSE ELSIF END EXCEPTION EXCLUSIVE EXISTS FILE FLOAT FOR FROM FUNCTION GRANT GROUP HAVING IDENTIFIED IF IMMEDIATE IN INCREMENT INDEX INITIAL INSERT INTEGER INTERSECT INTO IS LEVEL LIKE LOCK LONG LOOP MAXEXTENTS MINUS MLSLABEL MODE MODIFY NOAUDIT NOCOMPRESS NOT NOWAIT NULL NUMBER OF OFFLINE ON ONLINE OPTION OR ORDER PACKAGE PCTFREE PRIOR PROCEDURE PUBLIC RAISE RAW RENAME RESOURCE RETURN REVOKE ROW ROWID ROWNUM ROWS SELECT SESSION SET SHARE SIZE SMALLINT START SUCCESSFUL SYNONYM SYSDATE TABLE THEN TO TRIGGER UID UNION UNIQUE UPDATE USER VALIDATE VALUES VARCHAR VARCHAR2 VIEW WHENEVER WHEN WHERE WHILE WITH'.split(
+    ' ',
+  ),
+);
+
+const IDENTIFIER_TOKEN = /^(?:[A-Za-z][\w$#]*|"[^"]+")$/;
+
+function definitionFor(
+  source: RenameSource,
+  symbol: SymbolDefinition,
+): PlSqlDefinition | undefined {
+  const facts = evidence.get(source);
+  if (!facts || !symbol.nameRange) return undefined;
+  const key = plsqlRangeKey(symbol.nameRange);
+  return facts.definitions.find((d) => plsqlRangeKey(plsqlNameRange(d)) === key);
+}
+
+export const plsqlRenameProvider: RenameProvider = {
+  canonicalName: (name) => normaliseIdentifier(name),
+
+  validateName(name) {
+    if (!/^[A-Za-z][A-Za-z0-9_$#]{0,127}$/.test(name) || PLSQL_RESERVED.has(name.toUpperCase())) {
+      return {
+        code: 'invalid_name',
+        message:
+          'Use an unquoted PL/SQL identifier: a letter followed by letters, digits, _, $ or #, at most 128 characters, and no reserved word.',
+      };
+    }
+  },
+
+  matchesGraphIdentity({ definition, node }) {
+    return (
+      definition.type === node.label &&
+      definition.declarationRange !== undefined &&
+      definition.declarationRange.startLine === node.properties.startLine! + 1
+    );
+  },
+
+  parseSource({ filePath, content, languageProvider }) {
+    const facts = plsqlFactsFor(content);
+    const parsed = extractParsedFile(languageProvider, content, filePath);
+    if (!parsed)
+      throw {
+        code: 'incomplete_semantics',
+        message: `Could not extract PL/SQL bindings in ${filePath}.`,
+      };
+
+    const definitions = new Map(
+      parsed.localDefs.filter((d) => d.nameRange).map((d) => [plsqlRangeKey(d.nameRange!), d]),
+    );
+    const references = new Map(
+      parsed.referenceSites.filter((s) => s.nameRange).map((s) => [plsqlRangeKey(s.nameRange!), s]),
+    );
+    const unproven = new Set(facts.expressionNames.map((t) => plsqlRangeKey(plsqlTokenRange(t))));
+
+    const lineStarts = [0];
+    for (let i = 0; i < content.length; i++) if (content[i] === '\n') lineStarts.push(i + 1);
+
+    // Pre-processing keeps every line and column of the remaining text, so
+    // token positions map straight back onto the original content.
+    const lexer = new PlSqlLexer(CharStream.fromString(preprocessPlSql(content)));
+    lexer.removeErrorListeners();
+    const stream = new CommonTokenStream(lexer);
+    stream.fill();
+    const occurrences = new Map<string, RenameOccurrence>();
+    for (const token of stream.getTokens()) {
+      if (token.channel !== Token.DEFAULT_CHANNEL || token.type === Token.EOF) continue;
+      const text = token.text ?? '';
+      if (!IDENTIFIER_TOKEN.test(text)) continue;
+      const range: Range = {
+        startLine: token.line,
+        startCol: token.column,
+        endLine: token.line,
+        endCol: token.column + text.length,
+      };
+      const key = plsqlRangeKey(range);
+      const definition = definitions.get(key);
+      const referenceSite = references.get(key);
+      occurrences.set(key, {
+        name: normaliseIdentifier(text),
+        range,
+        spans: [{ start: lineStarts[token.line - 1]! + token.column, length: text.length }],
+        ...(definition ? { definitionId: definition.nodeId } : {}),
+        ...(referenceSite ? { referenceSite } : {}),
+        role: definition || referenceSite || unproven.has(key) ? 'name' : 'unrelated',
+      });
+    }
+    const source: RenameSource = {
+      path: filePath,
+      content,
+      parsed,
+      occurrences: [...occurrences.values()],
+    };
+    evidence.set(source, facts);
+    return source;
+  },
+
+  symbolFamily(context) {
+    const targetSource = context.files.get(context.target.filePath);
+    const target = targetSource && definitionFor(targetSource, context.target);
+    if (!target) return unsupported('The PL/SQL declaration has no source identity.');
+    const sameEntity = (d: PlSqlDefinition) =>
+      target.kind === 'package'
+        ? d.kind === 'package' && d.name === target.name
+        : d.kind === target.kind && plsqlSignatureKey(d) === plsqlSignatureKey(target);
+    return context.definitions.filter((symbol) => {
+      const source = context.files.get(symbol.filePath);
+      const def = source && definitionFor(source, symbol);
+      return def !== undefined && sameEntity(def);
+    });
+  },
+
+  checkSafety(context) {
+    const source = context.files.get(context.target.filePath);
+    const target = source && definitionFor(source, context.target);
+    if (!target) return unsupported('The PL/SQL declaration has no source identity.');
+    if (target.fromFallback)
+      return unsupported(
+        'The declaration was recovered without a full parse; rename cannot prove its references.',
+      );
+    const word = new RegExp(`(^|[^\\w$#])${target.name.replace(/[$#]/g, '\\$&')}($|[^\\w$#])`, 'i');
+    for (const file of context.files.values()) {
+      const facts = evidence.get(file);
+      if (!facts) continue;
+      const dynamic = facts.dynamicSql.find((d) =>
+        d.literal === undefined ? false : word.test(d.literal),
+      );
+      if (dynamic)
+        return unsupported(
+          `${target.name} appears in dynamic SQL at ${file.path}:${dynamic.line}; rename cannot rewrite it safely.`,
+        );
+      if (facts.segmentsWithErrors > 0 && word.test(file.content)) {
+        return unsupported(
+          `${file.path} has PL/SQL the grammar could not fully parse and mentions ${target.name}.`,
+        );
+      }
+    }
+  },
+};
diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
new file mode 100644
index 000000000..7c456ec3e
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -0,0 +1,157 @@
+/**
+ * PL/SQL `ScopeResolver` registered in `SCOPE_RESOLVERS`.
+ *
+ * Structural CONTAINS / CALLS / ACCESSES / IMPORTS edges are owned by
+ * `plsql-processor.ts` (`callable-flow-only` edge mode, COBOL precedent).
+ * This resolver contributes the declaration model and, when a consumer such
+ * as rename asks for it, the exact source binding of every written name —
+ * decided by the same `PlSqlNameIndex` the processor uses for CALLS.
+ *
+ * Reference: `languages/cobol/scope-resolver.ts`.
+ */
+
+import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
+import { SupportedLanguages } from 'gitnexus-shared';
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+import { plsqlProvider } from '../plsql.js';
+import { PlSqlNameIndex, type PlSqlIndexEntry } from '../../plsql/resolve.js';
+import { resolvePlSqlScriptInclude } from '../../plsql/script-include.js';
+import type { PlSqlCallSite, PlSqlDefinition } from '../../plsql/extract.js';
+import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
+
+interface BoundEntry extends PlSqlIndexEntry {
+  readonly symbol: SymbolDefinition;
+}
+
+type SiteMeaning =
+  | { kind: 'callee'; call: PlSqlCallSite }
+  | { kind: 'qualifier'; call: PlSqlCallSite; part: number }
+  | { kind: 'end-label'; def: PlSqlDefinition };
+
+const plsqlScopeResolver: ScopeResolver = {
+  language: SupportedLanguages.PlSql,
+  languageProvider: plsqlProvider,
+  importEdgeReason: 'plsql-scope: script-include',
+
+  resolveImportTarget: (targetRaw, fromFile, allFilePaths) =>
+    resolvePlSqlScriptInclude(targetRaw, fromFile, allFilePaths),
+
+  mergeBindings: (existing) => [...existing],
+
+  // Defaulted parameters make arity a range, not a single count.
+  arityCompatibility: (callsite, def) => {
+    if (callsite.arity === undefined || def.parameterCount === undefined) return 'unknown';
+    const required = def.requiredParameterCount ?? def.parameterCount;
+    return callsite.arity >= required && callsite.arity <= def.parameterCount
+      ? 'compatible'
+      : 'incompatible';
+  },
+
+  scopeResolutionEdgeMode: 'callable-flow-only',
+
+  // Object-type inheritance (UNDER) is not modelled yet.
+  buildMro: () => new Map(),
+
+  populateOwners: (_parsed: ParsedFile) => {},
+
+  emitPostResolutionEdges(_graph, parsedFiles, _nodeLookup, _indexes, context) {
+    if (!context?.recordSourceBinding) return;
+    const record = context.recordSourceBinding;
+
+    const index = new PlSqlNameIndex<BoundEntry>();
+    const symbolOf = new Map<PlSqlDefinition, SymbolDefinition>();
+    const files = parsedFiles.map((parsed) => {
+      const facts = plsqlFactsFor(context.fileContents.get(parsed.filePath) ?? '');
+      const byNameRange = new Map(
+        parsed.localDefs.filter((d) => d.nameRange).map((d) => [plsqlRangeKey(d.nameRange!), d]),
+      );
+      for (const def of facts.definitions) {
+        const symbol = byNameRange.get(plsqlRangeKey(plsqlNameRange(def)));
+        if (!symbol) continue;
+        symbolOf.set(def, symbol);
+        index.add({ def, filePath: parsed.filePath, symbol });
+      }
+      return { parsed, facts };
+    });
+
+    // A package name denotes the package; its spec when indexed.
+    const packageSymbol = new Map<string, SymbolDefinition>();
+    for (const [def, symbol] of symbolOf) {
+      if (def.kind !== 'package') continue;
+      if (!packageSymbol.has(def.name) || def.isSpec) packageSymbol.set(def.name, symbol);
+    }
+
+    for (const { parsed, facts } of files) {
+      const meaning = new Map<string, SiteMeaning>();
+      for (const call of facts.calls) {
+        call.nameTokens.forEach((token, part) => {
+          meaning.set(
+            plsqlRangeKey(plsqlTokenRange(token)),
+            part === call.nameTokens.length - 1
+              ? { kind: 'callee', call }
+              : { kind: 'qualifier', call, part },
+          );
+        });
+      }
+      for (const def of facts.definitions) {
+        for (const label of def.endLabels)
+          meaning.set(plsqlRangeKey(plsqlTokenRange(label)), { kind: 'end-label', def });
+      }
+
+      for (const site of parsed.referenceSites) {
+        const m = site.nameRange && meaning.get(plsqlRangeKey(site.nameRange));
+        if (!m) continue;
+        if (m.kind === 'end-label') {
+          const symbol = symbolOf.get(m.def);
+          record(
+            site,
+            symbol
+              ? { status: 'resolved', targetDefIds: [symbol.nodeId], basis: 'plsql-end-label' }
+              : { status: 'unresolved', targetDefIds: [], basis: 'plsql-end-label' },
+          );
+          continue;
+        }
+        if (m.kind === 'qualifier') {
+          // In `S.A.N` only `A` (the part before the callee) can name a package.
+          const symbol =
+            m.part === m.call.nameParts.length - 2
+              ? packageSymbol.get(m.call.nameParts[m.part]!)
+              : undefined;
+          record(
+            site,
+            symbol
+              ? {
+                  status: 'resolved',
+                  targetDefIds: [symbol.nodeId],
+                  basis: 'plsql-package-qualifier',
+                }
+              : { status: 'unresolved', targetDefIds: [], basis: 'plsql-qualifier' },
+          );
+          continue;
+        }
+        const targets = m.call.dbLink ? [] : index.resolve(m.call);
+        const ids = targets.map((t) => t.symbol.nodeId);
+        record(
+          site,
+          ids.length === 1
+            ? { status: 'resolved', targetDefIds: ids, basis: 'plsql-call' }
+            : ids.length > 1
+              ? {
+                  status: 'ambiguous',
+                  targetDefIds: ids,
+                  candidatesComplete: true,
+                  basis: 'plsql-overload',
+                }
+              : { status: 'unresolved', targetDefIds: [], basis: 'plsql-call' },
+        );
+      }
+    }
+  },
+
+  isSuperReceiver: () => false,
+
+  fieldFallbackOnMethodLookup: false,
+  propagatesReturnTypesAcrossImports: false,
+};
+
+export { plsqlScopeResolver };
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/index.ts b/gitnexus/src/core/ingestion/pipeline-phases/index.ts
index 99b7cc253..6d4faf469 100644
--- a/gitnexus/src/core/ingestion/pipeline-phases/index.ts
+++ b/gitnexus/src/core/ingestion/pipeline-phases/index.ts
@@ -11,6 +11,7 @@ export { scanPhase, type ScanOutput } from './scan.js';
 export { structurePhase, type StructureOutput } from './structure.js';
 export { markdownPhase, type MarkdownOutput } from './markdown.js';
 export { cobolPhase, type CobolOutput } from './cobol.js';
+export { plsqlPhase, type PlSqlOutput } from './plsql.js';
 export { parsePhase, type ParseOutput } from './parse.js';
 export { routesPhase, type RoutesOutput, type RouteEntry } from './routes.js';
 export { toolsPhase, type ToolsOutput, type ToolDef } from './tools.js';
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/parse.ts b/gitnexus/src/core/ingestion/pipeline-phases/parse.ts
index 6e43352a3..b8d115d54 100644
--- a/gitnexus/src/core/ingestion/pipeline-phases/parse.ts
+++ b/gitnexus/src/core/ingestion/pipeline-phases/parse.ts
@@ -9,7 +9,7 @@
  * from the original pipeline. The chunk loop is a memory optimization
  * internal to this phase, not a phase boundary.
  *
- * @deps    structure, markdown, cobol
+ * @deps    structure, markdown, cobol, plsql
  * @reads   scannedFiles, allPaths, totalFiles (from structure)
  * @writes  graph (Symbol nodes, IMPORTS/CALLS/EXTENDS/IMPLEMENTS/ACCESSES edges)
  * @output  exportedTypeMap, allFetchCalls, allExtractedRoutes, allDecoratorRoutes,
@@ -117,7 +117,7 @@ export interface ParseOutput {
 
 export const parsePhase: PipelinePhase<ParseOutput> = {
   name: 'parse',
-  deps: ['structure', 'markdown', 'cobol'],
+  deps: ['structure', 'markdown', 'cobol', 'plsql'],
 
   async execute(
     ctx: PipelineContext,
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
new file mode 100644
index 000000000..44bc34e06
--- /dev/null
+++ b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
@@ -0,0 +1,70 @@
+/**
+ * Phase: plsql
+ *
+ * Processes Oracle PL/SQL files with the ANTLR4 PlSql grammar (no tree-sitter).
+ * Dedicated extensions (.pks, .pkb, …) are always included; `.sql` files only
+ * when their content holds an Oracle PL/SQL unit.
+ *
+ * @deps    structure
+ * @reads   scannedFiles (from structure phase)
+ * @writes  graph (package Module, subprogram/trigger Function, table Record
+ *          nodes; CONTAINS / CALLS / ACCESSES edges)
+ */
+
+import type { PipelinePhase, PipelineContext, PhaseResult } from './types.js';
+import { getPhaseOutput } from './types.js';
+import { processPlSql, isPlSqlSource } from '../plsql-processor.js';
+import { hasPlSqlExtension, isSqlFile } from '../plsql/file-types.js';
+import { readFileContents } from '../filesystem-walker.js';
+import type { StructureOutput } from './structure.js';
+import { isDev } from '../utils/env.js';
+
+import { logger } from '../../logger.js';
+
+export interface PlSqlOutput {
+  files: number;
+  packages: number;
+  subprograms: number;
+}
+
+export const plsqlPhase: PipelinePhase<PlSqlOutput> = {
+  name: 'plsql',
+  deps: ['structure'],
+
+  async execute(
+    ctx: PipelineContext,
+    deps: ReadonlyMap<string, PhaseResult<unknown>>,
+  ): Promise<PlSqlOutput> {
+    const { scannedFiles, allPathSet } = getPhaseOutput<StructureOutput>(deps, 'structure');
+
+    const candidates = scannedFiles.filter((f) => hasPlSqlExtension(f.path) || isSqlFile(f.path));
+    if (candidates.length === 0) return { files: 0, packages: 0, subprograms: 0 };
+
+    const contents = await readFileContents(
+      ctx.repoPath,
+      candidates.map((f) => f.path),
+    );
+    const files = candidates
+      .filter((f) => contents.has(f.path) && isPlSqlSource(f.path, contents.get(f.path)!))
+      .map((f) => ({ path: f.path, content: contents.get(f.path)! }));
+    if (files.length === 0) return { files: 0, packages: 0, subprograms: 0 };
+
+    const result = processPlSql(ctx.graph, files, allPathSet);
+
+    if (isDev) {
+      logger.info(
+        `  PL/SQL: ${result.packages} packages, ${result.subprograms} subprograms, ${result.triggers} triggers, ${result.tables} tables from ${result.files} files`,
+      );
+      logger.info(
+        `  PL/SQL edges: ${result.calls} calls (${result.ambiguousCalls} ambiguous, ${result.unresolvedCalls} unresolved), ${result.accesses} table accesses, ${result.dynamicSqlSites} dynamic SQL sites`,
+      );
+      if (result.segmentsWithErrors > 0) {
+        logger.info(
+          `  PL/SQL degraded: ${result.segmentsWithErrors} segments with syntax errors, ${result.fallbackDefinitions} fallback definitions`,
+        );
+      }
+    }
+
+    return { files: result.files, packages: result.packages, subprograms: result.subprograms };
+  },
+};
diff --git a/gitnexus/src/core/ingestion/pipeline.ts b/gitnexus/src/core/ingestion/pipeline.ts
index a6d51e0ad..bf0cada62 100644
--- a/gitnexus/src/core/ingestion/pipeline.ts
+++ b/gitnexus/src/core/ingestion/pipeline.ts
@@ -28,6 +28,7 @@ import {
   structurePhase,
   markdownPhase,
   cobolPhase,
+  plsqlPhase,
   parsePhase,
   routesPhase,
   toolsPhase,
@@ -316,7 +317,7 @@ export interface PipelineOptions {
  *
  * Phase dependency graph:
  *
- *   scan → structure → [springConfig, markdown, cobol] → parse → [routes, tools, orm]
+ *   scan → structure → [springConfig, markdown, cobol, plsql] → parse → [routes, tools, orm]
  *     → crossFile → scopeResolution → [springAutoConfiguration, springAop,
  *       springDestinations] → pruneLocalSymbols
  *     → mro → springAopInheritance → di → communities → processes
@@ -339,6 +340,7 @@ export function buildPhaseList(options?: PipelineOptions): PipelinePhase[] {
       .register(springConfigPhase)
       .register(markdownPhase)
       .register(cobolPhase)
+      .register(plsqlPhase)
       .register(parsePhase)
       .register(routesPhase)
       .register(toolsPhase)
diff --git a/gitnexus/src/core/ingestion/plsql-processor.ts b/gitnexus/src/core/ingestion/plsql-processor.ts
new file mode 100644
index 000000000..7c2d7aec3
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql-processor.ts
@@ -0,0 +1,361 @@
+/**
+ * Oracle PL/SQL → knowledge graph.
+ *
+ * Standalone processor (COBOL precedent): parses PL/SQL files with the
+ * ANTLR4 grammar (`plsql/`), resolves names across the whole repository and
+ * writes structural nodes and edges directly into the graph before the parse
+ * phase. The PL/SQL scope resolver runs in `callable-flow-only` mode, so every
+ * structural edge below is owned here.
+ *
+ * Mapping (no schema extension):
+ *   package (spec + body)            → Module   (one node, anchored at the spec)
+ *   procedure / function / trigger   → Function (CONTAINS from its owner)
+ *   table / view                     → Record   (one node per table name)
+ *   call                             → CALLS    (reason plsql-call*)
+ *   DML / SELECT / trigger target    → ACCESSES (reason plsql-<op>)
+ *   SQL*Plus @@script / START        → IMPORTS  (File → File)
+ *
+ * Resolution is deliberately conservative: a call only becomes an edge when it
+ * resolves to a definition indexed from this repository. Built-ins
+ * (`TRUNC`, `DBMS_OUTPUT.PUT_LINE`) and objects outside the repository yield
+ * no edge rather than a guessed one; overloads that arity and named arguments
+ * cannot tell apart yield one lower-confidence edge per candidate.
+ */
+
+import { SupportedLanguages } from 'gitnexus-shared';
+import { generateId } from '../../lib/utils.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import { toZeroBasedLine } from './utils/line-base.js';
+import { extractPlSqlFacts, type PlSqlDefinition, type PlSqlFileFacts } from './plsql/extract.js';
+import { isPlSqlSource } from './plsql/file-types.js';
+import { resolvePlSqlScriptInclude } from './plsql/script-include.js';
+import { PlSqlNameIndex, plsqlSignatureKey, type PlSqlIndexEntry } from './plsql/resolve.js';
+
+export interface PlSqlFile {
+  readonly path: string;
+  readonly content: string;
+}
+
+export interface PlSqlProcessResult {
+  readonly files: number;
+  readonly packages: number;
+  readonly subprograms: number;
+  readonly triggers: number;
+  readonly tables: number;
+  readonly calls: number;
+  readonly ambiguousCalls: number;
+  readonly unresolvedCalls: number;
+  readonly accesses: number;
+  readonly scriptIncludes: number;
+  readonly dynamicSqlSites: number;
+  readonly segmentsWithErrors: number;
+  readonly fallbackDefinitions: number;
+}
+
+export { isPlSqlSource };
+
+// ─── node identity ────────────────────────────────────────────────────────
+
+/** A package is one node for spec and body, keyed by the file that declares it. */
+export function plsqlPackageNodeId(homeFile: string, packageName: string): string {
+  return generateId('Module', `${homeFile}:${packageName}`);
+}
+
+/**
+ * Subprograms are keyed by owner path plus the normalised parameter signature,
+ * so overloads get distinct ids that survive edits elsewhere in the file.
+ */
+export function plsqlSubprogramNodeId(filePath: string, def: PlSqlDefinition): string {
+  return generateId(
+    'Function',
+    `${filePath}:${plsqlSignatureKey(def)}${def.kind === 'trigger' ? ':trigger' : ''}`,
+  );
+}
+
+export function plsqlTableNodeId(tableName: string): string {
+  return generateId('Record', `plsql-table:${tableName}`);
+}
+
+interface Entry extends PlSqlIndexEntry {
+  /** Graph node of this definition (a spec declaration with a body maps to the body). */
+  nodeId?: string;
+}
+
+// ─── graph mapping ────────────────────────────────────────────────────────
+
+export function processPlSql(
+  graph: KnowledgeGraph,
+  files: readonly PlSqlFile[],
+  allPaths: ReadonlySet<string> = new Set(files.map((f) => f.path)),
+): PlSqlProcessResult {
+  const facts = new Map<string, PlSqlFileFacts>();
+  for (const file of files) facts.set(file.path, extractPlSqlFacts(file.content));
+
+  const index = new PlSqlNameIndex<Entry>();
+  const entryOf = new Map<PlSqlDefinition, Entry>();
+  for (const [filePath, f] of facts) {
+    for (const def of f.definitions) {
+      const entry: Entry = { def, filePath };
+      entryOf.set(def, entry);
+      index.add(entry);
+    }
+  }
+
+  // ── packages: one Module per name, anchored at the spec when indexed ──
+  const packageHome = new Map<string, { file: string; def: PlSqlDefinition; files: Set<string> }>();
+  for (const [filePath, f] of facts) {
+    for (const def of f.definitions) {
+      if (def.kind !== 'package') continue;
+      const home = packageHome.get(def.name);
+      if (!home) packageHome.set(def.name, { file: filePath, def, files: new Set([filePath]) });
+      else {
+        home.files.add(filePath);
+        if (def.isSpec && !home.def.isSpec) Object.assign(home, { file: filePath, def });
+      }
+    }
+  }
+  const packageNode = new Map<string, string>();
+  for (const [name, home] of packageHome) {
+    const nodeId = plsqlPackageNodeId(home.file, name);
+    packageNode.set(name, nodeId);
+    const bodyFiles = [...home.files].filter((f) => f !== home.file);
+    graph.addNode({
+      id: nodeId,
+      label: 'Module',
+      properties: {
+        name,
+        filePath: home.file,
+        startLine: toZeroBasedLine(home.def.startLine),
+        endLine: toZeroBasedLine(home.def.endLine),
+        language: SupportedLanguages.PlSql,
+        isExported: true,
+        description:
+          bodyFiles.length > 0
+            ? `PL/SQL package; also defined in ${bodyFiles.join(', ')}`
+            : 'PL/SQL package',
+      },
+    });
+    for (const file of home.files) {
+      addEdge(graph, 'CONTAINS', generateId('File', file), nodeId, 1.0, 'plsql-package');
+    }
+  }
+  for (const entry of entryOf.values()) {
+    if (entry.def.kind === 'package') entry.nodeId = packageNode.get(entry.def.name);
+  }
+
+  // ── subprograms and triggers ──
+  const bodySignatures = new Set<string>();
+  const specSignatures = new Set<string>();
+  for (const entry of entryOf.values()) {
+    if (entry.def.kind === 'package') continue;
+    (entry.def.isSpec ? specSignatures : bodySignatures).add(plsqlSignatureKey(entry.def));
+  }
+  const bodyNodeBySignature = new Map<string, string>();
+  let subprograms = 0;
+  let triggers = 0;
+  let fallbackDefinitions = 0;
+  for (const entry of entryOf.values()) {
+    const { def, filePath } = entry;
+    if (def.kind === 'package') continue;
+    if (def.fromFallback) fallbackDefinitions++;
+    // A spec declaration with an indexed body is the same subprogram.
+    if (def.isSpec && bodySignatures.has(plsqlSignatureKey(def))) continue;
+    entry.nodeId = plsqlSubprogramNodeId(filePath, def);
+    if (!def.isSpec) bodyNodeBySignature.set(plsqlSignatureKey(def), entry.nodeId);
+    if (def.kind === 'trigger') triggers++;
+    else subprograms++;
+    const packageMember = def.ownerPath.length === 1 && packageNode.has(def.ownerPath[0]!);
+    graph.addNode({
+      id: entry.nodeId,
+      label: 'Function',
+      properties: {
+        name: def.name,
+        filePath,
+        startLine: toZeroBasedLine(def.startLine),
+        endLine: toZeroBasedLine(def.endLine),
+        language: SupportedLanguages.PlSql,
+        // Package members are public exactly when the spec declares them.
+        isExported: packageMember
+          ? specSignatures.has(plsqlSignatureKey(def))
+          : def.ownerPath.length === 0,
+        parameterCount: def.parameters.length,
+        description: describeDefinition(def),
+      },
+    });
+  }
+  for (const entry of entryOf.values()) {
+    if (entry.def.isSpec && entry.def.kind !== 'package' && !entry.nodeId) {
+      entry.nodeId = bodyNodeBySignature.get(plsqlSignatureKey(entry.def));
+    }
+  }
+
+  /** Graph node of the innermost definition enclosing `ownerPath` in `filePath`. */
+  const ownerNode = (filePath: string, ownerPath: readonly string[]): string | undefined => {
+    if (ownerPath.length === 0) return undefined;
+    const name = ownerPath[ownerPath.length - 1]!;
+    const parent = ownerPath.slice(0, -1);
+    const local = index
+      .lookup(parent, name)
+      .find((e) => e.filePath === filePath && !e.def.isSpec && e.nodeId !== undefined);
+    if (local) return local.nodeId;
+    return ownerPath.length === 1 ? packageNode.get(name) : undefined;
+  };
+
+  for (const entry of entryOf.values()) {
+    const { def, filePath, nodeId } = entry;
+    if (
+      def.kind === 'package' ||
+      !nodeId ||
+      (def.isSpec && bodySignatures.has(plsqlSignatureKey(def)))
+    )
+      continue;
+    const owner = ownerNode(filePath, def.ownerPath) ?? generateId('File', filePath);
+    addEdge(
+      graph,
+      'CONTAINS',
+      owner,
+      nodeId,
+      1.0,
+      def.kind === 'trigger' ? 'plsql-trigger' : 'plsql-subprogram',
+    );
+  }
+
+  // ── calls ──
+  let calls = 0;
+  let ambiguousCalls = 0;
+  let unresolvedCalls = 0;
+  for (const [filePath, f] of facts) {
+    const degraded = f.segmentsWithErrors > 0;
+    for (const call of f.calls) {
+      const sourceId = ownerNode(filePath, call.ownerPath);
+      if (!sourceId) continue; // top-level script statements have no callable owner
+      const targets = call.dbLink ? [] : index.resolve(call).filter((t) => t.nodeId !== undefined);
+      if (targets.length === 0) {
+        if (call.form === 'statement') unresolvedCalls++;
+        continue;
+      }
+      const ambiguous = targets.length > 1;
+      if (ambiguous) ambiguousCalls++;
+      for (const target of targets) {
+        graph.addRelationship({
+          id: generateId('CALLS', `${sourceId}->${target.nodeId}:L${call.line}:${call.column}`),
+          type: 'CALLS',
+          sourceId,
+          targetId: target.nodeId!,
+          confidence: ambiguous ? 0.5 : degraded || target.def.fromFallback ? 0.7 : 1.0,
+          reason: ambiguous ? 'plsql-call-ambiguous' : 'plsql-call',
+        });
+        calls++;
+      }
+    }
+  }
+
+  // ── table accesses ──
+  const tables = new Set<string>();
+  let accesses = 0;
+  for (const [filePath, f] of facts) {
+    for (const access of f.accesses) {
+      const sourceId = ownerNode(filePath, access.ownerPath);
+      if (!sourceId) continue;
+      const tableId = plsqlTableNodeId(access.table);
+      if (!tables.has(access.table)) {
+        tables.add(access.table);
+        graph.addNode({
+          id: tableId,
+          label: 'Record',
+          properties: {
+            name: access.table,
+            // A table is a database object, not source; anchor it at its first
+            // reference so it stays navigable.
+            filePath,
+            startLine: toZeroBasedLine(access.line),
+            endLine: toZeroBasedLine(access.line),
+            language: SupportedLanguages.PlSql,
+            description: 'database table or view referenced from PL/SQL',
+          },
+        });
+      }
+      graph.addRelationship({
+        id: generateId(
+          'ACCESSES',
+          `${sourceId}->${tableId}:${access.kind}:L${access.line}:${access.column}`,
+        ),
+        type: 'ACCESSES',
+        sourceId,
+        targetId: tableId,
+        confidence: f.segmentsWithErrors > 0 ? 0.7 : 1.0,
+        reason: `plsql-${access.kind}`,
+      });
+      accesses++;
+    }
+  }
+
+  // ── SQL*Plus script includes ──
+  let scriptIncludes = 0;
+  for (const [filePath, f] of facts) {
+    for (const include of f.scriptIncludes) {
+      const target = resolvePlSqlScriptInclude(include.target, filePath, allPaths);
+      if (!target) continue;
+      addEdge(
+        graph,
+        'IMPORTS',
+        generateId('File', filePath),
+        generateId('File', target),
+        1.0,
+        'plsql-script-include',
+        `:L${include.line}`,
+      );
+      scriptIncludes++;
+    }
+  }
+
+  let segmentsWithErrors = 0;
+  let dynamicSqlSites = 0;
+  for (const f of facts.values()) {
+    segmentsWithErrors += f.segmentsWithErrors;
+    dynamicSqlSites += f.dynamicSql.length;
+  }
+
+  return {
+    files: files.length,
+    packages: packageNode.size,
+    subprograms,
+    triggers,
+    tables: tables.size,
+    calls,
+    ambiguousCalls,
+    unresolvedCalls,
+    accesses,
+    scriptIncludes,
+    dynamicSqlSites,
+    segmentsWithErrors,
+    fallbackDefinitions,
+  };
+}
+
+function addEdge(
+  graph: KnowledgeGraph,
+  type: 'CONTAINS' | 'IMPORTS',
+  sourceId: string,
+  targetId: string,
+  confidence: number,
+  reason: string,
+  idSuffix = '',
+): void {
+  graph.addRelationship({
+    id: generateId(type, `${sourceId}->${targetId}${idSuffix}`),
+    type,
+    sourceId,
+    targetId,
+    confidence,
+    reason,
+  });
+}
+
+function describeDefinition(def: PlSqlDefinition): string | undefined {
+  const parts: string[] = [];
+  if (def.kind === 'trigger' && def.triggerTable) parts.push(`trigger on ${def.triggerTable}`);
+  if (def.isSpec) parts.push('declared in package spec (no body indexed)');
+  if (def.fromFallback) parts.push('recovered by fallback; parameters unknown');
+  return parts.length > 0 ? parts.join('; ') : undefined;
+}
diff --git a/gitnexus/src/core/ingestion/plsql/extract.ts b/gitnexus/src/core/ingestion/plsql/extract.ts
new file mode 100644
index 000000000..c0faff0ce
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/extract.ts
@@ -0,0 +1,650 @@
+/**
+ * PL/SQL fact extraction: walks the ANTLR parse tree of every segment and
+ * returns parser-independent facts (definitions, call sites, table accesses,
+ * dynamic SQL sites). Segments the grammar could not fully parse additionally
+ * get regex-level definitions, marked `fromFallback`, for any subprogram the
+ * error-recovered tree lost.
+ *
+ * Names are normalised the Oracle way: unquoted identifiers upper-case,
+ * quoted identifiers verbatim without quotes.
+ */
+
+import {
+  ParseTreeWalker,
+  ParserRuleContext,
+  type ParseTree,
+  type ParseTreeListener,
+} from 'antlr4ng';
+import { PlSqlParser as P } from './generated/PlSqlParser.js';
+import { parsePlSqlSource, type PlSqlSegment } from './parse.js';
+import type { ScriptInclude } from './preprocess.js';
+
+export type PlSqlDefKind = 'package' | 'procedure' | 'function' | 'trigger';
+export type PlSqlAccessKind =
+  | 'select'
+  | 'insert'
+  | 'update'
+  | 'delete'
+  | 'merge'
+  | 'lock'
+  | 'trigger';
+
+/** One written identifier: normalised name plus its exact source position. */
+export interface PlSqlNameToken {
+  readonly name: string;
+  readonly line: number;
+  /** 0-based column. */
+  readonly column: number;
+  readonly length: number;
+}
+
+export interface PlSqlParameter {
+  readonly name: string;
+  readonly hasDefault: boolean;
+  /** Normalised type text (`NUMBER`, `T_LOAN.ID%TYPE`); empty when omitted. */
+  readonly type: string;
+}
+
+export interface PlSqlDefinition {
+  readonly kind: PlSqlDefKind;
+  readonly name: string;
+  /** Schema prefix written on a top-level CREATE (`CREATE PACKAGE loan.pkg`). */
+  readonly schema?: string;
+  /** Enclosing definition names, outermost first (package, then subprograms). */
+  readonly ownerPath: readonly string[];
+  readonly startLine: number;
+  /** 0-based column of the first token of the definition. */
+  readonly startColumn: number;
+  readonly endLine: number;
+  /** 0-based column just past the last token of the definition. */
+  readonly endColumn: number;
+  readonly nameLine: number;
+  readonly nameColumn: number;
+  readonly nameLength: number;
+  /** `END <name>` closing labels, which must be renamed with the definition. */
+  readonly endLabels: readonly PlSqlNameToken[];
+  readonly parameters: readonly PlSqlParameter[];
+  /** Package spec, or a subprogram declared (not implemented) in a package spec. */
+  readonly isSpec: boolean;
+  /** Trigger only: the table the trigger fires on. */
+  readonly triggerTable?: string;
+  /** True when the definition was recovered by the regex fallback. */
+  readonly fromFallback: boolean;
+}
+
+export interface PlSqlCallSite {
+  readonly ownerPath: readonly string[];
+  readonly line: number;
+  readonly column: number;
+  /** Dotted name parts (`PKG_LOG`, `WARN`); optional schema first. */
+  readonly nameParts: readonly string[];
+  /** Source position of every name part, aligned with `nameParts`. */
+  readonly nameTokens: readonly PlSqlNameToken[];
+  readonly arity?: number;
+  readonly namedArguments: readonly string[];
+  /** `statement` = procedure call statement, `expression` = function call in an expression. */
+  readonly form: 'statement' | 'expression';
+  readonly dbLink?: string;
+}
+
+export interface PlSqlTableAccess {
+  readonly ownerPath: readonly string[];
+  readonly line: number;
+  readonly column: number;
+  readonly table: string;
+  readonly schema?: string;
+  readonly dbLink?: string;
+  readonly kind: PlSqlAccessKind;
+}
+
+export interface PlSqlDynamicSqlSite {
+  readonly ownerPath: readonly string[];
+  readonly line: number;
+  /** Literal statement text when the argument is a string literal. */
+  readonly literal?: string;
+}
+
+export interface PlSqlFileFacts {
+  readonly scriptIncludes: readonly ScriptInclude[];
+  /**
+   * Identifiers in expression positions that are not recorded call sites:
+   * variables, columns, record fields — or argument-less function calls the
+   * grammar cannot tell apart from them. Rename treats a same-named one as
+   * unproven and refuses rather than guessing.
+   */
+  readonly expressionNames: readonly PlSqlNameToken[];
+  readonly definitions: readonly PlSqlDefinition[];
+  readonly calls: readonly PlSqlCallSite[];
+  readonly accesses: readonly PlSqlTableAccess[];
+  readonly dynamicSql: readonly PlSqlDynamicSqlSite[];
+  readonly segments: number;
+  readonly segmentsWithErrors: number;
+  readonly segmentsTimedOut: number;
+  readonly firstError?: string;
+}
+
+// ─── helpers ──────────────────────────────────────────────────────────────
+
+export function normaliseIdentifier(text: string): string {
+  return text.startsWith('"') && text.endsWith('"') && text.length >= 2
+    ? text.slice(1, -1)
+    : text.toUpperCase();
+}
+
+function splitDotted(text: string): string[] {
+  // `"a.b".c` keeps the quoted part intact.
+  const parts: string[] = [];
+  let current = '';
+  let quoted = false;
+  for (const ch of text) {
+    if (ch === '"') quoted = !quoted;
+    if (ch === '.' && !quoted) {
+      parts.push(normaliseIdentifier(current));
+      current = '';
+    } else current += ch;
+  }
+  if (current !== '') parts.push(normaliseIdentifier(current));
+  return parts;
+}
+
+function childRule(ctx: ParserRuleContext, rule: number): ParserRuleContext | undefined {
+  for (const c of ctx.children)
+    if (c instanceof ParserRuleContext && c.ruleIndex === rule) return c;
+  return undefined;
+}
+
+function childRules(ctx: ParserRuleContext, rule: number): ParserRuleContext[] {
+  return ctx.children.filter(
+    (c): c is ParserRuleContext => c instanceof ParserRuleContext && c.ruleIndex === rule,
+  );
+}
+
+function hasTerminal(ctx: ParserRuleContext, tokenType: number): boolean {
+  return ctx.children.some(
+    (c) =>
+      !(c instanceof ParserRuleContext) &&
+      (c as { symbol?: { type: number } }).symbol?.type === tokenType,
+  );
+}
+
+function textOf(tree: ParseTree | undefined): string {
+  return tree ? tree.getText() : '';
+}
+
+function nameTokenOf(ctx: ParserRuleContext): PlSqlNameToken {
+  return {
+    name: normaliseIdentifier(ctx.getText()),
+    line: ctx.start!.line,
+    column: ctx.start!.column,
+    length: (ctx.stop?.stop ?? ctx.start!.stop) - ctx.start!.start + 1,
+  };
+}
+
+/** The last written identifier of a (possibly dotted) name rule. */
+function lastNameCtx(ctx: ParserRuleContext): ParserRuleContext {
+  const parts = ctx.children.filter(
+    (c): c is ParserRuleContext =>
+      c instanceof ParserRuleContext &&
+      (c.ruleIndex === P.RULE_identifier || c.ruleIndex === P.RULE_id_expression),
+  );
+  return parts[parts.length - 1] ?? ctx;
+}
+
+/** Every written identifier of a dotted name rule, in order. */
+function nameCtxs(ctx: ParserRuleContext): ParserRuleContext[] {
+  const parts = ctx.children.filter(
+    (c): c is ParserRuleContext =>
+      c instanceof ParserRuleContext &&
+      (c.ruleIndex === P.RULE_identifier || c.ruleIndex === P.RULE_id_expression),
+  );
+  return parts.length > 0 ? parts : [ctx];
+}
+
+/** `END <label>` of a subprogram/trigger body or package. */
+function endLabelsOf(ctx: ParserRuleContext): PlSqlNameToken[] {
+  if (ctx.ruleIndex === P.RULE_create_package || ctx.ruleIndex === P.RULE_create_package_body) {
+    const names = childRules(ctx, P.RULE_package_name);
+    return names.length > 1 ? [nameTokenOf(lastNameCtx(names[names.length - 1]!))] : [];
+  }
+  const findBody = (n: ParserRuleContext, depth: number): ParserRuleContext | undefined => {
+    for (const c of n.children) {
+      if (!(c instanceof ParserRuleContext)) continue;
+      if (c.ruleIndex === P.RULE_body) return c;
+      if (
+        depth > 0 &&
+        (c.ruleIndex === P.RULE_trigger_body || c.ruleIndex === P.RULE_trigger_block)
+      ) {
+        const nested = findBody(c, depth - 1);
+        if (nested) return nested;
+      }
+      if (c.ruleIndex === P.RULE_compound_trigger_block) {
+        const label = childRule(c, P.RULE_trigger_name);
+        return label ? c : undefined;
+      }
+    }
+    return undefined;
+  };
+  const body = findBody(ctx, 2);
+  if (!body) return [];
+  const label =
+    body.ruleIndex === P.RULE_compound_trigger_block
+      ? childRule(body, P.RULE_trigger_name)
+      : childRule(body, P.RULE_label_name);
+  return label ? [nameTokenOf(lastNameCtx(label))] : [];
+}
+
+function parametersOf(ctx: ParserRuleContext): PlSqlParameter[] {
+  return childRules(ctx, P.RULE_parameter).map((p) => ({
+    name: normaliseIdentifier(textOf(childRule(p, P.RULE_parameter_name))),
+    hasDefault: childRule(p, P.RULE_default_value_part) !== undefined,
+    type: textOf(childRule(p, P.RULE_type_spec)).toUpperCase(),
+  }));
+}
+
+function argumentsOf(fnArg: ParserRuleContext | undefined): { arity?: number; named: string[] } {
+  if (!fnArg) return { named: [] };
+  const args = childRules(fnArg, P.RULE_argument);
+  const named = args.flatMap((a) => {
+    const id = childRule(a, P.RULE_identifier);
+    return id ? [normaliseIdentifier(id.getText())] : [];
+  });
+  return { arity: args.length, named };
+}
+
+/** Decide read vs write for a `tableview_name`, from its nearest deciding ancestor. */
+function accessKindOf(ctx: ParserRuleContext): PlSqlAccessKind | undefined {
+  let prev: ParserRuleContext = ctx;
+  for (let a = ctx.parent; a; prev = a, a = a.parent) {
+    switch (a.ruleIndex) {
+      case P.RULE_query_block:
+      case P.RULE_subquery:
+        return 'select';
+      case P.RULE_insert_into_clause:
+        return 'insert';
+      case P.RULE_update_statement:
+        return 'update';
+      case P.RULE_delete_statement:
+        return 'delete';
+      case P.RULE_merge_statement:
+        return childRule(a, P.RULE_selected_tableview) === prev ? 'merge' : 'select';
+      case P.RULE_lock_table_statement:
+        return 'lock';
+      case P.RULE_create_trigger:
+        return 'trigger';
+      // DDL and type references are not data accesses.
+      case P.RULE_create_table:
+      case P.RULE_create_view:
+      case P.RULE_type_spec:
+      case P.RULE_parameter:
+        return undefined;
+    }
+  }
+  return undefined;
+}
+
+/** Common-table-expression names visible at a statement (filtered from accesses). */
+function cteNamesAbove(ctx: ParserRuleContext): Set<string> {
+  const names = new Set<string>();
+  for (let a = ctx.parent; a; a = a.parent) {
+    const withClause =
+      a.ruleIndex === P.RULE_select_statement || a.ruleIndex === P.RULE_subquery
+        ? childRule(a, P.RULE_with_clause)
+        : undefined;
+    if (!withClause) continue;
+    const visit = (n: ParserRuleContext) => {
+      if (n.ruleIndex === P.RULE_query_name) names.add(normaliseIdentifier(n.getText()));
+      for (const c of n.children) if (c instanceof ParserRuleContext) visit(c);
+    };
+    visit(withClause);
+  }
+  return names;
+}
+
+const PSEUDO_TABLES = new Set(['DUAL']);
+
+// ─── tree walk ────────────────────────────────────────────────────────────
+
+const SCOPE_RULES = new Set([
+  P.RULE_create_package,
+  P.RULE_create_package_body,
+  P.RULE_procedure_body,
+  P.RULE_function_body,
+  P.RULE_create_procedure_body,
+  P.RULE_create_function_body,
+  P.RULE_create_trigger,
+]);
+
+function extractSegment(
+  segment: PlSqlSegment,
+  out: {
+    definitions: PlSqlDefinition[];
+    calls: PlSqlCallSite[];
+    accesses: PlSqlTableAccess[];
+    dynamicSql: PlSqlDynamicSqlSite[];
+    expressionNames: PlSqlNameToken[];
+  },
+): void {
+  if (!segment.tree) return;
+  const scope: string[] = [];
+
+  const define = (
+    ctx: ParserRuleContext,
+    kind: PlSqlDefKind,
+    nameCtx: ParserRuleContext | undefined,
+    extra: { schema?: string; isSpec?: boolean; triggerTable?: string; push?: boolean } = {},
+  ) => {
+    const parts = splitDotted(textOf(nameCtx));
+    const name = parts[parts.length - 1] ?? '?';
+    const schema = extra.schema ?? (parts.length > 1 ? parts[parts.length - 2] : undefined);
+    const token = nameTokenOf(nameCtx ? lastNameCtx(nameCtx) : ctx);
+    const stop = ctx.stop ?? ctx.start!;
+    out.definitions.push({
+      kind,
+      name,
+      schema,
+      ownerPath: [...scope],
+      startLine: ctx.start!.line,
+      startColumn: ctx.start!.column,
+      endLine: stop.line,
+      endColumn: stop.column + (stop.stop - stop.start + 1),
+      nameLine: token.line,
+      nameColumn: token.column,
+      nameLength: token.length,
+      endLabels: endLabelsOf(ctx),
+      parameters: parametersOf(ctx),
+      isSpec: extra.isSpec ?? false,
+      triggerTable: extra.triggerTable,
+      fromFallback: false,
+    });
+    if (extra.push !== false) scope.push(name);
+  };
+
+  const listener: ParseTreeListener = {
+    visitTerminal() {},
+    visitErrorNode() {},
+    enterEveryRule(ctx: ParserRuleContext) {
+      switch (ctx.ruleIndex) {
+        case P.RULE_create_package:
+        case P.RULE_create_package_body: {
+          const schemaCtx = childRule(ctx, P.RULE_schema_object_name);
+          define(ctx, 'package', childRule(ctx, P.RULE_package_name), {
+            schema: schemaCtx ? normaliseIdentifier(schemaCtx.getText()) : undefined,
+            isSpec: ctx.ruleIndex === P.RULE_create_package,
+          });
+          break;
+        }
+        case P.RULE_procedure_spec:
+          define(ctx, 'procedure', childRule(ctx, P.RULE_identifier), {
+            isSpec: true,
+            push: false,
+          });
+          break;
+        case P.RULE_function_spec:
+          define(ctx, 'function', childRule(ctx, P.RULE_identifier), { isSpec: true, push: false });
+          break;
+        case P.RULE_procedure_body:
+          define(ctx, 'procedure', childRule(ctx, P.RULE_identifier));
+          break;
+        case P.RULE_function_body:
+          define(ctx, 'function', childRule(ctx, P.RULE_identifier));
+          break;
+        case P.RULE_create_procedure_body:
+          define(ctx, 'procedure', childRule(ctx, P.RULE_procedure_name));
+          break;
+        case P.RULE_create_function_body:
+          define(ctx, 'function', childRule(ctx, P.RULE_function_name));
+          break;
+        case P.RULE_create_trigger: {
+          let triggerTable: string | undefined;
+          const findTable = (n: ParserRuleContext): boolean => {
+            if (n.ruleIndex === P.RULE_tableview_name) {
+              const parts = splitDotted(n.getText());
+              triggerTable = parts[parts.length - 1];
+              return true;
+            }
+            return n.children.some(
+              (c) =>
+                c instanceof ParserRuleContext &&
+                c.ruleIndex !== P.RULE_trigger_body &&
+                findTable(c),
+            );
+          };
+          findTable(ctx);
+          define(ctx, 'trigger', childRule(ctx, P.RULE_trigger_name), { triggerTable });
+          break;
+        }
+        case P.RULE_call_statement: {
+          const routines = childRules(ctx, P.RULE_routine_name);
+          const fnArgs = childRules(ctx, P.RULE_function_argument);
+          // `a.b(x).c(y)` chains are rare; the first routine_name is the callee.
+          const routine = routines[0];
+          if (!routine) break;
+          const raw = routine.getText();
+          const at = raw.indexOf('@');
+          const { arity, named } = argumentsOf(fnArgs[0]);
+          out.calls.push({
+            ownerPath: [...scope],
+            line: routine.start!.line,
+            column: routine.start!.column,
+            nameParts: splitDotted(at >= 0 ? raw.slice(0, at) : raw),
+            nameTokens: nameCtxs(routine).map(nameTokenOf),
+            arity: arity ?? 0,
+            namedArguments: named,
+            form: 'statement',
+            dbLink: at >= 0 ? raw.slice(at + 1).toUpperCase() : undefined,
+          });
+          break;
+        }
+        case P.RULE_general_element: {
+          // `pkg.fn(args)` / `fn(args)` in an expression. Only the outermost
+          // general_element; collection indexing `arr(i)` looks identical and
+          // is disambiguated later by name resolution against definitions.
+          if (ctx.parent?.ruleIndex === P.RULE_general_element) break;
+          const parts = flattenGeneralElement(ctx);
+          if (parts.length === 0) break;
+          const last = parts[parts.length - 1]!;
+          const fnArg = childRule(last, P.RULE_function_argument);
+          if (!fnArg) {
+            for (const p of parts) {
+              const id = childRule(p, P.RULE_id_expression);
+              if (id) out.expressionNames.push(nameTokenOf(id));
+            }
+            break;
+          }
+          const idCtxs = parts.map((p) => childRule(p, P.RULE_id_expression));
+          if (idCtxs.some((c) => c === undefined)) break;
+          const names = idCtxs.map((c) => normaliseIdentifier(c!.getText()));
+          const { arity, named } = argumentsOf(fnArg);
+          out.calls.push({
+            ownerPath: [...scope],
+            line: ctx.start!.line,
+            column: ctx.start!.column,
+            nameParts: names,
+            nameTokens: idCtxs.map((c) => nameTokenOf(c!)),
+            arity,
+            namedArguments: named,
+            form: 'expression',
+          });
+          break;
+        }
+        case P.RULE_tableview_name: {
+          const kind = accessKindOf(ctx);
+          if (!kind) break;
+          const raw = ctx.getText();
+          const at = raw.indexOf('@');
+          const parts = splitDotted(at >= 0 ? raw.slice(0, at) : raw);
+          const table = parts[parts.length - 1]!;
+          if (PSEUDO_TABLES.has(table)) break;
+          if (parts.length === 1 && cteNamesAbove(ctx).has(table)) break;
+          out.accesses.push({
+            ownerPath: [...scope],
+            line: ctx.start!.line,
+            column: ctx.start!.column,
+            table,
+            schema: parts.length > 1 ? parts[parts.length - 2] : undefined,
+            dbLink: at >= 0 ? raw.slice(at + 1).toUpperCase() : undefined,
+            kind,
+          });
+          break;
+        }
+        case P.RULE_execute_immediate: {
+          const expr = childRule(ctx, P.RULE_expression);
+          const text = expr?.getText() ?? '';
+          out.dynamicSql.push({
+            ownerPath: [...scope],
+            line: ctx.start!.line,
+            literal: /^'[\s\S]*'$/.test(text) ? text.slice(1, -1).replace(/''/g, "'") : undefined,
+          });
+          break;
+        }
+      }
+    },
+    exitEveryRule(ctx: ParserRuleContext) {
+      if (SCOPE_RULES.has(ctx.ruleIndex)) scope.pop();
+    },
+  };
+  ParseTreeWalker.DEFAULT.walk(listener, segment.tree);
+}
+
+/** `a.b(x).c` → [a, b(x), c] general_element_part nodes in source order. */
+function flattenGeneralElement(ctx: ParserRuleContext): ParserRuleContext[] {
+  const out: ParserRuleContext[] = [];
+  for (const c of ctx.children) {
+    if (!(c instanceof ParserRuleContext)) continue;
+    if (c.ruleIndex === P.RULE_general_element) out.push(...flattenGeneralElement(c));
+    else if (c.ruleIndex === P.RULE_general_element_part) out.push(c);
+  }
+  return out;
+}
+
+// ─── regex fallback ───────────────────────────────────────────────────────
+
+const FALLBACK_UNIT =
+  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(package\s+body|package|procedure|function|trigger)\s+((?:"[^"]+"|[\w$#]+)(?:\.(?:"[^"]+"|[\w$#]+))?)/gim;
+const FALLBACK_SUBPROGRAM = /^[ \t]*(procedure|function)\s+("[^"]+"|[\w$#]+)/gim;
+
+function lineAt(text: string, offset: number, firstLine: number): number {
+  let line = firstLine;
+  for (let i = 0; i < offset; i++) if (text.charCodeAt(i) === 10) line++;
+  return line;
+}
+
+/**
+ * Regex-level definitions for a segment whose tree is missing or erroneous.
+ * Only names the tree did not already yield are added.
+ */
+function fallbackDefinitions(segment: PlSqlSegment, known: ReadonlySet<string>): PlSqlDefinition[] {
+  const out: PlSqlDefinition[] = [];
+  const text = segment.text;
+  let unit: { name: string; kind: PlSqlDefKind; isSpec: boolean } | undefined;
+  for (const m of text.matchAll(FALLBACK_UNIT)) {
+    const kindText = m[1]!.toLowerCase().replace(/\s+/g, ' ');
+    const parts = splitDotted(m[2]!);
+    const kind: PlSqlDefKind = kindText.startsWith('package')
+      ? 'package'
+      : (kindText as PlSqlDefKind);
+    const name = parts[parts.length - 1]!;
+    const line = lineAt(text, m.index!, segment.startLine);
+    if (!known.has(`|${name}`)) {
+      out.push(
+        makeFallback(
+          kind,
+          name,
+          [],
+          line,
+          segment.endLine,
+          parts.length > 1 ? parts[0] : undefined,
+          kindText === 'package',
+        ),
+      );
+    }
+    unit = { name, kind, isSpec: kindText === 'package' };
+    break; // one top-level unit per segment
+  }
+  if (unit?.kind !== 'package') return out;
+  for (const m of text.matchAll(FALLBACK_SUBPROGRAM)) {
+    const name = normaliseIdentifier(m[2]!);
+    if (known.has(`${unit.name}|${name}`)) continue;
+    const line = lineAt(text, m.index!, segment.startLine);
+    out.push(
+      makeFallback(
+        m[1]!.toLowerCase() as PlSqlDefKind,
+        name,
+        [unit.name],
+        line,
+        line,
+        undefined,
+        unit.isSpec,
+      ),
+    );
+  }
+  return out;
+}
+
+function makeFallback(
+  kind: PlSqlDefKind,
+  name: string,
+  ownerPath: string[],
+  startLine: number,
+  endLine: number,
+  schema: string | undefined,
+  isSpec: boolean,
+): PlSqlDefinition {
+  return {
+    kind,
+    name,
+    schema,
+    ownerPath,
+    startLine,
+    startColumn: 0,
+    endLine,
+    endColumn: 0,
+    nameLine: startLine,
+    nameColumn: 0,
+    nameLength: name.length,
+    endLabels: [],
+    parameters: [],
+    isSpec,
+    fromFallback: true,
+  };
+}
+
+// ─── entry point ──────────────────────────────────────────────────────────
+
+export function extractPlSqlFacts(
+  source: string,
+  options: { segmentDeadlineMs?: number } = {},
+): PlSqlFileFacts {
+  const parsed = parsePlSqlSource(source, options);
+  const out = {
+    definitions: [] as PlSqlDefinition[],
+    calls: [] as PlSqlCallSite[],
+    accesses: [] as PlSqlTableAccess[],
+    dynamicSql: [] as PlSqlDynamicSqlSite[],
+    expressionNames: [] as PlSqlNameToken[],
+  };
+  let segmentsWithErrors = 0;
+  let segmentsTimedOut = 0;
+  let firstError: string | undefined;
+  for (const segment of parsed.segments) {
+    const before = out.definitions.length;
+    extractSegment(segment, out);
+    if (segment.syntaxErrors > 0) {
+      segmentsWithErrors++;
+      if (segment.mode === 'timeout') segmentsTimedOut++;
+      firstError ??= segment.firstError;
+      const known = new Set(
+        out.definitions.slice(before).map((d) => `${d.ownerPath.join('.')}|${d.name}`),
+      );
+      out.definitions.push(...fallbackDefinitions(segment, known));
+    }
+  }
+  return {
+    ...out,
+    scriptIncludes: parsed.scriptIncludes,
+    segments: parsed.segments.length,
+    segmentsWithErrors,
+    segmentsTimedOut,
+    firstError,
+  };
+}
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
new file mode 100644
index 000000000..9a50b0957
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -0,0 +1,77 @@
+/**
+ * Oracle PL/SQL file detection.
+ *
+ * Dedicated extensions are always PL/SQL. `.sql` is shared by every SQL
+ * dialect, so it is claimed only when the content contains an Oracle PL/SQL
+ * compilation unit (see `looksLikeOraclePlSql`).
+ */
+
+/** Extensions that are unambiguously Oracle PL/SQL source. */
+export const PLSQL_EXTENSIONS = [
+  '.pks', // package spec
+  '.pkb', // package body
+  '.pck', // spec + body
+  '.pls', // generic PL/SQL source
+  '.plb', // body (often wrapped)
+  '.prc', // standalone procedure
+  '.fnc', // standalone function
+  '.trg', // trigger
+  '.tps', // object type spec
+  '.tpb', // object type body
+] as const;
+
+const PLSQL_EXTENSION_SET: ReadonlySet<string> = new Set(PLSQL_EXTENSIONS);
+
+function extensionOf(filePath: string): string {
+  const slash = filePath.lastIndexOf('/');
+  const dot = filePath.lastIndexOf('.');
+  return dot > slash ? filePath.slice(dot).toLowerCase() : '';
+}
+
+export function hasPlSqlExtension(filePath: string): boolean {
+  return PLSQL_EXTENSION_SET.has(extensionOf(filePath));
+}
+
+export function isSqlFile(filePath: string): boolean {
+  return extensionOf(filePath) === '.sql';
+}
+
+/**
+ * `CREATE [OR REPLACE] [EDITIONABLE|NONEDITIONABLE] PACKAGE|PROCEDURE|FUNCTION|TRIGGER|TYPE <name> ... IS|AS`
+ * at the start of a line. `IS`/`AS` (or a trigger timing keyword) must follow
+ * within the header, which rules out PostgreSQL's `CREATE FUNCTION ... AS $$`
+ * (handled by `POSTGRES_DOLLAR_BODY`) and T-SQL's `CREATE PROCEDURE ... AS BEGIN`
+ * without Oracle markers.
+ */
+const ORACLE_UNIT_HEADER =
+  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package(?:\s+body)?|procedure|function|trigger|type(?:\s+body)?)\s+[\w$#."]+/im;
+const POSTGRES_DOLLAR_BODY = /\bas\s+\$[\w]*\$|\blanguage\s+plpgsql\b/i;
+const TSQL_MARKERS = /^\s*go\s*$|\bnvarchar\s*\(\s*max\s*\)|@@identity|\bset\s+nocount\s+on\b/im;
+/** Constructs that only appear in Oracle PL/SQL. */
+const ORACLE_MARKERS =
+  /%(?:row)?type\b|^\s*\/\s*$|\bpragma\s+(?:autonomous_transaction|exception_init|serially_reusable|restrict_references)\b|\bexecute\s+immediate\b|\bdbms_\w+\.|\braise_application_error\b|\bsys_refcursor\b|\bvarchar2\b|\bnvl\s*\(/im;
+
+/**
+ * A SQL*Plus script inclusion of a PL/SQL or SQL file on its own line. `@@`,
+ * `@path.ext` and `START path.ext` are SQL*Plus client syntax (psql uses `\i`,
+ * sqlcmd `:r`), so install scripts made of them are Oracle sources too.
+ */
+const SQLPLUS_INCLUDE =
+  /^[ \t]*(?:@@|@|sta(?:rt)?[ \t]+)[\w./\\-]+\.(?:sql|pks|pkb|pck|pls|plb|prc|fnc|trg|tps|tpb)[ \t]*\r?$/im;
+
+/**
+ * True when `.sql` content holds at least one Oracle PL/SQL compilation unit,
+ * or is a SQL*Plus script that includes other scripts.
+ */
+export function looksLikeOraclePlSql(content: string): boolean {
+  if (SQLPLUS_INCLUDE.test(content) && !TSQL_MARKERS.test(content)) return true;
+  if (!ORACLE_UNIT_HEADER.test(content)) return false;
+  if (POSTGRES_DOLLAR_BODY.test(content) || TSQL_MARKERS.test(content)) return false;
+  return ORACLE_MARKERS.test(content);
+}
+
+/** File-level predicate used by the PL/SQL phase. */
+export function isPlSqlSource(filePath: string, content: string): boolean {
+  if (hasPlSqlExtension(filePath)) return true;
+  return isSqlFile(filePath) && looksLikeOraclePlSql(content);
+}
diff --git a/gitnexus/src/core/ingestion/plsql/generated/PlSqlLexer.ts b/gitnexus/src/core/ingestion/plsql/generated/PlSqlLexer.ts
new file mode 100644
index 000000000..61635f0c5
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/generated/PlSqlLexer.ts
@@ -0,0 +1,17382 @@
+
+import * as antlr from "antlr4ng";
+import { Token } from "antlr4ng";
+
+import { PlSqlLexerBase } from "./PlSqlLexerBase.js"
+
+export class PlSqlLexer extends PlSqlLexerBase {
+    public static readonly ABORT = 1;
+    public static readonly ABS = 2;
+    public static readonly ABSENT = 3;
+    public static readonly ACCESS = 4;
+    public static readonly ACCESSED = 5;
+    public static readonly ACCESSIBLE = 6;
+    public static readonly ACCOUNT = 7;
+    public static readonly ACL = 8;
+    public static readonly ACOS = 9;
+    public static readonly ACROSS = 10;
+    public static readonly ACTION = 11;
+    public static readonly ACTIONS = 12;
+    public static readonly ACTIVATE = 13;
+    public static readonly ACTIVE = 14;
+    public static readonly ACTIVE_COMPONENT = 15;
+    public static readonly ACTIVE_DATA = 16;
+    public static readonly ACTIVE_FUNCTION = 17;
+    public static readonly ACTIVE_TAG = 18;
+    public static readonly ACTIVITY = 19;
+    public static readonly ADAPTIVE_PLAN = 20;
+    public static readonly ADD = 21;
+    public static readonly ADD_COLUMN = 22;
+    public static readonly ADD_GROUP = 23;
+    public static readonly ADD_MONTHS = 24;
+    public static readonly ADJ_DATE = 25;
+    public static readonly ADMIN = 26;
+    public static readonly ADMINISTER = 27;
+    public static readonly ADMINISTRATOR = 28;
+    public static readonly ADVANCED = 29;
+    public static readonly ADVISE = 30;
+    public static readonly ADVISOR = 31;
+    public static readonly AFD_DISKSTRING = 32;
+    public static readonly AFTER = 33;
+    public static readonly AGENT = 34;
+    public static readonly AGGREGATE = 35;
+    public static readonly A_LETTER = 36;
+    public static readonly ALIAS = 37;
+    public static readonly ALL = 38;
+    public static readonly ALLOCATE = 39;
+    public static readonly ALLOW = 40;
+    public static readonly ALL_ROWS = 41;
+    public static readonly ALTER = 42;
+    public static readonly ALTERNATE = 43;
+    public static readonly ALWAYS = 44;
+    public static readonly ANALYTIC = 45;
+    public static readonly ANALYZE = 46;
+    public static readonly ANCESTOR = 47;
+    public static readonly ANCILLARY = 48;
+    public static readonly AND = 49;
+    public static readonly AND_EQUAL = 50;
+    public static readonly ANNOTATIONS = 51;
+    public static readonly ANOMALY = 52;
+    public static readonly ANSI_REARCH = 53;
+    public static readonly ANTIJOIN = 54;
+    public static readonly ANY = 55;
+    public static readonly ANYSCHEMA = 56;
+    public static readonly APPEND = 57;
+    public static readonly APPENDCHILDXML = 58;
+    public static readonly APPEND_VALUES = 59;
+    public static readonly APPLICATION = 60;
+    public static readonly APPLY = 61;
+    public static readonly APPROX_COUNT_DISTINCT = 62;
+    public static readonly ARCHIVAL = 63;
+    public static readonly ARCHIVE = 64;
+    public static readonly ARCHIVED = 65;
+    public static readonly ARCHIVELOG = 66;
+    public static readonly ARE = 67;
+    public static readonly ARRAY = 68;
+    public static readonly AS = 69;
+    public static readonly ASC = 70;
+    public static readonly ASCII = 71;
+    public static readonly ASCIISTR = 72;
+    public static readonly ASIN = 73;
+    public static readonly ASIS = 74;
+    public static readonly ASSEMBLY = 75;
+    public static readonly ASSIGN = 76;
+    public static readonly ASSOCIATE = 77;
+    public static readonly ASYNC = 78;
+    public static readonly ASYNCHRONOUS = 79;
+    public static readonly ATAN2 = 80;
+    public static readonly ATAN = 81;
+    public static readonly AT = 82;
+    public static readonly ATTRIBUTE = 83;
+    public static readonly ATTRIBUTES = 84;
+    public static readonly AUDIT = 85;
+    public static readonly AUTHENTICATED = 86;
+    public static readonly AUTHENTICATION = 87;
+    public static readonly AUTHID = 88;
+    public static readonly AUTHORIZATION = 89;
+    public static readonly AUTOALLOCATE = 90;
+    public static readonly AUTO = 91;
+    public static readonly AUTOBACKUP = 92;
+    public static readonly AUTOEXTEND = 93;
+    public static readonly AUTO_LOGIN = 94;
+    public static readonly AUTOMATIC = 95;
+    public static readonly AUTONOMOUS_TRANSACTION = 96;
+    public static readonly AUTO_REOPTIMIZE = 97;
+    public static readonly AVAILABILITY = 98;
+    public static readonly AVRO = 99;
+    public static readonly BACKGROUND = 100;
+    public static readonly BACKINGFILE = 101;
+    public static readonly BACKUP = 102;
+    public static readonly BACKUPS = 103;
+    public static readonly BACKUPSET = 104;
+    public static readonly BADFILE = 105;
+    public static readonly BASIC = 106;
+    public static readonly BASICFILE = 107;
+    public static readonly BATCH = 108;
+    public static readonly BATCHSIZE = 109;
+    public static readonly BATCH_TABLE_ACCESS_BY_ROWID = 110;
+    public static readonly BECOME = 111;
+    public static readonly BEFORE = 112;
+    public static readonly BEGIN = 113;
+    public static readonly BEGINNING = 114;
+    public static readonly BEGIN_OUTLINE_DATA = 115;
+    public static readonly BEHALF = 116;
+    public static readonly BEQUEATH = 117;
+    public static readonly BETWEEN = 118;
+    public static readonly BFILE = 119;
+    public static readonly BFILENAME = 120;
+    public static readonly BIG = 121;
+    public static readonly BIGFILE = 122;
+    public static readonly BIGINT = 123;
+    public static readonly BINARY = 124;
+    public static readonly BINARY_DOUBLE = 125;
+    public static readonly BINARY_DOUBLE_INFINITY = 126;
+    public static readonly BINARY_DOUBLE_NAN = 127;
+    public static readonly BINARY_FLOAT = 128;
+    public static readonly BINARY_FLOAT_INFINITY = 129;
+    public static readonly BINARY_FLOAT_NAN = 130;
+    public static readonly BINARY_INTEGER = 131;
+    public static readonly BIND_AWARE = 132;
+    public static readonly BINDING = 133;
+    public static readonly BIN_TO_NUM = 134;
+    public static readonly BITAND = 135;
+    public static readonly BITMAP_AND = 136;
+    public static readonly BITMAP = 137;
+    public static readonly BITMAPS = 138;
+    public static readonly BITMAP_TREE = 139;
+    public static readonly BITS = 140;
+    public static readonly BLANKS = 141;
+    public static readonly BLOB = 142;
+    public static readonly BLOCK = 143;
+    public static readonly BLOCK_RANGE = 144;
+    public static readonly BLOCKS = 145;
+    public static readonly BLOCKSIZE = 146;
+    public static readonly BODY = 147;
+    public static readonly BOOLEAN = 148;
+    public static readonly BOTH = 149;
+    public static readonly BOUND = 150;
+    public static readonly BRANCH = 151;
+    public static readonly BREADTH = 152;
+    public static readonly BROADCAST = 153;
+    public static readonly BSON = 154;
+    public static readonly BUFFER = 155;
+    public static readonly BUFFER_CACHE = 156;
+    public static readonly BUFFER_POOL = 157;
+    public static readonly BUILD = 158;
+    public static readonly BULK = 159;
+    public static readonly BY = 160;
+    public static readonly BYPASS_RECURSIVE_CHECK = 161;
+    public static readonly BYPASS_UJVC = 162;
+    public static readonly BYTE = 163;
+    public static readonly BYTES = 164;
+    public static readonly BYTEORDERMARK = 165;
+    public static readonly CACHE = 166;
+    public static readonly CACHE_CB = 167;
+    public static readonly CACHE_INSTANCES = 168;
+    public static readonly CACHE_TEMP_TABLE = 169;
+    public static readonly CACHING = 170;
+    public static readonly CALCULATED = 171;
+    public static readonly CALLBACK = 172;
+    public static readonly CALL = 173;
+    public static readonly CANCEL = 174;
+    public static readonly CANONICAL = 175;
+    public static readonly CAPACITY = 176;
+    public static readonly CAPTION = 177;
+    public static readonly CARDINALITY = 178;
+    public static readonly CASCADE = 179;
+    public static readonly CASE = 180;
+    public static readonly CAST = 181;
+    public static readonly CASESENSITIVE = 182;
+    public static readonly CATEGORY = 183;
+    public static readonly CDBDEFAULT = 184;
+    public static readonly CEIL = 185;
+    public static readonly CELL_FLASH_CACHE = 186;
+    public static readonly CERTIFICATE = 187;
+    public static readonly CFILE = 188;
+    public static readonly CHAINED = 189;
+    public static readonly CHANGE = 190;
+    public static readonly CHANGETRACKING = 191;
+    public static readonly CHANGE_DUPKEY_ERROR_INDEX = 192;
+    public static readonly CHARACTER = 193;
+    public static readonly CHARACTERS = 194;
+    public static readonly CHARACTERSET = 195;
+    public static readonly CHAR = 196;
+    public static readonly CHAR_CS = 197;
+    public static readonly CHARTOROWID = 198;
+    public static readonly CHECK_ACL_REWRITE = 199;
+    public static readonly CHECK = 200;
+    public static readonly CHECKPOINT = 201;
+    public static readonly CHILD = 202;
+    public static readonly CHOOSE = 203;
+    public static readonly CHR = 204;
+    public static readonly CHUNK = 205;
+    public static readonly CLASS = 206;
+    public static readonly CLASSIFICATION = 207;
+    public static readonly CLASSIFIER = 208;
+    public static readonly CLAUSE = 209;
+    public static readonly CLEAN = 210;
+    public static readonly CLEANUP = 211;
+    public static readonly CLEAR = 212;
+    public static readonly C_LETTER = 213;
+    public static readonly CLIENT = 214;
+    public static readonly CLOB = 215;
+    public static readonly CLONE = 216;
+    public static readonly CLOSE_CACHED_OPEN_CURSORS = 217;
+    public static readonly CLOSE = 218;
+    public static readonly CLUSTER_BY_ROWID = 219;
+    public static readonly CLUSTER = 220;
+    public static readonly CLUSTER_DETAILS = 221;
+    public static readonly CLUSTER_DISTANCE = 222;
+    public static readonly CLUSTER_ID = 223;
+    public static readonly CLUSTERING = 224;
+    public static readonly CLUSTERING_FACTOR = 225;
+    public static readonly CLUSTER_PROBABILITY = 226;
+    public static readonly CLUSTER_SET = 227;
+    public static readonly COALESCE = 228;
+    public static readonly COALESCE_SQ = 229;
+    public static readonly COARSE = 230;
+    public static readonly CO_AUTH_IND = 231;
+    public static readonly COLD = 232;
+    public static readonly COLLECT = 233;
+    public static readonly COLLECTION = 234;
+    public static readonly COLUMNAR = 235;
+    public static readonly COLUMN_AUTH_INDICATOR = 236;
+    public static readonly COLUMN = 237;
+    public static readonly COLUMNS = 238;
+    public static readonly COLUMN_STATS = 239;
+    public static readonly COLUMN_VALUE = 240;
+    public static readonly COMMENT = 241;
+    public static readonly COMMIT = 242;
+    public static readonly COMMITTED = 243;
+    public static readonly COMMON = 244;
+    public static readonly COMMON_DATA = 245;
+    public static readonly COMPACT = 246;
+    public static readonly COMPATIBLE = 247;
+    public static readonly COMPATIBILITY = 248;
+    public static readonly COMPILE = 249;
+    public static readonly COMPLETE = 250;
+    public static readonly COMPLIANCE = 251;
+    public static readonly COMPONENT = 252;
+    public static readonly COMPONENTS = 253;
+    public static readonly COMPOSE = 254;
+    public static readonly COMPOSITE = 255;
+    public static readonly COMPOSITE_LIMIT = 256;
+    public static readonly COMPOUND = 257;
+    public static readonly COMPRESS = 258;
+    public static readonly COMPRESSION = 259;
+    public static readonly COMPUTE = 260;
+    public static readonly COMPUTATION = 261;
+    public static readonly CONCAT = 262;
+    public static readonly CONCURRENT = 263;
+    public static readonly CON_DBID_TO_ID = 264;
+    public static readonly CONDITIONAL = 265;
+    public static readonly CONDITION = 266;
+    public static readonly CONFIRM = 267;
+    public static readonly CONFORMING = 268;
+    public static readonly CON_GUID_TO_ID = 269;
+    public static readonly CON_ID = 270;
+    public static readonly CON_NAME_TO_ID = 271;
+    public static readonly CONNECT_BY_CB_WHR_ONLY = 272;
+    public static readonly CONNECT_BY_COMBINE_SW = 273;
+    public static readonly CONNECT_BY_COST_BASED = 274;
+    public static readonly CONNECT_BY_ELIM_DUPS = 275;
+    public static readonly CONNECT_BY_FILTERING = 276;
+    public static readonly CONNECT_BY_ISCYCLE = 277;
+    public static readonly CONNECT_BY_ISLEAF = 278;
+    public static readonly CONNECT_BY_ROOT = 279;
+    public static readonly CONNECT = 280;
+    public static readonly CONNECT_TIME = 281;
+    public static readonly CONSIDER = 282;
+    public static readonly CONSISTENT = 283;
+    public static readonly CONSTANT = 284;
+    public static readonly CONST = 285;
+    public static readonly CONSTRAINT = 286;
+    public static readonly CONSTRAINTS = 287;
+    public static readonly CONSTRUCTOR = 288;
+    public static readonly CONTAINER = 289;
+    public static readonly CONTAINERS = 290;
+    public static readonly CONTAINERS_DEFAULT = 291;
+    public static readonly CONTAINER_DATA = 292;
+    public static readonly CONTAINER_MAP = 293;
+    public static readonly CONTENT = 294;
+    public static readonly CONTENTS = 295;
+    public static readonly CONTEXT = 296;
+    public static readonly CONTINUE = 297;
+    public static readonly CONTROLFILE = 298;
+    public static readonly CON_UID_TO_ID = 299;
+    public static readonly CONVERT = 300;
+    public static readonly CONVERSION = 301;
+    public static readonly COOKIE = 302;
+    public static readonly COPY = 303;
+    public static readonly CORR_K = 304;
+    public static readonly CORR_S = 305;
+    public static readonly CORRUPTION = 306;
+    public static readonly CORRUPT_XID_ALL = 307;
+    public static readonly CORRUPT_XID = 308;
+    public static readonly COS = 309;
+    public static readonly COSH = 310;
+    public static readonly COST = 311;
+    public static readonly COST_XML_QUERY_REWRITE = 312;
+    public static readonly COUNT = 313;
+    public static readonly COUNTED = 314;
+    public static readonly COVAR_POP = 315;
+    public static readonly COVAR_SAMP = 316;
+    public static readonly CPU_COSTING = 317;
+    public static readonly CPU_PER_CALL = 318;
+    public static readonly CPU_PER_SESSION = 319;
+    public static readonly CRASH = 320;
+    public static readonly CREATE = 321;
+    public static readonly CREATE_FILE_DEST = 322;
+    public static readonly CREATE_STORED_OUTLINES = 323;
+    public static readonly CREATION = 324;
+    public static readonly CREDENTIAL = 325;
+    public static readonly CRITICAL = 326;
+    public static readonly CROSS = 327;
+    public static readonly CROSSEDITION = 328;
+    public static readonly CSCONVERT = 329;
+    public static readonly CSV = 330;
+    public static readonly CUBE_AJ = 331;
+    public static readonly CUBE = 332;
+    public static readonly CUBE_GB = 333;
+    public static readonly CUBE_SJ = 334;
+    public static readonly CUME_DISTM = 335;
+    public static readonly CURRENT = 336;
+    public static readonly CURRENT_DATE = 337;
+    public static readonly CURRENT_SCHEMA = 338;
+    public static readonly CURRENT_TIME = 339;
+    public static readonly CURRENT_TIMESTAMP = 340;
+    public static readonly CURRENT_USER = 341;
+    public static readonly CURRENTV = 342;
+    public static readonly CURSOR = 343;
+    public static readonly CURSOR_SHARING_EXACT = 344;
+    public static readonly CURSOR_SPECIFIC_SEGMENT = 345;
+    public static readonly CUSTOMDATUM = 346;
+    public static readonly CV = 347;
+    public static readonly CYCLE = 348;
+    public static readonly DANGLING = 349;
+    public static readonly DATABASE = 350;
+    public static readonly DATA = 351;
+    public static readonly DATAFILE = 352;
+    public static readonly DATAFILES = 353;
+    public static readonly DATAGUARDCONFIG = 354;
+    public static readonly DATAMOVEMENT = 355;
+    public static readonly DATAOBJNO = 356;
+    public static readonly DATAOBJ_TO_MAT_PARTITION = 357;
+    public static readonly DATAOBJ_TO_PARTITION = 358;
+    public static readonly DATAPUMP = 359;
+    public static readonly DATA_SECURITY_REWRITE_LIMIT = 360;
+    public static readonly DATE = 361;
+    public static readonly DATE_CACHE = 362;
+    public static readonly DATE_FORMAT = 363;
+    public static readonly DATE_MODE = 364;
+    public static readonly DAY = 365;
+    public static readonly DAYS = 366;
+    public static readonly DAY_TO_SECOND = 367;
+    public static readonly DBA = 368;
+    public static readonly DBA_RECYCLEBIN = 369;
+    public static readonly DBLINK = 370;
+    public static readonly DBMS_STATS = 371;
+    public static readonly DB_ROLE_CHANGE = 372;
+    public static readonly DBTIMEZONE = 373;
+    public static readonly DB_UNIQUE_NAME = 374;
+    public static readonly DB_VERSION = 375;
+    public static readonly DDL = 376;
+    public static readonly DEALLOCATE = 377;
+    public static readonly DEBUG = 378;
+    public static readonly DEBUGGER = 379;
+    public static readonly DEC = 380;
+    public static readonly DECIMAL = 381;
+    public static readonly DECLARE = 382;
+    public static readonly DECOMPOSE = 383;
+    public static readonly DECORRELATE = 384;
+    public static readonly DECR = 385;
+    public static readonly DECREMENT = 386;
+    public static readonly DECRYPT = 387;
+    public static readonly DEDUPLICATE = 388;
+    public static readonly DEFAULT = 389;
+    public static readonly DEFAULTIF = 390;
+    public static readonly DEFAULTS = 391;
+    public static readonly DEFAULT_COLLATION = 392;
+    public static readonly DEFAULT_CREDENTIAL = 393;
+    public static readonly DEFERRABLE = 394;
+    public static readonly DEFERRED = 395;
+    public static readonly DEFINED = 396;
+    public static readonly DEFINE = 397;
+    public static readonly DEFINER = 398;
+    public static readonly DEGREE = 399;
+    public static readonly DELAY = 400;
+    public static readonly DELEGATE = 401;
+    public static readonly DELETE_ALL = 402;
+    public static readonly DELETE = 403;
+    public static readonly DELETEXML = 404;
+    public static readonly DELIMITED = 405;
+    public static readonly DEMAND = 406;
+    public static readonly DENSE_RANKM = 407;
+    public static readonly DEPENDENT = 408;
+    public static readonly DEPRECATE = 409;
+    public static readonly DEPTH = 410;
+    public static readonly DEQUEUE = 411;
+    public static readonly DEREF = 412;
+    public static readonly DEREF_NO_REWRITE = 413;
+    public static readonly DESC = 414;
+    public static readonly DESCRIPTION = 415;
+    public static readonly DESTROY = 416;
+    public static readonly DETACHED = 417;
+    public static readonly DETECTED = 418;
+    public static readonly DETERMINES = 419;
+    public static readonly DETERMINISTIC = 420;
+    public static readonly DICTIONARY = 421;
+    public static readonly DIMENSION = 422;
+    public static readonly DIMENSIONS = 423;
+    public static readonly DIRECTIO = 424;
+    public static readonly DIRECT_LOAD = 425;
+    public static readonly DIRECTORY = 426;
+    public static readonly DIRECT_PATH = 427;
+    public static readonly DISABLE_ALL = 428;
+    public static readonly DISABLE = 429;
+    public static readonly DISABLED = 430;
+    public static readonly DISABLE_DIRECTORY_LINK_CHECK = 431;
+    public static readonly DISABLE_PARALLEL_DML = 432;
+    public static readonly DISABLE_PRESET = 433;
+    public static readonly DISABLE_RPKE = 434;
+    public static readonly DISALLOW = 435;
+    public static readonly DISASSOCIATE = 436;
+    public static readonly DISCARD = 437;
+    public static readonly DISCARDFILE = 438;
+    public static readonly DISCONNECT = 439;
+    public static readonly DISK = 440;
+    public static readonly DISKGROUP = 441;
+    public static readonly DISKGROUP_PLUS = 442;
+    public static readonly DISKS = 443;
+    public static readonly DISMOUNT = 444;
+    public static readonly DISTINCT = 445;
+    public static readonly DISTINGUISHED = 446;
+    public static readonly DISTRIBUTED = 447;
+    public static readonly DISTRIBUTE = 448;
+    public static readonly DML = 449;
+    public static readonly DML_UPDATE = 450;
+    public static readonly DNFS_DISABLE = 451;
+    public static readonly DNFS_ENABLE = 452;
+    public static readonly DNFS_READBUFFERS = 453;
+    public static readonly DOCFIDELITY = 454;
+    public static readonly DOCUMENT = 455;
+    public static readonly DOLLAR_ELSE = 456;
+    public static readonly DOLLAR_ELSIF = 457;
+    public static readonly DOLLAR_END = 458;
+    public static readonly DOLLAR_ERROR = 459;
+    public static readonly DOLLAR_IF = 460;
+    public static readonly DOLLAR_THEN = 461;
+    public static readonly DOMAIN_INDEX_FILTER = 462;
+    public static readonly DOMAIN_INDEX_NO_SORT = 463;
+    public static readonly DOMAIN_INDEX_SORT = 464;
+    public static readonly DOUBLE = 465;
+    public static readonly DOWNGRADE = 466;
+    public static readonly DRIVING_SITE = 467;
+    public static readonly DROP_COLUMN = 468;
+    public static readonly DROP = 469;
+    public static readonly DROP_GROUP = 470;
+    public static readonly DSINTERVAL_UNCONSTRAINED = 471;
+    public static readonly DST_UPGRADE_INSERT_CONV = 472;
+    public static readonly DUMP = 473;
+    public static readonly DUMPSET = 474;
+    public static readonly DUPLICATE = 475;
+    public static readonly DV = 476;
+    public static readonly DYNAMIC = 477;
+    public static readonly DYNAMIC_SAMPLING = 478;
+    public static readonly DYNAMIC_SAMPLING_EST_CDN = 479;
+    public static readonly E_LETTER = 480;
+    public static readonly EACH = 481;
+    public static readonly EDITIONABLE = 482;
+    public static readonly EDITION = 483;
+    public static readonly EDITIONING = 484;
+    public static readonly EDITIONS = 485;
+    public static readonly ELEMENT = 486;
+    public static readonly ELIM_GROUPBY = 487;
+    public static readonly ELIMINATE_JOIN = 488;
+    public static readonly ELIMINATE_OBY = 489;
+    public static readonly ELIMINATE_OUTER_JOIN = 490;
+    public static readonly ELSE = 491;
+    public static readonly ELSIF = 492;
+    public static readonly EM = 493;
+    public static readonly EMBEDDED = 494;
+    public static readonly EMPTY_BLOB = 495;
+    public static readonly EMPTY_CLOB = 496;
+    public static readonly EMPTY_ = 497;
+    public static readonly ENABLE_ALL = 498;
+    public static readonly ENABLE = 499;
+    public static readonly ENABLED = 500;
+    public static readonly ENABLE_PARALLEL_DML = 501;
+    public static readonly ENABLE_PRESET = 502;
+    public static readonly ENCLOSED = 503;
+    public static readonly ENCODING = 504;
+    public static readonly ENCRYPT = 505;
+    public static readonly ENCRYPTION = 506;
+    public static readonly ENCRYPTPASSWORDISNULL = 507;
+    public static readonly END = 508;
+    public static readonly END_OUTLINE_DATA = 509;
+    public static readonly ENDIAN = 510;
+    public static readonly ENFORCED = 511;
+    public static readonly ENFORCE = 512;
+    public static readonly ENQUEUE = 513;
+    public static readonly ENTERPRISE = 514;
+    public static readonly ENTITYESCAPING = 515;
+    public static readonly ENTRY = 516;
+    public static readonly EQUIPART = 517;
+    public static readonly ERR = 518;
+    public static readonly ERROR_ARGUMENT = 519;
+    public static readonly ERROR = 520;
+    public static readonly ERROR_ON_OVERLAP_TIME = 521;
+    public static readonly ERRORS = 522;
+    public static readonly ERROR_INDEX = 523;
+    public static readonly ERROR_CODE = 524;
+    public static readonly ESCAPE = 525;
+    public static readonly ESCAPED = 526;
+    public static readonly ESTIMATE = 527;
+    public static readonly EVAL = 528;
+    public static readonly EVALNAME = 529;
+    public static readonly EVALUATE = 530;
+    public static readonly EVALUATION = 531;
+    public static readonly EVENTS = 532;
+    public static readonly EVERY = 533;
+    public static readonly EXCEPT = 534;
+    public static readonly EXCEPTION = 535;
+    public static readonly EXCEPTION_INIT = 536;
+    public static readonly EXCEPTIONS = 537;
+    public static readonly EXCHANGE = 538;
+    public static readonly EXCLUDE = 539;
+    public static readonly EXCLUDING = 540;
+    public static readonly EXCLUSIVE = 541;
+    public static readonly EXEC = 542;
+    public static readonly EXECUTE = 543;
+    public static readonly EXEMPT = 544;
+    public static readonly EXISTING = 545;
+    public static readonly EXISTS = 546;
+    public static readonly EXISTSNODE = 547;
+    public static readonly EXIT = 548;
+    public static readonly EXPAND_GSET_TO_UNION = 549;
+    public static readonly EXPAND_TABLE = 550;
+    public static readonly EXP = 551;
+    public static readonly EXPIRE = 552;
+    public static readonly EXPLAIN = 553;
+    public static readonly EXPLOSION = 554;
+    public static readonly EXPORT = 555;
+    public static readonly EXPR_CORR_CHECK = 556;
+    public static readonly EXPRESS = 557;
+    public static readonly EXTENDS = 558;
+    public static readonly EXTENT = 559;
+    public static readonly EXTENTS = 560;
+    public static readonly EXTERNAL = 561;
+    public static readonly EXTERNALLY = 562;
+    public static readonly EXTRACTCLOBXML = 563;
+    public static readonly EXTRACT = 564;
+    public static readonly EXTRACTVALUE = 565;
+    public static readonly EXTRA = 566;
+    public static readonly FACILITY = 567;
+    public static readonly FACT = 568;
+    public static readonly FACTOR = 569;
+    public static readonly FACTORIZE_JOIN = 570;
+    public static readonly FAILED = 571;
+    public static readonly FAILED_LOGIN_ATTEMPTS = 572;
+    public static readonly FAILGROUP = 573;
+    public static readonly FAILOVER = 574;
+    public static readonly FAILURE = 575;
+    public static readonly FALSE = 576;
+    public static readonly FAMILY = 577;
+    public static readonly FAR = 578;
+    public static readonly FAST = 579;
+    public static readonly FASTSTART = 580;
+    public static readonly FBTSCAN = 581;
+    public static readonly FEATURE = 582;
+    public static readonly FEATURE_DETAILS = 583;
+    public static readonly FEATURE_ID = 584;
+    public static readonly FEATURE_SET = 585;
+    public static readonly FEATURE_VALUE = 586;
+    public static readonly FETCH = 587;
+    public static readonly FIELD = 588;
+    public static readonly FIELDS = 589;
+    public static readonly FILE = 590;
+    public static readonly FILE_NAME_CONVERT = 591;
+    public static readonly FILEGROUP = 592;
+    public static readonly FILESTORE = 593;
+    public static readonly FILESYSTEM_LIKE_LOGGING = 594;
+    public static readonly FILTER = 595;
+    public static readonly FINAL = 596;
+    public static readonly FINE = 597;
+    public static readonly FINISH = 598;
+    public static readonly FIRST = 599;
+    public static readonly FIRSTM = 600;
+    public static readonly FIRST_ROWS = 601;
+    public static readonly FIRST_VALUE = 602;
+    public static readonly FIXED = 603;
+    public static readonly FIXED_VIEW_DATA = 604;
+    public static readonly FLAGGER = 605;
+    public static readonly FLASHBACK = 606;
+    public static readonly FLASH_CACHE = 607;
+    public static readonly FLOAT = 608;
+    public static readonly FLOB = 609;
+    public static readonly FLEX = 610;
+    public static readonly FLOOR = 611;
+    public static readonly FLUSH = 612;
+    public static readonly FOLDER = 613;
+    public static readonly FOLLOWING = 614;
+    public static readonly FOLLOWS = 615;
+    public static readonly FORALL = 616;
+    public static readonly FORCE = 617;
+    public static readonly FORCE_XML_QUERY_REWRITE = 618;
+    public static readonly FOREIGN = 619;
+    public static readonly FOREVER = 620;
+    public static readonly FOR = 621;
+    public static readonly FORMAT = 622;
+    public static readonly FORWARD = 623;
+    public static readonly FRAGMENT_NUMBER = 624;
+    public static readonly FREELIST = 625;
+    public static readonly FREELISTS = 626;
+    public static readonly FREEPOOLS = 627;
+    public static readonly FRESH = 628;
+    public static readonly FROM = 629;
+    public static readonly FROM_TZ = 630;
+    public static readonly FULL = 631;
+    public static readonly FULL_OUTER_JOIN_TO_OUTER = 632;
+    public static readonly FUNCTION = 633;
+    public static readonly FUNCTIONS = 634;
+    public static readonly FTP = 635;
+    public static readonly G_LETTER = 636;
+    public static readonly GATHER_OPTIMIZER_STATISTICS = 637;
+    public static readonly GATHER_PLAN_STATISTICS = 638;
+    public static readonly GBY_CONC_ROLLUP = 639;
+    public static readonly GBY_PUSHDOWN = 640;
+    public static readonly GENERATED = 641;
+    public static readonly GET = 642;
+    public static readonly GLOBAL = 643;
+    public static readonly GLOBALLY = 644;
+    public static readonly GLOBAL_NAME = 645;
+    public static readonly GLOBAL_TOPIC_ENABLED = 646;
+    public static readonly GOTO = 647;
+    public static readonly GRANT = 648;
+    public static readonly GROUP_BY = 649;
+    public static readonly GROUP = 650;
+    public static readonly GROUP_ID = 651;
+    public static readonly GROUPING = 652;
+    public static readonly GROUPING_ID = 653;
+    public static readonly GROUPS = 654;
+    public static readonly GUARANTEED = 655;
+    public static readonly GUARANTEE = 656;
+    public static readonly GUARD = 657;
+    public static readonly HADOOP_TRAILERS = 658;
+    public static readonly HALF_YEARS = 659;
+    public static readonly HASH_AJ = 660;
+    public static readonly HASH = 661;
+    public static readonly HASHKEYS = 662;
+    public static readonly HASH_SJ = 663;
+    public static readonly HAVING = 664;
+    public static readonly HEADER = 665;
+    public static readonly HEAP = 666;
+    public static readonly HELP = 667;
+    public static readonly HEXTORAW = 668;
+    public static readonly HEXTOREF = 669;
+    public static readonly HIDDEN_KEYWORD = 670;
+    public static readonly HIDE = 671;
+    public static readonly HIER_ORDER = 672;
+    public static readonly HIERARCHICAL = 673;
+    public static readonly HIERARCHIES = 674;
+    public static readonly HIERARCHY = 675;
+    public static readonly HIGH = 676;
+    public static readonly HINTSET_BEGIN = 677;
+    public static readonly HINTSET_END = 678;
+    public static readonly HOT = 679;
+    public static readonly HOUR = 680;
+    public static readonly HOURS = 681;
+    public static readonly HTTP = 682;
+    public static readonly HWM_BROKERED = 683;
+    public static readonly HYBRID = 684;
+    public static readonly H_LETTER = 685;
+    public static readonly IDENTIFIED = 686;
+    public static readonly IDENTIFIER = 687;
+    public static readonly IDENTITY = 688;
+    public static readonly IDGENERATORS = 689;
+    public static readonly ID = 690;
+    public static readonly IDLE_TIME = 691;
+    public static readonly IF = 692;
+    public static readonly IGNORE = 693;
+    public static readonly IGNORE_CHARS_AFTER_EOR = 694;
+    public static readonly IGNORE_OPTIM_EMBEDDED_HINTS = 695;
+    public static readonly IGNORE_ROW_ON_DUPKEY_INDEX = 696;
+    public static readonly IGNORE_WHERE_CLAUSE = 697;
+    public static readonly ILM = 698;
+    public static readonly IMMEDIATE = 699;
+    public static readonly IMPACT = 700;
+    public static readonly IMPORT = 701;
+    public static readonly INACTIVE = 702;
+    public static readonly INACTIVE_ACCOUNT_TIME = 703;
+    public static readonly INCLUDE = 704;
+    public static readonly INCLUDE_VERSION = 705;
+    public static readonly INCLUDING = 706;
+    public static readonly INCREMENTAL = 707;
+    public static readonly INCREMENT = 708;
+    public static readonly INCR = 709;
+    public static readonly INDENT = 710;
+    public static readonly INDEX_ASC = 711;
+    public static readonly INDEX_COMBINE = 712;
+    public static readonly INDEX_DESC = 713;
+    public static readonly INDEXED = 714;
+    public static readonly INDEXES = 715;
+    public static readonly INDEX_FFS = 716;
+    public static readonly INDEX_FILTER = 717;
+    public static readonly INDEX = 718;
+    public static readonly INDEXING = 719;
+    public static readonly INDEX_JOIN = 720;
+    public static readonly INDEX_ROWS = 721;
+    public static readonly INDEX_RRS = 722;
+    public static readonly INDEX_RS_ASC = 723;
+    public static readonly INDEX_RS_DESC = 724;
+    public static readonly INDEX_RS = 725;
+    public static readonly INDEX_SCAN = 726;
+    public static readonly INDEX_SKIP_SCAN = 727;
+    public static readonly INDEX_SS_ASC = 728;
+    public static readonly INDEX_SS_DESC = 729;
+    public static readonly INDEX_SS = 730;
+    public static readonly INDEX_STATS = 731;
+    public static readonly INDEXTYPE = 732;
+    public static readonly INDEXTYPES = 733;
+    public static readonly INDICATOR = 734;
+    public static readonly INDICES = 735;
+    public static readonly INFINITE = 736;
+    public static readonly INFORMATIONAL = 737;
+    public static readonly INHERIT = 738;
+    public static readonly IN = 739;
+    public static readonly INITCAP = 740;
+    public static readonly INITIAL = 741;
+    public static readonly INITIALIZED = 742;
+    public static readonly INITIALLY = 743;
+    public static readonly INITRANS = 744;
+    public static readonly INLINE = 745;
+    public static readonly INLINE_XMLTYPE_NT = 746;
+    public static readonly INMEMORY = 747;
+    public static readonly IN_MEMORY_METADATA = 748;
+    public static readonly INMEMORY_PRUNING = 749;
+    public static readonly INNER = 750;
+    public static readonly INOUT = 751;
+    public static readonly INPLACE = 752;
+    public static readonly INPUTFORMAT = 753;
+    public static readonly INSERTCHILDXMLAFTER = 754;
+    public static readonly INSERTCHILDXMLBEFORE = 755;
+    public static readonly INSERTCHILDXML = 756;
+    public static readonly INSERT = 757;
+    public static readonly INSERTXMLAFTER = 758;
+    public static readonly INSERTXMLBEFORE = 759;
+    public static readonly INSTANCE = 760;
+    public static readonly INSTANCES = 761;
+    public static readonly INSTANTIABLE = 762;
+    public static readonly INSTANTLY = 763;
+    public static readonly INSTEAD = 764;
+    public static readonly INSTR2 = 765;
+    public static readonly INSTR4 = 766;
+    public static readonly INSTRB = 767;
+    public static readonly INSTRC = 768;
+    public static readonly INSTR = 769;
+    public static readonly INTEGER = 770;
+    public static readonly INTERLEAVED = 771;
+    public static readonly INTERMEDIATE = 772;
+    public static readonly INTERNAL_CONVERT = 773;
+    public static readonly INTERNAL_USE = 774;
+    public static readonly INTERPRETED = 775;
+    public static readonly INTERSECT = 776;
+    public static readonly INTERVAL = 777;
+    public static readonly INT = 778;
+    public static readonly INTERNAL = 779;
+    public static readonly INTO = 780;
+    public static readonly INVALIDATE = 781;
+    public static readonly INVALIDATION = 782;
+    public static readonly INVISIBLE = 783;
+    public static readonly IN_XQUERY = 784;
+    public static readonly IO_OPTIONS = 785;
+    public static readonly IS = 786;
+    public static readonly IS_LEAF = 787;
+    public static readonly ISOLATION = 788;
+    public static readonly ISOLATION_LEVEL = 789;
+    public static readonly ITEMS = 790;
+    public static readonly ITERATE = 791;
+    public static readonly ITERATION_NUMBER = 792;
+    public static readonly JAVA = 793;
+    public static readonly JOB = 794;
+    public static readonly JOIN = 795;
+    public static readonly JSON_ARRAYAGG = 796;
+    public static readonly JSON_ARRAY = 797;
+    public static readonly JSON_EQUAL = 798;
+    public static readonly JSON_EXISTS2 = 799;
+    public static readonly JSON_EXISTS = 800;
+    public static readonly JSONGET = 801;
+    public static readonly JSON = 802;
+    public static readonly JSON_OBJECTAGG = 803;
+    public static readonly JSON_OBJECT = 804;
+    public static readonly JSONPARSE = 805;
+    public static readonly JSON_QUERY = 806;
+    public static readonly JSON_SERIALIZE = 807;
+    public static readonly JSON_TABLE = 808;
+    public static readonly JSON_TEXTCONTAINS2 = 809;
+    public static readonly JSON_TEXTCONTAINS = 810;
+    public static readonly JSON_TRANSFORM = 811;
+    public static readonly JSON_VALUE = 812;
+    public static readonly K_LETTER = 813;
+    public static readonly KEEP_DUPLICATES = 814;
+    public static readonly KEEP = 815;
+    public static readonly KERBEROS = 816;
+    public static readonly KEY = 817;
+    public static readonly KEY_LENGTH = 818;
+    public static readonly KEYSIZE = 819;
+    public static readonly KEYS = 820;
+    public static readonly KEYSTORE = 821;
+    public static readonly KILL = 822;
+    public static readonly LABEL = 823;
+    public static readonly LANGUAGE = 824;
+    public static readonly LAST_DAY = 825;
+    public static readonly LAST = 826;
+    public static readonly LAST_VALUE = 827;
+    public static readonly LATERAL = 828;
+    public static readonly LATEST = 829;
+    public static readonly LAX = 830;
+    public static readonly LAYER = 831;
+    public static readonly LDAP_REGISTRATION_ENABLED = 832;
+    public static readonly LDAP_REGISTRATION = 833;
+    public static readonly LDAP_REG_SYNC_INTERVAL = 834;
+    public static readonly LDRTRIM = 835;
+    public static readonly LEAF = 836;
+    public static readonly LEAD_CDB = 837;
+    public static readonly LEAD_CDB_URI = 838;
+    public static readonly LEADING = 839;
+    public static readonly LEFT = 840;
+    public static readonly LENGTH2 = 841;
+    public static readonly LENGTH4 = 842;
+    public static readonly LENGTHB = 843;
+    public static readonly LENGTHC = 844;
+    public static readonly LENGTH = 845;
+    public static readonly LESS = 846;
+    public static readonly LEVEL = 847;
+    public static readonly LEVEL_NAME = 848;
+    public static readonly LEVELS = 849;
+    public static readonly LIBRARY = 850;
+    public static readonly LIFECYCLE = 851;
+    public static readonly LIFE = 852;
+    public static readonly LIFETIME = 853;
+    public static readonly LIKE2 = 854;
+    public static readonly LIKE4 = 855;
+    public static readonly LIKEC = 856;
+    public static readonly LIKE_EXPAND = 857;
+    public static readonly LIKE = 858;
+    public static readonly LIMIT = 859;
+    public static readonly LINEAR = 860;
+    public static readonly LINES = 861;
+    public static readonly LINK = 862;
+    public static readonly LIST = 863;
+    public static readonly LITTLE = 864;
+    public static readonly LLS = 865;
+    public static readonly LN = 866;
+    public static readonly LNNVL = 867;
+    public static readonly LOAD = 868;
+    public static readonly LOB = 869;
+    public static readonly LOBFILE = 870;
+    public static readonly LOBNVL = 871;
+    public static readonly LOBS = 872;
+    public static readonly LOCAL_INDEXES = 873;
+    public static readonly LOCAL = 874;
+    public static readonly LOCALTIME = 875;
+    public static readonly LOCALTIMESTAMP = 876;
+    public static readonly LOCATION = 877;
+    public static readonly LOCATOR = 878;
+    public static readonly LOCKDOWN = 879;
+    public static readonly LOCKED = 880;
+    public static readonly LOCKING = 881;
+    public static readonly LOCK = 882;
+    public static readonly LOGFILE = 883;
+    public static readonly LOGFILES = 884;
+    public static readonly LOGGING = 885;
+    public static readonly LOGICAL = 886;
+    public static readonly LOGICAL_READS_PER_CALL = 887;
+    public static readonly LOGICAL_READS_PER_SESSION = 888;
+    public static readonly LOG = 889;
+    public static readonly LOGMINING = 890;
+    public static readonly LOGOFF = 891;
+    public static readonly LOGON = 892;
+    public static readonly LOG_READ_ONLY_VIOLATIONS = 893;
+    public static readonly LONG = 894;
+    public static readonly LOOP = 895;
+    public static readonly LOST = 896;
+    public static readonly LOWER = 897;
+    public static readonly LOW = 898;
+    public static readonly LPAD = 899;
+    public static readonly LRTRIM = 900;
+    public static readonly LTRIM = 901;
+    public static readonly M_LETTER = 902;
+    public static readonly MAIN = 903;
+    public static readonly MAKE_REF = 904;
+    public static readonly MANAGED = 905;
+    public static readonly MANAGE = 906;
+    public static readonly MANAGEMENT = 907;
+    public static readonly MANAGER = 908;
+    public static readonly MANDATORY = 909;
+    public static readonly MANUAL = 910;
+    public static readonly MAP = 911;
+    public static readonly MAPPING = 912;
+    public static readonly MASK = 913;
+    public static readonly MASTER = 914;
+    public static readonly MATCHED = 915;
+    public static readonly MATCHES = 916;
+    public static readonly MATCH = 917;
+    public static readonly MATCH_NUMBER = 918;
+    public static readonly MATCH_RECOGNIZE = 919;
+    public static readonly MATERIALIZED = 920;
+    public static readonly MATERIALIZE = 921;
+    public static readonly MAXARCHLOGS = 922;
+    public static readonly MAXDATAFILES = 923;
+    public static readonly MAXEXTENTS = 924;
+    public static readonly MAXIMIZE = 925;
+    public static readonly MAXINSTANCES = 926;
+    public static readonly MAXLOGFILES = 927;
+    public static readonly MAXLOGHISTORY = 928;
+    public static readonly MAXLOGMEMBERS = 929;
+    public static readonly MAX_SHARED_TEMP_SIZE = 930;
+    public static readonly MAXSIZE = 931;
+    public static readonly MAXTRANS = 932;
+    public static readonly MAXVALUE = 933;
+    public static readonly MEASURE = 934;
+    public static readonly MEASURES = 935;
+    public static readonly MEDIUM = 936;
+    public static readonly MEMBER = 937;
+    public static readonly MEMBER_CAPTION = 938;
+    public static readonly MEMBER_DESCRIPTION = 939;
+    public static readonly MEMBER_NAME = 940;
+    public static readonly MEMBER_UNIQUE_NAME = 941;
+    public static readonly MEMCOMPRESS = 942;
+    public static readonly MEMORY = 943;
+    public static readonly MERGEACTIONS = 944;
+    public static readonly MERGE_AJ = 945;
+    public static readonly MERGE_CONST_ON = 946;
+    public static readonly MERGE = 947;
+    public static readonly MERGE_SJ = 948;
+    public static readonly METADATA = 949;
+    public static readonly METHOD = 950;
+    public static readonly MIGRATE = 951;
+    public static readonly MIGRATION = 952;
+    public static readonly MINEXTENTS = 953;
+    public static readonly MINIMIZE = 954;
+    public static readonly MINIMUM = 955;
+    public static readonly MINING = 956;
+    public static readonly MINUS = 957;
+    public static readonly MINUS_NULL = 958;
+    public static readonly MINUTE = 959;
+    public static readonly MINUTES = 960;
+    public static readonly MINVALUE = 961;
+    public static readonly MIRRORCOLD = 962;
+    public static readonly MIRRORHOT = 963;
+    public static readonly MIRROR = 964;
+    public static readonly MISSING = 965;
+    public static readonly MISMATCH = 966;
+    public static readonly MLSLABEL = 967;
+    public static readonly MODEL_COMPILE_SUBQUERY = 968;
+    public static readonly MODEL_DONTVERIFY_UNIQUENESS = 969;
+    public static readonly MODEL_DYNAMIC_SUBQUERY = 970;
+    public static readonly MODEL_MIN_ANALYSIS = 971;
+    public static readonly MODEL = 972;
+    public static readonly MODEL_NB = 973;
+    public static readonly MODEL_NO_ANALYSIS = 974;
+    public static readonly MODEL_PBY = 975;
+    public static readonly MODEL_PUSH_REF = 976;
+    public static readonly MODEL_SV = 977;
+    public static readonly MODE = 978;
+    public static readonly MODIFICATION = 979;
+    public static readonly MODIFY_COLUMN_TYPE = 980;
+    public static readonly MODIFY = 981;
+    public static readonly MOD = 982;
+    public static readonly MODULE = 983;
+    public static readonly MONITORING = 984;
+    public static readonly MONITOR = 985;
+    public static readonly MONTH = 986;
+    public static readonly MONTHS_BETWEEN = 987;
+    public static readonly MONTHS = 988;
+    public static readonly MOUNT = 989;
+    public static readonly MOUNTPATH = 990;
+    public static readonly MOUNTPOINT = 991;
+    public static readonly MOVEMENT = 992;
+    public static readonly MOVE = 993;
+    public static readonly MULTIDIMENSIONAL = 994;
+    public static readonly MULTISET = 995;
+    public static readonly MV_MERGE = 996;
+    public static readonly NAMED = 997;
+    public static readonly NAME = 998;
+    public static readonly NAMESPACE = 999;
+    public static readonly NAN_ = 1000;
+    public static readonly NANVL = 1001;
+    public static readonly NATIONAL = 1002;
+    public static readonly NATIVE_FULL_OUTER_JOIN = 1003;
+    public static readonly NATIVE = 1004;
+    public static readonly NATURAL = 1005;
+    public static readonly NATURALN = 1006;
+    public static readonly NAV = 1007;
+    public static readonly NCHAR_CS = 1008;
+    public static readonly NCHAR = 1009;
+    public static readonly NCHR = 1010;
+    public static readonly NCLOB = 1011;
+    public static readonly NEEDED = 1012;
+    public static readonly NEG = 1013;
+    public static readonly NESTED = 1014;
+    public static readonly NESTED_TABLE_FAST_INSERT = 1015;
+    public static readonly NESTED_TABLE_GET_REFS = 1016;
+    public static readonly NESTED_TABLE_ID = 1017;
+    public static readonly NESTED_TABLE_SET_REFS = 1018;
+    public static readonly NESTED_TABLE_SET_SETID = 1019;
+    public static readonly NETWORK = 1020;
+    public static readonly NEVER = 1021;
+    public static readonly NEW = 1022;
+    public static readonly NEWLINE_ = 1023;
+    public static readonly NEW_TIME = 1024;
+    public static readonly NEXT_DAY = 1025;
+    public static readonly NEXT = 1026;
+    public static readonly NL_AJ = 1027;
+    public static readonly NLJ_BATCHING = 1028;
+    public static readonly NLJ_INDEX_FILTER = 1029;
+    public static readonly NLJ_INDEX_SCAN = 1030;
+    public static readonly NLJ_PREFETCH = 1031;
+    public static readonly NLS_CALENDAR = 1032;
+    public static readonly NLS_CHARACTERSET = 1033;
+    public static readonly NLS_CHARSET_DECL_LEN = 1034;
+    public static readonly NLS_CHARSET_ID = 1035;
+    public static readonly NLS_CHARSET_NAME = 1036;
+    public static readonly NLS_COMP = 1037;
+    public static readonly NLS_CURRENCY = 1038;
+    public static readonly NLS_DATE_FORMAT = 1039;
+    public static readonly NLS_DATE_LANGUAGE = 1040;
+    public static readonly NLS_INITCAP = 1041;
+    public static readonly NLS_ISO_CURRENCY = 1042;
+    public static readonly NL_SJ = 1043;
+    public static readonly NLS_LANG = 1044;
+    public static readonly NLS_LANGUAGE = 1045;
+    public static readonly NLS_LENGTH_SEMANTICS = 1046;
+    public static readonly NLS_LOWER = 1047;
+    public static readonly NLS_NCHAR_CONV_EXCP = 1048;
+    public static readonly NLS_NUMERIC_CHARACTERS = 1049;
+    public static readonly NLS_SORT = 1050;
+    public static readonly NLSSORT = 1051;
+    public static readonly NLS_SPECIAL_CHARS = 1052;
+    public static readonly NLS_TERRITORY = 1053;
+    public static readonly NLS_UPPER = 1054;
+    public static readonly NO_ACCESS = 1055;
+    public static readonly NO_ADAPTIVE_PLAN = 1056;
+    public static readonly NO_ANSI_REARCH = 1057;
+    public static readonly NOAPPEND = 1058;
+    public static readonly NOARCHIVELOG = 1059;
+    public static readonly NOAUDIT = 1060;
+    public static readonly NOBADFILE = 1061;
+    public static readonly NO_AUTO_REOPTIMIZE = 1062;
+    public static readonly NO_BASETABLE_MULTIMV_REWRITE = 1063;
+    public static readonly NO_BATCH_TABLE_ACCESS_BY_ROWID = 1064;
+    public static readonly NO_BIND_AWARE = 1065;
+    public static readonly NO_BUFFER = 1066;
+    public static readonly NOCACHE = 1067;
+    public static readonly NOCHECK = 1068;
+    public static readonly NO_CARTESIAN = 1069;
+    public static readonly NO_CHECK_ACL_REWRITE = 1070;
+    public static readonly NO_CLUSTER_BY_ROWID = 1071;
+    public static readonly NO_CLUSTERING = 1072;
+    public static readonly NO_COALESCE_SQ = 1073;
+    public static readonly NO_COMMON_DATA = 1074;
+    public static readonly NOCOMPRESS = 1075;
+    public static readonly NO_CONNECT_BY_CB_WHR_ONLY = 1076;
+    public static readonly NO_CONNECT_BY_COMBINE_SW = 1077;
+    public static readonly NO_CONNECT_BY_COST_BASED = 1078;
+    public static readonly NO_CONNECT_BY_ELIM_DUPS = 1079;
+    public static readonly NO_CONNECT_BY_FILTERING = 1080;
+    public static readonly NOCOPY = 1081;
+    public static readonly NO_COST_XML_QUERY_REWRITE = 1082;
+    public static readonly NO_CPU_COSTING = 1083;
+    public static readonly NOCPU_COSTING = 1084;
+    public static readonly NOCYCLE = 1085;
+    public static readonly NO_DATA_SECURITY_REWRITE = 1086;
+    public static readonly NO_DECORRELATE = 1087;
+    public static readonly NODELAY = 1088;
+    public static readonly NODIRECTIO = 1089;
+    public static readonly NODISCARDFILE = 1090;
+    public static readonly NO_DOMAIN_INDEX_FILTER = 1091;
+    public static readonly NO_DST_UPGRADE_INSERT_CONV = 1092;
+    public static readonly NO_ELIM_GROUPBY = 1093;
+    public static readonly NO_ELIMINATE_JOIN = 1094;
+    public static readonly NO_ELIMINATE_OBY = 1095;
+    public static readonly NO_ELIMINATE_OUTER_JOIN = 1096;
+    public static readonly NOENTITYESCAPING = 1097;
+    public static readonly NO_EXPAND_GSET_TO_UNION = 1098;
+    public static readonly NO_EXPAND = 1099;
+    public static readonly NO_EXPAND_TABLE = 1100;
+    public static readonly NOEXTEND = 1101;
+    public static readonly NO_FACT = 1102;
+    public static readonly NO_FACTORIZE_JOIN = 1103;
+    public static readonly NO_FILTERING = 1104;
+    public static readonly NOFORCE = 1105;
+    public static readonly NO_FULL_OUTER_JOIN_TO_OUTER = 1106;
+    public static readonly NO_GATHER_OPTIMIZER_STATISTICS = 1107;
+    public static readonly NO_GBY_PUSHDOWN = 1108;
+    public static readonly NOGUARANTEE = 1109;
+    public static readonly NO_INDEX_FFS = 1110;
+    public static readonly NO_INDEX = 1111;
+    public static readonly NO_INDEX_SS = 1112;
+    public static readonly NO_INMEMORY = 1113;
+    public static readonly NO_INMEMORY_PRUNING = 1114;
+    public static readonly NOKEEP = 1115;
+    public static readonly NO_LOAD = 1116;
+    public static readonly NOLOCAL = 1117;
+    public static readonly NOLOG = 1118;
+    public static readonly NOLOGFILE = 1119;
+    public static readonly NOLOGGING = 1120;
+    public static readonly NOMAPPING = 1121;
+    public static readonly NOMAXVALUE = 1122;
+    public static readonly NO_MERGE = 1123;
+    public static readonly NOMINIMIZE = 1124;
+    public static readonly NOMINVALUE = 1125;
+    public static readonly NO_MODEL_PUSH_REF = 1126;
+    public static readonly NO_MONITORING = 1127;
+    public static readonly NOMONITORING = 1128;
+    public static readonly NO_MONITOR = 1129;
+    public static readonly NO_MULTIMV_REWRITE = 1130;
+    public static readonly NO_NATIVE_FULL_OUTER_JOIN = 1131;
+    public static readonly NONBLOCKING = 1132;
+    public static readonly NONEDITIONABLE = 1133;
+    public static readonly NONE = 1134;
+    public static readonly NONPARTITIONED = 1135;
+    public static readonly NONULLIF = 1136;
+    public static readonly NO_NLJ_BATCHING = 1137;
+    public static readonly NO_NLJ_PREFETCH = 1138;
+    public static readonly NO = 1139;
+    public static readonly NONSCHEMA = 1140;
+    public static readonly NO_OBJECT_LINK = 1141;
+    public static readonly NOORDER = 1142;
+    public static readonly NO_ORDER_ROLLUPS = 1143;
+    public static readonly NO_OUTER_JOIN_TO_ANTI = 1144;
+    public static readonly NO_OUTER_JOIN_TO_INNER = 1145;
+    public static readonly NOOVERRIDE = 1146;
+    public static readonly NO_PARALLEL_INDEX = 1147;
+    public static readonly NOPARALLEL_INDEX = 1148;
+    public static readonly NO_PARALLEL = 1149;
+    public static readonly NOPARALLEL = 1150;
+    public static readonly NO_PARTIAL_COMMIT = 1151;
+    public static readonly NO_PARTIAL_JOIN = 1152;
+    public static readonly NO_PARTIAL_ROLLUP_PUSHDOWN = 1153;
+    public static readonly NOPARTITION = 1154;
+    public static readonly NO_PLACE_DISTINCT = 1155;
+    public static readonly NO_PLACE_GROUP_BY = 1156;
+    public static readonly NO_PQ_CONCURRENT_UNION = 1157;
+    public static readonly NO_PQ_MAP = 1158;
+    public static readonly NOPROMPT = 1159;
+    public static readonly NO_PQ_REPLICATE = 1160;
+    public static readonly NO_PQ_SKEW = 1161;
+    public static readonly NO_PRUNE_GSETS = 1162;
+    public static readonly NO_PULL_PRED = 1163;
+    public static readonly NO_PUSH_PRED = 1164;
+    public static readonly NO_PUSH_SUBQ = 1165;
+    public static readonly NO_PX_FAULT_TOLERANCE = 1166;
+    public static readonly NO_PX_JOIN_FILTER = 1167;
+    public static readonly NO_QKN_BUFF = 1168;
+    public static readonly NO_QUERY_TRANSFORMATION = 1169;
+    public static readonly NO_REF_CASCADE = 1170;
+    public static readonly NORELOCATE = 1171;
+    public static readonly NORELY = 1172;
+    public static readonly NOREPAIR = 1173;
+    public static readonly NOREPLAY = 1174;
+    public static readonly NORESETLOGS = 1175;
+    public static readonly NO_RESULT_CACHE = 1176;
+    public static readonly NOREVERSE = 1177;
+    public static readonly NO_REWRITE = 1178;
+    public static readonly NOREWRITE = 1179;
+    public static readonly NORMAL = 1180;
+    public static readonly NO_ROOT_SW_FOR_LOCAL = 1181;
+    public static readonly NOROWDEPENDENCIES = 1182;
+    public static readonly NOSCALE = 1183;
+    public static readonly NOSCHEMACHECK = 1184;
+    public static readonly NOSEGMENT = 1185;
+    public static readonly NO_SEMIJOIN = 1186;
+    public static readonly NO_SEMI_TO_INNER = 1187;
+    public static readonly NO_SET_TO_JOIN = 1188;
+    public static readonly NOSHARD = 1189;
+    public static readonly NOSORT = 1190;
+    public static readonly NO_SQL_TRANSLATION = 1191;
+    public static readonly NO_SQL_TUNE = 1192;
+    public static readonly NO_STAR_TRANSFORMATION = 1193;
+    public static readonly NO_STATEMENT_QUEUING = 1194;
+    public static readonly NO_STATS_GSETS = 1195;
+    public static readonly NOSTRICT = 1196;
+    public static readonly NO_SUBQUERY_PRUNING = 1197;
+    public static readonly NO_SUBSTRB_PAD = 1198;
+    public static readonly NO_SWAP_JOIN_INPUTS = 1199;
+    public static readonly NOSWITCH = 1200;
+    public static readonly NO_TABLE_LOOKUP_BY_NL = 1201;
+    public static readonly NO_TEMP_TABLE = 1202;
+    public static readonly NOTHING = 1203;
+    public static readonly NOTIFICATION = 1204;
+    public static readonly NOTRIM = 1205;
+    public static readonly NOT = 1206;
+    public static readonly NO_TRANSFORM_DISTINCT_AGG = 1207;
+    public static readonly NO_UNNEST = 1208;
+    public static readonly NO_USE_CUBE = 1209;
+    public static readonly NO_USE_HASH_AGGREGATION = 1210;
+    public static readonly NO_USE_HASH_GBY_FOR_PUSHDOWN = 1211;
+    public static readonly NO_USE_HASH = 1212;
+    public static readonly NO_USE_INVISIBLE_INDEXES = 1213;
+    public static readonly NO_USE_MERGE = 1214;
+    public static readonly NO_USE_NL = 1215;
+    public static readonly NO_USE_VECTOR_AGGREGATION = 1216;
+    public static readonly NOVALIDATE = 1217;
+    public static readonly NO_VECTOR_TRANSFORM_DIMS = 1218;
+    public static readonly NO_VECTOR_TRANSFORM_FACT = 1219;
+    public static readonly NO_VECTOR_TRANSFORM = 1220;
+    public static readonly NOWAIT = 1221;
+    public static readonly NO_XDB_FASTPATH_INSERT = 1222;
+    public static readonly NO_XML_DML_REWRITE = 1223;
+    public static readonly NO_XMLINDEX_REWRITE_IN_SELECT = 1224;
+    public static readonly NO_XMLINDEX_REWRITE = 1225;
+    public static readonly NO_XML_QUERY_REWRITE = 1226;
+    public static readonly NO_ZONEMAP = 1227;
+    public static readonly NTH_VALUE = 1228;
+    public static readonly NULLIF = 1229;
+    public static readonly NULL_ = 1230;
+    public static readonly NULLS = 1231;
+    public static readonly NUMBER = 1232;
+    public static readonly NUMERIC = 1233;
+    public static readonly NUM_INDEX_KEYS = 1234;
+    public static readonly NUMTODSINTERVAL = 1235;
+    public static readonly NUMTOYMINTERVAL = 1236;
+    public static readonly NVARCHAR2 = 1237;
+    public static readonly NVL2 = 1238;
+    public static readonly OBJECT2XML = 1239;
+    public static readonly OBJECT = 1240;
+    public static readonly OBJ_ID = 1241;
+    public static readonly OBJNO = 1242;
+    public static readonly OBJNO_REUSE = 1243;
+    public static readonly OCCURENCES = 1244;
+    public static readonly OFFLINE = 1245;
+    public static readonly OFF = 1246;
+    public static readonly OFFSET = 1247;
+    public static readonly OF = 1248;
+    public static readonly OIDINDEX = 1249;
+    public static readonly OID = 1250;
+    public static readonly OLAP = 1251;
+    public static readonly OLD = 1252;
+    public static readonly OLD_PUSH_PRED = 1253;
+    public static readonly OLS = 1254;
+    public static readonly OLTP = 1255;
+    public static readonly OMIT = 1256;
+    public static readonly ONE = 1257;
+    public static readonly ONLINE = 1258;
+    public static readonly ONLINELOG = 1259;
+    public static readonly ONLY = 1260;
+    public static readonly ON = 1261;
+    public static readonly OPAQUE = 1262;
+    public static readonly OPAQUE_TRANSFORM = 1263;
+    public static readonly OPAQUE_XCANONICAL = 1264;
+    public static readonly OPCODE = 1265;
+    public static readonly OPEN = 1266;
+    public static readonly OPERATIONS = 1267;
+    public static readonly OPERATOR = 1268;
+    public static readonly OPT_ESTIMATE = 1269;
+    public static readonly OPTIMAL = 1270;
+    public static readonly OPTIMIZE = 1271;
+    public static readonly OPTIMIZER_FEATURES_ENABLE = 1272;
+    public static readonly OPTIMIZER_GOAL = 1273;
+    public static readonly OPTION = 1274;
+    public static readonly OPTIONALLY = 1275;
+    public static readonly OPT_PARAM = 1276;
+    public static readonly ORA_BRANCH = 1277;
+    public static readonly ORA_CHECK_ACL = 1278;
+    public static readonly ORA_CHECK_PRIVILEGE = 1279;
+    public static readonly ORA_CLUSTERING = 1280;
+    public static readonly ORADATA = 1281;
+    public static readonly ORC = 1282;
+    public static readonly ORACLE_DATE = 1283;
+    public static readonly ORACLE_NUMBER = 1284;
+    public static readonly ORADEBUG = 1285;
+    public static readonly ORA_DST_AFFECTED = 1286;
+    public static readonly ORA_DST_CONVERT = 1287;
+    public static readonly ORA_DST_ERROR = 1288;
+    public static readonly ORA_GET_ACLIDS = 1289;
+    public static readonly ORA_GET_PRIVILEGES = 1290;
+    public static readonly ORA_HASH = 1291;
+    public static readonly ORA_INVOKING_USERID = 1292;
+    public static readonly ORA_INVOKING_USER = 1293;
+    public static readonly ORA_INVOKING_XS_USER_GUID = 1294;
+    public static readonly ORA_INVOKING_XS_USER = 1295;
+    public static readonly ORA_RAWCOMPARE = 1296;
+    public static readonly ORA_RAWCONCAT = 1297;
+    public static readonly ORA_ROWSCN = 1298;
+    public static readonly ORA_ROWSCN_RAW = 1299;
+    public static readonly ORA_ROWVERSION = 1300;
+    public static readonly ORA_TABVERSION = 1301;
+    public static readonly ORA_WRITE_TIME = 1302;
+    public static readonly ORDERED = 1303;
+    public static readonly ORDERED_PREDICATES = 1304;
+    public static readonly ORDER = 1305;
+    public static readonly ORDINALITY = 1306;
+    public static readonly OR_EXPAND = 1307;
+    public static readonly ORGANIZATION = 1308;
+    public static readonly OR = 1309;
+    public static readonly OR_PREDICATES = 1310;
+    public static readonly OSERROR = 1311;
+    public static readonly OTHER = 1312;
+    public static readonly OUTER_JOIN_TO_ANTI = 1313;
+    public static readonly OUTER_JOIN_TO_INNER = 1314;
+    public static readonly OUTER = 1315;
+    public static readonly OUTLINE_LEAF = 1316;
+    public static readonly OUTLINE = 1317;
+    public static readonly OUTPUTFORMAT = 1318;
+    public static readonly OUT_OF_LINE = 1319;
+    public static readonly OUT = 1320;
+    public static readonly OVERFLOW_NOMOVE = 1321;
+    public static readonly OVERFLOW_ = 1322;
+    public static readonly OVERLAPS = 1323;
+    public static readonly OVER = 1324;
+    public static readonly OVERRIDE = 1325;
+    public static readonly OVERRIDING = 1326;
+    public static readonly OWNER = 1327;
+    public static readonly OWNERSHIP = 1328;
+    public static readonly OWN = 1329;
+    public static readonly P_LETTER = 1330;
+    public static readonly PACKAGE = 1331;
+    public static readonly PACKAGES = 1332;
+    public static readonly PARALLEL_ENABLE = 1333;
+    public static readonly PARALLEL_INDEX = 1334;
+    public static readonly PARALLEL = 1335;
+    public static readonly PARAMETERFILE = 1336;
+    public static readonly PARAMETERS = 1337;
+    public static readonly PARAM = 1338;
+    public static readonly PARENT = 1339;
+    public static readonly PARENT_LEVEL_NAME = 1340;
+    public static readonly PARENT_UNIQUE_NAME = 1341;
+    public static readonly PARITY = 1342;
+    public static readonly PARQUET = 1343;
+    public static readonly PARTIAL_JOIN = 1344;
+    public static readonly PARTIALLY = 1345;
+    public static readonly PARTIAL = 1346;
+    public static readonly PARTIAL_ROLLUP_PUSHDOWN = 1347;
+    public static readonly PARTITION_HASH = 1348;
+    public static readonly PARTITION_LIST = 1349;
+    public static readonly PARTITION = 1350;
+    public static readonly PARTITION_RANGE = 1351;
+    public static readonly PARTITIONS = 1352;
+    public static readonly PARTNUMINST = 1353;
+    public static readonly PASSING = 1354;
+    public static readonly PASSWORD_GRACE_TIME = 1355;
+    public static readonly PASSWORD_LIFE_TIME = 1356;
+    public static readonly PASSWORD_LOCK_TIME = 1357;
+    public static readonly PASSWORD = 1358;
+    public static readonly PASSWORD_REUSE_MAX = 1359;
+    public static readonly PASSWORD_REUSE_TIME = 1360;
+    public static readonly PASSWORD_ROLLOVER_TIME = 1361;
+    public static readonly PASSWORD_VERIFY_FUNCTION = 1362;
+    public static readonly PAST = 1363;
+    public static readonly PATCH = 1364;
+    public static readonly PATH = 1365;
+    public static readonly PATH_PREFIX = 1366;
+    public static readonly PATHS = 1367;
+    public static readonly PATTERN = 1368;
+    public static readonly PBL_HS_BEGIN = 1369;
+    public static readonly PBL_HS_END = 1370;
+    public static readonly PCTFREE = 1371;
+    public static readonly PCTINCREASE = 1372;
+    public static readonly PCTTHRESHOLD = 1373;
+    public static readonly PCTUSED = 1374;
+    public static readonly PCTVERSION = 1375;
+    public static readonly PENDING = 1376;
+    public static readonly PERCENT_FOUND = 1377;
+    public static readonly PERCENT_ISOPEN = 1378;
+    public static readonly PERCENT_NOTFOUND = 1379;
+    public static readonly PERCENT_KEYWORD = 1380;
+    public static readonly PERCENT_RANKM = 1381;
+    public static readonly PERCENT_ROWCOUNT = 1382;
+    public static readonly PERCENT_ROWTYPE = 1383;
+    public static readonly PERCENT_TYPE = 1384;
+    public static readonly PERCENT_BULK_EXCEPTIONS = 1385;
+    public static readonly PERCENT_BULK_ROWCOUNT = 1386;
+    public static readonly PERFORMANCE = 1387;
+    public static readonly PERIOD_KEYWORD = 1388;
+    public static readonly PERMANENT = 1389;
+    public static readonly PERMISSION = 1390;
+    public static readonly PERMUTE = 1391;
+    public static readonly PER = 1392;
+    public static readonly PFILE = 1393;
+    public static readonly PHYSICAL = 1394;
+    public static readonly PIKEY = 1395;
+    public static readonly PIPELINED = 1396;
+    public static readonly PIPE = 1397;
+    public static readonly PIV_GB = 1398;
+    public static readonly PIVOT = 1399;
+    public static readonly PIV_SSF = 1400;
+    public static readonly PLACE_DISTINCT = 1401;
+    public static readonly PLACE_GROUP_BY = 1402;
+    public static readonly PLAN = 1403;
+    public static readonly PLSCOPE_SETTINGS = 1404;
+    public static readonly PLS_INTEGER = 1405;
+    public static readonly PLSQL_CCFLAGS = 1406;
+    public static readonly PLSQL_CODE_TYPE = 1407;
+    public static readonly PLSQL_DEBUG = 1408;
+    public static readonly PLSQL_OPTIMIZE_LEVEL = 1409;
+    public static readonly PLSQL_WARNINGS = 1410;
+    public static readonly PLUGGABLE = 1411;
+    public static readonly PMEM = 1412;
+    public static readonly POINT = 1413;
+    public static readonly POLICY = 1414;
+    public static readonly POOL_16K = 1415;
+    public static readonly POOL_2K = 1416;
+    public static readonly POOL_32K = 1417;
+    public static readonly POOL_4K = 1418;
+    public static readonly POOL_8K = 1419;
+    public static readonly POSITION = 1420;
+    public static readonly POSITIVEN = 1421;
+    public static readonly POSITIVE = 1422;
+    public static readonly POST_TRANSACTION = 1423;
+    public static readonly POWERMULTISET_BY_CARDINALITY = 1424;
+    public static readonly POWERMULTISET = 1425;
+    public static readonly POWER = 1426;
+    public static readonly PQ_CONCURRENT_UNION = 1427;
+    public static readonly PQ_DISTRIBUTE = 1428;
+    public static readonly PQ_DISTRIBUTE_WINDOW = 1429;
+    public static readonly PQ_FILTER = 1430;
+    public static readonly PQ_MAP = 1431;
+    public static readonly PQ_NOMAP = 1432;
+    public static readonly PQ_REPLICATE = 1433;
+    public static readonly PQ_SKEW = 1434;
+    public static readonly PRAGMA = 1435;
+    public static readonly PREBUILT = 1436;
+    public static readonly PRECEDES = 1437;
+    public static readonly PRECEDING = 1438;
+    public static readonly PRECISION = 1439;
+    public static readonly PRECOMPUTE_SUBQUERY = 1440;
+    public static readonly PREDICATE_REORDERS = 1441;
+    public static readonly PRELOAD = 1442;
+    public static readonly PREPARE = 1443;
+    public static readonly PREPROCESSOR = 1444;
+    public static readonly PRESENTNNV = 1445;
+    public static readonly PRESENT = 1446;
+    public static readonly PRESENTV = 1447;
+    public static readonly PRESERVE_OID = 1448;
+    public static readonly PRESERVE = 1449;
+    public static readonly PRETTY = 1450;
+    public static readonly PREVIOUS = 1451;
+    public static readonly PREV = 1452;
+    public static readonly PRIMARY = 1453;
+    public static readonly PRINTBLOBTOCLOB = 1454;
+    public static readonly PRIORITY = 1455;
+    public static readonly PRIOR = 1456;
+    public static readonly PRIVATE = 1457;
+    public static readonly PRIVATE_SGA = 1458;
+    public static readonly PRIVILEGED = 1459;
+    public static readonly PRIVILEGE = 1460;
+    public static readonly PRIVILEGES = 1461;
+    public static readonly PROCEDURAL = 1462;
+    public static readonly PROCEDURE = 1463;
+    public static readonly PROCESS = 1464;
+    public static readonly PROFILE = 1465;
+    public static readonly PROGRAM = 1466;
+    public static readonly PROJECT = 1467;
+    public static readonly PROPAGATE = 1468;
+    public static readonly PROPERTY = 1469;
+    public static readonly PROTECTED = 1470;
+    public static readonly PROTECTION = 1471;
+    public static readonly PROTOCOL = 1472;
+    public static readonly PROXY = 1473;
+    public static readonly PRUNING = 1474;
+    public static readonly PUBLIC = 1475;
+    public static readonly PULL_PRED = 1476;
+    public static readonly PURGE = 1477;
+    public static readonly PUSH_PRED = 1478;
+    public static readonly PUSH_SUBQ = 1479;
+    public static readonly PX_FAULT_TOLERANCE = 1480;
+    public static readonly PX_GRANULE = 1481;
+    public static readonly PX_JOIN_FILTER = 1482;
+    public static readonly QB_NAME = 1483;
+    public static readonly QUARTERS = 1484;
+    public static readonly QUERY_BLOCK = 1485;
+    public static readonly QUERY = 1486;
+    public static readonly QUEUE_CURR = 1487;
+    public static readonly QUEUE = 1488;
+    public static readonly QUEUE_ROWP = 1489;
+    public static readonly QUIESCE = 1490;
+    public static readonly QUORUM = 1491;
+    public static readonly QUOTA = 1492;
+    public static readonly QUOTAGROUP = 1493;
+    public static readonly RAISE = 1494;
+    public static readonly RANDOM_LOCAL = 1495;
+    public static readonly RANDOM = 1496;
+    public static readonly RANGE = 1497;
+    public static readonly RANKM = 1498;
+    public static readonly RAPIDLY = 1499;
+    public static readonly RAW = 1500;
+    public static readonly RAWTOHEX = 1501;
+    public static readonly RAWTONHEX = 1502;
+    public static readonly RBA = 1503;
+    public static readonly RBO_OUTLINE = 1504;
+    public static readonly RCFILE = 1505;
+    public static readonly RDBA = 1506;
+    public static readonly READ = 1507;
+    public static readonly READS = 1508;
+    public static readonly READSIZE = 1509;
+    public static readonly REALM = 1510;
+    public static readonly REAL = 1511;
+    public static readonly REBALANCE = 1512;
+    public static readonly REBUILD = 1513;
+    public static readonly RECORD = 1514;
+    public static readonly RECORDS = 1515;
+    public static readonly RECORDS_PER_BLOCK = 1516;
+    public static readonly RECOVERABLE = 1517;
+    public static readonly RECOVER = 1518;
+    public static readonly RECOVERY = 1519;
+    public static readonly RECYCLEBIN = 1520;
+    public static readonly RECYCLE = 1521;
+    public static readonly REDACTION = 1522;
+    public static readonly REDEFINE = 1523;
+    public static readonly REDO = 1524;
+    public static readonly REDUCED = 1525;
+    public static readonly REDUNDANCY = 1526;
+    public static readonly REF_CASCADE_CURSOR = 1527;
+    public static readonly REFERENCED = 1528;
+    public static readonly REFERENCE = 1529;
+    public static readonly REFERENCES = 1530;
+    public static readonly REFERENCING = 1531;
+    public static readonly REF = 1532;
+    public static readonly REFRESH = 1533;
+    public static readonly REFTOHEX = 1534;
+    public static readonly REGEXP_COUNT = 1535;
+    public static readonly REGEXP_INSTR = 1536;
+    public static readonly REGEXP_LIKE = 1537;
+    public static readonly REGEXP_REPLACE = 1538;
+    public static readonly REGEXP_SUBSTR = 1539;
+    public static readonly REGISTER = 1540;
+    public static readonly REGR_AVGX = 1541;
+    public static readonly REGR_AVGY = 1542;
+    public static readonly REGR_COUNT = 1543;
+    public static readonly REGR_INTERCEPT = 1544;
+    public static readonly REGR_R2 = 1545;
+    public static readonly REGR_SLOPE = 1546;
+    public static readonly REGR_SXX = 1547;
+    public static readonly REGR_SXY = 1548;
+    public static readonly REGR_SYY = 1549;
+    public static readonly REGULAR = 1550;
+    public static readonly REJECT = 1551;
+    public static readonly REKEY = 1552;
+    public static readonly RELATIONAL = 1553;
+    public static readonly RELIES_ON = 1554;
+    public static readonly RELOCATE = 1555;
+    public static readonly RELY = 1556;
+    public static readonly REMAINDER = 1557;
+    public static readonly REMOTE = 1558;
+    public static readonly REMOTE_MAPPED = 1559;
+    public static readonly REMOVE = 1560;
+    public static readonly RENAME = 1561;
+    public static readonly REPAIR = 1562;
+    public static readonly REPEAT = 1563;
+    public static readonly REPLACE = 1564;
+    public static readonly REPLICATION = 1565;
+    public static readonly REQUIRED = 1566;
+    public static readonly RESETLOGS = 1567;
+    public static readonly RESET = 1568;
+    public static readonly RESIZE = 1569;
+    public static readonly RESOLVE = 1570;
+    public static readonly RESOLVER = 1571;
+    public static readonly RESOURCE = 1572;
+    public static readonly RESPECT = 1573;
+    public static readonly RESTART = 1574;
+    public static readonly RESTORE_AS_INTERVALS = 1575;
+    public static readonly RESTORE = 1576;
+    public static readonly RESTRICT_ALL_REF_CONS = 1577;
+    public static readonly RESTRICTED = 1578;
+    public static readonly RESTRICT_REFERENCES = 1579;
+    public static readonly RESTRICT = 1580;
+    public static readonly RESULT_CACHE = 1581;
+    public static readonly RESULT = 1582;
+    public static readonly RESUMABLE = 1583;
+    public static readonly RESUME = 1584;
+    public static readonly RETENTION = 1585;
+    public static readonly RETRY_ON_ROW_CHANGE = 1586;
+    public static readonly RETURNING = 1587;
+    public static readonly RETURN = 1588;
+    public static readonly REUSE = 1589;
+    public static readonly REVERSE = 1590;
+    public static readonly REVOKE = 1591;
+    public static readonly REWRITE_OR_ERROR = 1592;
+    public static readonly REWRITE = 1593;
+    public static readonly RIGHT = 1594;
+    public static readonly ROLE = 1595;
+    public static readonly ROLESET = 1596;
+    public static readonly ROLES = 1597;
+    public static readonly ROLLBACK = 1598;
+    public static readonly ROLLING = 1599;
+    public static readonly ROLLUP = 1600;
+    public static readonly ROWDEPENDENCIES = 1601;
+    public static readonly ROWID_MAPPING_TABLE = 1602;
+    public static readonly ROWID = 1603;
+    public static readonly ROWIDTOCHAR = 1604;
+    public static readonly ROWIDTONCHAR = 1605;
+    public static readonly ROW_LENGTH = 1606;
+    public static readonly ROWNUM = 1607;
+    public static readonly ROW = 1608;
+    public static readonly ROWS = 1609;
+    public static readonly RPAD = 1610;
+    public static readonly RTRIM = 1611;
+    public static readonly RULE = 1612;
+    public static readonly RULES = 1613;
+    public static readonly RUNNING = 1614;
+    public static readonly SALT = 1615;
+    public static readonly SAMPLE = 1616;
+    public static readonly SAVE_AS_INTERVALS = 1617;
+    public static readonly SAVEPOINT = 1618;
+    public static readonly SAVE = 1619;
+    public static readonly SB4 = 1620;
+    public static readonly SCALE_ROWS = 1621;
+    public static readonly SCALE = 1622;
+    public static readonly SCAN_INSTANCES = 1623;
+    public static readonly SCAN = 1624;
+    public static readonly SCHEDULER = 1625;
+    public static readonly SCHEMACHECK = 1626;
+    public static readonly SCHEMA = 1627;
+    public static readonly SCN_ASCENDING = 1628;
+    public static readonly SCN = 1629;
+    public static readonly SCOPE = 1630;
+    public static readonly SCRUB = 1631;
+    public static readonly SD_ALL = 1632;
+    public static readonly SD_INHIBIT = 1633;
+    public static readonly SDO_GEOM_MBR = 1634;
+    public static readonly SDO_GEOMETRY = 1635;
+    public static readonly SD_SHOW = 1636;
+    public static readonly SEARCH = 1637;
+    public static readonly SECOND = 1638;
+    public static readonly SECONDS = 1639;
+    public static readonly SECRET = 1640;
+    public static readonly SECUREFILE_DBA = 1641;
+    public static readonly SECUREFILE = 1642;
+    public static readonly SECURITY = 1643;
+    public static readonly SEED = 1644;
+    public static readonly SEG_BLOCK = 1645;
+    public static readonly SEG_FILE = 1646;
+    public static readonly SEGMENT = 1647;
+    public static readonly SELECTIVITY = 1648;
+    public static readonly SELECT = 1649;
+    public static readonly SELF = 1650;
+    public static readonly SEMIJOIN_DRIVER = 1651;
+    public static readonly SEMIJOIN = 1652;
+    public static readonly SEMI_TO_INNER = 1653;
+    public static readonly SEQUENCED = 1654;
+    public static readonly SEQUENCE = 1655;
+    public static readonly SEQUENCEFILE = 1656;
+    public static readonly SEQUENTIAL = 1657;
+    public static readonly SEQ = 1658;
+    public static readonly SERDE = 1659;
+    public static readonly SERDEPROPERTIES = 1660;
+    public static readonly SERIALIZABLE = 1661;
+    public static readonly SERIALLY_REUSABLE = 1662;
+    public static readonly SERIAL = 1663;
+    public static readonly SERVERERROR = 1664;
+    public static readonly SERVICE_NAME_CONVERT = 1665;
+    public static readonly SERVICE = 1666;
+    public static readonly SERVICES = 1667;
+    public static readonly SESSION_CACHED_CURSORS = 1668;
+    public static readonly SESSION = 1669;
+    public static readonly SESSIONS_PER_USER = 1670;
+    public static readonly SESSIONTIMEZONE = 1671;
+    public static readonly SESSIONTZNAME = 1672;
+    public static readonly SET = 1673;
+    public static readonly SETS = 1674;
+    public static readonly SETTINGS = 1675;
+    public static readonly SET_TO_JOIN = 1676;
+    public static readonly SEVERE = 1677;
+    public static readonly SHARD = 1678;
+    public static readonly SHARDSPACE = 1679;
+    public static readonly SHARED_POOL = 1680;
+    public static readonly SHARED = 1681;
+    public static readonly SHARE = 1682;
+    public static readonly SHARING = 1683;
+    public static readonly SHELFLIFE = 1684;
+    public static readonly SHOW = 1685;
+    public static readonly SHRINK = 1686;
+    public static readonly SHUTDOWN = 1687;
+    public static readonly SIBLINGS = 1688;
+    public static readonly SID = 1689;
+    public static readonly SITE = 1690;
+    public static readonly SIGNAL_COMPONENT = 1691;
+    public static readonly SIGNAL_FUNCTION = 1692;
+    public static readonly SIGN = 1693;
+    public static readonly SIGNTYPE = 1694;
+    public static readonly SIMPLE_INTEGER = 1695;
+    public static readonly SIMPLE = 1696;
+    public static readonly SINGLE = 1697;
+    public static readonly SINGLETASK = 1698;
+    public static readonly SINH = 1699;
+    public static readonly SIN = 1700;
+    public static readonly SIZE = 1701;
+    public static readonly SIZES = 1702;
+    public static readonly SKIP_EXT_OPTIMIZER = 1703;
+    public static readonly SKIP_ = 1704;
+    public static readonly SKIP_UNQ_UNUSABLE_IDX = 1705;
+    public static readonly SKIP_UNUSABLE_INDEXES = 1706;
+    public static readonly SMALLFILE = 1707;
+    public static readonly SMALLINT = 1708;
+    public static readonly SNAPSHOT = 1709;
+    public static readonly SOME = 1710;
+    public static readonly SORT = 1711;
+    public static readonly SOUNDEX = 1712;
+    public static readonly SOURCE_FILE_DIRECTORY = 1713;
+    public static readonly SOURCE_FILE_NAME_CONVERT = 1714;
+    public static readonly SOURCE = 1715;
+    public static readonly SPACE_KEYWORD = 1716;
+    public static readonly SPECIFICATION = 1717;
+    public static readonly SPFILE = 1718;
+    public static readonly SPLIT = 1719;
+    public static readonly SPREADSHEET = 1720;
+    public static readonly SQLDATA = 1721;
+    public static readonly SQLERROR = 1722;
+    public static readonly SQLLDR = 1723;
+    public static readonly SQL = 1724;
+    public static readonly FILE_EXT = 1725;
+    public static readonly SQL_MACRO = 1726;
+    public static readonly SQL_TRACE = 1727;
+    public static readonly SQL_TRANSLATION_PROFILE = 1728;
+    public static readonly SQRT = 1729;
+    public static readonly STALE = 1730;
+    public static readonly STANDALONE = 1731;
+    public static readonly STANDARD = 1732;
+    public static readonly STANDARD_HASH = 1733;
+    public static readonly STANDBY_MAX_DATA_DELAY = 1734;
+    public static readonly STANDBYS = 1735;
+    public static readonly STANDBY = 1736;
+    public static readonly STAR = 1737;
+    public static readonly STAR_TRANSFORMATION = 1738;
+    public static readonly START = 1739;
+    public static readonly STARTOF = 1740;
+    public static readonly STARTUP = 1741;
+    public static readonly STATEMENT_ID = 1742;
+    public static readonly STATEMENT_QUEUING = 1743;
+    public static readonly STATEMENTS = 1744;
+    public static readonly STATEMENT = 1745;
+    public static readonly STATE = 1746;
+    public static readonly STATIC = 1747;
+    public static readonly STATISTICS = 1748;
+    public static readonly STATS_BINOMIAL_TEST = 1749;
+    public static readonly STATS_CROSSTAB = 1750;
+    public static readonly STATS_F_TEST = 1751;
+    public static readonly STATS_KS_TEST = 1752;
+    public static readonly STATS_MODE = 1753;
+    public static readonly STATS_MW_TEST = 1754;
+    public static readonly STATS_ONE_WAY_ANOVA = 1755;
+    public static readonly STATS_T_TEST_INDEP = 1756;
+    public static readonly STATS_T_TEST_INDEPU = 1757;
+    public static readonly STATS_T_TEST_ONE = 1758;
+    public static readonly STATS_T_TEST_PAIRED = 1759;
+    public static readonly STATS_WSR_TEST = 1760;
+    public static readonly STDDEV_POP = 1761;
+    public static readonly STDDEV_SAMP = 1762;
+    public static readonly STOP = 1763;
+    public static readonly STORAGE = 1764;
+    public static readonly STORE = 1765;
+    public static readonly STREAMS = 1766;
+    public static readonly STREAM = 1767;
+    public static readonly STRICT = 1768;
+    public static readonly STRING = 1769;
+    public static readonly STRIPE_COLUMNS = 1770;
+    public static readonly STRIPE_WIDTH = 1771;
+    public static readonly STRIP = 1772;
+    public static readonly STRUCTURE = 1773;
+    public static readonly SUBMULTISET = 1774;
+    public static readonly SUBPARTITION_REL = 1775;
+    public static readonly SUBPARTITIONS = 1776;
+    public static readonly SUBPARTITION = 1777;
+    public static readonly SUBQUERIES = 1778;
+    public static readonly SUBQUERY_PRUNING = 1779;
+    public static readonly SUBSCRIBE = 1780;
+    public static readonly SUBSET = 1781;
+    public static readonly SUBSTITUTABLE = 1782;
+    public static readonly SUBSTR2 = 1783;
+    public static readonly SUBSTR4 = 1784;
+    public static readonly SUBSTRB = 1785;
+    public static readonly SUBSTRC = 1786;
+    public static readonly SUBTYPE = 1787;
+    public static readonly SUCCESSFUL = 1788;
+    public static readonly SUCCESS = 1789;
+    public static readonly SUMMARY = 1790;
+    public static readonly SUPPLEMENTAL = 1791;
+    public static readonly SUSPEND = 1792;
+    public static readonly SWAP_JOIN_INPUTS = 1793;
+    public static readonly SWITCHOVER = 1794;
+    public static readonly SWITCH = 1795;
+    public static readonly SYNCHRONOUS = 1796;
+    public static readonly SYNC = 1797;
+    public static readonly SYNONYM = 1798;
+    public static readonly SYS = 1799;
+    public static readonly SYSASM = 1800;
+    public static readonly SYS_AUDIT = 1801;
+    public static readonly SYSAUX = 1802;
+    public static readonly SYSBACKUP = 1803;
+    public static readonly SYS_CHECKACL = 1804;
+    public static readonly SYS_CHECK_PRIVILEGE = 1805;
+    public static readonly SYS_CONNECT_BY_PATH = 1806;
+    public static readonly SYS_CONTEXT = 1807;
+    public static readonly SYSDATE = 1808;
+    public static readonly SYSDBA = 1809;
+    public static readonly SYS_DBURIGEN = 1810;
+    public static readonly SYSDG = 1811;
+    public static readonly SYS_DL_CURSOR = 1812;
+    public static readonly SYS_DM_RXFORM_CHR = 1813;
+    public static readonly SYS_DM_RXFORM_NUM = 1814;
+    public static readonly SYS_DOM_COMPARE = 1815;
+    public static readonly SYS_DST_PRIM2SEC = 1816;
+    public static readonly SYS_DST_SEC2PRIM = 1817;
+    public static readonly SYS_ET_BFILE_TO_RAW = 1818;
+    public static readonly SYS_ET_BLOB_TO_IMAGE = 1819;
+    public static readonly SYS_ET_IMAGE_TO_BLOB = 1820;
+    public static readonly SYS_ET_RAW_TO_BFILE = 1821;
+    public static readonly SYS_EXTPDTXT = 1822;
+    public static readonly SYS_EXTRACT_UTC = 1823;
+    public static readonly SYS_FBT_INSDEL = 1824;
+    public static readonly SYS_FILTER_ACLS = 1825;
+    public static readonly SYS_FNMATCHES = 1826;
+    public static readonly SYS_FNREPLACE = 1827;
+    public static readonly SYS_GET_ACLIDS = 1828;
+    public static readonly SYS_GET_COL_ACLIDS = 1829;
+    public static readonly SYS_GET_PRIVILEGES = 1830;
+    public static readonly SYS_GETTOKENID = 1831;
+    public static readonly SYS_GETXTIVAL = 1832;
+    public static readonly SYS_GUID = 1833;
+    public static readonly SYSGUID = 1834;
+    public static readonly SYSKM = 1835;
+    public static readonly SYS_MAKE_XMLNODEID = 1836;
+    public static readonly SYS_MAKEXML = 1837;
+    public static readonly SYS_MKXMLATTR = 1838;
+    public static readonly SYS_MKXTI = 1839;
+    public static readonly SYSOBJ = 1840;
+    public static readonly SYS_OP_ADT2BIN = 1841;
+    public static readonly SYS_OP_ADTCONS = 1842;
+    public static readonly SYS_OP_ALSCRVAL = 1843;
+    public static readonly SYS_OP_ATG = 1844;
+    public static readonly SYS_OP_BIN2ADT = 1845;
+    public static readonly SYS_OP_BITVEC = 1846;
+    public static readonly SYS_OP_BL2R = 1847;
+    public static readonly SYS_OP_BLOOM_FILTER_LIST = 1848;
+    public static readonly SYS_OP_BLOOM_FILTER = 1849;
+    public static readonly SYS_OP_C2C = 1850;
+    public static readonly SYS_OP_CAST = 1851;
+    public static readonly SYS_OP_CEG = 1852;
+    public static readonly SYS_OP_CL2C = 1853;
+    public static readonly SYS_OP_COMBINED_HASH = 1854;
+    public static readonly SYS_OP_COMP = 1855;
+    public static readonly SYS_OP_CONVERT = 1856;
+    public static readonly SYS_OP_COUNTCHG = 1857;
+    public static readonly SYS_OP_CSCONV = 1858;
+    public static readonly SYS_OP_CSCONVTEST = 1859;
+    public static readonly SYS_OP_CSR = 1860;
+    public static readonly SYS_OP_CSX_PATCH = 1861;
+    public static readonly SYS_OP_CYCLED_SEQ = 1862;
+    public static readonly SYS_OP_DECOMP = 1863;
+    public static readonly SYS_OP_DESCEND = 1864;
+    public static readonly SYS_OP_DISTINCT = 1865;
+    public static readonly SYS_OP_DRA = 1866;
+    public static readonly SYS_OP_DUMP = 1867;
+    public static readonly SYS_OP_DV_CHECK = 1868;
+    public static readonly SYS_OP_ENFORCE_NOT_NULL = 1869;
+    public static readonly SYSOPER = 1870;
+    public static readonly SYS_OP_EXTRACT = 1871;
+    public static readonly SYS_OP_GROUPING = 1872;
+    public static readonly SYS_OP_GUID = 1873;
+    public static readonly SYS_OP_HASH = 1874;
+    public static readonly SYS_OP_IIX = 1875;
+    public static readonly SYS_OP_ITR = 1876;
+    public static readonly SYS_OP_KEY_VECTOR_CREATE = 1877;
+    public static readonly SYS_OP_KEY_VECTOR_FILTER_LIST = 1878;
+    public static readonly SYS_OP_KEY_VECTOR_FILTER = 1879;
+    public static readonly SYS_OP_KEY_VECTOR_SUCCEEDED = 1880;
+    public static readonly SYS_OP_KEY_VECTOR_USE = 1881;
+    public static readonly SYS_OP_LBID = 1882;
+    public static readonly SYS_OP_LOBLOC2BLOB = 1883;
+    public static readonly SYS_OP_LOBLOC2CLOB = 1884;
+    public static readonly SYS_OP_LOBLOC2ID = 1885;
+    public static readonly SYS_OP_LOBLOC2NCLOB = 1886;
+    public static readonly SYS_OP_LOBLOC2TYP = 1887;
+    public static readonly SYS_OP_LSVI = 1888;
+    public static readonly SYS_OP_LVL = 1889;
+    public static readonly SYS_OP_MAKEOID = 1890;
+    public static readonly SYS_OP_MAP_NONNULL = 1891;
+    public static readonly SYS_OP_MSR = 1892;
+    public static readonly SYS_OP_NICOMBINE = 1893;
+    public static readonly SYS_OP_NIEXTRACT = 1894;
+    public static readonly SYS_OP_NII = 1895;
+    public static readonly SYS_OP_NIX = 1896;
+    public static readonly SYS_OP_NOEXPAND = 1897;
+    public static readonly SYS_OP_NTCIMG = 1898;
+    public static readonly SYS_OP_NUMTORAW = 1899;
+    public static readonly SYS_OP_OIDVALUE = 1900;
+    public static readonly SYS_OP_OPNSIZE = 1901;
+    public static readonly SYS_OP_PAR_1 = 1902;
+    public static readonly SYS_OP_PARGID_1 = 1903;
+    public static readonly SYS_OP_PARGID = 1904;
+    public static readonly SYS_OP_PAR = 1905;
+    public static readonly SYS_OP_PART_ID = 1906;
+    public static readonly SYS_OP_PIVOT = 1907;
+    public static readonly SYS_OP_R2O = 1908;
+    public static readonly SYS_OP_RAWTONUM = 1909;
+    public static readonly SYS_OP_RDTM = 1910;
+    public static readonly SYS_OP_REF = 1911;
+    public static readonly SYS_OP_RMTD = 1912;
+    public static readonly SYS_OP_ROWIDTOOBJ = 1913;
+    public static readonly SYS_OP_RPB = 1914;
+    public static readonly SYS_OPTLOBPRBSC = 1915;
+    public static readonly SYS_OP_TOSETID = 1916;
+    public static readonly SYS_OP_TPR = 1917;
+    public static readonly SYS_OP_TRTB = 1918;
+    public static readonly SYS_OPTXICMP = 1919;
+    public static readonly SYS_OPTXQCASTASNQ = 1920;
+    public static readonly SYS_OP_UNDESCEND = 1921;
+    public static readonly SYS_OP_VECAND = 1922;
+    public static readonly SYS_OP_VECBIT = 1923;
+    public static readonly SYS_OP_VECOR = 1924;
+    public static readonly SYS_OP_VECXOR = 1925;
+    public static readonly SYS_OP_VERSION = 1926;
+    public static readonly SYS_OP_VREF = 1927;
+    public static readonly SYS_OP_VVD = 1928;
+    public static readonly SYS_OP_XMLCONS_FOR_CSX = 1929;
+    public static readonly SYS_OP_XPTHATG = 1930;
+    public static readonly SYS_OP_XPTHIDX = 1931;
+    public static readonly SYS_OP_XPTHOP = 1932;
+    public static readonly SYS_OP_XTXT2SQLT = 1933;
+    public static readonly SYS_OP_ZONE_ID = 1934;
+    public static readonly SYS_ORDERKEY_DEPTH = 1935;
+    public static readonly SYS_ORDERKEY_MAXCHILD = 1936;
+    public static readonly SYS_ORDERKEY_PARENT = 1937;
+    public static readonly SYS_PARALLEL_TXN = 1938;
+    public static readonly SYS_PATHID_IS_ATTR = 1939;
+    public static readonly SYS_PATHID_IS_NMSPC = 1940;
+    public static readonly SYS_PATHID_LASTNAME = 1941;
+    public static readonly SYS_PATHID_LASTNMSPC = 1942;
+    public static readonly SYS_PATH_REVERSE = 1943;
+    public static readonly SYS_PXQEXTRACT = 1944;
+    public static readonly SYS_RAW_TO_XSID = 1945;
+    public static readonly SYS_RID_ORDER = 1946;
+    public static readonly SYS_ROW_DELTA = 1947;
+    public static readonly SYS_SC_2_XMLT = 1948;
+    public static readonly SYS_SYNRCIREDO = 1949;
+    public static readonly SYSTEM_DEFINED = 1950;
+    public static readonly SYSTEM = 1951;
+    public static readonly SYSTIMESTAMP = 1952;
+    public static readonly SYS_TYPEID = 1953;
+    public static readonly SYS_UMAKEXML = 1954;
+    public static readonly SYS_XMLANALYZE = 1955;
+    public static readonly SYS_XMLCONTAINS = 1956;
+    public static readonly SYS_XMLCONV = 1957;
+    public static readonly SYS_XMLEXNSURI = 1958;
+    public static readonly SYS_XMLGEN = 1959;
+    public static readonly SYS_XMLI_LOC_ISNODE = 1960;
+    public static readonly SYS_XMLI_LOC_ISTEXT = 1961;
+    public static readonly SYS_XMLINSTR = 1962;
+    public static readonly SYS_XMLLOCATOR_GETSVAL = 1963;
+    public static readonly SYS_XMLNODEID_GETCID = 1964;
+    public static readonly SYS_XMLNODEID_GETLOCATOR = 1965;
+    public static readonly SYS_XMLNODEID_GETOKEY = 1966;
+    public static readonly SYS_XMLNODEID_GETPATHID = 1967;
+    public static readonly SYS_XMLNODEID_GETPTRID = 1968;
+    public static readonly SYS_XMLNODEID_GETRID = 1969;
+    public static readonly SYS_XMLNODEID_GETSVAL = 1970;
+    public static readonly SYS_XMLNODEID_GETTID = 1971;
+    public static readonly SYS_XMLNODEID = 1972;
+    public static readonly SYS_XMLT_2_SC = 1973;
+    public static readonly SYS_XMLTRANSLATE = 1974;
+    public static readonly SYS_XMLTYPE2SQL = 1975;
+    public static readonly SYS_XQ_ASQLCNV = 1976;
+    public static readonly SYS_XQ_ATOMCNVCHK = 1977;
+    public static readonly SYS_XQBASEURI = 1978;
+    public static readonly SYS_XQCASTABLEERRH = 1979;
+    public static readonly SYS_XQCODEP2STR = 1980;
+    public static readonly SYS_XQCODEPEQ = 1981;
+    public static readonly SYS_XQCON2SEQ = 1982;
+    public static readonly SYS_XQCONCAT = 1983;
+    public static readonly SYS_XQDELETE = 1984;
+    public static readonly SYS_XQDFLTCOLATION = 1985;
+    public static readonly SYS_XQDOC = 1986;
+    public static readonly SYS_XQDOCURI = 1987;
+    public static readonly SYS_XQDURDIV = 1988;
+    public static readonly SYS_XQED4URI = 1989;
+    public static readonly SYS_XQENDSWITH = 1990;
+    public static readonly SYS_XQERRH = 1991;
+    public static readonly SYS_XQERR = 1992;
+    public static readonly SYS_XQESHTMLURI = 1993;
+    public static readonly SYS_XQEXLOBVAL = 1994;
+    public static readonly SYS_XQEXSTWRP = 1995;
+    public static readonly SYS_XQEXTRACT = 1996;
+    public static readonly SYS_XQEXTRREF = 1997;
+    public static readonly SYS_XQEXVAL = 1998;
+    public static readonly SYS_XQFB2STR = 1999;
+    public static readonly SYS_XQFNBOOL = 2000;
+    public static readonly SYS_XQFNCMP = 2001;
+    public static readonly SYS_XQFNDATIM = 2002;
+    public static readonly SYS_XQFNLNAME = 2003;
+    public static readonly SYS_XQFNNM = 2004;
+    public static readonly SYS_XQFNNSURI = 2005;
+    public static readonly SYS_XQFNPREDTRUTH = 2006;
+    public static readonly SYS_XQFNQNM = 2007;
+    public static readonly SYS_XQFNROOT = 2008;
+    public static readonly SYS_XQFORMATNUM = 2009;
+    public static readonly SYS_XQFTCONTAIN = 2010;
+    public static readonly SYS_XQFUNCR = 2011;
+    public static readonly SYS_XQGETCONTENT = 2012;
+    public static readonly SYS_XQINDXOF = 2013;
+    public static readonly SYS_XQINSERT = 2014;
+    public static readonly SYS_XQINSPFX = 2015;
+    public static readonly SYS_XQIRI2URI = 2016;
+    public static readonly SYS_XQLANG = 2017;
+    public static readonly SYS_XQLLNMFRMQNM = 2018;
+    public static readonly SYS_XQMKNODEREF = 2019;
+    public static readonly SYS_XQNILLED = 2020;
+    public static readonly SYS_XQNODENAME = 2021;
+    public static readonly SYS_XQNORMSPACE = 2022;
+    public static readonly SYS_XQNORMUCODE = 2023;
+    public static readonly SYS_XQ_NRNG = 2024;
+    public static readonly SYS_XQNSP4PFX = 2025;
+    public static readonly SYS_XQNSPFRMQNM = 2026;
+    public static readonly SYS_XQPFXFRMQNM = 2027;
+    public static readonly SYS_XQ_PKSQL2XML = 2028;
+    public static readonly SYS_XQPOLYABS = 2029;
+    public static readonly SYS_XQPOLYADD = 2030;
+    public static readonly SYS_XQPOLYCEL = 2031;
+    public static readonly SYS_XQPOLYCSTBL = 2032;
+    public static readonly SYS_XQPOLYCST = 2033;
+    public static readonly SYS_XQPOLYDIV = 2034;
+    public static readonly SYS_XQPOLYFLR = 2035;
+    public static readonly SYS_XQPOLYMOD = 2036;
+    public static readonly SYS_XQPOLYMUL = 2037;
+    public static readonly SYS_XQPOLYRND = 2038;
+    public static readonly SYS_XQPOLYSQRT = 2039;
+    public static readonly SYS_XQPOLYSUB = 2040;
+    public static readonly SYS_XQPOLYUMUS = 2041;
+    public static readonly SYS_XQPOLYUPLS = 2042;
+    public static readonly SYS_XQPOLYVEQ = 2043;
+    public static readonly SYS_XQPOLYVGE = 2044;
+    public static readonly SYS_XQPOLYVGT = 2045;
+    public static readonly SYS_XQPOLYVLE = 2046;
+    public static readonly SYS_XQPOLYVLT = 2047;
+    public static readonly SYS_XQPOLYVNE = 2048;
+    public static readonly SYS_XQREF2VAL = 2049;
+    public static readonly SYS_XQRENAME = 2050;
+    public static readonly SYS_XQREPLACE = 2051;
+    public static readonly SYS_XQRESVURI = 2052;
+    public static readonly SYS_XQRNDHALF2EVN = 2053;
+    public static readonly SYS_XQRSLVQNM = 2054;
+    public static readonly SYS_XQRYENVPGET = 2055;
+    public static readonly SYS_XQRYVARGET = 2056;
+    public static readonly SYS_XQRYWRP = 2057;
+    public static readonly SYS_XQSEQ2CON4XC = 2058;
+    public static readonly SYS_XQSEQ2CON = 2059;
+    public static readonly SYS_XQSEQDEEPEQ = 2060;
+    public static readonly SYS_XQSEQINSB = 2061;
+    public static readonly SYS_XQSEQRM = 2062;
+    public static readonly SYS_XQSEQRVS = 2063;
+    public static readonly SYS_XQSEQSUB = 2064;
+    public static readonly SYS_XQSEQTYPMATCH = 2065;
+    public static readonly SYS_XQSTARTSWITH = 2066;
+    public static readonly SYS_XQSTATBURI = 2067;
+    public static readonly SYS_XQSTR2CODEP = 2068;
+    public static readonly SYS_XQSTRJOIN = 2069;
+    public static readonly SYS_XQSUBSTRAFT = 2070;
+    public static readonly SYS_XQSUBSTRBEF = 2071;
+    public static readonly SYS_XQTOKENIZE = 2072;
+    public static readonly SYS_XQTREATAS = 2073;
+    public static readonly SYS_XQ_UPKXML2SQL = 2074;
+    public static readonly SYS_XQXFORM = 2075;
+    public static readonly SYS_XSID_TO_RAW = 2076;
+    public static readonly SYS_ZMAP_FILTER = 2077;
+    public static readonly SYS_ZMAP_REFRESH = 2078;
+    public static readonly T_LETTER = 2079;
+    public static readonly TABLE_LOOKUP_BY_NL = 2080;
+    public static readonly TABLESPACE_NO = 2081;
+    public static readonly TABLESPACE = 2082;
+    public static readonly TABLES = 2083;
+    public static readonly TABLE_STATS = 2084;
+    public static readonly TABLE = 2085;
+    public static readonly TABNO = 2086;
+    public static readonly TAG = 2087;
+    public static readonly TANH = 2088;
+    public static readonly TAN = 2089;
+    public static readonly TBLORIDXPARTNUM = 2090;
+    public static readonly TEMPFILE = 2091;
+    public static readonly TEMPLATE = 2092;
+    public static readonly TEMPLATE_TABLE = 2093;
+    public static readonly TEMPORARY = 2094;
+    public static readonly TEMP_TABLE = 2095;
+    public static readonly TERMINATED = 2096;
+    public static readonly TEST = 2097;
+    public static readonly TEXT = 2098;
+    public static readonly TEXTFILE = 2099;
+    public static readonly THAN = 2100;
+    public static readonly THEN = 2101;
+    public static readonly THE = 2102;
+    public static readonly THESE = 2103;
+    public static readonly THREAD = 2104;
+    public static readonly THROUGH = 2105;
+    public static readonly TIER = 2106;
+    public static readonly TIES = 2107;
+    public static readonly TIMEOUT = 2108;
+    public static readonly TIMESTAMP_LTZ_UNCONSTRAINED = 2109;
+    public static readonly TIMESTAMP = 2110;
+    public static readonly TIMESTAMP_TZ_UNCONSTRAINED = 2111;
+    public static readonly TIMESTAMP_UNCONSTRAINED = 2112;
+    public static readonly TIMES = 2113;
+    public static readonly TIME = 2114;
+    public static readonly TIMEZONE = 2115;
+    public static readonly TIMEZONE_ABBR = 2116;
+    public static readonly TIMEZONE_HOUR = 2117;
+    public static readonly TIMEZONE_MINUTE = 2118;
+    public static readonly TIMEZONE_OFFSET = 2119;
+    public static readonly TIMEZONE_REGION = 2120;
+    public static readonly TIME_ZONE = 2121;
+    public static readonly TIMING = 2122;
+    public static readonly TINYINT = 2123;
+    public static readonly TIV_GB = 2124;
+    public static readonly TIV_SSF = 2125;
+    public static readonly TO_ACLID = 2126;
+    public static readonly TO_BINARY_DOUBLE = 2127;
+    public static readonly TO_BINARY_FLOAT = 2128;
+    public static readonly TO_BLOB = 2129;
+    public static readonly TO_CLOB = 2130;
+    public static readonly TO_DSINTERVAL = 2131;
+    public static readonly TO_LOB = 2132;
+    public static readonly TO_MULTI_BYTE = 2133;
+    public static readonly TO_NCHAR = 2134;
+    public static readonly TO_NCLOB = 2135;
+    public static readonly TO_NUMBER = 2136;
+    public static readonly TOPLEVEL = 2137;
+    public static readonly TO_SINGLE_BYTE = 2138;
+    public static readonly TO_TIMESTAMP = 2139;
+    public static readonly TO_TIMESTAMP_TZ = 2140;
+    public static readonly TO_TIME = 2141;
+    public static readonly TO_TIME_TZ = 2142;
+    public static readonly TO = 2143;
+    public static readonly TO_YMINTERVAL = 2144;
+    public static readonly TRACE = 2145;
+    public static readonly TRACING = 2146;
+    public static readonly TRACKING = 2147;
+    public static readonly TRAILING = 2148;
+    public static readonly TRANSACTION = 2149;
+    public static readonly TRANSFORM = 2150;
+    public static readonly TRANSFORMS = 2151;
+    public static readonly TRANSFORM_DISTINCT_AGG = 2152;
+    public static readonly TRANSITIONAL = 2153;
+    public static readonly TRANSITION = 2154;
+    public static readonly TRANSLATE = 2155;
+    public static readonly TRANSLATION = 2156;
+    public static readonly TREAT = 2157;
+    public static readonly TRIGGERS = 2158;
+    public static readonly TRIGGER = 2159;
+    public static readonly TRUE = 2160;
+    public static readonly TRUNCATE = 2161;
+    public static readonly TRUNC = 2162;
+    public static readonly TRUSTED = 2163;
+    public static readonly TRUST = 2164;
+    public static readonly TUNING = 2165;
+    public static readonly TX = 2166;
+    public static readonly TYPES = 2167;
+    public static readonly TYPE = 2168;
+    public static readonly TZ_OFFSET = 2169;
+    public static readonly UB2 = 2170;
+    public static readonly UBA = 2171;
+    public static readonly UCS2 = 2172;
+    public static readonly UDF = 2173;
+    public static readonly UID = 2174;
+    public static readonly UNARCHIVED = 2175;
+    public static readonly UNBOUNDED = 2176;
+    public static readonly UNBOUND = 2177;
+    public static readonly UNCONDITIONAL = 2178;
+    public static readonly UNDER = 2179;
+    public static readonly UNDO = 2180;
+    public static readonly UNDROP = 2181;
+    public static readonly UNIFORM = 2182;
+    public static readonly UNION = 2183;
+    public static readonly UNIONTYPE = 2184;
+    public static readonly UNIQUE = 2185;
+    public static readonly UNISTR = 2186;
+    public static readonly UNLIMITED = 2187;
+    public static readonly UNLOAD = 2188;
+    public static readonly UNLOCK = 2189;
+    public static readonly UNMATCHED = 2190;
+    public static readonly UNNEST_INNERJ_DISTINCT_VIEW = 2191;
+    public static readonly UNNEST_NOSEMIJ_NODISTINCTVIEW = 2192;
+    public static readonly UNNEST_SEMIJ_VIEW = 2193;
+    public static readonly UNNEST = 2194;
+    public static readonly UNPACKED = 2195;
+    public static readonly UNPIVOT = 2196;
+    public static readonly UNPLUG = 2197;
+    public static readonly UNPROTECTED = 2198;
+    public static readonly UNQUIESCE = 2199;
+    public static readonly UNRECOVERABLE = 2200;
+    public static readonly UNRESTRICTED = 2201;
+    public static readonly UNSIGNED = 2202;
+    public static readonly UNSUBSCRIBE = 2203;
+    public static readonly UNTIL = 2204;
+    public static readonly UNUSABLE = 2205;
+    public static readonly UNUSED = 2206;
+    public static readonly UPDATABLE = 2207;
+    public static readonly UPDATED = 2208;
+    public static readonly UPDATE = 2209;
+    public static readonly UPDATEXML = 2210;
+    public static readonly UPD_INDEXES = 2211;
+    public static readonly UPD_JOININDEX = 2212;
+    public static readonly UPGRADE = 2213;
+    public static readonly UPPER = 2214;
+    public static readonly UPSERT = 2215;
+    public static readonly UROWID = 2216;
+    public static readonly USABLE = 2217;
+    public static readonly USAGE = 2218;
+    public static readonly USE_ANTI = 2219;
+    public static readonly USE_CONCAT = 2220;
+    public static readonly USE_CUBE = 2221;
+    public static readonly USE_HASH_AGGREGATION = 2222;
+    public static readonly USE_HASH_GBY_FOR_PUSHDOWN = 2223;
+    public static readonly USE_HASH = 2224;
+    public static readonly USE_HIDDEN_PARTITIONS = 2225;
+    public static readonly USE_INVISIBLE_INDEXES = 2226;
+    public static readonly USE_MERGE_CARTESIAN = 2227;
+    public static readonly USE_MERGE = 2228;
+    public static readonly USE_NL = 2229;
+    public static readonly USE_NL_WITH_INDEX = 2230;
+    public static readonly USE_PRIVATE_OUTLINES = 2231;
+    public static readonly USER_DATA = 2232;
+    public static readonly USER_DEFINED = 2233;
+    public static readonly USERENV = 2234;
+    public static readonly USERGROUP = 2235;
+    public static readonly USER_RECYCLEBIN = 2236;
+    public static readonly USERS = 2237;
+    public static readonly USER_TABLESPACES = 2238;
+    public static readonly USER = 2239;
+    public static readonly USE_SEMI = 2240;
+    public static readonly USE_STORED_OUTLINES = 2241;
+    public static readonly USE_TTT_FOR_GSETS = 2242;
+    public static readonly USE = 2243;
+    public static readonly USE_VECTOR_AGGREGATION = 2244;
+    public static readonly USE_WEAK_NAME_RESL = 2245;
+    public static readonly USING_NO_EXPAND = 2246;
+    public static readonly USING_NLS_COMP = 2247;
+    public static readonly USING = 2248;
+    public static readonly UTF16BE = 2249;
+    public static readonly UTF16LE = 2250;
+    public static readonly UTF32 = 2251;
+    public static readonly UTF8 = 2252;
+    public static readonly V1 = 2253;
+    public static readonly V2 = 2254;
+    public static readonly VALIDATE = 2255;
+    public static readonly VALIDATE_CONVERSION = 2256;
+    public static readonly VALIDATION = 2257;
+    public static readonly VALID_TIME_END = 2258;
+    public static readonly VALUES = 2259;
+    public static readonly VALUE = 2260;
+    public static readonly VARCHAR2 = 2261;
+    public static readonly VARCHAR = 2262;
+    public static readonly VARCHARC = 2263;
+    public static readonly VARIABLE = 2264;
+    public static readonly VARRAW = 2265;
+    public static readonly VARRAWC = 2266;
+    public static readonly VAR_POP = 2267;
+    public static readonly VARRAYS = 2268;
+    public static readonly VARRAY = 2269;
+    public static readonly VAR_SAMP = 2270;
+    public static readonly VARYING = 2271;
+    public static readonly VECTOR_READ_TRACE = 2272;
+    public static readonly VECTOR_READ = 2273;
+    public static readonly VECTOR_TRANSFORM_DIMS = 2274;
+    public static readonly VECTOR_TRANSFORM_FACT = 2275;
+    public static readonly VECTOR_TRANSFORM = 2276;
+    public static readonly VERIFIER = 2277;
+    public static readonly VERIFY = 2278;
+    public static readonly VERSIONING = 2279;
+    public static readonly VERSIONS_ENDSCN = 2280;
+    public static readonly VERSIONS_ENDTIME = 2281;
+    public static readonly VERSIONS_OPERATION = 2282;
+    public static readonly VERSIONS_STARTSCN = 2283;
+    public static readonly VERSIONS_STARTTIME = 2284;
+    public static readonly VERSIONS = 2285;
+    public static readonly VERSIONS_XID = 2286;
+    public static readonly VERSION = 2287;
+    public static readonly VIEW = 2288;
+    public static readonly VIOLATION = 2289;
+    public static readonly VIRTUAL = 2290;
+    public static readonly VISIBILITY = 2291;
+    public static readonly VISIBLE = 2292;
+    public static readonly VOLUME = 2293;
+    public static readonly VSIZE = 2294;
+    public static readonly WAIT = 2295;
+    public static readonly WALLET = 2296;
+    public static readonly WARNING = 2297;
+    public static readonly WEEKS = 2298;
+    public static readonly WEEK = 2299;
+    public static readonly WELLFORMED = 2300;
+    public static readonly WHENEVER = 2301;
+    public static readonly WHEN = 2302;
+    public static readonly WHERE = 2303;
+    public static readonly WHILE = 2304;
+    public static readonly WHITESPACE = 2305;
+    public static readonly WIDTH_BUCKET = 2306;
+    public static readonly WITHIN = 2307;
+    public static readonly WITHOUT = 2308;
+    public static readonly WITH_PLSQL = 2309;
+    public static readonly WITH = 2310;
+    public static readonly WORK = 2311;
+    public static readonly WORKERID = 2312;
+    public static readonly WRAPPED = 2313;
+    public static readonly WRAPPER = 2314;
+    public static readonly WRITE = 2315;
+    public static readonly XDB_FASTPATH_INSERT = 2316;
+    public static readonly XDB = 2317;
+    public static readonly X_DYN_PRUNE = 2318;
+    public static readonly XID = 2319;
+    public static readonly XML2OBJECT = 2320;
+    public static readonly XMLAGG = 2321;
+    public static readonly XMLATTRIBUTES = 2322;
+    public static readonly XMLCAST = 2323;
+    public static readonly XMLCDATA = 2324;
+    public static readonly XMLCOLATTVAL = 2325;
+    public static readonly XMLCOMMENT = 2326;
+    public static readonly XMLCONCAT = 2327;
+    public static readonly XMLDIFF = 2328;
+    public static readonly XML_DML_RWT_STMT = 2329;
+    public static readonly XMLELEMENT = 2330;
+    public static readonly XMLEXISTS2 = 2331;
+    public static readonly XMLEXISTS = 2332;
+    public static readonly XMLFOREST = 2333;
+    public static readonly XMLINDEX = 2334;
+    public static readonly XMLINDEX_REWRITE_IN_SELECT = 2335;
+    public static readonly XMLINDEX_REWRITE = 2336;
+    public static readonly XMLINDEX_SEL_IDX_TBL = 2337;
+    public static readonly XMLISNODE = 2338;
+    public static readonly XMLISVALID = 2339;
+    public static readonly XMLNAMESPACES = 2340;
+    public static readonly XMLPARSE = 2341;
+    public static readonly XMLPATCH = 2342;
+    public static readonly XMLPI = 2343;
+    public static readonly XMLQUERYVAL = 2344;
+    public static readonly XMLQUERY = 2345;
+    public static readonly XMLROOT = 2346;
+    public static readonly XMLSCHEMA = 2347;
+    public static readonly XMLSERIALIZE = 2348;
+    public static readonly XMLTABLE = 2349;
+    public static readonly XMLTAG = 2350;
+    public static readonly XMLTRANSFORMBLOB = 2351;
+    public static readonly XMLTRANSFORM = 2352;
+    public static readonly XMLTYPE = 2353;
+    public static readonly XML = 2354;
+    public static readonly XPATHTABLE = 2355;
+    public static readonly XS_SYS_CONTEXT = 2356;
+    public static readonly XS = 2357;
+    public static readonly XTRANSPORT = 2358;
+    public static readonly YEARS = 2359;
+    public static readonly YEAR = 2360;
+    public static readonly YEAR_TO_MONTH = 2361;
+    public static readonly YES = 2362;
+    public static readonly YMINTERVAL_UNCONSTRAINED = 2363;
+    public static readonly ZONEMAP = 2364;
+    public static readonly ZONE = 2365;
+    public static readonly ZONED = 2366;
+    public static readonly PREDICTION = 2367;
+    public static readonly PREDICTION_BOUNDS = 2368;
+    public static readonly PREDICTION_COST = 2369;
+    public static readonly PREDICTION_DETAILS = 2370;
+    public static readonly PREDICTION_PROBABILITY = 2371;
+    public static readonly PREDICTION_SET = 2372;
+    public static readonly BLOCKCHAIN = 2373;
+    public static readonly COLLATE = 2374;
+    public static readonly COLLATION = 2375;
+    public static readonly DEFINITION = 2376;
+    public static readonly DUPLICATED = 2377;
+    public static readonly EXTENDED = 2378;
+    public static readonly HASHING = 2379;
+    public static readonly IDLE = 2380;
+    public static readonly IMMUTABLE = 2381;
+    public static readonly ORACLE_DATAPUMP = 2382;
+    public static readonly ORACLE_HDFS = 2383;
+    public static readonly ORACLE_HIVE = 2384;
+    public static readonly ORACLE_LOADER = 2385;
+    public static readonly SHA2_512_Q = 2386;
+    public static readonly SHARDED = 2387;
+    public static readonly V1_Q = 2388;
+    public static readonly ISOLATE = 2389;
+    public static readonly ROOT = 2390;
+    public static readonly UNITE = 2391;
+    public static readonly ALGORITHM = 2392;
+    public static readonly CUME_DIST = 2393;
+    public static readonly DENSE_RANK = 2394;
+    public static readonly LISTAGG = 2395;
+    public static readonly PERCENT_RANK = 2396;
+    public static readonly PERCENTILE_CONT = 2397;
+    public static readonly PERCENTILE_DISC = 2398;
+    public static readonly RANK = 2399;
+    public static readonly AVG = 2400;
+    public static readonly CORR = 2401;
+    public static readonly COVAR_ = 2402;
+    public static readonly DECODE = 2403;
+    public static readonly LAG = 2404;
+    public static readonly LAG_DIFF = 2405;
+    public static readonly LAG_DIFF_PERCENT = 2406;
+    public static readonly LEAD = 2407;
+    public static readonly MAX = 2408;
+    public static readonly MEDIAN = 2409;
+    public static readonly MEMOPTIMIZE = 2410;
+    public static readonly MIN = 2411;
+    public static readonly NTILE = 2412;
+    public static readonly NVL = 2413;
+    public static readonly RATIO_TO_REPORT = 2414;
+    public static readonly REGR_ = 2415;
+    public static readonly ROUND = 2416;
+    public static readonly ROW_NUMBER = 2417;
+    public static readonly SUBSTR = 2418;
+    public static readonly TO_CHAR = 2419;
+    public static readonly TRIM = 2420;
+    public static readonly SUM = 2421;
+    public static readonly STDDEV = 2422;
+    public static readonly VAR_ = 2423;
+    public static readonly VARIANCE = 2424;
+    public static readonly LEAST = 2425;
+    public static readonly GREATEST = 2426;
+    public static readonly TO_DATE = 2427;
+    public static readonly CHARSETID = 2428;
+    public static readonly CHARSETFORM = 2429;
+    public static readonly DURATION = 2430;
+    public static readonly EXTEND = 2431;
+    public static readonly MAXLEN = 2432;
+    public static readonly PERSISTABLE = 2433;
+    public static readonly POLYMORPHIC = 2434;
+    public static readonly STRUCT = 2435;
+    public static readonly TDO = 2436;
+    public static readonly WM_CONCAT = 2437;
+    public static readonly NATIONAL_CHAR_STRING_LIT = 2438;
+    public static readonly BIT_STRING_LIT = 2439;
+    public static readonly HEX_STRING_LIT = 2440;
+    public static readonly DOUBLE_PERIOD = 2441;
+    public static readonly PERIOD = 2442;
+    public static readonly UNSIGNED_INTEGER = 2443;
+    public static readonly APPROXIMATE_NUM_LIT = 2444;
+    public static readonly CHAR_STRING = 2445;
+    public static readonly DELIMITED_ID = 2446;
+    public static readonly PERCENT = 2447;
+    public static readonly AMPERSAND = 2448;
+    public static readonly LEFT_PAREN = 2449;
+    public static readonly RIGHT_PAREN = 2450;
+    public static readonly DOUBLE_ASTERISK = 2451;
+    public static readonly ASTERISK = 2452;
+    public static readonly PLUS_SIGN = 2453;
+    public static readonly MINUS_SIGN = 2454;
+    public static readonly COMMA = 2455;
+    public static readonly SOLIDUS = 2456;
+    public static readonly RSOLIDUS = 2457;
+    public static readonly AT_SIGN = 2458;
+    public static readonly ASSIGN_OP = 2459;
+    public static readonly HASH_OP = 2460;
+    public static readonly LEFT_CURLY_PAREN = 2461;
+    public static readonly RIGHT_CURLY_PAREN = 2462;
+    public static readonly SQ = 2463;
+    public static readonly BINDVAR = 2464;
+    public static readonly NOT_EQUAL_OP = 2465;
+    public static readonly CARRET_OPERATOR_PART = 2466;
+    public static readonly TILDE_OPERATOR_PART = 2467;
+    public static readonly EXCLAMATION_OPERATOR_PART = 2468;
+    public static readonly GREATER_THAN_OP = 2469;
+    public static readonly LESS_THAN_OP = 2470;
+    public static readonly COLON = 2471;
+    public static readonly SEMICOLON = 2472;
+    public static readonly BAR = 2473;
+    public static readonly EQUALS_OP = 2474;
+    public static readonly LEFT_BRACKET = 2475;
+    public static readonly RIGHT_BRACKET = 2476;
+    public static readonly INTRODUCER = 2477;
+    public static readonly SINGLE_LINE_COMMENT = 2478;
+    public static readonly MULTI_LINE_COMMENT = 2479;
+    public static readonly REMARK_COMMENT = 2480;
+    public static readonly PROMPT_MESSAGE = 2481;
+    public static readonly REGULAR_ID = 2482;
+    public static readonly INQUIRY_DIRECTIVE = 2483;
+    public static readonly SPACES = 2484;
+
+    public static readonly channelNames = [
+        "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+    ];
+
+    public static readonly literalNames = [
+        null, "'ABORT'", "'ABS'", "'ABSENT'", "'ACCESS'", "'ACCESSED'", 
+        "'ACCESSIBLE'", "'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'", "'ANNOTATIONS'", 
+        "'ANOMALY'", "'ANSI_REARCH'", "'ANTIJOIN'", "'ANY'", "'ANYSCHEMA'", 
+        "'APPEND'", "'APPENDCHILDXML'", "'APPEND_VALUES'", "'APPLICATION'", 
+        "'APPLY'", "'APPROX_COUNT_DISTINCT'", "'ARCHIVAL'", "'ARCHIVE'", 
+        "'ARCHIVED'", "'ARCHIVELOG'", "'ARE'", "'ARRAY'", "'AS'", "'ASC'", 
+        "'ASCII'", "'ASCIISTR'", "'ASIN'", "'ASIS'", "'ASSEMBLY'", "'ASSIGN'", 
+        "'ASSOCIATE'", "'ASYNC'", "'ASYNCHRONOUS'", "'ATAN2'", "'ATAN'", 
+        "'AT'", "'ATTRIBUTE'", "'ATTRIBUTES'", "'AUDIT'", "'AUTHENTICATED'", 
+        "'AUTHENTICATION'", "'AUTHID'", "'AUTHORIZATION'", "'AUTOALLOCATE'", 
+        "'AUTO'", "'AUTOBACKUP'", "'AUTOEXTEND'", "'AUTO_LOGIN'", "'AUTOMATIC'", 
+        "'AUTONOMOUS_TRANSACTION'", "'AUTO_REOPTIMIZE'", "'AVAILABILITY'", 
+        "'AVRO'", "'BACKGROUND'", "'BACKINGFILE'", "'BACKUP'", "'BACKUPS'", 
+        "'BACKUPSET'", "'BADFILE'", "'BASIC'", "'BASICFILE'", "'BATCH'", 
+        "'BATCHSIZE'", "'BATCH_TABLE_ACCESS_BY_ROWID'", "'BECOME'", "'BEFORE'", 
+        "'BEGIN'", "'BEGINNING'", "'BEGIN_OUTLINE_DATA'", "'BEHALF'", "'BEQUEATH'", 
+        "'BETWEEN'", "'BFILE'", "'BFILENAME'", "'BIG'", "'BIGFILE'", "'BIGINT'", 
+        "'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'", "'BLANKS'", "'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'", "'BYTES'", "'BYTEORDERMARK'", "'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'", 
+        "'CHANGETRACKING'", "'CHANGE_DUPKEY_ERROR_INDEX'", "'CHARACTER'", 
+        "'CHARACTERS'", "'CHARACTERSET'", "'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'", "'COLLECTION'", "'COLUMNAR'", "'COLUMN_AUTH_INDICATOR'", 
+        "'COLUMN'", "'COLUMNS'", "'COLUMN_STATS'", "'COLUMN_VALUE'", "'COMMENT'", 
+        "'COMMIT'", "'COMMITTED'", "'COMMON'", "'COMMON_DATA'", "'COMPACT'", 
+        "'COMPATIBLE'", "'COMPATIBILITY'", "'COMPILE'", "'COMPLETE'", "'COMPLIANCE'", 
+        "'COMPONENT'", "'COMPONENTS'", "'COMPOSE'", "'COMPOSITE'", "'COMPOSITE_LIMIT'", 
+        "'COMPOUND'", "'COMPRESS'", "'COMPRESSION'", "'COMPUTE'", "'COMPUTATION'", 
+        "'CONCAT'", "'CONCURRENT'", "'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'", 
+        "'COUNTED'", "'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'", "'CSV'", "'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'", 
+        "'DATAGUARDCONFIG'", "'DATAMOVEMENT'", "'DATAOBJNO'", "'DATAOBJ_TO_MAT_PARTITION'", 
+        "'DATAOBJ_TO_PARTITION'", "'DATAPUMP'", "'DATA_SECURITY_REWRITE_LIMIT'", 
+        "'DATE'", "'DATE_CACHE'", "'DATE_FORMAT'", "'DATE_MODE'", "'DAY'", 
+        "'DAYS'", "'DAY_TO_SECOND'", "'DBA'", "'DBA_RECYCLEBIN'", "'DBLINK'", 
+        "'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'", 
+        "'DEFAULTIF'", "'DEFAULTS'", "'DEFAULT_COLLATION'", "'DEFAULT_CREDENTIAL'", 
+        "'DEFERRABLE'", "'DEFERRED'", "'DEFINED'", "'DEFINE'", "'DEFINER'", 
+        "'DEGREE'", "'DELAY'", "'DELEGATE'", "'DELETE_ALL'", "'DELETE'", 
+        "'DELETEXML'", "'DELIMITED'", "'DEMAND'", "'DENSE_RANKM'", "'DEPENDENT'", 
+        "'DEPRECATE'", "'DEPTH'", "'DEQUEUE'", "'DEREF'", "'DEREF_NO_REWRITE'", 
+        "'DESC'", "'DESCRIPTION'", "'DESTROY'", "'DETACHED'", "'DETECTED'", 
+        "'DETERMINES'", "'DETERMINISTIC'", "'DICTIONARY'", "'DIMENSION'", 
+        "'DIMENSIONS'", "'DIRECTIO'", "'DIRECT_LOAD'", "'DIRECTORY'", "'DIRECT_PATH'", 
+        "'DISABLE_ALL'", "'DISABLE'", "'DISABLED'", "'DISABLE_DIRECTORY_LINK_CHECK'", 
+        "'DISABLE_PARALLEL_DML'", "'DISABLE_PRESET'", "'DISABLE_RPKE'", 
+        "'DISALLOW'", "'DISASSOCIATE'", "'DISCARD'", "'DISCARDFILE'", "'DISCONNECT'", 
+        "'DISK'", "'DISKGROUP'", "''+ DISKGROUP'", "'DISKS'", "'DISMOUNT'", 
+        "'DISTINCT'", "'DISTINGUISHED'", "'DISTRIBUTED'", "'DISTRIBUTE'", 
+        "'DML'", "'DML_UPDATE'", "'DNFS_DISABLE'", "'DNFS_ENABLE'", "'DNFS_READBUFFERS'", 
+        "'DOCFIDELITY'", "'DOCUMENT'", "'$ELSE'", "'$ELSIF'", "'$END'", 
+        "'$ERROR'", "'$IF'", "'$THEN'", "'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'", "'DUMPSET'", "'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'", "'EMBEDDED'", 
+        "'EMPTY_BLOB'", "'EMPTY_CLOB'", "'EMPTY'", "'ENABLE_ALL'", "'ENABLE'", 
+        "'ENABLED'", "'ENABLE_PARALLEL_DML'", "'ENABLE_PRESET'", "'ENCLOSED'", 
+        "'ENCODING'", "'ENCRYPT'", "'ENCRYPTION'", "'ENCRYPTPASSWORDISNULL'", 
+        "'END'", "'END_OUTLINE_DATA'", "'ENDIAN'", "'ENFORCED'", "'ENFORCE'", 
+        "'ENQUEUE'", "'ENTERPRISE'", "'ENTITYESCAPING'", "'ENTRY'", "'EQUIPART'", 
+        "'ERR'", "'ERROR_ARGUMENT'", "'ERROR'", "'ERROR_ON_OVERLAP_TIME'", 
+        "'ERRORS'", "'ERROR_INDEX'", "'ERROR_CODE'", "'ESCAPE'", "'ESCAPED'", 
+        "'ESTIMATE'", "'EVAL'", "'EVALNAME'", "'EVALUATE'", "'EVALUATION'", 
+        "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCEPTION'", "'EXCEPTION_INIT'", 
+        "'EXCEPTIONS'", "'EXCHANGE'", "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", 
+        "'EXEC'", "'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'", "'FIELD'", 
+        "'FIELDS'", "'FILE'", "'FILE_NAME_CONVERT'", "'FILEGROUP'", "'FILESTORE'", 
+        "'FILESYSTEM_LIKE_LOGGING'", "'FILTER'", "'FINAL'", "'FINE'", "'FINISH'", 
+        "'FIRST'", "'FIRSTM'", "'FIRST_ROWS'", "'FIRST_VALUE'", "'FIXED'", 
+        "'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'", "'HADOOP_TRAILERS'", "'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_CHARS_AFTER_EOR'", 
+        "'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'", "'INPUTFORMAT'", "'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'", "'INTERNAL'", "'INTO'", "'INVALIDATE'", "'INVALIDATION'", 
+        "'INVISIBLE'", "'IN_XQUERY'", "'IO_OPTIONS'", "'IS'", "'IS_LEAF'", 
+        "'ISOLATION'", "'ISOLATION_LEVEL'", "'ITEMS'", "'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'", "'LATEST'", "'LAX'", "'LAYER'", "'LDAP_REGISTRATION_ENABLED'", 
+        "'LDAP_REGISTRATION'", "'LDAP_REG_SYNC_INTERVAL'", "'LDRTRIM'", 
+        "'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'", "'LINES'", "'LINK'", "'LIST'", 
+        "'LITTLE'", "'LLS'", "'LN'", "'LNNVL'", "'LOAD'", "'LOB'", "'LOBFILE'", 
+        "'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'", "'LRTRIM'", 
+        "'LTRIM'", "'M'", "'MAIN'", "'MAKE_REF'", "'MANAGED'", "'MANAGE'", 
+        "'MANAGEMENT'", "'MANAGER'", "'MANDATORY'", "'MANUAL'", "'MAP'", 
+        "'MAPPING'", "'MASK'", "'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'", "'NEWLINE'", 
+        "'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'", "'NOBADFILE'", "'NO_AUTO_REOPTIMIZE'", 
+        "'NO_BASETABLE_MULTIMV_REWRITE'", "'NO_BATCH_TABLE_ACCESS_BY_ROWID'", 
+        "'NO_BIND_AWARE'", "'NO_BUFFER'", "'NOCACHE'", "'NOCHECK'", "'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'", "'NODIRECTIO'", "'NODISCARDFILE'", 
+        "'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'", "'NOEXTEND'", "'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'", "'NOLOG'", 
+        "'NOLOGFILE'", "'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'", "'NONPARTITIONED'", 
+        "'NONULLIF'", "'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'", "'NOSCALE'", "'NOSCHEMACHECK'", "'NOSEGMENT'", 
+        "'NO_SEMIJOIN'", "'NO_SEMI_TO_INNER'", "'NO_SET_TO_JOIN'", "'NOSHARD'", 
+        "'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'", "'NOTRIM'", "'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'", "'ONLINELOG'", "'ONLY'", "'ON'", 
+        "'OPAQUE'", "'OPAQUE_TRANSFORM'", "'OPAQUE_XCANONICAL'", "'OPCODE'", 
+        "'OPEN'", "'OPERATIONS'", "'OPERATOR'", "'OPT_ESTIMATE'", "'OPTIMAL'", 
+        "'OPTIMIZE'", "'OPTIMIZER_FEATURES_ENABLE'", "'OPTIMIZER_GOAL'", 
+        "'OPTION'", "'OPTIONALLY'", "'OPT_PARAM'", "'ORA_BRANCH'", "'ORA_CHECK_ACL'", 
+        "'ORA_CHECK_PRIVILEGE'", "'ORA_CLUSTERING'", "'ORADATA'", "'ORC'", 
+        "'ORACLE_DATE'", "'ORACLE_NUMBER'", "'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'", "'OUTPUTFORMAT'", "'OUT_OF_LINE'", 
+        "'OUT'", "'OVERFLOW_NOMOVE'", "'OVERFLOW'", "'OVERLAPS'", "'OVER'", 
+        "'OVERRIDE'", "'OVERRIDING'", "'OWNER'", "'OWNERSHIP'", "'OWN'", 
+        "'P'", "'PACKAGE'", "'PACKAGES'", "'PARALLEL_ENABLE'", "'PARALLEL_INDEX'", 
+        "'PARALLEL'", "'PARAMETERFILE'", "'PARAMETERS'", "'PARAM'", "'PARENT'", 
+        "'PARENT_LEVEL_NAME'", "'PARENT_UNIQUE_NAME'", "'PARITY'", "'PARQUET'", 
+        "'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'", null, 
+        null, null, "'PERCENT'", "'PERCENT_RANKM'", null, null, null, null, 
+        null, "'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'", 
+        "'POSITION'", "'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'", 
+        "'PREPROCESSOR'", "'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'", 
+        "'RCFILE'", "'RDBA'", "'READ'", "'READS'", "'READSIZE'", "'REALM'", 
+        "'REAL'", "'REBALANCE'", "'REBUILD'", "'RECORD'", "'RECORDS'", "'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'", "'SEQUENCEFILE'", "'SEQUENTIAL'", "'SEQ'", 
+        "'SERDE'", "'SERDEPROPERTIES'", "'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'", "'SHARD'", "'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'", 
+        "'SIZES'", "'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'", 
+        null, "'SQL_MACRO'", "'SQL_TRACE'", "'SQL_TRANSLATION_PROFILE'", 
+        "'SQRT'", "'STALE'", "'STANDALONE'", "'STANDARD'", "'STANDARD_HASH'", 
+        "'STANDBY_MAX_DATA_DELAY'", "'STANDBYS'", "'STANDBY'", "'STAR'", 
+        "'STAR_TRANSFORMATION'", "'START'", "'STARTOF'", "'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'", "'TEMPLATE_TABLE'", 
+        "'TEMPORARY'", "'TEMP_TABLE'", "'TERMINATED'", "'TEST'", "'TEXT'", 
+        "'TEXTFILE'", "'THAN'", "'THEN'", "'THE'", "'THESE'", "'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'", "'TINYINT'", "'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'", "'TRANSFORMS'", "'TRANSFORM_DISTINCT_AGG'", "'TRANSITIONAL'", 
+        "'TRANSITION'", "'TRANSLATE'", "'TRANSLATION'", "'TREAT'", "'TRIGGERS'", 
+        "'TRIGGER'", "'TRUE'", "'TRUNCATE'", "'TRUNC'", "'TRUSTED'", "'TRUST'", 
+        "'TUNING'", "'TX'", "'TYPES'", "'TYPE'", "'TZ_OFFSET'", "'UB2'", 
+        "'UBA'", "'UCS2'", "'UDF'", "'UID'", "'UNARCHIVED'", "'UNBOUNDED'", 
+        "'UNBOUND'", "'UNCONDITIONAL'", "'UNDER'", "'UNDO'", "'UNDROP'", 
+        "'UNIFORM'", "'UNION'", "'UNIONTYPE'", "'UNIQUE'", "'UNISTR'", "'UNLIMITED'", 
+        "'UNLOAD'", "'UNLOCK'", "'UNMATCHED'", "'UNNEST_INNERJ_DISTINCT_VIEW'", 
+        "'UNNEST_NOSEMIJ_NODISTINCTVIEW'", "'UNNEST_SEMIJ_VIEW'", "'UNNEST'", 
+        "'UNPACKED'", "'UNPIVOT'", "'UNPLUG'", "'UNPROTECTED'", "'UNQUIESCE'", 
+        "'UNRECOVERABLE'", "'UNRESTRICTED'", "'UNSIGNED'", "'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_NLS_COMP'", "'USING'", "'UTF16BE'", "'UTF16LE'", "'UTF32'", 
+        "'UTF8'", "'V1'", "'V2'", "'VALIDATE'", "'VALIDATE_CONVERSION'", 
+        "'VALIDATION'", "'VALID_TIME_END'", "'VALUES'", "'VALUE'", "'VARCHAR2'", 
+        "'VARCHAR'", "'VARCHARC'", "'VARIABLE'", "'VARRAW'", "'VARRAWC'", 
+        "'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'", "'WORKERID'", "'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'", "'XMLTAG'", "'XMLTRANSFORMBLOB'", 
+        "'XMLTRANSFORM'", "'XMLTYPE'", "'XML'", "'XPATHTABLE'", "'XS_SYS_CONTEXT'", 
+        "'XS'", "'XTRANSPORT'", "'YEARS'", "'YEAR'", "'YEAR_TO_MONTH'", 
+        "'YES'", "'YMINTERVAL_UNCONSTRAINED'", "'ZONEMAP'", "'ZONE'", "'ZONED'", 
+        "'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'", "'CHARSETID'", "'CHARSETFORM'", "'DURATION'", "'EXTEND'", 
+        "'MAXLEN'", "'PERSISTABLE'", "'POLYMORPHIC'", "'STRUCT'", "'TDO'", 
+        "'WM_CONCAT'", null, null, null, "'..'", "'.'", null, null, null, 
+        null, "'%'", "'&'", "'('", "')'", "'**'", "'*'", "'+'", "'-'", "','", 
+        "'/'", "'\\'", "'@'", "':='", "'#'", "'{'", "'}'", "'''", null, 
+        null, "'^'", "'~'", "'!'", "'>'", "'<'", "':'", "';'", "'|'", "'='", 
+        "'['", "']'", "'_'"
+    ];
+
+    public static readonly symbolicNames = [
+        null, "ABORT", "ABS", "ABSENT", "ACCESS", "ACCESSED", "ACCESSIBLE", 
+        "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", "ANNOTATIONS", "ANOMALY", "ANSI_REARCH", 
+        "ANTIJOIN", "ANY", "ANYSCHEMA", "APPEND", "APPENDCHILDXML", "APPEND_VALUES", 
+        "APPLICATION", "APPLY", "APPROX_COUNT_DISTINCT", "ARCHIVAL", "ARCHIVE", 
+        "ARCHIVED", "ARCHIVELOG", "ARE", "ARRAY", "AS", "ASC", "ASCII", 
+        "ASCIISTR", "ASIN", "ASIS", "ASSEMBLY", "ASSIGN", "ASSOCIATE", "ASYNC", 
+        "ASYNCHRONOUS", "ATAN2", "ATAN", "AT", "ATTRIBUTE", "ATTRIBUTES", 
+        "AUDIT", "AUTHENTICATED", "AUTHENTICATION", "AUTHID", "AUTHORIZATION", 
+        "AUTOALLOCATE", "AUTO", "AUTOBACKUP", "AUTOEXTEND", "AUTO_LOGIN", 
+        "AUTOMATIC", "AUTONOMOUS_TRANSACTION", "AUTO_REOPTIMIZE", "AVAILABILITY", 
+        "AVRO", "BACKGROUND", "BACKINGFILE", "BACKUP", "BACKUPS", "BACKUPSET", 
+        "BADFILE", "BASIC", "BASICFILE", "BATCH", "BATCHSIZE", "BATCH_TABLE_ACCESS_BY_ROWID", 
+        "BECOME", "BEFORE", "BEGIN", "BEGINNING", "BEGIN_OUTLINE_DATA", 
+        "BEHALF", "BEQUEATH", "BETWEEN", "BFILE", "BFILENAME", "BIG", "BIGFILE", 
+        "BIGINT", "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", "BLANKS", "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", "BYTES", "BYTEORDERMARK", "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", 
+        "CHANGETRACKING", "CHANGE_DUPKEY_ERROR_INDEX", "CHARACTER", "CHARACTERS", 
+        "CHARACTERSET", "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", "COLLECTION", "COLUMNAR", "COLUMN_AUTH_INDICATOR", 
+        "COLUMN", "COLUMNS", "COLUMN_STATS", "COLUMN_VALUE", "COMMENT", 
+        "COMMIT", "COMMITTED", "COMMON", "COMMON_DATA", "COMPACT", "COMPATIBLE", 
+        "COMPATIBILITY", "COMPILE", "COMPLETE", "COMPLIANCE", "COMPONENT", 
+        "COMPONENTS", "COMPOSE", "COMPOSITE", "COMPOSITE_LIMIT", "COMPOUND", 
+        "COMPRESS", "COMPRESSION", "COMPUTE", "COMPUTATION", "CONCAT", "CONCURRENT", 
+        "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", "COUNTED", "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", 
+        "CSV", "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", "DATAGUARDCONFIG", "DATAMOVEMENT", "DATAOBJNO", "DATAOBJ_TO_MAT_PARTITION", 
+        "DATAOBJ_TO_PARTITION", "DATAPUMP", "DATA_SECURITY_REWRITE_LIMIT", 
+        "DATE", "DATE_CACHE", "DATE_FORMAT", "DATE_MODE", "DAY", "DAYS", 
+        "DAY_TO_SECOND", "DBA", "DBA_RECYCLEBIN", "DBLINK", "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", "DEFAULTIF", "DEFAULTS", "DEFAULT_COLLATION", "DEFAULT_CREDENTIAL", 
+        "DEFERRABLE", "DEFERRED", "DEFINED", "DEFINE", "DEFINER", "DEGREE", 
+        "DELAY", "DELEGATE", "DELETE_ALL", "DELETE", "DELETEXML", "DELIMITED", 
+        "DEMAND", "DENSE_RANKM", "DEPENDENT", "DEPRECATE", "DEPTH", "DEQUEUE", 
+        "DEREF", "DEREF_NO_REWRITE", "DESC", "DESCRIPTION", "DESTROY", "DETACHED", 
+        "DETECTED", "DETERMINES", "DETERMINISTIC", "DICTIONARY", "DIMENSION", 
+        "DIMENSIONS", "DIRECTIO", "DIRECT_LOAD", "DIRECTORY", "DIRECT_PATH", 
+        "DISABLE_ALL", "DISABLE", "DISABLED", "DISABLE_DIRECTORY_LINK_CHECK", 
+        "DISABLE_PARALLEL_DML", "DISABLE_PRESET", "DISABLE_RPKE", "DISALLOW", 
+        "DISASSOCIATE", "DISCARD", "DISCARDFILE", "DISCONNECT", "DISK", 
+        "DISKGROUP", "DISKGROUP_PLUS", "DISKS", "DISMOUNT", "DISTINCT", 
+        "DISTINGUISHED", "DISTRIBUTED", "DISTRIBUTE", "DML", "DML_UPDATE", 
+        "DNFS_DISABLE", "DNFS_ENABLE", "DNFS_READBUFFERS", "DOCFIDELITY", 
+        "DOCUMENT", "DOLLAR_ELSE", "DOLLAR_ELSIF", "DOLLAR_END", "DOLLAR_ERROR", 
+        "DOLLAR_IF", "DOLLAR_THEN", "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", "DUMPSET", "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", 
+        "EMBEDDED", "EMPTY_BLOB", "EMPTY_CLOB", "EMPTY_", "ENABLE_ALL", 
+        "ENABLE", "ENABLED", "ENABLE_PARALLEL_DML", "ENABLE_PRESET", "ENCLOSED", 
+        "ENCODING", "ENCRYPT", "ENCRYPTION", "ENCRYPTPASSWORDISNULL", "END", 
+        "END_OUTLINE_DATA", "ENDIAN", "ENFORCED", "ENFORCE", "ENQUEUE", 
+        "ENTERPRISE", "ENTITYESCAPING", "ENTRY", "EQUIPART", "ERR", "ERROR_ARGUMENT", 
+        "ERROR", "ERROR_ON_OVERLAP_TIME", "ERRORS", "ERROR_INDEX", "ERROR_CODE", 
+        "ESCAPE", "ESCAPED", "ESTIMATE", "EVAL", "EVALNAME", "EVALUATE", 
+        "EVALUATION", "EVENTS", "EVERY", "EXCEPT", "EXCEPTION", "EXCEPTION_INIT", 
+        "EXCEPTIONS", "EXCHANGE", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXEC", 
+        "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", "FIELD", "FIELDS", "FILE", "FILE_NAME_CONVERT", 
+        "FILEGROUP", "FILESTORE", "FILESYSTEM_LIKE_LOGGING", "FILTER", "FINAL", 
+        "FINE", "FINISH", "FIRST", "FIRSTM", "FIRST_ROWS", "FIRST_VALUE", 
+        "FIXED", "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", "HADOOP_TRAILERS", 
+        "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_CHARS_AFTER_EOR", 
+        "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", "INPUTFORMAT", "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", "INTERNAL", "INTO", "INVALIDATE", 
+        "INVALIDATION", "INVISIBLE", "IN_XQUERY", "IO_OPTIONS", "IS", "IS_LEAF", 
+        "ISOLATION", "ISOLATION_LEVEL", "ITEMS", "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", "LATEST", "LAX", "LAYER", "LDAP_REGISTRATION_ENABLED", 
+        "LDAP_REGISTRATION", "LDAP_REG_SYNC_INTERVAL", "LDRTRIM", "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", "LINES", "LINK", "LIST", 
+        "LITTLE", "LLS", "LN", "LNNVL", "LOAD", "LOB", "LOBFILE", "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", "LRTRIM", "LTRIM", "M_LETTER", "MAIN", "MAKE_REF", "MANAGED", 
+        "MANAGE", "MANAGEMENT", "MANAGER", "MANDATORY", "MANUAL", "MAP", 
+        "MAPPING", "MASK", "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", "NEWLINE_", "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", "NOBADFILE", "NO_AUTO_REOPTIMIZE", "NO_BASETABLE_MULTIMV_REWRITE", 
+        "NO_BATCH_TABLE_ACCESS_BY_ROWID", "NO_BIND_AWARE", "NO_BUFFER", 
+        "NOCACHE", "NOCHECK", "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", 
+        "NODIRECTIO", "NODISCARDFILE", "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", 
+        "NOEXTEND", "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", 
+        "NOLOG", "NOLOGFILE", "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", "NONPARTITIONED", "NONULLIF", 
+        "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", "NOSCALE", "NOSCHEMACHECK", "NOSEGMENT", "NO_SEMIJOIN", 
+        "NO_SEMI_TO_INNER", "NO_SET_TO_JOIN", "NOSHARD", "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", "NOTRIM", "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", "ONLINELOG", "ONLY", "ON", 
+        "OPAQUE", "OPAQUE_TRANSFORM", "OPAQUE_XCANONICAL", "OPCODE", "OPEN", 
+        "OPERATIONS", "OPERATOR", "OPT_ESTIMATE", "OPTIMAL", "OPTIMIZE", 
+        "OPTIMIZER_FEATURES_ENABLE", "OPTIMIZER_GOAL", "OPTION", "OPTIONALLY", 
+        "OPT_PARAM", "ORA_BRANCH", "ORA_CHECK_ACL", "ORA_CHECK_PRIVILEGE", 
+        "ORA_CLUSTERING", "ORADATA", "ORC", "ORACLE_DATE", "ORACLE_NUMBER", 
+        "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", "OUTPUTFORMAT", 
+        "OUT_OF_LINE", "OUT", "OVERFLOW_NOMOVE", "OVERFLOW_", "OVERLAPS", 
+        "OVER", "OVERRIDE", "OVERRIDING", "OWNER", "OWNERSHIP", "OWN", "P_LETTER", 
+        "PACKAGE", "PACKAGES", "PARALLEL_ENABLE", "PARALLEL_INDEX", "PARALLEL", 
+        "PARAMETERFILE", "PARAMETERS", "PARAM", "PARENT", "PARENT_LEVEL_NAME", 
+        "PARENT_UNIQUE_NAME", "PARITY", "PARQUET", "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", "PERCENT_BULK_EXCEPTIONS", 
+        "PERCENT_BULK_ROWCOUNT", "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", "POSITION", "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", "PREPROCESSOR", "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", 
+        "RCFILE", "RDBA", "READ", "READS", "READSIZE", "REALM", "REAL", 
+        "REBALANCE", "REBUILD", "RECORD", "RECORDS", "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", "SEQUENCEFILE", "SEQUENTIAL", 
+        "SEQ", "SERDE", "SERDEPROPERTIES", "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", 
+        "SHARD", "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", "SIZES", 
+        "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", "FILE_EXT", "SQL_MACRO", "SQL_TRACE", "SQL_TRANSLATION_PROFILE", 
+        "SQRT", "STALE", "STANDALONE", "STANDARD", "STANDARD_HASH", "STANDBY_MAX_DATA_DELAY", 
+        "STANDBYS", "STANDBY", "STAR", "STAR_TRANSFORMATION", "START", "STARTOF", 
+        "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", "TEMPLATE_TABLE", "TEMPORARY", 
+        "TEMP_TABLE", "TERMINATED", "TEST", "TEXT", "TEXTFILE", "THAN", 
+        "THEN", "THE", "THESE", "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", "TINYINT", "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", "TRANSFORMS", 
+        "TRANSFORM_DISTINCT_AGG", "TRANSITIONAL", "TRANSITION", "TRANSLATE", 
+        "TRANSLATION", "TREAT", "TRIGGERS", "TRIGGER", "TRUE", "TRUNCATE", 
+        "TRUNC", "TRUSTED", "TRUST", "TUNING", "TX", "TYPES", "TYPE", "TZ_OFFSET", 
+        "UB2", "UBA", "UCS2", "UDF", "UID", "UNARCHIVED", "UNBOUNDED", "UNBOUND", 
+        "UNCONDITIONAL", "UNDER", "UNDO", "UNDROP", "UNIFORM", "UNION", 
+        "UNIONTYPE", "UNIQUE", "UNISTR", "UNLIMITED", "UNLOAD", "UNLOCK", 
+        "UNMATCHED", "UNNEST_INNERJ_DISTINCT_VIEW", "UNNEST_NOSEMIJ_NODISTINCTVIEW", 
+        "UNNEST_SEMIJ_VIEW", "UNNEST", "UNPACKED", "UNPIVOT", "UNPLUG", 
+        "UNPROTECTED", "UNQUIESCE", "UNRECOVERABLE", "UNRESTRICTED", "UNSIGNED", 
+        "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_NLS_COMP", "USING", "UTF16BE", "UTF16LE", 
+        "UTF32", "UTF8", "V1", "V2", "VALIDATE", "VALIDATE_CONVERSION", 
+        "VALIDATION", "VALID_TIME_END", "VALUES", "VALUE", "VARCHAR2", "VARCHAR", 
+        "VARCHARC", "VARIABLE", "VARRAW", "VARRAWC", "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", "WORKERID", "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", "XMLTAG", "XMLTRANSFORMBLOB", 
+        "XMLTRANSFORM", "XMLTYPE", "XML", "XPATHTABLE", "XS_SYS_CONTEXT", 
+        "XS", "XTRANSPORT", "YEARS", "YEAR", "YEAR_TO_MONTH", "YES", "YMINTERVAL_UNCONSTRAINED", 
+        "ZONEMAP", "ZONE", "ZONED", "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", "CHARSETID", 
+        "CHARSETFORM", "DURATION", "EXTEND", "MAXLEN", "PERSISTABLE", "POLYMORPHIC", 
+        "STRUCT", "TDO", "WM_CONCAT", "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", "RSOLIDUS", "AT_SIGN", 
+        "ASSIGN_OP", "HASH_OP", "LEFT_CURLY_PAREN", "RIGHT_CURLY_PAREN", 
+        "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", "REGULAR_ID", "INQUIRY_DIRECTIVE", "SPACES"
+    ];
+
+    public static readonly modeNames = [
+        "DEFAULT_MODE",
+    ];
+
+    public static readonly ruleNames = [
+        "ABORT", "ABS", "ABSENT", "ACCESS", "ACCESSED", "ACCESSIBLE", "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", "ANNOTATIONS", "ANOMALY", "ANSI_REARCH", "ANTIJOIN", 
+        "ANY", "ANYSCHEMA", "APPEND", "APPENDCHILDXML", "APPEND_VALUES", 
+        "APPLICATION", "APPLY", "APPROX_COUNT_DISTINCT", "ARCHIVAL", "ARCHIVE", 
+        "ARCHIVED", "ARCHIVELOG", "ARE", "ARRAY", "AS", "ASC", "ASCII", 
+        "ASCIISTR", "ASIN", "ASIS", "ASSEMBLY", "ASSIGN", "ASSOCIATE", "ASYNC", 
+        "ASYNCHRONOUS", "ATAN2", "ATAN", "AT", "ATTRIBUTE", "ATTRIBUTES", 
+        "AUDIT", "AUTHENTICATED", "AUTHENTICATION", "AUTHID", "AUTHORIZATION", 
+        "AUTOALLOCATE", "AUTO", "AUTOBACKUP", "AUTOEXTEND", "AUTO_LOGIN", 
+        "AUTOMATIC", "AUTONOMOUS_TRANSACTION", "AUTO_REOPTIMIZE", "AVAILABILITY", 
+        "AVRO", "BACKGROUND", "BACKINGFILE", "BACKUP", "BACKUPS", "BACKUPSET", 
+        "BADFILE", "BASIC", "BASICFILE", "BATCH", "BATCHSIZE", "BATCH_TABLE_ACCESS_BY_ROWID", 
+        "BECOME", "BEFORE", "BEGIN", "BEGINNING", "BEGIN_OUTLINE_DATA", 
+        "BEHALF", "BEQUEATH", "BETWEEN", "BFILE", "BFILENAME", "BIG", "BIGFILE", 
+        "BIGINT", "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", "BLANKS", "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", "BYTES", "BYTEORDERMARK", "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", 
+        "CHANGETRACKING", "CHANGE_DUPKEY_ERROR_INDEX", "CHARACTER", "CHARACTERS", 
+        "CHARACTERSET", "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", "COLLECTION", "COLUMNAR", "COLUMN_AUTH_INDICATOR", 
+        "COLUMN", "COLUMNS", "COLUMN_STATS", "COLUMN_VALUE", "COMMENT", 
+        "COMMIT", "COMMITTED", "COMMON", "COMMON_DATA", "COMPACT", "COMPATIBLE", 
+        "COMPATIBILITY", "COMPILE", "COMPLETE", "COMPLIANCE", "COMPONENT", 
+        "COMPONENTS", "COMPOSE", "COMPOSITE", "COMPOSITE_LIMIT", "COMPOUND", 
+        "COMPRESS", "COMPRESSION", "COMPUTE", "COMPUTATION", "CONCAT", "CONCURRENT", 
+        "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", "COUNTED", "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", 
+        "CSV", "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", "DATAGUARDCONFIG", "DATAMOVEMENT", "DATAOBJNO", "DATAOBJ_TO_MAT_PARTITION", 
+        "DATAOBJ_TO_PARTITION", "DATAPUMP", "DATA_SECURITY_REWRITE_LIMIT", 
+        "DATE", "DATE_CACHE", "DATE_FORMAT", "DATE_MODE", "DAY", "DAYS", 
+        "DAY_TO_SECOND", "DBA", "DBA_RECYCLEBIN", "DBLINK", "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", "DEFAULTIF", "DEFAULTS", "DEFAULT_COLLATION", "DEFAULT_CREDENTIAL", 
+        "DEFERRABLE", "DEFERRED", "DEFINED", "DEFINE", "DEFINER", "DEGREE", 
+        "DELAY", "DELEGATE", "DELETE_ALL", "DELETE", "DELETEXML", "DELIMITED", 
+        "DEMAND", "DENSE_RANKM", "DEPENDENT", "DEPRECATE", "DEPTH", "DEQUEUE", 
+        "DEREF", "DEREF_NO_REWRITE", "DESC", "DESCRIPTION", "DESTROY", "DETACHED", 
+        "DETECTED", "DETERMINES", "DETERMINISTIC", "DICTIONARY", "DIMENSION", 
+        "DIMENSIONS", "DIRECTIO", "DIRECT_LOAD", "DIRECTORY", "DIRECT_PATH", 
+        "DISABLE_ALL", "DISABLE", "DISABLED", "DISABLE_DIRECTORY_LINK_CHECK", 
+        "DISABLE_PARALLEL_DML", "DISABLE_PRESET", "DISABLE_RPKE", "DISALLOW", 
+        "DISASSOCIATE", "DISCARD", "DISCARDFILE", "DISCONNECT", "DISK", 
+        "DISKGROUP", "DISKGROUP_PLUS", "DISKS", "DISMOUNT", "DISTINCT", 
+        "DISTINGUISHED", "DISTRIBUTED", "DISTRIBUTE", "DML", "DML_UPDATE", 
+        "DNFS_DISABLE", "DNFS_ENABLE", "DNFS_READBUFFERS", "DOCFIDELITY", 
+        "DOCUMENT", "DOLLAR_ELSE", "DOLLAR_ELSIF", "DOLLAR_END", "DOLLAR_ERROR", 
+        "DOLLAR_IF", "DOLLAR_THEN", "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", "DUMPSET", "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", 
+        "EMBEDDED", "EMPTY_BLOB", "EMPTY_CLOB", "EMPTY_", "ENABLE_ALL", 
+        "ENABLE", "ENABLED", "ENABLE_PARALLEL_DML", "ENABLE_PRESET", "ENCLOSED", 
+        "ENCODING", "ENCRYPT", "ENCRYPTION", "ENCRYPTPASSWORDISNULL", "END", 
+        "END_OUTLINE_DATA", "ENDIAN", "ENFORCED", "ENFORCE", "ENQUEUE", 
+        "ENTERPRISE", "ENTITYESCAPING", "ENTRY", "EQUIPART", "ERR", "ERROR_ARGUMENT", 
+        "ERROR", "ERROR_ON_OVERLAP_TIME", "ERRORS", "ERROR_INDEX", "ERROR_CODE", 
+        "ESCAPE", "ESCAPED", "ESTIMATE", "EVAL", "EVALNAME", "EVALUATE", 
+        "EVALUATION", "EVENTS", "EVERY", "EXCEPT", "EXCEPTION", "EXCEPTION_INIT", 
+        "EXCEPTIONS", "EXCHANGE", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXEC", 
+        "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", "FIELD", "FIELDS", "FILE", "FILE_NAME_CONVERT", 
+        "FILEGROUP", "FILESTORE", "FILESYSTEM_LIKE_LOGGING", "FILTER", "FINAL", 
+        "FINE", "FINISH", "FIRST", "FIRSTM", "FIRST_ROWS", "FIRST_VALUE", 
+        "FIXED", "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", "HADOOP_TRAILERS", 
+        "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_CHARS_AFTER_EOR", 
+        "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", "INPUTFORMAT", "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", "INTERNAL", "INTO", "INVALIDATE", 
+        "INVALIDATION", "INVISIBLE", "IN_XQUERY", "IO_OPTIONS", "IS", "IS_LEAF", 
+        "ISOLATION", "ISOLATION_LEVEL", "ITEMS", "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", "LATEST", "LAX", "LAYER", "LDAP_REGISTRATION_ENABLED", 
+        "LDAP_REGISTRATION", "LDAP_REG_SYNC_INTERVAL", "LDRTRIM", "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", "LINES", "LINK", "LIST", 
+        "LITTLE", "LLS", "LN", "LNNVL", "LOAD", "LOB", "LOBFILE", "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", "LRTRIM", "LTRIM", "M_LETTER", "MAIN", "MAKE_REF", "MANAGED", 
+        "MANAGE", "MANAGEMENT", "MANAGER", "MANDATORY", "MANUAL", "MAP", 
+        "MAPPING", "MASK", "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", "NEWLINE_", "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", "NOBADFILE", "NO_AUTO_REOPTIMIZE", "NO_BASETABLE_MULTIMV_REWRITE", 
+        "NO_BATCH_TABLE_ACCESS_BY_ROWID", "NO_BIND_AWARE", "NO_BUFFER", 
+        "NOCACHE", "NOCHECK", "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", 
+        "NODIRECTIO", "NODISCARDFILE", "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", 
+        "NOEXTEND", "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", 
+        "NOLOG", "NOLOGFILE", "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", "NONPARTITIONED", "NONULLIF", 
+        "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", "NOSCALE", "NOSCHEMACHECK", "NOSEGMENT", "NO_SEMIJOIN", 
+        "NO_SEMI_TO_INNER", "NO_SET_TO_JOIN", "NOSHARD", "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", "NOTRIM", "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", "ONLINELOG", "ONLY", "ON", 
+        "OPAQUE", "OPAQUE_TRANSFORM", "OPAQUE_XCANONICAL", "OPCODE", "OPEN", 
+        "OPERATIONS", "OPERATOR", "OPT_ESTIMATE", "OPTIMAL", "OPTIMIZE", 
+        "OPTIMIZER_FEATURES_ENABLE", "OPTIMIZER_GOAL", "OPTION", "OPTIONALLY", 
+        "OPT_PARAM", "ORA_BRANCH", "ORA_CHECK_ACL", "ORA_CHECK_PRIVILEGE", 
+        "ORA_CLUSTERING", "ORADATA", "ORC", "ORACLE_DATE", "ORACLE_NUMBER", 
+        "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", "OUTPUTFORMAT", 
+        "OUT_OF_LINE", "OUT", "OVERFLOW_NOMOVE", "OVERFLOW_", "OVERLAPS", 
+        "OVER", "OVERRIDE", "OVERRIDING", "OWNER", "OWNERSHIP", "OWN", "P_LETTER", 
+        "PACKAGE", "PACKAGES", "PARALLEL_ENABLE", "PARALLEL_INDEX", "PARALLEL", 
+        "PARAMETERFILE", "PARAMETERS", "PARAM", "PARENT", "PARENT_LEVEL_NAME", 
+        "PARENT_UNIQUE_NAME", "PARITY", "PARQUET", "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", "PERCENT_BULK_EXCEPTIONS", 
+        "PERCENT_BULK_ROWCOUNT", "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", "POSITION", "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", "PREPROCESSOR", "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", 
+        "RCFILE", "RDBA", "READ", "READS", "READSIZE", "REALM", "REAL", 
+        "REBALANCE", "REBUILD", "RECORD", "RECORDS", "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", "SEQUENCEFILE", "SEQUENTIAL", 
+        "SEQ", "SERDE", "SERDEPROPERTIES", "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", 
+        "SHARD", "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", "SIZES", 
+        "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", "FILE_EXT", "SQL_MACRO", "SQL_TRACE", "SQL_TRANSLATION_PROFILE", 
+        "SQRT", "STALE", "STANDALONE", "STANDARD", "STANDARD_HASH", "STANDBY_MAX_DATA_DELAY", 
+        "STANDBYS", "STANDBY", "STAR", "STAR_TRANSFORMATION", "START", "STARTOF", 
+        "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", "TEMPLATE_TABLE", "TEMPORARY", 
+        "TEMP_TABLE", "TERMINATED", "TEST", "TEXT", "TEXTFILE", "THAN", 
+        "THEN", "THE", "THESE", "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", "TINYINT", "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", "TRANSFORMS", 
+        "TRANSFORM_DISTINCT_AGG", "TRANSITIONAL", "TRANSITION", "TRANSLATE", 
+        "TRANSLATION", "TREAT", "TRIGGERS", "TRIGGER", "TRUE", "TRUNCATE", 
+        "TRUNC", "TRUSTED", "TRUST", "TUNING", "TX", "TYPES", "TYPE", "TZ_OFFSET", 
+        "UB2", "UBA", "UCS2", "UDF", "UID", "UNARCHIVED", "UNBOUNDED", "UNBOUND", 
+        "UNCONDITIONAL", "UNDER", "UNDO", "UNDROP", "UNIFORM", "UNION", 
+        "UNIONTYPE", "UNIQUE", "UNISTR", "UNLIMITED", "UNLOAD", "UNLOCK", 
+        "UNMATCHED", "UNNEST_INNERJ_DISTINCT_VIEW", "UNNEST_NOSEMIJ_NODISTINCTVIEW", 
+        "UNNEST_SEMIJ_VIEW", "UNNEST", "UNPACKED", "UNPIVOT", "UNPLUG", 
+        "UNPROTECTED", "UNQUIESCE", "UNRECOVERABLE", "UNRESTRICTED", "UNSIGNED", 
+        "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_NLS_COMP", "USING", "UTF16BE", "UTF16LE", 
+        "UTF32", "UTF8", "V1", "V2", "VALIDATE", "VALIDATE_CONVERSION", 
+        "VALIDATION", "VALID_TIME_END", "VALUES", "VALUE", "VARCHAR2", "VARCHAR", 
+        "VARCHARC", "VARIABLE", "VARRAW", "VARRAWC", "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", "WORKERID", "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", "XMLTAG", "XMLTRANSFORMBLOB", 
+        "XMLTRANSFORM", "XMLTYPE", "XML", "XPATHTABLE", "XS_SYS_CONTEXT", 
+        "XS", "XTRANSPORT", "YEARS", "YEAR", "YEAR_TO_MONTH", "YES", "YMINTERVAL_UNCONSTRAINED", 
+        "ZONEMAP", "ZONE", "ZONED", "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", "CHARSETID", 
+        "CHARSETFORM", "DURATION", "EXTEND", "MAXLEN", "PERSISTABLE", "POLYMORPHIC", 
+        "STRUCT", "TDO", "WM_CONCAT", "NATIONAL_CHAR_STRING_LIT", "BIT_STRING_LIT", 
+        "HEX_STRING_LIT", "DOUBLE_PERIOD", "PERIOD", "UNSIGNED_INTEGER", 
+        "APPROXIMATE_NUM_LIT", "CHAR_STRING", "CHAR_STRING_PERL", "DELIMITED_ID", 
+        "PERCENT", "AMPERSAND", "LEFT_PAREN", "RIGHT_PAREN", "DOUBLE_ASTERISK", 
+        "ASTERISK", "PLUS_SIGN", "MINUS_SIGN", "COMMA", "SOLIDUS", "RSOLIDUS", 
+        "AT_SIGN", "ASSIGN_OP", "HASH_OP", "LEFT_CURLY_PAREN", "RIGHT_CURLY_PAREN", 
+        "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", "REGULAR_ID", "INQUIRY_DIRECTIVE", "SPACES", "NEWLINE_EOF", 
+        "QUESTION_MARK", "SIMPLE_LETTER", "FLOAT_FRAGMENT", "NEWLINE", "SPACE",
+    ];
+
+
+    public constructor(input: antlr.CharStream) {
+        super(input);
+        this.interpreter = new antlr.LexerATNSimulator(this, PlSqlLexer._ATN, PlSqlLexer.decisionsToDFA, new antlr.PredictionContextCache());
+    }
+
+    public get grammarFileName(): string { return "PlSqlLexer.g4"; }
+
+    public get literalNames(): (string | null)[] { return PlSqlLexer.literalNames; }
+    public get symbolicNames(): (string | null)[] { return PlSqlLexer.symbolicNames; }
+    public get ruleNames(): string[] { return PlSqlLexer.ruleNames; }
+
+    public get serializedATN(): number[] { return PlSqlLexer._serializedATN; }
+
+    public get channelNames(): string[] { return PlSqlLexer.channelNames; }
+
+    public get modeNames(): string[] { return PlSqlLexer.modeNames; }
+
+    public override sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean {
+        switch (ruleIndex) {
+        case 2445:
+            return this.CHAR_STRING_PERL_sempred(localContext, predIndex);
+        case 2480:
+            return this.REMARK_COMMENT_sempred(localContext, predIndex);
+        case 2481:
+            return this.PROMPT_MESSAGE_sempred(localContext, predIndex);
+        }
+        return true;
+    }
+    private CHAR_STRING_PERL_sempred(localContext: antlr.ParserRuleContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 0:
+            return this.IsQQuoteDelimiter();
+        }
+        return true;
+    }
+    private REMARK_COMMENT_sempred(localContext: antlr.ParserRuleContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 1:
+            return this.IsNewlineAtPos(-4);
+        }
+        return true;
+    }
+    private PROMPT_MESSAGE_sempred(localContext: antlr.ParserRuleContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 2:
+            return this.IsNewlineAtPos(-4);
+        }
+        return true;
+    }
+
+    public static readonly _serializedATN: number[] = [
+        4,0,2484,32351,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,
+        2,2444,7,2444,2,2445,7,2445,2,2446,7,2446,2,2447,7,2447,2,2448,7,
+        2448,2,2449,7,2449,2,2450,7,2450,2,2451,7,2451,2,2452,7,2452,2,2453,
+        7,2453,2,2454,7,2454,2,2455,7,2455,2,2456,7,2456,2,2457,7,2457,2,
+        2458,7,2458,2,2459,7,2459,2,2460,7,2460,2,2461,7,2461,2,2462,7,2462,
+        2,2463,7,2463,2,2464,7,2464,2,2465,7,2465,2,2466,7,2466,2,2467,7,
+        2467,2,2468,7,2468,2,2469,7,2469,2,2470,7,2470,2,2471,7,2471,2,2472,
+        7,2472,2,2473,7,2473,2,2474,7,2474,2,2475,7,2475,2,2476,7,2476,2,
+        2477,7,2477,2,2478,7,2478,2,2479,7,2479,2,2480,7,2480,2,2481,7,2481,
+        2,2482,7,2482,2,2483,7,2483,2,2484,7,2484,2,2485,7,2485,2,2486,7,
+        2486,2,2487,7,2487,2,2488,7,2488,2,2489,7,2489,2,2490,7,2490,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,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,
+        1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,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,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,12,1,
+        12,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,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,16,1,16,1,
+        16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,
+        16,1,17,1,17,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,19,1,19,1,19,1,19,1,19,1,
+        19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,
+        21,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,23,1,23,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,24,1,
+        24,1,24,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,27,1,27,1,27,1,27,1,27,1,27,1,27,1,
+        27,1,27,1,27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,
+        28,1,28,1,28,1,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,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,
+        31,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,1,
+        33,1,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,
+        34,1,34,1,34,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,37,1,37,1,
+        37,1,37,1,38,1,38,1,38,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,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,
+        41,1,41,1,41,1,41,1,41,1,41,1,42,1,42,1,42,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,44,1,44,1,44,1,
+        44,1,44,1,44,1,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,
+        45,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,47,1,47,1,47,1,
+        47,1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,49,1,49,1,
+        49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,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,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,
+        52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,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,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,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,58,1,
+        58,1,58,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,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,61,1,61,1,61,1,61,1,61,1,
+        61,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,
+        64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,
+        65,1,65,1,65,1,65,1,65,1,65,1,65,1,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,69,1,69,1,69,1,69,1,70,1,70,1,
+        70,1,70,1,70,1,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,
+        72,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,
+        74,1,74,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,
+        76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,77,1,77,1,77,1,
+        77,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,
+        78,1,78,1,78,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1,80,1,
+        80,1,81,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,
+        82,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,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,86,1,86,1,87,1,87,1,87,1,87,1,87,1,
+        87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,
+        88,1,88,1,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,
+        89,1,89,1,89,1,90,1,90,1,90,1,90,1,90,1,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,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,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,95,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,96,1,96,1,96,1,96,1,97,1,
+        97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,98,1,
+        98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,
+        99,1,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,
+        100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,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,104,1,104,1,104,1,104,1,104,
+        1,104,1,104,1,104,1,105,1,105,1,105,1,105,1,105,1,105,1,106,1,106,
+        1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,107,1,107,1,107,
+        1,107,1,107,1,107,1,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,109,1,109,
+        1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,
+        1,109,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,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,114,1,114,1,114,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,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,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,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,122,
+        1,122,1,122,1,122,1,122,1,122,1,122,1,123,1,123,1,123,1,123,1,123,
+        1,123,1,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,
+        1,124,1,124,1,124,1,124,1,124,1,125,1,125,1,125,1,125,1,125,1,125,
+        1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,
+        1,125,1,125,1,125,1,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,
+        1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126,
+        1,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,127,1,127,1,128,1,128,1,128,1,128,1,128,1,128,1,128,
+        1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,
+        1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,
+        1,129,1,129,1,129,1,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,130,1,130,1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,
+        1,131,1,131,1,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,
+        1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,
+        1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,135,1,135,1,135,1,135,
+        1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,136,1,136,1,136,1,136,
+        1,136,1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,
+        1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,
+        1,138,1,139,1,139,1,139,1,139,1,139,1,140,1,140,1,140,1,140,1,140,
+        1,140,1,140,1,141,1,141,1,141,1,141,1,141,1,142,1,142,1,142,1,142,
+        1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,143,1,143,1,143,1,143,
+        1,143,1,143,1,143,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,145,
+        1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,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,148,1,148,1,148,1,148,1,148,1,149,1,149,1,149,1,149,1,149,1,149,
+        1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,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,153,1,153,1,153,1,153,1,153,1,154,1,154,1,154,
+        1,154,1,154,1,154,1,154,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
+        1,155,1,155,1,155,1,155,1,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,157,1,157,1,157,1,157,
+        1,157,1,157,1,158,1,158,1,158,1,158,1,158,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,160,1,160,1,160,
+        1,160,1,160,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,161,1,161,1,161,1,161,1,161,1,161,
+        1,161,1,162,1,162,1,162,1,162,1,162,1,163,1,163,1,163,1,163,1,163,
+        1,163,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,164,
+        1,164,1,164,1,164,1,164,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,167,1,167,1,167,
+        1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,
+        1,167,1,167,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,
+        1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,169,1,169,1,169,
+        1,169,1,169,1,169,1,169,1,169,1,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,173,1,173,1,173,
+        1,173,1,173,1,173,1,173,1,174,1,174,1,174,1,174,1,174,1,174,1,174,
+        1,174,1,174,1,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,
+        1,175,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,177,1,177,
+        1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,178,
+        1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,179,1,179,1,179,1,179,
+        1,179,1,180,1,180,1,180,1,180,1,180,1,181,1,181,1,181,1,181,1,181,
+        1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,182,
+        1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,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,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,
+        1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,185,1,186,1,186,
+        1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,187,
+        1,187,1,187,1,187,1,187,1,187,1,188,1,188,1,188,1,188,1,188,1,188,
+        1,188,1,188,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,190,1,190,
+        1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,
+        1,190,1,190,1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,
+        1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,
+        1,191,1,191,1,191,1,191,1,191,1,191,1,192,1,192,1,192,1,192,1,192,
+        1,192,1,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,194,1,194,1,194,1,194,1,194,1,194,1,195,1,195,1,195,1,195,
+        1,195,1,196,1,196,1,196,1,196,1,196,1,196,1,196,1,196,1,197,1,197,
+        1,197,1,197,1,197,1,197,1,197,1,197,1,197,1,197,1,197,1,197,1,198,
+        1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,
+        1,198,1,198,1,198,1,198,1,198,1,198,1,199,1,199,1,199,1,199,1,199,
+        1,199,1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,1,200,
+        1,200,1,201,1,201,1,201,1,201,1,201,1,201,1,202,1,202,1,202,1,202,
+        1,202,1,202,1,202,1,203,1,203,1,203,1,203,1,204,1,204,1,204,1,204,
+        1,204,1,204,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,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,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,211,1,211,1,211,1,211,1,211,1,211,1,212,1,212,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,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,216,1,216,1,216,1,216,1,216,1,216,
+        1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,217,1,217,1,217,
+        1,217,1,217,1,217,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,
+        1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,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,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,
+        1,221,1,221,1,221,1,221,1,221,1,221,1,222,1,222,1,222,1,222,1,222,
+        1,222,1,222,1,222,1,222,1,222,1,222,1,223,1,223,1,223,1,223,1,223,
+        1,223,1,223,1,223,1,223,1,223,1,223,1,224,1,224,1,224,1,224,1,224,
+        1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,
+        1,224,1,224,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,
+        1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,
+        1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
+        1,226,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,228,1,228,1,228,1,228,1,228,
+        1,229,1,229,1,229,1,229,1,229,1,229,1,229,1,230,1,230,1,230,1,230,
+        1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,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,233,1,233,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,235,1,235,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,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,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,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,242,1,242,
+        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,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,246,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,
+        1,247,1,247,1,247,1,247,1,247,1,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,250,1,250,1,250,1,250,1,250,1,250,1,250,1,250,1,250,1,250,1,250,
+        1,251,1,251,1,251,1,251,1,251,1,251,1,251,1,251,1,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,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,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,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,259,1,259,1,259,
+        1,259,1,259,1,259,1,259,1,259,1,260,1,260,1,260,1,260,1,260,1,260,
+        1,260,1,260,1,260,1,260,1,260,1,260,1,261,1,261,1,261,1,261,1,261,
+        1,261,1,261,1,262,1,262,1,262,1,262,1,262,1,262,1,262,1,262,1,262,
+        1,262,1,262,1,263,1,263,1,263,1,263,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,264,1,264,1,264,1,265,1,265,1,265,1,265,
+        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,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,268,1,268,1,268,1,269,1,269,1,269,1,269,
+        1,269,1,269,1,269,1,270,1,270,1,270,1,270,1,270,1,270,1,270,1,270,
+        1,270,1,270,1,270,1,270,1,270,1,270,1,270,1,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,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,272,1,272,1,272,1,272,1,272,1,272,1,272,1,273,1,273,1,273,
+        1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,
+        1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,274,1,274,1,274,
+        1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,
+        1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,275,1,275,1,275,1,275,
+        1,275,1,275,1,275,1,275,1,275,1,275,1,275,1,275,1,275,1,275,1,275,
+        1,275,1,275,1,275,1,275,1,275,1,275,1,276,1,276,1,276,1,276,1,276,
+        1,276,1,276,1,276,1,276,1,276,1,276,1,276,1,276,1,276,1,276,1,276,
+        1,276,1,276,1,276,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,
+        1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,278,
+        1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278,
+        1,278,1,278,1,278,1,278,1,279,1,279,1,279,1,279,1,279,1,279,1,279,
+        1,279,1,280,1,280,1,280,1,280,1,280,1,280,1,280,1,280,1,280,1,280,
+        1,280,1,280,1,280,1,281,1,281,1,281,1,281,1,281,1,281,1,281,1,281,
+        1,281,1,282,1,282,1,282,1,282,1,282,1,282,1,282,1,282,1,282,1,282,
+        1,282,1,283,1,283,1,283,1,283,1,283,1,283,1,283,1,283,1,283,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,285,1,285,1,285,1,285,1,286,1,286,1,286,1,286,1,286,1,286,
+        1,286,1,286,1,286,1,286,1,286,1,286,1,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,289,1,289,1,289,1,289,1,289,
+        1,289,1,289,1,289,1,289,1,289,1,289,1,290,1,290,1,290,1,290,1,290,
+        1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,
+        1,290,1,290,1,290,1,291,1,291,1,291,1,291,1,291,1,291,1,291,1,291,
+        1,291,1,291,1,291,1,291,1,291,1,291,1,291,1,292,1,292,1,292,1,292,
+        1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,293,
+        1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,294,1,294,1,294,1,294,
+        1,294,1,294,1,294,1,294,1,294,1,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,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,299,1,299,1,299,1,299,1,299,1,299,1,299,
+        1,299,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,
+        1,300,1,301,1,301,1,301,1,301,1,301,1,301,1,301,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,304,1,304,
+        1,304,1,304,1,304,1,304,1,304,1,305,1,305,1,305,1,305,1,305,1,305,
+        1,305,1,305,1,305,1,305,1,305,1,306,1,306,1,306,1,306,1,306,1,306,
+        1,306,1,306,1,306,1,306,1,306,1,306,1,306,1,306,1,306,1,306,1,307,
+        1,307,1,307,1,307,1,307,1,307,1,307,1,307,1,307,1,307,1,307,1,307,
+        1,308,1,308,1,308,1,308,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,311,1,311,1,311,1,311,1,311,1,311,1,311,1,311,1,311,1,311,1,311,
+        1,311,1,311,1,311,1,311,1,312,1,312,1,312,1,312,1,312,1,312,1,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,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,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,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,321,1,321,1,321,1,321,1,321,1,321,
+        1,321,1,321,1,321,1,321,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,322,
+        1,322,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,325,
+        1,325,1,325,1,325,1,325,1,325,1,325,1,325,1,325,1,326,1,326,1,326,
+        1,326,1,326,1,326,1,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,
+        1,327,1,327,1,327,1,327,1,327,1,328,1,328,1,328,1,328,1,328,1,328,
+        1,328,1,328,1,328,1,328,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,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,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,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,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,338,1,338,1,338,1,338,
+        1,338,1,338,1,338,1,338,1,338,1,338,1,338,1,338,1,338,1,339,1,339,
+        1,339,1,339,1,339,1,339,1,339,1,339,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,340,1,340,
+        1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,341,1,341,1,341,1,341,
+        1,341,1,341,1,341,1,341,1,341,1,342,1,342,1,342,1,342,1,342,1,342,
+        1,342,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,
+        1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,
+        1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,
+        1,344,1,344,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,346,1,346,1,346,1,347,1,347,1,347,1,347,1,347,
+        1,347,1,348,1,348,1,348,1,348,1,348,1,348,1,348,1,348,1,348,1,349,
+        1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,350,1,350,1,350,
+        1,350,1,350,1,351,1,351,1,351,1,351,1,351,1,351,1,351,1,351,1,351,
+        1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,353,
+        1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,
+        1,353,1,353,1,353,1,353,1,354,1,354,1,354,1,354,1,354,1,354,1,354,
+        1,354,1,354,1,354,1,354,1,354,1,354,1,355,1,355,1,355,1,355,1,355,
+        1,355,1,355,1,355,1,355,1,355,1,356,1,356,1,356,1,356,1,356,1,356,
+        1,356,1,356,1,356,1,356,1,356,1,356,1,356,1,356,1,356,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,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,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,359,1,359,1,359,1,359,1,359,1,359,1,359,
+        1,359,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,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,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,363,1,364,1,364,1,364,1,364,1,365,1,365,
+        1,365,1,365,1,365,1,366,1,366,1,366,1,366,1,366,1,366,1,366,1,366,
+        1,366,1,366,1,366,1,366,1,366,1,366,1,367,1,367,1,367,1,367,1,368,
+        1,368,1,368,1,368,1,368,1,368,1,368,1,368,1,368,1,368,1,368,1,368,
+        1,368,1,368,1,368,1,369,1,369,1,369,1,369,1,369,1,369,1,369,1,370,
+        1,370,1,370,1,370,1,370,1,370,1,370,1,370,1,370,1,370,1,370,1,371,
+        1,371,1,371,1,371,1,371,1,371,1,371,1,371,1,371,1,371,1,371,1,371,
+        1,371,1,371,1,371,1,372,1,372,1,372,1,372,1,372,1,372,1,372,1,372,
+        1,372,1,372,1,372,1,373,1,373,1,373,1,373,1,373,1,373,1,373,1,373,
+        1,373,1,373,1,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,376,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,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,380,1,380,1,380,
+        1,380,1,380,1,380,1,380,1,380,1,381,1,381,1,381,1,381,1,381,1,381,
+        1,381,1,381,1,382,1,382,1,382,1,382,1,382,1,382,1,382,1,382,1,382,
+        1,382,1,383,1,383,1,383,1,383,1,383,1,383,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,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,387,1,387,1,387,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,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,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,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,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,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,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,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,
+        1,401,1,402,1,402,1,402,1,402,1,402,1,402,1,402,1,403,1,403,1,403,
+        1,403,1,403,1,403,1,403,1,403,1,403,1,403,1,404,1,404,1,404,1,404,
+        1,404,1,404,1,404,1,404,1,404,1,404,1,405,1,405,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,406,1,406,1,407,1,407,1,407,1,407,1,407,1,407,1,407,1,407,
+        1,407,1,407,1,408,1,408,1,408,1,408,1,408,1,408,1,408,1,408,1,408,
+        1,408,1,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,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,412,
+        1,412,1,412,1,412,1,412,1,412,1,413,1,413,1,413,1,413,1,413,1,414,
+        1,414,1,414,1,414,1,414,1,414,1,414,1,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,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,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,420,1,420,1,420,1,420,
+        1,420,1,420,1,420,1,420,1,420,1,420,1,420,1,421,1,421,1,421,1,421,
+        1,421,1,421,1,421,1,421,1,421,1,421,1,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,424,1,424,1,424,1,424,1,424,1,424,1,424,
+        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,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,428,1,428,1,428,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,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,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,1,430,1,430,1,431,1,431,1,431,
+        1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,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,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,434,1,434,1,434,1,434,1,434,1,434,1,434,
+        1,435,1,435,1,435,1,435,1,435,1,435,1,435,1,435,1,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,437,
+        1,437,1,437,1,437,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,440,1,440,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,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,445,1,445,1,445,
+        1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445,
+        1,446,1,446,1,446,1,446,1,446,1,446,1,446,1,446,1,446,1,446,1,446,
+        1,446,1,447,1,447,1,447,1,447,1,447,1,447,1,447,1,447,1,447,1,447,
+        1,447,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,450,1,450,1,450,1,450,1,450,1,450,1,450,1,451,1,451,1,451,1,451,
+        1,451,1,451,1,451,1,451,1,451,1,451,1,451,1,451,1,452,1,452,1,452,
+        1,452,1,452,1,452,1,452,1,452,1,452,1,452,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,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,456,1,456,1,456,
+        1,456,1,456,1,456,1,456,1,457,1,457,1,457,1,457,1,457,1,458,1,458,
+        1,458,1,458,1,458,1,458,1,458,1,459,1,459,1,459,1,459,1,460,1,460,
+        1,460,1,460,1,460,1,460,1,461,1,461,1,461,1,461,1,461,1,461,1,461,
+        1,461,1,461,1,461,1,461,1,461,1,461,1,461,1,461,1,461,1,461,1,461,
+        1,461,1,461,1,462,1,462,1,462,1,462,1,462,1,462,1,462,1,462,1,462,
+        1,462,1,462,1,462,1,462,1,462,1,462,1,462,1,462,1,462,1,462,1,462,
+        1,462,1,463,1,463,1,463,1,463,1,463,1,463,1,463,1,463,1,463,1,463,
+        1,463,1,463,1,463,1,463,1,463,1,463,1,463,1,463,1,464,1,464,1,464,
+        1,464,1,464,1,464,1,464,1,465,1,465,1,465,1,465,1,465,1,465,1,465,
+        1,465,1,465,1,465,1,466,1,466,1,466,1,466,1,466,1,466,1,466,1,466,
+        1,466,1,466,1,466,1,466,1,466,1,467,1,467,1,467,1,467,1,467,1,467,
+        1,467,1,467,1,467,1,467,1,467,1,467,1,468,1,468,1,468,1,468,1,468,
+        1,469,1,469,1,469,1,469,1,469,1,469,1,469,1,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,470,1,470,1,470,1,471,1,471,1,471,1,471,1,471,1,471,1,471,1,471,
+        1,471,1,471,1,471,1,471,1,471,1,471,1,471,1,471,1,471,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,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,474,1,474,1,474,1,474,1,474,1,475,1,475,1,475,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,477,1,477,1,477,1,477,1,477,
+        1,477,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,
+        1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,
+        1,478,1,478,1,478,1,478,1,479,1,479,1,480,1,480,1,480,1,480,1,480,
+        1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,
+        1,481,1,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,486,1,486,1,486,1,487,1,487,1,487,1,487,1,487,
+        1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,488,
+        1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,
+        1,488,1,488,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,
+        1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,
+        1,489,1,490,1,490,1,490,1,490,1,490,1,491,1,491,1,491,1,491,1,491,
+        1,491,1,492,1,492,1,492,1,493,1,493,1,493,1,493,1,493,1,493,1,493,
+        1,493,1,493,1,494,1,494,1,494,1,494,1,494,1,494,1,494,1,494,1,494,
+        1,494,1,494,1,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,496,1,496,1,497,1,497,1,497,
+        1,497,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,499,1,499,1,499,1,499,1,499,1,499,1,499,
+        1,499,1,500,1,500,1,500,1,500,1,500,1,500,1,500,1,500,1,500,1,500,
+        1,500,1,500,1,500,1,500,1,500,1,500,1,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,502,1,502,1,502,1,502,1,502,1,502,1,502,1,502,1,502,
+        1,503,1,503,1,503,1,503,1,503,1,503,1,503,1,503,1,503,1,504,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,505,1,505,1,505,1,506,1,506,1,506,1,506,1,506,
+        1,506,1,506,1,506,1,506,1,506,1,506,1,506,1,506,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,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,508,1,508,1,509,1,509,1,509,1,509,1,509,1,509,
+        1,509,1,510,1,510,1,510,1,510,1,510,1,510,1,510,1,510,1,510,1,511,
+        1,511,1,511,1,511,1,511,1,511,1,511,1,511,1,512,1,512,1,512,1,512,
+        1,512,1,512,1,512,1,512,1,513,1,513,1,513,1,513,1,513,1,513,1,513,
+        1,513,1,513,1,513,1,513,1,514,1,514,1,514,1,514,1,514,1,514,1,514,
+        1,514,1,514,1,514,1,514,1,514,1,514,1,514,1,514,1,515,1,515,1,515,
+        1,515,1,515,1,515,1,516,1,516,1,516,1,516,1,516,1,516,1,516,1,516,
+        1,516,1,517,1,517,1,517,1,517,1,518,1,518,1,518,1,518,1,518,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,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,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,521,
+        1,522,1,522,1,522,1,522,1,522,1,522,1,522,1,522,1,522,1,522,1,522,
+        1,522,1,523,1,523,1,523,1,523,1,523,1,523,1,523,1,523,1,523,1,523,
+        1,523,1,524,1,524,1,524,1,524,1,524,1,524,1,524,1,525,1,525,1,525,
+        1,525,1,525,1,525,1,525,1,525,1,526,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,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,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,532,1,532,1,532,1,532,1,532,1,532,1,533,1,533,1,533,1,533,1,533,
+        1,533,1,533,1,534,1,534,1,534,1,534,1,534,1,534,1,534,1,534,1,534,
+        1,534,1,535,1,535,1,535,1,535,1,535,1,535,1,535,1,535,1,535,1,535,
+        1,535,1,535,1,535,1,535,1,535,1,536,1,536,1,536,1,536,1,536,1,536,
+        1,536,1,536,1,536,1,536,1,536,1,537,1,537,1,537,1,537,1,537,1,537,
+        1,537,1,537,1,537,1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538,
+        1,539,1,539,1,539,1,539,1,539,1,539,1,539,1,539,1,539,1,539,1,540,
+        1,540,1,540,1,540,1,540,1,540,1,540,1,540,1,540,1,540,1,541,1,541,
+        1,541,1,541,1,541,1,542,1,542,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,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,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,548,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,549,1,550,1,550,1,550,1,550,
+        1,551,1,551,1,551,1,551,1,551,1,551,1,551,1,552,1,552,1,552,1,552,
+        1,552,1,552,1,552,1,552,1,553,1,553,1,553,1,553,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,554,1,555,
+        1,555,1,555,1,555,1,555,1,555,1,555,1,555,1,555,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,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,559,1,559,1,560,1,560,1,560,1,560,1,560,1,560,1,560,1,560,1,560,
+        1,561,1,561,1,561,1,561,1,561,1,561,1,561,1,561,1,561,1,561,1,561,
+        1,562,1,562,1,562,1,562,1,562,1,562,1,562,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,563,1,563,1,563,
+        1,563,1,564,1,564,1,564,1,564,1,564,1,564,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,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,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,569,1,569,1,569,1,569,
+        1,569,1,570,1,570,1,570,1,570,1,570,1,570,1,570,1,571,1,571,1,571,
+        1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,
+        1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,572,1,572,1,572,
+        1,572,1,572,1,572,1,572,1,572,1,572,1,572,1,573,1,573,1,573,1,573,
+        1,573,1,573,1,573,1,573,1,573,1,574,1,574,1,574,1,574,1,574,1,574,
+        1,574,1,574,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,577,1,577,1,577,1,577,1,578,1,578,1,578,
+        1,578,1,578,1,579,1,579,1,579,1,579,1,579,1,579,1,579,1,579,1,579,
+        1,579,1,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,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,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,583,
+        1,584,1,584,1,584,1,584,1,584,1,584,1,584,1,584,1,584,1,584,1,584,
+        1,584,1,585,1,585,1,585,1,585,1,585,1,585,1,585,1,585,1,585,1,585,
+        1,585,1,585,1,585,1,585,1,586,1,586,1,586,1,586,1,586,1,586,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,589,1,589,1,589,1,589,1,589,1,590,1,590,1,590,1,590,1,590,
+        1,590,1,590,1,590,1,590,1,590,1,590,1,590,1,590,1,590,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,591,1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592,
+        1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,
+        1,593,1,593,1,593,1,593,1,593,1,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,595,1,595,
+        1,595,1,595,1,595,1,595,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,598,1,598,1,598,1,598,1,598,1,598,
+        1,599,1,599,1,599,1,599,1,599,1,599,1,599,1,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,601,1,601,1,601,1,601,1,602,1,602,1,602,
+        1,602,1,602,1,602,1,603,1,603,1,603,1,603,1,603,1,603,1,603,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,605,1,605,1,605,1,606,1,606,1,606,1,606,1,606,1,606,1,606,
+        1,606,1,606,1,606,1,606,1,606,1,607,1,607,1,607,1,607,1,607,1,607,
+        1,608,1,608,1,608,1,608,1,608,1,609,1,609,1,609,1,609,1,609,1,610,
+        1,610,1,610,1,610,1,610,1,610,1,611,1,611,1,611,1,611,1,611,1,611,
+        1,612,1,612,1,612,1,612,1,612,1,612,1,612,1,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,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,617,1,617,1,617,1,617,1,617,1,617,
+        1,617,1,617,1,617,1,617,1,617,1,617,1,617,1,617,1,617,1,617,1,617,
+        1,617,1,617,1,617,1,617,1,617,1,617,1,617,1,618,1,618,1,618,1,618,
+        1,618,1,618,1,618,1,618,1,619,1,619,1,619,1,619,1,619,1,619,1,619,
+        1,619,1,620,1,620,1,620,1,620,1,621,1,621,1,621,1,621,1,621,1,621,
+        1,621,1,622,1,622,1,622,1,622,1,622,1,622,1,622,1,622,1,623,1,623,
+        1,623,1,623,1,623,1,623,1,623,1,623,1,623,1,623,1,623,1,623,1,623,
+        1,623,1,623,1,623,1,624,1,624,1,624,1,624,1,624,1,624,1,624,1,624,
+        1,624,1,625,1,625,1,625,1,625,1,625,1,625,1,625,1,625,1,625,1,625,
+        1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,627,
+        1,627,1,627,1,627,1,627,1,627,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,630,1,630,1,630,1,630,
+        1,630,1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,
+        1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,1,631,
+        1,631,1,631,1,631,1,631,1,632,1,632,1,632,1,632,1,632,1,632,1,632,
+        1,632,1,632,1,633,1,633,1,633,1,633,1,633,1,633,1,633,1,633,1,633,
+        1,633,1,634,1,634,1,634,1,634,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,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,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,1,638,1,638,1,638,1,638,1,638,1,638,1,639,1,639,1,639,
+        1,639,1,639,1,639,1,639,1,639,1,639,1,639,1,639,1,639,1,639,1,640,
+        1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,641,1,641,
+        1,641,1,641,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,644,1,644,1,644,1,644,
+        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,645,1,645,1,645,1,645,1,645,1,646,1,646,1,646,1,646,
+        1,646,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,649,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,650,1,650,1,651,1,651,
+        1,651,1,651,1,651,1,651,1,651,1,651,1,651,1,652,1,652,1,652,1,652,
+        1,652,1,652,1,652,1,652,1,652,1,652,1,652,1,652,1,653,1,653,1,653,
+        1,653,1,653,1,653,1,653,1,654,1,654,1,654,1,654,1,654,1,654,1,654,
+        1,654,1,654,1,654,1,654,1,655,1,655,1,655,1,655,1,655,1,655,1,655,
+        1,655,1,655,1,655,1,656,1,656,1,656,1,656,1,656,1,656,1,657,1,657,
+        1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,
+        1,657,1,657,1,657,1,658,1,658,1,658,1,658,1,658,1,658,1,658,1,658,
+        1,658,1,658,1,658,1,659,1,659,1,659,1,659,1,659,1,659,1,659,1,659,
+        1,660,1,660,1,660,1,660,1,660,1,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,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,665,1,665,1,665,1,665,1,665,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,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,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,672,
+        1,672,1,672,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,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,676,1,676,1,676,1,676,1,676,
+        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,678,
+        1,678,1,678,1,678,1,679,1,679,1,679,1,679,1,679,1,680,1,680,1,680,
+        1,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,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,684,1,684,1,685,1,685,1,685,
+        1,685,1,685,1,685,1,685,1,685,1,685,1,685,1,685,1,686,1,686,1,686,
+        1,686,1,686,1,686,1,686,1,686,1,686,1,686,1,686,1,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,689,1,689,1,689,
+        1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,691,
+        1,691,1,691,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,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,694,1,694,
+        1,694,1,694,1,694,1,694,1,694,1,695,1,695,1,695,1,695,1,695,1,695,
+        1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,
+        1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,695,1,696,
+        1,696,1,696,1,696,1,696,1,696,1,696,1,696,1,696,1,696,1,696,1,696,
+        1,696,1,696,1,696,1,696,1,696,1,696,1,696,1,696,1,697,1,697,1,697,
+        1,697,1,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,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,702,1,702,1,702,1,702,1,702,1,702,1,702,1,702,1,702,1,702,
+        1,702,1,702,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,704,1,704,1,704,1,704,1,704,1,704,
+        1,704,1,704,1,704,1,705,1,705,1,705,1,705,1,705,1,705,1,705,1,705,
+        1,705,1,705,1,706,1,706,1,706,1,706,1,706,1,706,1,706,1,706,1,706,
+        1,706,1,706,1,706,1,707,1,707,1,707,1,707,1,707,1,707,1,707,1,707,
+        1,707,1,707,1,708,1,708,1,708,1,708,1,708,1,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,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,711,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,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,716,1,716,1,716,1,716,
+        1,717,1,717,1,717,1,717,1,717,1,717,1,718,1,718,1,718,1,718,1,718,
+        1,718,1,718,1,718,1,718,1,719,1,719,1,719,1,719,1,719,1,719,1,719,
+        1,719,1,719,1,719,1,719,1,720,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,722,1,722,1,722,1,722,1,722,
+        1,722,1,722,1,722,1,722,1,722,1,723,1,723,1,723,1,723,1,723,1,723,
+        1,723,1,723,1,723,1,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,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,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,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,729,1,729,1,729,1,729,1,729,1,729,
+        1,729,1,729,1,729,1,730,1,730,1,730,1,730,1,730,1,730,1,730,1,730,
+        1,730,1,730,1,730,1,730,1,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,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,736,1,736,1,736,
+        1,736,1,736,1,736,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,737,1,737,1,737,1,738,1,738,1,738,
+        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,741,1,741,1,741,1,741,1,741,1,741,
+        1,741,1,741,1,741,1,741,1,741,1,741,1,742,1,742,1,742,1,742,1,742,
+        1,742,1,742,1,742,1,742,1,742,1,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,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,747,1,747,1,747,1,747,1,747,1,747,1,747,
+        1,747,1,747,1,747,1,747,1,747,1,747,1,747,1,747,1,747,1,747,1,747,
+        1,747,1,748,1,748,1,748,1,748,1,748,1,748,1,748,1,748,1,748,1,748,
+        1,748,1,748,1,748,1,748,1,748,1,748,1,748,1,749,1,749,1,749,1,749,
+        1,749,1,749,1,750,1,750,1,750,1,750,1,750,1,750,1,751,1,751,1,751,
+        1,751,1,751,1,751,1,751,1,751,1,752,1,752,1,752,1,752,1,752,1,752,
+        1,752,1,752,1,752,1,752,1,752,1,752,1,753,1,753,1,753,1,753,1,753,
+        1,753,1,753,1,753,1,753,1,753,1,753,1,753,1,753,1,753,1,753,1,753,
+        1,753,1,753,1,753,1,753,1,754,1,754,1,754,1,754,1,754,1,754,1,754,
+        1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,
+        1,754,1,754,1,754,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,
+        1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,756,1,756,1,756,1,756,
+        1,756,1,756,1,756,1,757,1,757,1,757,1,757,1,757,1,757,1,757,1,757,
+        1,757,1,757,1,757,1,757,1,757,1,757,1,757,1,758,1,758,1,758,1,758,
+        1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,
+        1,758,1,759,1,759,1,759,1,759,1,759,1,759,1,759,1,759,1,759,1,760,
+        1,760,1,760,1,760,1,760,1,760,1,760,1,760,1,760,1,760,1,761,1,761,
+        1,761,1,761,1,761,1,761,1,761,1,761,1,761,1,761,1,761,1,761,1,761,
+        1,762,1,762,1,762,1,762,1,762,1,762,1,762,1,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,764,1,764,1,764,1,765,1,765,1,765,1,765,1,765,1,765,1,765,1,766,
+        1,766,1,766,1,766,1,766,1,766,1,766,1,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,769,1,769,1,769,
+        1,769,1,769,1,769,1,769,1,769,1,770,1,770,1,770,1,770,1,770,1,770,
+        1,770,1,770,1,770,1,770,1,770,1,770,1,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,772,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,773,1,773,1,773,
+        1,773,1,773,1,773,1,773,1,773,1,774,1,774,1,774,1,774,1,774,1,774,
+        1,774,1,774,1,774,1,774,1,774,1,774,1,775,1,775,1,775,1,775,1,775,
+        1,775,1,775,1,775,1,775,1,775,1,776,1,776,1,776,1,776,1,776,1,776,
+        1,776,1,776,1,776,1,777,1,777,1,777,1,777,1,778,1,778,1,778,1,778,
+        1,778,1,778,1,778,1,778,1,778,1,779,1,779,1,779,1,779,1,779,1,780,
+        1,780,1,780,1,780,1,780,1,780,1,780,1,780,1,780,1,780,1,780,1,781,
+        1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,
+        1,781,1,782,1,782,1,782,1,782,1,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,783,1,783,1,784,
+        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,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,787,1,787,1,787,1,787,1,788,1,788,
+        1,788,1,788,1,788,1,788,1,788,1,788,1,788,1,788,1,788,1,788,1,788,
+        1,788,1,788,1,788,1,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,791,1,791,1,791,1,791,1,791,
+        1,791,1,791,1,791,1,791,1,791,1,791,1,791,1,791,1,791,1,791,1,791,
+        1,791,1,792,1,792,1,792,1,792,1,792,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,795,1,795,
+        1,795,1,795,1,795,1,795,1,795,1,795,1,795,1,796,1,796,1,796,1,796,
+        1,796,1,796,1,796,1,796,1,796,1,796,1,796,1,797,1,797,1,797,1,797,
+        1,797,1,797,1,797,1,797,1,797,1,797,1,797,1,798,1,798,1,798,1,798,
+        1,798,1,798,1,798,1,798,1,798,1,798,1,798,1,798,1,798,1,799,1,799,
+        1,799,1,799,1,799,1,799,1,799,1,799,1,799,1,799,1,799,1,799,1,800,
+        1,800,1,800,1,800,1,800,1,800,1,800,1,800,1,801,1,801,1,801,1,801,
+        1,801,1,802,1,802,1,802,1,802,1,802,1,802,1,802,1,802,1,802,1,802,
+        1,802,1,802,1,802,1,802,1,802,1,803,1,803,1,803,1,803,1,803,1,803,
+        1,803,1,803,1,803,1,803,1,803,1,803,1,804,1,804,1,804,1,804,1,804,
+        1,804,1,804,1,804,1,804,1,804,1,805,1,805,1,805,1,805,1,805,1,805,
+        1,805,1,805,1,805,1,805,1,805,1,806,1,806,1,806,1,806,1,806,1,806,
+        1,806,1,806,1,806,1,806,1,806,1,806,1,806,1,806,1,806,1,807,1,807,
+        1,807,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,808,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,809,1,809,1,809,1,809,1,809,1,809,1,809,1,809,1,809,
+        1,809,1,809,1,810,1,810,1,810,1,810,1,810,1,810,1,810,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,811,1,811,1,811,1,811,1,811,1,811,1,812,1,812,1,813,1,813,1,813,
+        1,813,1,813,1,813,1,813,1,813,1,813,1,813,1,813,1,813,1,813,1,813,
+        1,813,1,813,1,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,815,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,818,1,818,
+        1,818,1,818,1,818,1,818,1,818,1,818,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,820,1,820,1,821,1,821,
+        1,821,1,821,1,821,1,822,1,822,1,822,1,822,1,822,1,822,1,823,1,823,
+        1,823,1,823,1,823,1,823,1,823,1,823,1,823,1,824,1,824,1,824,1,824,
+        1,824,1,824,1,824,1,824,1,824,1,825,1,825,1,825,1,825,1,825,1,826,
+        1,826,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,828,1,828,1,828,1,828,
+        1,828,1,828,1,828,1,829,1,829,1,829,1,829,1,830,1,830,1,830,1,830,
+        1,830,1,830,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,
+        1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,
+        1,831,1,831,1,831,1,831,1,831,1,831,1,832,1,832,1,832,1,832,1,832,
+        1,832,1,832,1,832,1,832,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,833,
+        1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,
+        1,833,1,833,1,833,1,834,1,834,1,834,1,834,1,834,1,834,1,834,1,834,
+        1,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,836,1,837,1,837,1,837,1,837,1,837,1,837,1,837,1,837,
+        1,837,1,837,1,837,1,837,1,837,1,838,1,838,1,838,1,838,1,838,1,838,
+        1,838,1,838,1,839,1,839,1,839,1,839,1,839,1,840,1,840,1,840,1,840,
+        1,840,1,840,1,840,1,840,1,841,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,844,1,845,1,845,1,845,1,845,1,845,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,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,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,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,854,1,854,1,854,1,854,1,854,1,854,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,857,1,857,1,857,1,857,1,857,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,860,1,860,1,860,1,860,1,860,1,860,1,861,1,861,1,861,1,861,
+        1,861,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,865,1,865,1,865,1,866,1,866,
+        1,866,1,866,1,866,1,866,1,867,1,867,1,867,1,867,1,867,1,868,1,868,
+        1,868,1,868,1,869,1,869,1,869,1,869,1,869,1,869,1,869,1,869,1,870,
+        1,870,1,870,1,870,1,870,1,870,1,870,1,871,1,871,1,871,1,871,1,871,
+        1,872,1,872,1,872,1,872,1,872,1,872,1,872,1,872,1,872,1,872,1,872,
+        1,872,1,872,1,872,1,873,1,873,1,873,1,873,1,873,1,873,1,874,1,874,
+        1,874,1,874,1,874,1,874,1,874,1,874,1,874,1,874,1,875,1,875,1,875,
+        1,875,1,875,1,875,1,875,1,875,1,875,1,875,1,875,1,875,1,875,1,875,
+        1,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,877,1,878,1,878,1,878,1,878,
+        1,878,1,878,1,878,1,878,1,878,1,879,1,879,1,879,1,879,1,879,1,879,
+        1,879,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,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,883,1,883,1,884,1,884,
+        1,884,1,884,1,884,1,884,1,884,1,884,1,885,1,885,1,885,1,885,1,885,
+        1,885,1,885,1,885,1,886,1,886,1,886,1,886,1,886,1,886,1,886,1,886,
+        1,886,1,886,1,886,1,886,1,886,1,886,1,886,1,886,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,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,
+        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,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,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,892,
+        1,892,1,892,1,892,1,892,1,892,1,892,1,892,1,892,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,894,
+        1,894,1,894,1,894,1,894,1,895,1,895,1,895,1,895,1,895,1,896,1,896,
+        1,896,1,896,1,896,1,896,1,897,1,897,1,897,1,897,1,898,1,898,1,898,
+        1,898,1,898,1,899,1,899,1,899,1,899,1,899,1,899,1,899,1,900,1,900,
+        1,900,1,900,1,900,1,900,1,901,1,901,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,904,1,904,
+        1,904,1,904,1,904,1,904,1,904,1,904,1,905,1,905,1,905,1,905,1,905,
+        1,905,1,905,1,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,908,
+        1,908,1,908,1,908,1,908,1,908,1,908,1,908,1,908,1,908,1,909,1,909,
+        1,909,1,909,1,909,1,909,1,909,1,910,1,910,1,910,1,910,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,913,1,913,1,913,1,913,1,913,1,913,1,913,1,914,1,914,1,914,1,914,
+        1,914,1,914,1,914,1,914,1,915,1,915,1,915,1,915,1,915,1,915,1,915,
+        1,915,1,916,1,916,1,916,1,916,1,916,1,916,1,917,1,917,1,917,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,918,1,918,
+        1,918,1,918,1,918,1,919,1,919,1,919,1,919,1,919,1,919,1,919,1,919,
+        1,919,1,919,1,919,1,919,1,919,1,920,1,920,1,920,1,920,1,920,1,920,
+        1,920,1,920,1,920,1,920,1,920,1,920,1,921,1,921,1,921,1,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,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,923,1,923,1,924,1,924,
+        1,924,1,924,1,924,1,924,1,924,1,924,1,924,1,925,1,925,1,925,1,925,
+        1,925,1,925,1,925,1,925,1,925,1,925,1,925,1,925,1,925,1,926,1,926,
+        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,927,1,927,1,927,1,927,1,927,1,927,1,927,1,927,
+        1,927,1,927,1,928,1,928,1,928,1,928,1,928,1,928,1,928,1,928,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,929,1,929,1,929,1,929,1,929,1,929,1,929,1,929,
+        1,929,1,929,1,929,1,929,1,930,1,930,1,930,1,930,1,930,1,930,1,930,
+        1,930,1,931,1,931,1,931,1,931,1,931,1,931,1,931,1,931,1,931,1,932,
+        1,932,1,932,1,932,1,932,1,932,1,932,1,932,1,932,1,933,1,933,1,933,
+        1,933,1,933,1,933,1,933,1,933,1,934,1,934,1,934,1,934,1,934,1,934,
+        1,934,1,934,1,934,1,935,1,935,1,935,1,935,1,935,1,935,1,935,1,936,
+        1,936,1,936,1,936,1,936,1,936,1,936,1,937,1,937,1,937,1,937,1,937,
+        1,937,1,937,1,937,1,937,1,937,1,937,1,937,1,937,1,937,1,937,1,938,
+        1,938,1,938,1,938,1,938,1,938,1,938,1,938,1,938,1,938,1,938,1,938,
+        1,938,1,938,1,938,1,938,1,938,1,938,1,938,1,939,1,939,1,939,1,939,
+        1,939,1,939,1,939,1,939,1,939,1,939,1,939,1,939,1,940,1,940,1,940,
+        1,940,1,940,1,940,1,940,1,940,1,940,1,940,1,940,1,940,1,940,1,940,
+        1,940,1,940,1,940,1,940,1,940,1,941,1,941,1,941,1,941,1,941,1,941,
+        1,941,1,941,1,941,1,941,1,941,1,941,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,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,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,947,
+        1,948,1,948,1,948,1,948,1,948,1,948,1,948,1,948,1,948,1,949,1,949,
+        1,949,1,949,1,949,1,949,1,949,1,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,951,1,952,1,952,1,952,1,952,1,952,1,952,1,952,1,952,1,952,1,952,
+        1,952,1,953,1,953,1,953,1,953,1,953,1,953,1,953,1,953,1,953,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,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,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,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,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,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,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,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,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,969,1,969,1,969,1,969,1,969,1,969,1,969,1,969,1,969,1,969,
+        1,969,1,969,1,969,1,969,1,969,1,969,1,969,1,970,1,970,1,970,1,970,
+        1,970,1,970,1,970,1,970,1,970,1,970,1,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,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,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,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,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,979,1,979,1,979,1,979,1,979,1,980,1,980,
+        1,980,1,980,1,980,1,980,1,980,1,981,1,981,1,981,1,981,1,982,1,982,
+        1,982,1,982,1,982,1,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,984,1,984,1,984,1,984,1,984,1,984,
+        1,984,1,984,1,985,1,985,1,985,1,985,1,985,1,985,1,986,1,986,1,986,
+        1,986,1,986,1,986,1,986,1,986,1,986,1,986,1,986,1,986,1,986,1,986,
+        1,986,1,987,1,987,1,987,1,987,1,987,1,987,1,987,1,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,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,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,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,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,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,999,1,999,1,999,1,999,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,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,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,1005,1,1005,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,1008,1,1008,
+        1,1008,1,1008,1,1008,1,1008,1,1009,1,1009,1,1009,1,1009,1,1009,1,
+        1010,1,1010,1,1010,1,1010,1,1010,1,1010,1,1011,1,1011,1,1011,1,1011,
+        1,1011,1,1011,1,1011,1,1012,1,1012,1,1012,1,1012,1,1013,1,1013,1,
+        1013,1,1013,1,1013,1,1013,1,1013,1,1014,1,1014,1,1014,1,1014,1,1014,
+        1,1014,1,1014,1,1014,1,1014,1,1014,1,1014,1,1014,1,1014,1,1014,1,
+        1014,1,1014,1,1014,1,1014,1,1014,1,1014,1,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,1015,1,1015,
+        1,1015,1,1015,1,1015,1,1015,1,1016,1,1016,1,1016,1,1016,1,1016,1,
+        1016,1,1016,1,1016,1,1016,1,1016,1,1016,1,1016,1,1016,1,1016,1,1016,
+        1,1016,1,1017,1,1017,1,1017,1,1017,1,1017,1,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,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,1021,1,1021,1,1021,1,1021,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,1023,1,1024,1,1024,1,1024,1,1024,1,
+        1024,1,1024,1,1024,1,1024,1,1024,1,1025,1,1025,1,1025,1,1025,1,1025,
+        1,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,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,1030,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,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,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,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,1036,1,1036,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,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,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,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,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,1041,1,1041,
+        1,1041,1,1041,1,1041,1,1041,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,1044,1,1044,1,1044,1,1044,1,1044,1,1044,1,1044,1,1044,1,1044,1,
+        1044,1,1044,1,1044,1,1044,1,1045,1,1045,1,1045,1,1045,1,1045,1,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,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,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,1048,
+        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,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,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,1053,1,1053,1,1053,1,1053,1,1053,1,1053,1,
+        1053,1,1053,1,1053,1,1053,1,1054,1,1054,1,1054,1,1054,1,1054,1,1054,
+        1,1054,1,1054,1,1054,1,1054,1,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,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,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,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,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,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,1063,1,1063,1,1063,1,1063,1,1063,1,1063,1,1063,1,
+        1063,1,1063,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,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,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,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,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,1071,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,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,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,1075,1,1075,1,1075,1,1075,1,1075,1,1075,1,1075,1,1075,1,1075,1,
+        1075,1,1075,1,1075,1,1075,1,1075,1,1075,1,1075,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,1076,1,1076,1,1076,
+        1,1076,1,1076,1,1076,1,1076,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,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,1078,1,1078,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,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,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,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,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,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,1085,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,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,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,1090,1,1090,1,1090,1,1090,1,1090,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,1091,1,1091,1,1091,1,1091,1,1091,
+        1,1091,1,1091,1,1091,1,1091,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,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,1093,1,1093,1,
+        1094,1,1094,1,1094,1,1094,1,1094,1,1094,1,1094,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,1095,
+        1,1095,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,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,1097,1,1097,
+        1,1097,1,1097,1,1097,1,1097,1,1097,1,1097,1,1097,1,1097,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,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,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,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,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,
+        1105,1,1105,1,1105,1,1105,1,1105,1,1105,1,1105,1,1105,1,1105,1,1105,
+        1,1105,1,1105,1,1105,1,1105,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,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,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,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,1111,1,1111,1,1111,
+        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,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,1113,1,1113,
+        1,1113,1,1113,1,1113,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,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,1118,1,1118,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,1120,1,1120,1,1120,1,1120,1,1120,
+        1,1120,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,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,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,1126,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,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,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,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,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,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,1135,1,1135,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,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,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,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,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,1143,1,1143,1,1143,1,1143,1,1143,1,1143,1,1143,1,1143,
+        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,1144,1,1144,1,1144,1,1144,1,1144,1,1144,1,1144,
+        1,1144,1,1144,1,1144,1,1144,1,1144,1,1144,1,1144,1,1144,1,1144,1,
+        1144,1,1144,1,1145,1,1145,1,1145,1,1145,1,1145,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,1146,1,1146,1,1146,1,1146,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,1147,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,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,1150,1,1150,1,1151,1,1151,1,1151,1,1151,1,1151,1,1151,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,1152,1,1152,1,1152,1,1152,1,
+        1152,1,1152,1,1152,1,1152,1,1152,1,1152,1,1152,1,1152,1,1152,1,1152,
+        1,1152,1,1152,1,1152,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,1153,1,1154,1,1154,1,1154,1,1154,1,1154,1,1154,1,1154,1,1154,1,
+        1154,1,1154,1,1154,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,1155,1,1155,1,
+        1155,1,1155,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,1156,1,1156,1,1156,1,1156,1,
+        1156,1,1156,1,1156,1,1156,1,1156,1,1156,1,1156,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,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,1159,1,1159,1,1159,1,1159,1,1159,1,1159,1,1159,1,1159,
+        1,1160,1,1160,1,1160,1,1160,1,1160,1,1160,1,1160,1,1160,1,1160,1,
+        1160,1,1160,1,1161,1,1161,1,1161,1,1161,1,1161,1,1161,1,1161,1,1161,
+        1,1161,1,1161,1,1161,1,1161,1,1161,1,1161,1,1161,1,1162,1,1162,1,
+        1162,1,1162,1,1162,1,1162,1,1162,1,1162,1,1162,1,1162,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,1163,1,1163,1,1163,1,1163,1,1164,1,1164,1,1164,1,1164,1,1164,
+        1,1164,1,1164,1,1164,1,1164,1,1164,1,1164,1,1164,1,1164,1,1165,1,
+        1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,
+        1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,1165,1,
+        1165,1,1165,1,1166,1,1166,1,1166,1,1166,1,1166,1,1166,1,1166,1,1166,
+        1,1166,1,1166,1,1166,1,1166,1,1166,1,1166,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,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,
+        1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,
+        1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1168,1,1169,1,
+        1169,1,1169,1,1169,1,1169,1,1169,1,1169,1,1169,1,1169,1,1169,1,1169,
+        1,1169,1,1169,1,1169,1,1169,1,1170,1,1170,1,1170,1,1170,1,1170,1,
+        1170,1,1170,1,1170,1,1170,1,1170,1,1170,1,1171,1,1171,1,1171,1,1171,
+        1,1171,1,1171,1,1171,1,1172,1,1172,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,1173,1,1173,
+        1,1173,1,1173,1,1174,1,1174,1,1174,1,1174,1,1174,1,1174,1,1174,1,
+        1174,1,1174,1,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,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,1178,1,1178,1,1178,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,
+        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,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,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,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,1,1183,1,1184,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,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,1186,1,1186,1,1187,1,1187,1,1187,
+        1,1187,1,1187,1,1187,1,1187,1,1187,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,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,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,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,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,1193,1,1193,1,1193,1,1193,1,1193,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,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,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,
+        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,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,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,1200,1,1200,1,1200,1,1200,1,1200,1,1200,1,1200,1,1200,1,1200,1,
+        1200,1,1200,1,1200,1,1200,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,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,1204,1,1204,1,1204,1,1204,1,1204,1,1204,1,1204,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,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,
+        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,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,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,1212,1,1212,1,1212,1,1212,1,1212,1,1212,1,1212,1,1212,1,1212,
+        1,1212,1,1212,1,1212,1,1212,1,1212,1,1212,1,1212,1,1212,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,1214,1,1214,1,1214,1,1214,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,1215,1,1215,1,1215,1,1215,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,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,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,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,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,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,1221,1,1221,1,1221,1,1221,1,1221,1,1221,1,1221,1,1221,1,
+        1221,1,1221,1,1221,1,1221,1,1221,1,1221,1,1221,1,1221,1,1221,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,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,1224,1,1224,1,1224,1,1224,1,1224,1,1224,1,
+        1224,1,1224,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,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,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,1228,1,1228,1,1228,1,1228,1,1228,1,1228,1,1228,1,
+        1229,1,1229,1,1229,1,1229,1,1229,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,1232,1,
+        1232,1,1232,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,1233,1,
+        1233,1,1233,1,1233,1,1234,1,1234,1,1234,1,1234,1,1234,1,1234,1,1234,
+        1,1234,1,1234,1,1234,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,1235,1,1235,1,1235,1,1235,1,1235,1,1235,1,1236,1,1236,1,1236,1,
+        1236,1,1236,1,1236,1,1236,1,1236,1,1236,1,1236,1,1237,1,1237,1,1237,
+        1,1237,1,1237,1,1238,1,1238,1,1238,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,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,1242,1,1242,1,1242,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,1244,1,1244,1,1245,1,1245,1,
+        1245,1,1245,1,1246,1,1246,1,1246,1,1246,1,1246,1,1246,1,1246,1,1247,
+        1,1247,1,1247,1,1248,1,1248,1,1248,1,1248,1,1248,1,1248,1,1248,1,
+        1248,1,1248,1,1249,1,1249,1,1249,1,1249,1,1250,1,1250,1,1250,1,1250,
+        1,1250,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,1253,1,1253,1,1253,1,1253,1,1254,1,1254,1,1254,1,1254,1,1254,1,
+        1255,1,1255,1,1255,1,1255,1,1255,1,1256,1,1256,1,1256,1,1256,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,1259,1,1259,1,1259,
+        1,1259,1,1259,1,1260,1,1260,1,1260,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,1263,1,1263,1,1263,1,1263,1,1263,1,1263,1,1263,1,1263,1,1263,
+        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,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,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,1268,1,
+        1268,1,1268,1,1268,1,1268,1,1268,1,1268,1,1268,1,1269,1,1269,1,1269,
+        1,1269,1,1269,1,1269,1,1269,1,1269,1,1270,1,1270,1,1270,1,1270,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,1271,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,1271,1,1272,1,1272,1,1272,1,1272,1,1272,1,1272,1,1272,1,
+        1272,1,1272,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,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,1276,1,1276,1,
+        1276,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,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,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,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,1281,
+        1,1281,1,1281,1,1281,1,1282,1,1282,1,1282,1,1282,1,1282,1,1282,1,
+        1282,1,1282,1,1282,1,1282,1,1282,1,1282,1,1283,1,1283,1,1283,1,1283,
+        1,1283,1,1283,1,1283,1,1283,1,1283,1,1283,1,1283,1,1283,1,1283,1,
+        1283,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,1285,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,1286,1,1286,1,1287,1,1287,1,1287,1,1287,1,1287,
+        1,1287,1,1287,1,1287,1,1287,1,1287,1,1287,1,1287,1,1287,1,1287,1,
+        1288,1,1288,1,1288,1,1288,1,1288,1,1288,1,1288,1,1288,1,1288,1,1288,
+        1,1288,1,1288,1,1288,1,1288,1,1288,1,1289,1,1289,1,1289,1,1289,1,
+        1289,1,1289,1,1289,1,1289,1,1289,1,1289,1,1289,1,1289,1,1289,1,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,1291,1,1291,1,1291,1,1291,1,1291,
+        1,1291,1,1291,1,1291,1,1291,1,1291,1,1291,1,1291,1,1291,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,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,1293,1,1293,1,1293,1,
+        1293,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,1294,1,1294,1,1294,1,1294,1,1294,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,1295,1,
+        1295,1,1295,1,1295,1,1295,1,1295,1,1295,1,1295,1,1295,1,1295,1,1295,
+        1,1296,1,1296,1,1296,1,1296,1,1296,1,1296,1,1296,1,1296,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,1297,1,1297,1,1298,1,1298,1,1298,1,
+        1298,1,1298,1,1298,1,1298,1,1298,1,1298,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,1299,1,1299,1,1299,1,1299,1,1299,1,1300,1,1300,
+        1,1300,1,1300,1,1300,1,1300,1,1300,1,1300,1,1300,1,1300,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,1301,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,1302,1,1302,1,1303,1,1303,
+        1,1303,1,1303,1,1303,1,1303,1,1303,1,1303,1,1303,1,1303,1,1303,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,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,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,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,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,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,1313,1,
+        1313,1,1313,1,1313,1,1313,1,1314,1,1314,1,1314,1,1314,1,1314,1,1314,
+        1,1315,1,1315,1,1315,1,1315,1,1315,1,1315,1,1315,1,1315,1,1315,1,
+        1315,1,1315,1,1315,1,1315,1,1316,1,1316,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,
+        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,1318,1,1318,1,1318,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,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,1321,1,1322,
+        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,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,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,1328,1,1328,1,1328,1,1328,1,1329,1,1329,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,1332,1,1332,1,1332,1,1332,
+        1,1332,1,1332,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,1333,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,1335,1,1336,1,1336,1,1336,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,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,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,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,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,1344,1,1344,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,1346,1,1346,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,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,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,1350,1,1350,1,1350,1,1350,1,1350,1,1350,1,1350,
+        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,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,1352,1,1352,1,1352,1,1352,1,1352,1,1353,1,1353,1,1353,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,1354,1,1354,1,1354,1,1354,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,1355,1,1355,1,1355,1,1356,1,1356,1,1356,1,1356,1,
+        1356,1,1356,1,1356,1,1356,1,1356,1,1356,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,1357,1,1357,1,1357,1,1358,1,1358,1,1358,1,1358,1,1358,
+        1,1358,1,1358,1,1358,1,1358,1,1358,1,1358,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,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,1360,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,1361,1,1361,1,1361,1,1361,1,1361,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,1363,1,1363,1,1363,1,1363,1,1363,1,1363,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,1365,1,1365,1,1365,1,1365,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,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,1369,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,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,1372,1,
+        1372,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,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,5,1376,19919,8,1376,10,1376,12,1376,19922,9,1376,1,1376,1,
+        1376,1,1376,1,1376,1,1376,1,1376,1,1377,1,1377,5,1377,19932,8,1377,
+        10,1377,12,1377,19935,9,1377,1,1377,1,1377,1,1377,1,1377,1,1377,
+        1,1377,1,1377,1,1378,1,1378,5,1378,19946,8,1378,10,1378,12,1378,
+        19949,9,1378,1,1378,1,1378,1,1378,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,1380,1,1380,1,1380,1,1380,1,1380,1,1380,1,1380,1,1380,1,1380,1,
+        1380,1,1380,1,1380,1,1380,1,1380,1,1381,1,1381,5,1381,19984,8,1381,
+        10,1381,12,1381,19987,9,1381,1,1381,1,1381,1,1381,1,1381,1,1381,
+        1,1381,1,1381,1,1381,1,1381,1,1382,1,1382,5,1382,20000,8,1382,10,
+        1382,12,1382,20003,9,1382,1,1382,1,1382,1,1382,1,1382,1,1382,1,1382,
+        1,1382,1,1382,1,1383,1,1383,5,1383,20015,8,1383,10,1383,12,1383,
+        20018,9,1383,1,1383,1,1383,1,1383,1,1383,1,1383,1,1384,1,1384,5,
+        1384,20027,8,1384,10,1384,12,1384,20030,9,1384,1,1384,1,1384,1,1384,
+        1,1384,1,1384,1,1384,1,1384,1,1384,1,1384,1,1384,1,1384,1,1384,1,
+        1384,1,1384,1,1384,1,1384,1,1385,1,1385,5,1385,20050,8,1385,10,1385,
+        12,1385,20053,9,1385,1,1385,1,1385,1,1385,1,1385,1,1385,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,1387,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,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,1391,1,
+        1391,1,1391,1,1391,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,1393,1,1393,1,1393,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,1395,1,1395,1,1395,1,1395,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,1399,1,1399,1,1400,1,1400,1,1400,1,1400,1,1400,1,1400,1,1400,
+        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,1401,1,1401,1,1401,1,1401,1,1401,1,1401,1,1401,
+        1,1401,1,1401,1,1401,1,1401,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,1403,1,1403,1,1403,1,1403,1,1403,1,1403,1,1403,1,1404,1,1404,1,
+        1404,1,1404,1,1404,1,1404,1,1404,1,1404,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,1405,1,1405,1,1406,1,1406,1,1406,1,1406,1,1406,
+        1,1406,1,1406,1,1406,1,1406,1,1406,1,1406,1,1406,1,1406,1,1406,1,
+        1406,1,1406,1,1407,1,1407,1,1407,1,1407,1,1407,1,1407,1,1407,1,1407,
+        1,1407,1,1407,1,1407,1,1407,1,1408,1,1408,1,1408,1,1408,1,1408,1,
+        1408,1,1408,1,1408,1,1408,1,1408,1,1408,1,1408,1,1408,1,1408,1,1408,
+        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,1409,1,1409,1,1409,1,1409,1,1409,1,1409,1,1409,
+        1,1409,1,1409,1,1410,1,1410,1,1410,1,1410,1,1410,1,1410,1,1410,1,
+        1410,1,1410,1,1410,1,1411,1,1411,1,1411,1,1411,1,1411,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,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,1416,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,1419,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,1422,1,1422,1,1422,1,1422,1,1422,1,1422,1,1422,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,1423,1,1423,1,1423,1,1423,1,1423,1,1423,1,1423,1,1423,
+        1,1423,1,1423,1,1423,1,1423,1,1423,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,1424,1,1424,1,1424,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,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,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,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,1430,1,1430,1,1430,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,1431,
+        1,1432,1,1432,1,1432,1,1432,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,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,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,1438,
+        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,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,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,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,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,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,1447,1,1447,1,1447,1,1447,1,1448,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,1450,1,1450,1,
+        1450,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,1453,1,1453,1,1453,1,1453,1,1453,1,
+        1453,1,1453,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,1454,1,1454,1,1454,1,
+        1454,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,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,1458,1,1458,
+        1,1458,1,1458,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,1459,1,1459,1,1459,
+        1,1460,1,1460,1,1460,1,1460,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,1461,
+        1,1461,1,1461,1,1461,1,1462,1,1462,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,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,1466,
+        1,1466,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,1467,1,1467,1,1467,1,1468,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,1469,1,1470,1,1470,
+        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,1471,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,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,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,1478,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,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,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,1481,1,1481,1,1481,1,1481,1,1481,1,1482,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,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,1486,1,1486,1,1486,1,1486,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,
+        1488,1,1488,1,1488,1,1489,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,1491,1,
+        1491,1,1491,1,1491,1,1491,1,1491,1,1492,1,1492,1,1492,1,1492,1,1492,
+        1,1492,1,1492,1,1492,1,1492,1,1492,1,1492,1,1493,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,1494,1,1494,1,1494,1,1494,1,1494,1,1495,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,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,1498,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,1501,1,
+        1501,1,1501,1,1501,1,1501,1,1501,1,1501,1,1501,1,1501,1,1501,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,1504,1,1504,1,1504,1,1504,
+        1,1504,1,1504,1,1504,1,1505,1,1505,1,1505,1,1505,1,1505,1,1506,1,
+        1506,1,1506,1,1506,1,1506,1,1507,1,1507,1,1507,1,1507,1,1507,1,1507,
+        1,1508,1,1508,1,1508,1,1508,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,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,1513,1,1513,1,1514,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,1516,1,1516,1,1517,1,1517,1,
+        1517,1,1517,1,1517,1,1517,1,1517,1,1517,1,1518,1,1518,1,1518,1,1518,
+        1,1518,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,1520,1,1520,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,1522,1,1522,1,1522,1,1522,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,1525,
+        1,1525,1,1525,1,1525,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,1526,1,1526,1,1526,1,1526,1,
+        1526,1,1527,1,1527,1,1527,1,1527,1,1527,1,1527,1,1527,1,1527,1,1527,
+        1,1527,1,1527,1,1528,1,1528,1,1528,1,1528,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,1529,
+        1,1529,1,1529,1,1529,1,1529,1,1530,1,1530,1,1530,1,1530,1,1530,1,
+        1530,1,1530,1,1530,1,1530,1,1530,1,1530,1,1530,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,
+        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,1534,1,1534,1,
+        1534,1,1534,1,1534,1,1535,1,1535,1,1535,1,1535,1,1535,1,1535,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,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,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,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,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,1541,
+        1,1542,1,1542,1,1542,1,1542,1,1542,1,1542,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,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,1545,1,1545,1,1545,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,1547,1,1547,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,1548,1,1548,1,1548,1,1548,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,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,1552,1,
+        1553,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,
+        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,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,1558,1,1558,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,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,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,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,1567,1,1567,
+        1,1567,1,1567,1,1567,1,1567,1,1568,1,1568,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,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,1571,1,1571,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,1574,1,1574,1,1574,1,1574,
+        1,1574,1,1574,1,1574,1,1574,1,1574,1,1574,1,1574,1,1574,1,1574,1,
+        1574,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,1575,1,1575,1,1576,1,1576,1,1576,1,
+        1576,1,1576,1,1576,1,1576,1,1576,1,1576,1,1576,1,1576,1,1576,1,1576,
+        1,1576,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,1577,1,1578,1,1578,1,1578,1,1578,1,1578,1,1578,1,1578,1,1578,1,
+        1578,1,1578,1,1578,1,1578,1,1578,1,1578,1,1578,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,
+        1579,1,1579,1,1580,1,1580,1,1580,1,1580,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,1582,1,1582,1,1582,1,1582,1,1582,1,1582,1,1582,
+        1,1582,1,1582,1,1582,1,1583,1,1583,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,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,1585,1,1585,
+        1,1585,1,1585,1,1586,1,1586,1,1586,1,1586,1,1586,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,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,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,1591,1,1591,1,1591,1,1591,1,1591,1,1591,
+        1,1592,1,1592,1,1592,1,1592,1,1592,1,1592,1,1592,1,1592,1,1593,1,
+        1593,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,1596,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,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,1600,1,1600,1,1600,1,1600,1,1600,1,1600,1,1600,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,1601,1,1601,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,1602,1,1603,1,1603,1,1603,1,1603,1,1603,1,
+        1603,1,1603,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,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,1606,1,1606,1,1606,1,1606,1,1606,1,1606,1,1606,1,
+        1607,1,1607,1,1607,1,1607,1,1608,1,1608,1,1608,1,1608,1,1608,1,1609,
+        1,1609,1,1609,1,1609,1,1609,1,1610,1,1610,1,1610,1,1610,1,1610,1,
+        1610,1,1611,1,1611,1,1611,1,1611,1,1611,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,1615,1,1615,1,1615,1,1615,
+        1,1615,1,1615,1,1615,1,1616,1,1616,1,1616,1,1616,1,1616,1,1616,1,
+        1616,1,1616,1,1616,1,1616,1,1616,1,1616,1,1616,1,1616,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,1619,1,1619,
+        1,1619,1,1619,1,1620,1,1620,1,1620,1,1620,1,1620,1,1620,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,1622,1,1622,1,1622,1,1622,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,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,1627,1,1627,1,1627,1,1627,1,1627,1,1627,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,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,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,1634,1,1634,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,1636,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,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,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,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,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,1648,1,1648,1,1648,1,1648,1,1648,1,1648,1,1648,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,1650,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,1652,1,1652,1,1653,1,1653,1,1653,1,1653,1,
+        1653,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,1654,1,1655,1,1655,1,1655,1,1655,1,
+        1655,1,1655,1,1655,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,1656,1,1656,1,
+        1656,1,1657,1,1657,1,1657,1,1657,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,1659,1,
+        1659,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,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,1661,1,1661,1,1661,1,1661,1,
+        1661,1,1662,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,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,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,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,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,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,1669,1,1670,1,1670,1,1670,1,1670,1,1670,1,1670,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,1671,1,1671,1,1671,1,
+        1671,1,1671,1,1671,1,1671,1,1672,1,1672,1,1672,1,1672,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,1674,1,1675,1,1675,1,1675,1,1675,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,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,1679,
+        1,1679,1,1679,1,1679,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,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,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,1687,1,1687,
+        1,1687,1,1687,1,1687,1,1687,1,1687,1,1687,1,1687,1,1688,1,1688,1,
+        1688,1,1688,1,1689,1,1689,1,1689,1,1689,1,1689,1,1690,1,1690,1,1690,
+        1,1690,1,1690,1,1690,1,1690,1,1690,1,1690,1,1690,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,1691,1,1691,1,1691,1,1691,1,
+        1691,1,1691,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,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,1694,1,1694,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,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,1699,1,1699,1,1699,1,1699,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,1702,1,1702,1,1702,1,1702,1,1702,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,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,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,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,1709,1,1709,1,1709,1,1709,1,1709,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,
+        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,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,
+        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,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,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,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,1722,1,1722,1,1722,1,1722,1,1722,1,1722,1,1722,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,1724,1,1724,1,1724,1,1724,1,1724,1,1724,1,1724,1,1724,
+        1,1724,3,1724,23378,8,1724,1,1725,1,1725,1,1725,1,1725,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,1727,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,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,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,
+        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,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,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,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,1737,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,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,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,
+        1741,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,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,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,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,
+        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,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,1750,1,1750,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,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,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,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,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,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,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,1760,1,1760,
+        1,1760,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,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,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,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,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,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,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,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,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,
+        1778,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,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,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,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,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,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,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,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,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,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,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,1795,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,1798,1,1798,1,1798,1,1798,
+        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,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,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,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,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,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,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,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,
+        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,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,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,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,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,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,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,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,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,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,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,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,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,
+        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,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,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,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,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,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,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,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,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,1841,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,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,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,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,1847,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,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,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,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,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,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,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,
+        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,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,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,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,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,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,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,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,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,1876,1,1876,1,1876,1,1876,1,1876,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,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,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,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,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,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,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,1881,1,1882,1,1882,1,1882,1,1882,1,1882,1,1882,1,1882,1,
+        1882,1,1882,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,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,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,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,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,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,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,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,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,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,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,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,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,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,1901,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,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,1903,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,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,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,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,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,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,1914,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,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,1915,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,1949,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,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,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,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,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,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,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,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,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,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,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,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,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,
+        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,1968,1,1968,1,1968,1,1968,1,1969,
+        1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,
+        1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,1,1969,
+        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,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,1972,1,1972,1,1972,1,1973,1,1973,1,1973,1,1973,1,1973,1,1973,
+        1,1973,1,1973,1,1973,1,1973,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,1974,1,1974,1,1974,1,1974,1,1975,1,
+        1975,1,1975,1,1975,1,1975,1,1975,1,1975,1,1975,1,1975,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,1976,1,1976,1,1976,1,1976,1,1976,1,1976,1,1976,1,1976,1,1976,
+        1,1976,1,1976,1,1976,1,1977,1,1977,1,1977,1,1977,1,1977,1,1977,1,
+        1977,1,1977,1,1977,1,1977,1,1977,1,1977,1,1977,1,1977,1,1978,1,1978,
+        1,1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,
+        1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,1978,1,1979,1,1979,
+        1,1979,1,1979,1,1979,1,1979,1,1979,1,1979,1,1979,1,1979,1,1979,1,
+        1979,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,
+        1981,1,1981,1,1981,1,1981,1,1981,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,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,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,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,1985,1,1985,1,1985,
+        1,1985,1,1985,1,1986,1,1986,1,1986,1,1986,1,1986,1,1986,1,1986,1,
+        1986,1,1986,1,1986,1,1986,1,1986,1,1986,1,1987,1,1987,1,1987,1,1987,
+        1,1987,1,1987,1,1987,1,1987,1,1987,1,1987,1,1987,1,1987,1,1987,1,
+        1988,1,1988,1,1988,1,1988,1,1988,1,1988,1,1988,1,1988,1,1988,1,1988,
+        1,1988,1,1988,1,1988,1,1989,1,1989,1,1989,1,1989,1,1989,1,1989,1,
+        1989,1,1989,1,1989,1,1989,1,1989,1,1989,1,1989,1,1989,1,1989,1,1990,
+        1,1990,1,1990,1,1990,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,1991,
+        1,1991,1,1992,1,1992,1,1992,1,1992,1,1992,1,1992,1,1992,1,1992,1,
+        1992,1,1992,1,1992,1,1992,1,1992,1,1992,1,1992,1,1992,1,1993,1,1993,
+        1,1993,1,1993,1,1993,1,1993,1,1993,1,1993,1,1993,1,1993,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,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,1996,1,1996,1,1996,1,1996,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,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,1999,1,1999,1,1999,1,1999,1,1999,1,1999,1,1999,1,2000,1,2000,
+        1,2000,1,2000,1,2000,1,2000,1,2000,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,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,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,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,2007,1,2007,
+        1,2007,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,2008,
+        1,2008,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,2009,1,2009,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,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,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,
+        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,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,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,2017,1,2017,1,2017,1,2017,1,2017,1,2017,1,
+        2017,1,2017,1,2017,1,2017,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,2018,1,2018,1,2019,1,2019,
+        1,2019,1,2019,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,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,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,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,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,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,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,2027,1,2027,1,2027,1,2027,1,2027,1,2027,
+        1,2028,1,2028,1,2028,1,2028,1,2028,1,2028,1,2028,1,2028,1,2028,1,
+        2028,1,2028,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,2030,1,2030,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,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,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,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,2034,1,2034,1,2035,1,2035,1,2035,1,2035,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,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,2037,1,
+        2038,1,2038,1,2038,1,2038,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,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,2040,1,2040,1,2040,1,2041,1,2041,1,2041,1,2041,
+        1,2041,1,2041,1,2041,1,2041,1,2041,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,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,2043,1,2043,1,2043,1,2043,1,2043,
+        1,2043,1,2044,1,2044,1,2044,1,2044,1,2044,1,2044,1,2044,1,2044,1,
+        2044,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,2045,1,2045,1,2045,1,2045,1,
+        2045,1,2046,1,2046,1,2046,1,2046,1,2046,1,2046,1,2046,1,2046,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,2047,1,2047,1,2047,1,2047,1,2047,1,2047,
+        1,2048,1,2048,1,2048,1,2048,1,2048,1,2048,1,2048,1,2048,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,2049,1,2049,1,2049,1,2049,1,2049,1,2049,1,2050,1,
+        2050,1,2050,1,2050,1,2050,1,2050,1,2050,1,2050,1,2050,1,2050,1,2050,
+        1,2050,1,2050,1,2050,1,2051,1,2051,1,2051,1,2051,1,2051,1,2051,1,
+        2051,1,2051,1,2051,1,2051,1,2051,1,2051,1,2051,1,2051,1,2052,1,2052,
+        1,2052,1,2052,1,2052,1,2052,1,2052,1,2052,1,2052,1,2052,1,2052,1,
+        2052,1,2052,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,2053,1,2053,1,
+        2053,1,2053,1,2054,1,2054,1,2054,1,2054,1,2054,1,2054,1,2054,1,2054,
+        1,2054,1,2054,1,2054,1,2054,1,2054,1,2054,1,2054,1,2054,1,2055,1,
+        2055,1,2055,1,2055,1,2055,1,2055,1,2055,1,2055,1,2055,1,2055,1,2055,
+        1,2055,1,2055,1,2055,1,2055,1,2056,1,2056,1,2056,1,2056,1,2056,1,
+        2056,1,2056,1,2056,1,2056,1,2056,1,2056,1,2056,1,2057,1,2057,1,2057,
+        1,2057,1,2057,1,2057,1,2057,1,2057,1,2057,1,2057,1,2057,1,2057,1,
+        2057,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,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,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,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,2062,1,2062,1,2062,1,2062,1,2062,1,2062,
+        1,2062,1,2062,1,2062,1,2062,1,2062,1,2062,1,2062,1,2063,1,2063,1,
+        2063,1,2063,1,2063,1,2063,1,2063,1,2063,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,2064,1,
+        2064,1,2064,1,2064,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,2065,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,2066,1,2066,1,2066,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,2067,1,2067,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,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,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,
+        2070,1,2070,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,2071,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,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,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,2076,1,2076,
+        1,2076,1,2076,1,2076,1,2076,1,2076,1,2076,1,2076,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,2077,1,2077,1,2077,1,2077,1,2077,1,
+        2077,1,2077,1,2077,1,2078,1,2078,1,2079,1,2079,1,2079,1,2079,1,2079,
+        1,2079,1,2079,1,2079,1,2079,1,2079,1,2079,1,2079,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,2080,1,2080,1,
+        2081,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,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,2085,1,2085,1,
+        2085,1,2085,1,2085,1,2085,1,2086,1,2086,1,2086,1,2086,1,2087,1,2087,
+        1,2087,1,2087,1,2087,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,2089,1,2089,1,2089,1,2089,
+        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,2090,1,2090,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,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,2094,1,2094,1,2094,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,2095,1,2095,1,2095,1,2095,1,2095,1,2096,1,2096,1,2096,
+        1,2096,1,2096,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,2098,1,2098,1,2099,1,2099,1,2099,
+        1,2099,1,2099,1,2100,1,2100,1,2100,1,2100,1,2100,1,2101,1,2101,1,
+        2101,1,2101,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,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,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,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,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,2110,1,2110,1,2110,1,2110,1,2110,1,2110,1,2110,1,2110,1,2110,1,
+        2110,1,2110,1,2110,1,2110,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,2111,1,2111,1,2111,1,2111,1,2111,1,2111,1,2112,1,2112,1,2112,1,
+        2112,1,2112,1,2112,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,2115,1,2115,1,
+        2115,1,2115,1,2115,1,2115,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,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,2118,1,2118,1,2118,1,2118,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,2120,1,2120,1,
+        2120,1,2120,1,2120,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,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,2124,1,2124,1,2124,1,2124,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,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,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,2130,
+        1,2130,1,2130,1,2130,1,2130,1,2130,1,2131,1,2131,1,2131,1,2131,1,
+        2131,1,2131,1,2131,1,2132,1,2132,1,2132,1,2132,1,2132,1,2132,1,2132,
+        1,2132,1,2132,1,2132,1,2132,1,2132,1,2132,1,2132,1,2133,1,2133,1,
+        2133,1,2133,1,2133,1,2133,1,2133,1,2133,1,2133,1,2134,1,2134,1,2134,
+        1,2134,1,2134,1,2134,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,2135,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,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,2139,1,2139,1,2139,1,2139,
+        1,2139,1,2139,1,2139,1,2139,1,2139,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,2140,
+        1,2140,1,2141,1,2141,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,2143,1,2143,1,2143,1,2143,
+        1,2143,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,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,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,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,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,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,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,2154,1,2155,
+        1,2155,1,2155,1,2155,1,2155,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,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,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,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,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,2165,
+        1,2165,1,2165,1,2166,1,2166,1,2166,1,2166,1,2166,1,2166,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,2169,1,2169,1,2169,1,2169,1,2170,1,
+        2170,1,2170,1,2170,1,2171,1,2171,1,2171,1,2171,1,2171,1,2172,1,2172,
+        1,2172,1,2172,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,2174,1,2174,1,2174,1,2175,1,2175,
+        1,2175,1,2175,1,2175,1,2175,1,2175,1,2175,1,2175,1,2175,1,2176,1,
+        2176,1,2176,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,2177,1,
+        2177,1,2177,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,
+        2180,1,2181,1,2181,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,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,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,2187,1,2187,1,2188,1,
+        2188,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,2189,1,2189,1,2190,1,2190,1,2190,1,
+        2190,1,2190,1,2190,1,2190,1,2190,1,2190,1,2190,1,2190,1,2190,1,2190,
+        1,2190,1,2190,1,2190,1,2190,1,2190,1,2190,1,2190,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,2191,1,2191,1,2191,1,2191,1,2191,1,2191,1,2191,1,
+        2191,1,2191,1,2191,1,2191,1,2191,1,2191,1,2191,1,2191,1,2191,1,2191,
+        1,2191,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,2193,1,2193,1,2193,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,2195,1,2195,1,2195,1,2195,1,2195,1,2195,1,
+        2195,1,2195,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,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,2199,1,2199,1,2199,1,2199,1,2199,1,2199,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,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,2202,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,2204,
+        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,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,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,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,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,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,
+        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,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,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,2221,1,2221,1,2221,1,2221,1,2221,1,2221,
+        1,2221,1,2221,1,2221,1,2221,1,2221,1,2221,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,2222,1,2222,1,2222,1,2222,1,2222,1,
+        2222,1,2222,1,2222,1,2222,1,2222,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,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,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,2225,1,2225,1,2225,1,2225,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,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,2228,1,2228,1,2228,1,2228,1,2228,1,2228,1,2228,1,2229,1,2229,
+        1,2229,1,2229,1,2229,1,2229,1,2229,1,2229,1,2229,1,2229,1,2229,1,
+        2229,1,2229,1,2229,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,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,
+        2232,1,2232,1,2232,1,2232,1,2232,1,2232,1,2232,1,2232,1,2232,1,2232,
+        1,2232,1,2232,1,2232,1,2233,1,2233,1,2233,1,2233,1,2233,1,2233,1,
+        2233,1,2233,1,2234,1,2234,1,2234,1,2234,1,2234,1,2234,1,2234,1,2234,
+        1,2234,1,2234,1,2235,1,2235,1,2235,1,2235,1,2235,1,2235,1,2235,1,
+        2235,1,2235,1,2235,1,2235,1,2235,1,2235,1,2235,1,2235,1,2235,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,2237,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,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,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,2241,1,2241,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,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,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,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,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,2250,1,2250,1,2250,1,2250,1,2250,1,2250,1,2251,1,
+        2251,1,2251,1,2251,1,2251,1,2252,1,2252,1,2252,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,
+        2255,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,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,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,2257,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,2260,1,2260,1,2260,1,2260,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,2262,1,2262,1,2262,1,2262,1,2263,
+        1,2263,1,2263,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,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,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,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,2271,1,2271,1,2271,1,
+        2271,1,2271,1,2271,1,2271,1,2271,1,2271,1,2271,1,2271,1,2271,1,2271,
+        1,2271,1,2271,1,2271,1,2271,1,2271,1,2272,1,2272,1,2272,1,2272,1,
+        2272,1,2272,1,2272,1,2272,1,2272,1,2272,1,2272,1,2272,1,2273,1,2273,
+        1,2273,1,2273,1,2273,1,2273,1,2273,1,2273,1,2273,1,2273,1,2273,1,
+        2273,1,2273,1,2273,1,2273,1,2273,1,2273,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,2274,1,
+        2274,1,2274,1,2274,1,2274,1,2274,1,2274,1,2274,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,2275,1,2275,1,2275,1,2275,1,2275,1,2275,1,2275,1,2275,
+        1,2275,1,2275,1,2276,1,2276,1,2276,1,2276,1,2276,1,2276,1,2276,1,
+        2276,1,2276,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,2279,1,2279,1,2279,1,2279,1,2279,1,2279,1,2279,1,2279,1,2279,
+        1,2279,1,2279,1,2279,1,2279,1,2279,1,2279,1,2279,1,2280,1,2280,1,
+        2280,1,2280,1,2280,1,2280,1,2280,1,2280,1,2280,1,2280,1,2280,1,2280,
+        1,2280,1,2280,1,2280,1,2280,1,2280,1,2281,1,2281,1,2281,1,2281,1,
+        2281,1,2281,1,2281,1,2281,1,2281,1,2281,1,2281,1,2281,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,2282,1,2282,
+        1,2282,1,2282,1,2282,1,2282,1,2283,1,2283,1,2283,1,2283,1,2283,1,
+        2283,1,2283,1,2283,1,2283,1,2283,1,2283,1,2283,1,2283,1,2283,1,2283,
+        1,2283,1,2283,1,2283,1,2283,1,2284,1,2284,1,2284,1,2284,1,2284,1,
+        2284,1,2284,1,2284,1,2284,1,2285,1,2285,1,2285,1,2285,1,2285,1,2285,
+        1,2285,1,2285,1,2285,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,2287,1,2287,1,2287,1,2287,
+        1,2287,1,2288,1,2288,1,2288,1,2288,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,2290,1,2290,1,2290,1,2290,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,2292,1,2292,1,2293,1,2293,1,
+        2293,1,2293,1,2293,1,2293,1,2294,1,2294,1,2294,1,2294,1,2294,1,2295,
+        1,2295,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,2297,1,2297,1,2297,1,2297,1,2297,
+        1,2297,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,2299,1,2299,1,2299,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,2301,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,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,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,2309,1,2309,
+        1,2309,1,2309,1,2309,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,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,2314,1,2314,1,2314,1,2314,1,2314,
+        1,2314,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,
+        2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,1,2315,
+        1,2315,1,2315,1,2316,1,2316,1,2316,1,2316,1,2317,1,2317,1,2317,1,
+        2317,1,2317,1,2317,1,2317,1,2317,1,2317,1,2317,1,2317,1,2317,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,2319,1,2320,1,2320,1,2320,1,2320,1,2320,
+        1,2320,1,2320,1,2321,1,2321,1,2321,1,2321,1,2321,1,2321,1,2321,1,
+        2321,1,2321,1,2321,1,2321,1,2321,1,2321,1,2321,1,2322,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,2324,1,2324,1,2324,1,2324,1,2324,
+        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,2325,1,2325,1,2325,1,2325,1,2325,
+        1,2326,1,2326,1,2326,1,2326,1,2326,1,2326,1,2326,1,2326,1,2326,1,
+        2326,1,2327,1,2327,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,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,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,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,2333,1,2333,1,2333,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,2334,1,2334,1,2334,1,2334,1,2334,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,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,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,
+        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,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,2341,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,2345,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,2347,1,2347,1,2347,1,2347,1,2347,1,2347,1,2347,1,
+        2347,1,2347,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,2350,1,2350,1,2350,1,2350,1,2350,1,2350,1,2350,
+        1,2350,1,2350,1,2350,1,2350,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,2351,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,2353,1,2353,1,2353,1,2353,1,2354,1,2354,1,2354,
+        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,2355,1,2355,
+        1,2355,1,2355,1,2355,1,2355,1,2356,1,2356,1,2356,1,2357,1,2357,1,
+        2357,1,2357,1,2357,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,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,2360,
+        1,2360,1,2360,1,2360,1,2360,1,2360,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,2362,
+        1,2362,1,2362,1,2362,1,2362,1,2362,1,2362,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,
+        2365,1,2365,1,2365,1,2365,1,2365,1,2365,1,2366,1,2366,1,2366,1,2366,
+        1,2366,1,2366,1,2366,1,2366,1,2366,1,2366,1,2366,1,2367,1,2367,1,
+        2367,1,2367,1,2367,1,2367,1,2367,1,2367,1,2367,1,2367,1,2367,1,2367,
+        1,2367,1,2367,1,2367,1,2367,1,2367,1,2367,1,2368,1,2368,1,2368,1,
+        2368,1,2368,1,2368,1,2368,1,2368,1,2368,1,2368,1,2368,1,2368,1,2368,
+        1,2368,1,2368,1,2368,1,2369,1,2369,1,2369,1,2369,1,2369,1,2369,1,
+        2369,1,2369,1,2369,1,2369,1,2369,1,2369,1,2369,1,2369,1,2369,1,2369,
+        1,2369,1,2369,1,2369,1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,
+        2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,
+        1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,2370,1,2371,1,2371,1,
+        2371,1,2371,1,2371,1,2371,1,2371,1,2371,1,2371,1,2371,1,2371,1,2371,
+        1,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,2373,1,2373,1,2373,1,2373,1,2373,
+        1,2373,1,2373,1,2373,1,2374,1,2374,1,2374,1,2374,1,2374,1,2374,1,
+        2374,1,2374,1,2374,1,2374,1,2375,1,2375,1,2375,1,2375,1,2375,1,2375,
+        1,2375,1,2375,1,2375,1,2375,1,2375,1,2376,1,2376,1,2376,1,2376,1,
+        2376,1,2376,1,2376,1,2376,1,2376,1,2376,1,2376,1,2377,1,2377,1,2377,
+        1,2377,1,2377,1,2377,1,2377,1,2377,1,2377,1,2378,1,2378,1,2378,1,
+        2378,1,2378,1,2378,1,2378,1,2378,1,2379,1,2379,1,2379,1,2379,1,2379,
+        1,2380,1,2380,1,2380,1,2380,1,2380,1,2380,1,2380,1,2380,1,2380,1,
+        2380,1,2381,1,2381,1,2381,1,2381,1,2381,1,2381,1,2381,1,2381,1,2381,
+        1,2381,1,2381,1,2381,1,2381,1,2381,1,2381,1,2381,1,2382,1,2382,1,
+        2382,1,2382,1,2382,1,2382,1,2382,1,2382,1,2382,1,2382,1,2382,1,2382,
+        1,2383,1,2383,1,2383,1,2383,1,2383,1,2383,1,2383,1,2383,1,2383,1,
+        2383,1,2383,1,2383,1,2384,1,2384,1,2384,1,2384,1,2384,1,2384,1,2384,
+        1,2384,1,2384,1,2384,1,2384,1,2384,1,2384,1,2384,1,2385,1,2385,1,
+        2385,1,2385,1,2385,1,2385,1,2385,1,2385,1,2385,1,2385,1,2385,1,2386,
+        1,2386,1,2386,1,2386,1,2386,1,2386,1,2386,1,2386,1,2387,1,2387,1,
+        2387,1,2387,1,2387,1,2388,1,2388,1,2388,1,2388,1,2388,1,2388,1,2388,
+        1,2388,1,2389,1,2389,1,2389,1,2389,1,2389,1,2390,1,2390,1,2390,1,
+        2390,1,2390,1,2390,1,2391,1,2391,1,2391,1,2391,1,2391,1,2391,1,2391,
+        1,2391,1,2391,1,2391,1,2392,1,2392,1,2392,1,2392,1,2392,1,2392,1,
+        2392,1,2392,1,2392,1,2392,1,2393,1,2393,1,2393,1,2393,1,2393,1,2393,
+        1,2393,1,2393,1,2393,1,2393,1,2393,1,2394,1,2394,1,2394,1,2394,1,
+        2394,1,2394,1,2394,1,2394,1,2395,1,2395,1,2395,1,2395,1,2395,1,2395,
+        1,2395,1,2395,1,2395,1,2395,1,2395,1,2395,1,2395,1,2396,1,2396,1,
+        2396,1,2396,1,2396,1,2396,1,2396,1,2396,1,2396,1,2396,1,2396,1,2396,
+        1,2396,1,2396,1,2396,1,2396,1,2397,1,2397,1,2397,1,2397,1,2397,1,
+        2397,1,2397,1,2397,1,2397,1,2397,1,2397,1,2397,1,2397,1,2397,1,2397,
+        1,2397,1,2398,1,2398,1,2398,1,2398,1,2398,1,2399,1,2399,1,2399,1,
+        2399,1,2400,1,2400,1,2400,1,2400,1,2400,1,2401,1,2401,1,2401,1,2401,
+        1,2401,1,2401,1,2401,1,2402,1,2402,1,2402,1,2402,1,2402,1,2402,1,
+        2402,1,2403,1,2403,1,2403,1,2403,1,2404,1,2404,1,2404,1,2404,1,2404,
+        1,2404,1,2404,1,2404,1,2404,1,2405,1,2405,1,2405,1,2405,1,2405,1,
+        2405,1,2405,1,2405,1,2405,1,2405,1,2405,1,2405,1,2405,1,2405,1,2405,
+        1,2405,1,2405,1,2406,1,2406,1,2406,1,2406,1,2406,1,2407,1,2407,1,
+        2407,1,2407,1,2408,1,2408,1,2408,1,2408,1,2408,1,2408,1,2408,1,2409,
+        1,2409,1,2409,1,2409,1,2409,1,2409,1,2409,1,2409,1,2409,1,2409,1,
+        2409,1,2409,1,2410,1,2410,1,2410,1,2410,1,2411,1,2411,1,2411,1,2411,
+        1,2411,1,2411,1,2412,1,2412,1,2412,1,2412,1,2413,1,2413,1,2413,1,
+        2413,1,2413,1,2413,1,2413,1,2413,1,2413,1,2413,1,2413,1,2413,1,2413,
+        1,2413,1,2413,1,2413,1,2414,1,2414,1,2414,1,2414,1,2414,1,2414,1,
+        2415,1,2415,1,2415,1,2415,1,2415,1,2415,1,2416,1,2416,1,2416,1,2416,
+        1,2416,1,2416,1,2416,1,2416,1,2416,1,2416,1,2416,1,2417,1,2417,1,
+        2417,1,2417,1,2417,1,2417,1,2417,1,2418,1,2418,1,2418,1,2418,1,2418,
+        1,2418,1,2418,1,2418,1,2419,1,2419,1,2419,1,2419,1,2419,1,2420,1,
+        2420,1,2420,1,2420,1,2421,1,2421,1,2421,1,2421,1,2421,1,2421,1,2421,
+        1,2422,1,2422,1,2422,1,2422,1,2422,1,2423,1,2423,1,2423,1,2423,1,
+        2423,1,2423,1,2423,1,2423,1,2423,1,2424,1,2424,1,2424,1,2424,1,2424,
+        1,2424,1,2425,1,2425,1,2425,1,2425,1,2425,1,2425,1,2425,1,2425,1,
+        2425,1,2426,1,2426,1,2426,1,2426,1,2426,1,2426,1,2426,1,2426,1,2427,
+        1,2427,1,2427,1,2427,1,2427,1,2427,1,2427,1,2427,1,2427,1,2427,1,
+        2428,1,2428,1,2428,1,2428,1,2428,1,2428,1,2428,1,2428,1,2428,1,2428,
+        1,2428,1,2428,1,2429,1,2429,1,2429,1,2429,1,2429,1,2429,1,2429,1,
+        2429,1,2429,1,2430,1,2430,1,2430,1,2430,1,2430,1,2430,1,2430,1,2431,
+        1,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,1,2432,1,2432,1,2432,1,2432,1,2433,
+        1,2433,1,2433,1,2433,1,2433,1,2433,1,2433,1,2433,1,2433,1,2433,1,
+        2433,1,2433,1,2434,1,2434,1,2434,1,2434,1,2434,1,2434,1,2434,1,2435,
+        1,2435,1,2435,1,2435,1,2436,1,2436,1,2436,1,2436,1,2436,1,2436,1,
+        2436,1,2436,1,2436,1,2436,1,2437,1,2437,1,2437,1,2437,1,2437,1,2437,
+        5,2437,32040,8,2437,10,2437,12,2437,32043,9,2437,1,2437,1,2437,1,
+        2438,1,2438,1,2438,5,2438,32050,8,2438,10,2438,12,2438,32053,9,2438,
+        1,2438,4,2438,32056,8,2438,11,2438,12,2438,32057,1,2439,1,2439,1,
+        2439,3,2439,32063,8,2439,1,2439,1,2439,5,2439,32067,8,2439,10,2439,
+        12,2439,32070,9,2439,1,2439,4,2439,32073,8,2439,11,2439,12,2439,
+        32074,1,2440,1,2440,1,2440,1,2441,1,2441,1,2442,4,2442,32083,8,2442,
+        11,2442,12,2442,32084,1,2443,1,2443,1,2443,3,2443,32090,8,2443,1,
+        2443,1,2443,4,2443,32094,8,2443,11,2443,12,2443,32095,3,2443,32098,
+        8,2443,3,2443,32100,8,2443,1,2443,3,2443,32103,8,2443,1,2444,1,2444,
+        1,2444,1,2444,1,2444,5,2444,32110,8,2444,10,2444,12,2444,32113,9,
+        2444,1,2444,1,2444,1,2445,1,2445,1,2445,1,2445,5,2445,32121,8,2445,
+        10,2445,12,2445,32124,9,2445,1,2445,1,2445,1,2445,1,2445,1,2445,
+        1,2445,1,2446,1,2446,1,2446,1,2446,4,2446,32136,8,2446,11,2446,12,
+        2446,32137,1,2446,1,2446,1,2447,1,2447,1,2448,1,2448,1,2449,1,2449,
+        1,2450,1,2450,1,2451,1,2451,1,2451,1,2452,1,2452,1,2453,1,2453,1,
+        2454,1,2454,1,2455,1,2455,1,2456,1,2456,1,2457,1,2457,1,2458,1,2458,
+        1,2459,1,2459,1,2459,1,2460,1,2460,1,2461,1,2461,1,2462,1,2462,1,
+        2463,1,2463,1,2464,1,2464,1,2464,1,2464,5,2464,32182,8,2464,10,2464,
+        12,2464,32185,9,2464,1,2464,1,2464,1,2464,1,2464,1,2464,3,2464,32192,
+        8,2464,1,2465,1,2465,1,2465,1,2465,1,2465,1,2465,1,2465,1,2465,3,
+        2465,32202,8,2465,1,2466,1,2466,1,2467,1,2467,1,2468,1,2468,1,2469,
+        1,2469,1,2470,1,2470,1,2471,1,2471,1,2472,1,2472,1,2473,1,2473,1,
+        2474,1,2474,1,2475,1,2475,1,2476,1,2476,1,2477,1,2477,1,2478,1,2478,
+        1,2478,1,2478,5,2478,32232,8,2478,10,2478,12,2478,32235,9,2478,1,
+        2478,1,2478,1,2478,1,2478,1,2479,1,2479,1,2479,1,2479,5,2479,32245,
+        8,2479,10,2479,12,2479,32248,9,2479,1,2479,1,2479,1,2479,1,2479,
+        1,2479,1,2480,1,2480,1,2480,1,2480,1,2480,1,2480,1,2480,1,2480,3,
+        2480,32263,8,2480,1,2480,1,2480,5,2480,32267,8,2480,10,2480,12,2480,
+        32270,9,2480,3,2480,32272,8,2480,1,2480,1,2480,1,2480,1,2480,1,2481,
+        1,2481,1,2481,1,2481,1,2481,1,2481,1,2481,1,2481,3,2481,32286,8,
+        2481,1,2481,1,2481,5,2481,32290,8,2481,10,2481,12,2481,32293,9,2481,
+        3,2481,32295,8,2481,1,2481,1,2481,1,2482,1,2482,1,2482,5,2482,32302,
+        8,2482,10,2482,12,2482,32305,9,2482,1,2483,1,2483,1,2483,1,2483,
+        1,2483,4,2483,32312,8,2483,11,2483,12,2483,32313,1,2484,4,2484,32317,
+        8,2484,11,2484,12,2484,32318,1,2484,1,2484,1,2485,1,2485,3,2485,
+        32325,8,2485,1,2486,1,2486,1,2487,1,2487,1,2488,5,2488,32332,8,2488,
+        10,2488,12,2488,32335,9,2488,1,2488,3,2488,32338,8,2488,1,2488,4,
+        2488,32341,8,2488,11,2488,12,2488,32342,1,2489,3,2489,32346,8,2489,
+        1,2489,1,2489,1,2490,1,2490,2,32122,32246,0,2491,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,2373,4747,2374,4749,2375,4751,2376,4753,2377,4755,
+        2378,4757,2379,4759,2380,4761,2381,4763,2382,4765,2383,4767,2384,
+        4769,2385,4771,2386,4773,2387,4775,2388,4777,2389,4779,2390,4781,
+        2391,4783,2392,4785,2393,4787,2394,4789,2395,4791,2396,4793,2397,
+        4795,2398,4797,2399,4799,2400,4801,2401,4803,2402,4805,2403,4807,
+        2404,4809,2405,4811,2406,4813,2407,4815,2408,4817,2409,4819,2410,
+        4821,2411,4823,2412,4825,2413,4827,2414,4829,2415,4831,2416,4833,
+        2417,4835,2418,4837,2419,4839,2420,4841,2421,4843,2422,4845,2423,
+        4847,2424,4849,2425,4851,2426,4853,2427,4855,2428,4857,2429,4859,
+        2430,4861,2431,4863,2432,4865,2433,4867,2434,4869,2435,4871,2436,
+        4873,2437,4875,2438,4877,2439,4879,2440,4881,2441,4883,2442,4885,
+        2443,4887,2444,4889,2445,4891,0,4893,2446,4895,2447,4897,2448,4899,
+        2449,4901,2450,4903,2451,4905,2452,4907,2453,4909,2454,4911,2455,
+        4913,2456,4915,2457,4917,2458,4919,2459,4921,2460,4923,2461,4925,
+        2462,4927,2463,4929,2464,4931,2465,4933,2466,4935,2467,4937,2468,
+        4939,2469,4941,2470,4943,2471,4945,2472,4947,2473,4949,2474,4951,
+        2475,4953,2476,4955,2477,4957,2478,4959,2479,4961,2480,4963,2481,
+        4965,2482,4967,2483,4969,2484,4971,0,4973,0,4975,0,4977,0,4979,0,
+        4981,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,
+        73,73,105,105,2,0,76,76,108,108,2,0,85,85,117,117,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,9,10,13,13,32,32,2,0,0,0,34,34,2,0,48,57,95,95,2,0,10,
+        10,13,13,2,0,9,9,32,32,3,0,35,36,48,57,95,95,4,0,9,10,13,13,32,32,
+        12288,12288,677,0,65,90,97,122,170,170,181,181,186,186,192,214,216,
+        246,248,705,710,721,736,740,748,748,750,750,880,884,886,887,890,
+        893,895,895,902,902,904,906,908,908,910,929,931,1013,1015,1153,1162,
+        1327,1329,1366,1369,1369,1376,1416,1488,1514,1519,1522,1568,1610,
+        1646,1647,1649,1747,1749,1749,1765,1766,1774,1775,1786,1788,1791,
+        1791,1808,1808,1810,1839,1869,1957,1969,1969,1994,2026,2036,2037,
+        2042,2042,2048,2069,2074,2074,2084,2084,2088,2088,2112,2136,2144,
+        2154,2160,2183,2185,2190,2208,2249,2308,2361,2365,2365,2384,2384,
+        2392,2401,2417,2432,2437,2444,2447,2448,2451,2472,2474,2480,2482,
+        2482,2486,2489,2493,2493,2510,2510,2524,2525,2527,2529,2544,2545,
+        2556,2556,2565,2570,2575,2576,2579,2600,2602,2608,2610,2611,2613,
+        2614,2616,2617,2649,2652,2654,2654,2674,2676,2693,2701,2703,2705,
+        2707,2728,2730,2736,2738,2739,2741,2745,2749,2749,2768,2768,2784,
+        2785,2809,2809,2821,2828,2831,2832,2835,2856,2858,2864,2866,2867,
+        2869,2873,2877,2877,2908,2909,2911,2913,2929,2929,2947,2947,2949,
+        2954,2958,2960,2962,2965,2969,2970,2972,2972,2974,2975,2979,2980,
+        2984,2986,2990,3001,3024,3024,3077,3084,3086,3088,3090,3112,3114,
+        3129,3133,3133,3160,3162,3165,3165,3168,3169,3200,3200,3205,3212,
+        3214,3216,3218,3240,3242,3251,3253,3257,3261,3261,3293,3294,3296,
+        3297,3313,3314,3332,3340,3342,3344,3346,3386,3389,3389,3406,3406,
+        3412,3414,3423,3425,3450,3455,3461,3478,3482,3505,3507,3515,3517,
+        3517,3520,3526,3585,3632,3634,3635,3648,3654,3713,3714,3716,3716,
+        3718,3722,3724,3747,3749,3749,3751,3760,3762,3763,3773,3773,3776,
+        3780,3782,3782,3804,3807,3840,3840,3904,3911,3913,3948,3976,3980,
+        4096,4138,4159,4159,4176,4181,4186,4189,4193,4193,4197,4198,4206,
+        4208,4213,4225,4238,4238,4256,4293,4295,4295,4301,4301,4304,4346,
+        4348,4680,4682,4685,4688,4694,4696,4696,4698,4701,4704,4744,4746,
+        4749,4752,4784,4786,4789,4792,4798,4800,4800,4802,4805,4808,4822,
+        4824,4880,4882,4885,4888,4954,4992,5007,5024,5109,5112,5117,5121,
+        5740,5743,5759,5761,5786,5792,5866,5873,5880,5888,5905,5919,5937,
+        5952,5969,5984,5996,5998,6000,6016,6067,6103,6103,6108,6108,6176,
+        6264,6272,6276,6279,6312,6314,6314,6320,6389,6400,6430,6480,6509,
+        6512,6516,6528,6571,6576,6601,6656,6678,6688,6740,6823,6823,6917,
+        6963,6981,6988,7043,7072,7086,7087,7098,7141,7168,7203,7245,7247,
+        7258,7293,7296,7306,7312,7354,7357,7359,7401,7404,7406,7411,7413,
+        7414,7418,7418,7424,7615,7680,7957,7960,7965,7968,8005,8008,8013,
+        8016,8023,8025,8025,8027,8027,8029,8029,8031,8061,8064,8116,8118,
+        8124,8126,8126,8130,8132,8134,8140,8144,8147,8150,8155,8160,8172,
+        8178,8180,8182,8188,8305,8305,8319,8319,8336,8348,8450,8450,8455,
+        8455,8458,8467,8469,8469,8473,8477,8484,8484,8486,8486,8488,8488,
+        8490,8493,8495,8505,8508,8511,8517,8521,8526,8526,8579,8580,11264,
+        11492,11499,11502,11506,11507,11520,11557,11559,11559,11565,11565,
+        11568,11623,11631,11631,11648,11670,11680,11686,11688,11694,11696,
+        11702,11704,11710,11712,11718,11720,11726,11728,11734,11736,11742,
+        11823,11823,12293,12294,12337,12341,12347,12348,12353,12438,12445,
+        12447,12449,12538,12540,12543,12549,12591,12593,12686,12704,12735,
+        12784,12799,13312,19903,19968,42124,42192,42237,42240,42508,42512,
+        42527,42538,42539,42560,42606,42623,42653,42656,42725,42775,42783,
+        42786,42888,42891,42957,42960,42961,42963,42963,42965,42972,42994,
+        43009,43011,43013,43015,43018,43020,43042,43072,43123,43138,43187,
+        43250,43255,43259,43259,43261,43262,43274,43301,43312,43334,43360,
+        43388,43396,43442,43471,43471,43488,43492,43494,43503,43514,43518,
+        43520,43560,43584,43586,43588,43595,43616,43638,43642,43642,43646,
+        43695,43697,43697,43701,43702,43705,43709,43712,43712,43714,43714,
+        43739,43741,43744,43754,43762,43764,43777,43782,43785,43790,43793,
+        43798,43808,43814,43816,43822,43824,43866,43868,43881,43888,44002,
+        44032,55203,55216,55238,55243,55291,63744,64109,64112,64217,64256,
+        64262,64275,64279,64285,64285,64287,64296,64298,64310,64312,64316,
+        64318,64318,64320,64321,64323,64324,64326,64433,64467,64829,64848,
+        64911,64914,64967,65008,65019,65136,65140,65142,65276,65313,65338,
+        65345,65370,65382,65470,65474,65479,65482,65487,65490,65495,65498,
+        65500,65536,65547,65549,65574,65576,65594,65596,65597,65599,65613,
+        65616,65629,65664,65786,66176,66204,66208,66256,66304,66335,66349,
+        66368,66370,66377,66384,66421,66432,66461,66464,66499,66504,66511,
+        66560,66717,66736,66771,66776,66811,66816,66855,66864,66915,66928,
+        66938,66940,66954,66956,66962,66964,66965,66967,66977,66979,66993,
+        66995,67001,67003,67004,67008,67059,67072,67382,67392,67413,67424,
+        67431,67456,67461,67463,67504,67506,67514,67584,67589,67592,67592,
+        67594,67637,67639,67640,67644,67644,67647,67669,67680,67702,67712,
+        67742,67808,67826,67828,67829,67840,67861,67872,67897,67968,68023,
+        68030,68031,68096,68096,68112,68115,68117,68119,68121,68149,68192,
+        68220,68224,68252,68288,68295,68297,68324,68352,68405,68416,68437,
+        68448,68466,68480,68497,68608,68680,68736,68786,68800,68850,68864,
+        68899,68938,68965,68975,68997,69248,69289,69296,69297,69314,69316,
+        69376,69404,69415,69415,69424,69445,69488,69505,69552,69572,69600,
+        69622,69635,69687,69745,69746,69749,69749,69763,69807,69840,69864,
+        69891,69926,69956,69956,69959,69959,69968,70002,70006,70006,70019,
+        70066,70081,70084,70106,70106,70108,70108,70144,70161,70163,70187,
+        70207,70208,70272,70278,70280,70280,70282,70285,70287,70301,70303,
+        70312,70320,70366,70405,70412,70415,70416,70419,70440,70442,70448,
+        70450,70451,70453,70457,70461,70461,70480,70480,70493,70497,70528,
+        70537,70539,70539,70542,70542,70544,70581,70583,70583,70609,70609,
+        70611,70611,70656,70708,70727,70730,70751,70753,70784,70831,70852,
+        70853,70855,70855,71040,71086,71128,71131,71168,71215,71236,71236,
+        71296,71338,71352,71352,71424,71450,71488,71494,71680,71723,71840,
+        71903,71935,71942,71945,71945,71948,71955,71957,71958,71960,71983,
+        71999,71999,72001,72001,72096,72103,72106,72144,72161,72161,72163,
+        72163,72192,72192,72203,72242,72250,72250,72272,72272,72284,72329,
+        72349,72349,72368,72440,72640,72672,72704,72712,72714,72750,72768,
+        72768,72818,72847,72960,72966,72968,72969,72971,73008,73030,73030,
+        73056,73061,73063,73064,73066,73097,73112,73112,73440,73458,73474,
+        73474,73476,73488,73490,73523,73648,73648,73728,74649,74880,75075,
+        77712,77808,77824,78895,78913,78918,78944,82938,82944,83526,90368,
+        90397,92160,92728,92736,92766,92784,92862,92880,92909,92928,92975,
+        92992,92995,93027,93047,93053,93071,93504,93548,93760,93823,93952,
+        94026,94032,94032,94099,94111,94176,94177,94179,94179,94208,100343,
+        100352,101589,101631,101640,110576,110579,110581,110587,110589,110590,
+        110592,110882,110898,110898,110928,110930,110933,110933,110948,110951,
+        110960,111355,113664,113770,113776,113788,113792,113800,113808,113817,
+        119808,119892,119894,119964,119966,119967,119970,119970,119973,119974,
+        119977,119980,119982,119993,119995,119995,119997,120003,120005,120069,
+        120071,120074,120077,120084,120086,120092,120094,120121,120123,120126,
+        120128,120132,120134,120134,120138,120144,120146,120485,120488,120512,
+        120514,120538,120540,120570,120572,120596,120598,120628,120630,120654,
+        120656,120686,120688,120712,120714,120744,120746,120770,120772,120779,
+        122624,122654,122661,122666,122928,122989,123136,123180,123191,123197,
+        123214,123214,123536,123565,123584,123627,124112,124139,124368,124397,
+        124400,124400,124896,124902,124904,124907,124909,124910,124912,124926,
+        124928,125124,125184,125251,125259,125259,126464,126467,126469,126495,
+        126497,126498,126500,126500,126503,126503,126505,126514,126516,126519,
+        126521,126521,126523,126523,126530,126530,126535,126535,126537,126537,
+        126539,126539,126541,126543,126545,126546,126548,126548,126551,126551,
+        126553,126553,126555,126555,126557,126557,126559,126559,126561,126562,
+        126564,126564,126567,126570,126572,126578,126580,126583,126585,126588,
+        126590,126590,126592,126601,126603,126619,126625,126627,126629,126633,
+        126635,126651,131072,173791,173824,177977,177984,178205,178208,183969,
+        183984,191456,191472,192093,194560,195101,196608,201546,201552,205743,
+        32403,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,4747,1,0,0,0,0,4749,1,0,0,0,0,4751,1,0,0,0,0,4753,1,0,
+        0,0,0,4755,1,0,0,0,0,4757,1,0,0,0,0,4759,1,0,0,0,0,4761,1,0,0,0,
+        0,4763,1,0,0,0,0,4765,1,0,0,0,0,4767,1,0,0,0,0,4769,1,0,0,0,0,4771,
+        1,0,0,0,0,4773,1,0,0,0,0,4775,1,0,0,0,0,4777,1,0,0,0,0,4779,1,0,
+        0,0,0,4781,1,0,0,0,0,4783,1,0,0,0,0,4785,1,0,0,0,0,4787,1,0,0,0,
+        0,4789,1,0,0,0,0,4791,1,0,0,0,0,4793,1,0,0,0,0,4795,1,0,0,0,0,4797,
+        1,0,0,0,0,4799,1,0,0,0,0,4801,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,0,4875,
+        1,0,0,0,0,4877,1,0,0,0,0,4879,1,0,0,0,0,4881,1,0,0,0,0,4883,1,0,
+        0,0,0,4885,1,0,0,0,0,4887,1,0,0,0,0,4889,1,0,0,0,0,4891,1,0,0,0,
+        0,4893,1,0,0,0,0,4895,1,0,0,0,0,4897,1,0,0,0,0,4899,1,0,0,0,0,4901,
+        1,0,0,0,0,4903,1,0,0,0,0,4905,1,0,0,0,0,4907,1,0,0,0,0,4909,1,0,
+        0,0,0,4911,1,0,0,0,0,4913,1,0,0,0,0,4915,1,0,0,0,0,4917,1,0,0,0,
+        0,4919,1,0,0,0,0,4921,1,0,0,0,0,4923,1,0,0,0,0,4925,1,0,0,0,0,4927,
+        1,0,0,0,0,4929,1,0,0,0,0,4931,1,0,0,0,0,4933,1,0,0,0,0,4935,1,0,
+        0,0,0,4937,1,0,0,0,0,4939,1,0,0,0,0,4941,1,0,0,0,0,4943,1,0,0,0,
+        0,4945,1,0,0,0,0,4947,1,0,0,0,0,4949,1,0,0,0,0,4951,1,0,0,0,0,4953,
+        1,0,0,0,0,4955,1,0,0,0,0,4957,1,0,0,0,0,4959,1,0,0,0,0,4961,1,0,
+        0,0,0,4963,1,0,0,0,0,4965,1,0,0,0,0,4967,1,0,0,0,0,4969,1,0,0,0,
+        1,4983,1,0,0,0,3,4989,1,0,0,0,5,4993,1,0,0,0,7,5000,1,0,0,0,9,5007,
+        1,0,0,0,11,5016,1,0,0,0,13,5027,1,0,0,0,15,5035,1,0,0,0,17,5039,
+        1,0,0,0,19,5044,1,0,0,0,21,5051,1,0,0,0,23,5058,1,0,0,0,25,5066,
+        1,0,0,0,27,5075,1,0,0,0,29,5082,1,0,0,0,31,5099,1,0,0,0,33,5111,
+        1,0,0,0,35,5127,1,0,0,0,37,5138,1,0,0,0,39,5147,1,0,0,0,41,5161,
+        1,0,0,0,43,5165,1,0,0,0,45,5176,1,0,0,0,47,5186,1,0,0,0,49,5197,
+        1,0,0,0,51,5206,1,0,0,0,53,5212,1,0,0,0,55,5223,1,0,0,0,57,5237,
+        1,0,0,0,59,5246,1,0,0,0,61,5253,1,0,0,0,63,5261,1,0,0,0,65,5276,
+        1,0,0,0,67,5282,1,0,0,0,69,5288,1,0,0,0,71,5298,1,0,0,0,73,5300,
+        1,0,0,0,75,5306,1,0,0,0,77,5310,1,0,0,0,79,5319,1,0,0,0,81,5325,
+        1,0,0,0,83,5334,1,0,0,0,85,5340,1,0,0,0,87,5350,1,0,0,0,89,5357,
+        1,0,0,0,91,5366,1,0,0,0,93,5374,1,0,0,0,95,5383,1,0,0,0,97,5393,
+        1,0,0,0,99,5397,1,0,0,0,101,5407,1,0,0,0,103,5419,1,0,0,0,105,5427,
+        1,0,0,0,107,5439,1,0,0,0,109,5448,1,0,0,0,111,5452,1,0,0,0,113,5462,
+        1,0,0,0,115,5469,1,0,0,0,117,5484,1,0,0,0,119,5498,1,0,0,0,121,5510,
+        1,0,0,0,123,5516,1,0,0,0,125,5538,1,0,0,0,127,5547,1,0,0,0,129,5555,
+        1,0,0,0,131,5564,1,0,0,0,133,5575,1,0,0,0,135,5579,1,0,0,0,137,5585,
+        1,0,0,0,139,5588,1,0,0,0,141,5592,1,0,0,0,143,5598,1,0,0,0,145,5607,
+        1,0,0,0,147,5612,1,0,0,0,149,5617,1,0,0,0,151,5626,1,0,0,0,153,5633,
+        1,0,0,0,155,5643,1,0,0,0,157,5649,1,0,0,0,159,5662,1,0,0,0,161,5668,
+        1,0,0,0,163,5673,1,0,0,0,165,5676,1,0,0,0,167,5686,1,0,0,0,169,5697,
+        1,0,0,0,171,5703,1,0,0,0,173,5717,1,0,0,0,175,5732,1,0,0,0,177,5739,
+        1,0,0,0,179,5753,1,0,0,0,181,5766,1,0,0,0,183,5771,1,0,0,0,185,5782,
+        1,0,0,0,187,5793,1,0,0,0,189,5804,1,0,0,0,191,5814,1,0,0,0,193,5837,
+        1,0,0,0,195,5853,1,0,0,0,197,5866,1,0,0,0,199,5871,1,0,0,0,201,5882,
+        1,0,0,0,203,5894,1,0,0,0,205,5901,1,0,0,0,207,5909,1,0,0,0,209,5919,
+        1,0,0,0,211,5927,1,0,0,0,213,5933,1,0,0,0,215,5943,1,0,0,0,217,5949,
+        1,0,0,0,219,5959,1,0,0,0,221,5987,1,0,0,0,223,5994,1,0,0,0,225,6001,
+        1,0,0,0,227,6007,1,0,0,0,229,6017,1,0,0,0,231,6036,1,0,0,0,233,6043,
+        1,0,0,0,235,6052,1,0,0,0,237,6060,1,0,0,0,239,6066,1,0,0,0,241,6076,
+        1,0,0,0,243,6080,1,0,0,0,245,6088,1,0,0,0,247,6095,1,0,0,0,249,6102,
+        1,0,0,0,251,6116,1,0,0,0,253,6139,1,0,0,0,255,6157,1,0,0,0,257,6170,
+        1,0,0,0,259,6192,1,0,0,0,261,6209,1,0,0,0,263,6224,1,0,0,0,265,6235,
+        1,0,0,0,267,6243,1,0,0,0,269,6254,1,0,0,0,271,6261,1,0,0,0,273,6272,
+        1,0,0,0,275,6279,1,0,0,0,277,6287,1,0,0,0,279,6299,1,0,0,0,281,6304,
+        1,0,0,0,283,6311,1,0,0,0,285,6316,1,0,0,0,287,6322,1,0,0,0,289,6334,
+        1,0,0,0,291,6341,1,0,0,0,293,6351,1,0,0,0,295,6356,1,0,0,0,297,6364,
+        1,0,0,0,299,6369,1,0,0,0,301,6375,1,0,0,0,303,6382,1,0,0,0,305,6390,
+        1,0,0,0,307,6400,1,0,0,0,309,6405,1,0,0,0,311,6412,1,0,0,0,313,6425,
+        1,0,0,0,315,6437,1,0,0,0,317,6443,1,0,0,0,319,6448,1,0,0,0,321,6451,
+        1,0,0,0,323,6474,1,0,0,0,325,6486,1,0,0,0,327,6491,1,0,0,0,329,6497,
+        1,0,0,0,331,6511,1,0,0,0,333,6517,1,0,0,0,335,6526,1,0,0,0,337,6542,
+        1,0,0,0,339,6559,1,0,0,0,341,6567,1,0,0,0,343,6578,1,0,0,0,345,6587,
+        1,0,0,0,347,6592,1,0,0,0,349,6599,1,0,0,0,351,6609,1,0,0,0,353,6618,
+        1,0,0,0,355,6626,1,0,0,0,357,6638,1,0,0,0,359,6646,1,0,0,0,361,6651,
+        1,0,0,0,363,6656,1,0,0,0,365,6671,1,0,0,0,367,6680,1,0,0,0,369,6692,
+        1,0,0,0,371,6697,1,0,0,0,373,6714,1,0,0,0,375,6726,1,0,0,0,377,6732,
+        1,0,0,0,379,6740,1,0,0,0,381,6747,1,0,0,0,383,6762,1,0,0,0,385,6788,
+        1,0,0,0,387,6798,1,0,0,0,389,6809,1,0,0,0,391,6822,1,0,0,0,393,6827,
+        1,0,0,0,395,6835,1,0,0,0,397,6847,1,0,0,0,399,6865,1,0,0,0,401,6871,
+        1,0,0,0,403,6882,1,0,0,0,405,6888,1,0,0,0,407,6895,1,0,0,0,409,6899,
+        1,0,0,0,411,6905,1,0,0,0,413,6911,1,0,0,0,415,6926,1,0,0,0,417,6937,
+        1,0,0,0,419,6944,1,0,0,0,421,6950,1,0,0,0,423,6958,1,0,0,0,425,6964,
+        1,0,0,0,427,6966,1,0,0,0,429,6973,1,0,0,0,431,6978,1,0,0,0,433,6984,
+        1,0,0,0,435,7010,1,0,0,0,437,7016,1,0,0,0,439,7033,1,0,0,0,441,7041,
+        1,0,0,0,443,7057,1,0,0,0,445,7074,1,0,0,0,447,7085,1,0,0,0,449,7096,
+        1,0,0,0,451,7114,1,0,0,0,453,7134,1,0,0,0,455,7146,1,0,0,0,457,7155,
+        1,0,0,0,459,7167,1,0,0,0,461,7174,1,0,0,0,463,7186,1,0,0,0,465,7191,
+        1,0,0,0,467,7199,1,0,0,0,469,7210,1,0,0,0,471,7219,1,0,0,0,473,7241,
+        1,0,0,0,475,7248,1,0,0,0,477,7256,1,0,0,0,479,7269,1,0,0,0,481,7282,
+        1,0,0,0,483,7290,1,0,0,0,485,7297,1,0,0,0,487,7307,1,0,0,0,489,7314,
+        1,0,0,0,491,7326,1,0,0,0,493,7334,1,0,0,0,495,7345,1,0,0,0,497,7359,
+        1,0,0,0,499,7367,1,0,0,0,501,7376,1,0,0,0,503,7387,1,0,0,0,505,7397,
+        1,0,0,0,507,7408,1,0,0,0,509,7416,1,0,0,0,511,7426,1,0,0,0,513,7442,
+        1,0,0,0,515,7451,1,0,0,0,517,7460,1,0,0,0,519,7472,1,0,0,0,521,7480,
+        1,0,0,0,523,7492,1,0,0,0,525,7499,1,0,0,0,527,7510,1,0,0,0,529,7525,
+        1,0,0,0,531,7537,1,0,0,0,533,7547,1,0,0,0,535,7555,1,0,0,0,537,7566,
+        1,0,0,0,539,7581,1,0,0,0,541,7588,1,0,0,0,543,7603,1,0,0,0,545,7626,
+        1,0,0,0,547,7648,1,0,0,0,549,7670,1,0,0,0,551,7691,1,0,0,0,553,7712,
+        1,0,0,0,555,7731,1,0,0,0,557,7749,1,0,0,0,559,7765,1,0,0,0,561,7773,
+        1,0,0,0,563,7786,1,0,0,0,565,7795,1,0,0,0,567,7806,1,0,0,0,569,7815,
+        1,0,0,0,571,7821,1,0,0,0,573,7832,1,0,0,0,575,7844,1,0,0,0,577,7856,
+        1,0,0,0,579,7866,1,0,0,0,581,7877,1,0,0,0,583,7896,1,0,0,0,585,7911,
+        1,0,0,0,587,7925,1,0,0,0,589,7933,1,0,0,0,591,7942,1,0,0,0,593,7950,
+        1,0,0,0,595,7959,1,0,0,0,597,7971,1,0,0,0,599,7985,1,0,0,0,601,7993,
+        1,0,0,0,603,8004,1,0,0,0,605,8011,1,0,0,0,607,8016,1,0,0,0,609,8023,
+        1,0,0,0,611,8030,1,0,0,0,613,8041,1,0,0,0,615,8057,1,0,0,0,617,8069,
+        1,0,0,0,619,8073,1,0,0,0,621,8078,1,0,0,0,623,8083,1,0,0,0,625,8106,
+        1,0,0,0,627,8112,1,0,0,0,629,8120,1,0,0,0,631,8130,1,0,0,0,633,8141,
+        1,0,0,0,635,8153,1,0,0,0,637,8166,1,0,0,0,639,8182,1,0,0,0,641,8188,
+        1,0,0,0,643,8195,1,0,0,0,645,8212,1,0,0,0,647,8235,1,0,0,0,649,8244,
+        1,0,0,0,651,8255,1,0,0,0,653,8264,1,0,0,0,655,8270,1,0,0,0,657,8283,
+        1,0,0,0,659,8293,1,0,0,0,661,8297,1,0,0,0,663,8305,1,0,0,0,665,8310,
+        1,0,0,0,667,8318,1,0,0,0,669,8326,1,0,0,0,671,8337,1,0,0,0,673,8345,
+        1,0,0,0,675,8358,1,0,0,0,677,8373,1,0,0,0,679,8386,1,0,0,0,681,8404,
+        1,0,0,0,683,8417,1,0,0,0,685,8426,1,0,0,0,687,8433,1,0,0,0,689,8454,
+        1,0,0,0,691,8478,1,0,0,0,693,8490,1,0,0,0,695,8493,1,0,0,0,697,8499,
+        1,0,0,0,699,8508,1,0,0,0,701,8517,1,0,0,0,703,8522,1,0,0,0,705,8531,
+        1,0,0,0,707,8541,1,0,0,0,709,8557,1,0,0,0,711,8570,1,0,0,0,713,8580,
+        1,0,0,0,715,8605,1,0,0,0,717,8626,1,0,0,0,719,8635,1,0,0,0,721,8663,
+        1,0,0,0,723,8668,1,0,0,0,725,8679,1,0,0,0,727,8691,1,0,0,0,729,8701,
+        1,0,0,0,731,8705,1,0,0,0,733,8710,1,0,0,0,735,8724,1,0,0,0,737,8728,
+        1,0,0,0,739,8743,1,0,0,0,741,8750,1,0,0,0,743,8761,1,0,0,0,745,8776,
+        1,0,0,0,747,8787,1,0,0,0,749,8802,1,0,0,0,751,8813,1,0,0,0,753,8817,
+        1,0,0,0,755,8828,1,0,0,0,757,8834,1,0,0,0,759,8843,1,0,0,0,761,8847,
+        1,0,0,0,763,8855,1,0,0,0,765,8863,1,0,0,0,767,8873,1,0,0,0,769,8885,
+        1,0,0,0,771,8890,1,0,0,0,773,8900,1,0,0,0,775,8908,1,0,0,0,777,8920,
+        1,0,0,0,779,8928,1,0,0,0,781,8938,1,0,0,0,783,8947,1,0,0,0,785,8965,
+        1,0,0,0,787,8984,1,0,0,0,789,8995,1,0,0,0,791,9004,1,0,0,0,793,9012,
+        1,0,0,0,795,9019,1,0,0,0,797,9027,1,0,0,0,799,9034,1,0,0,0,801,9040,
+        1,0,0,0,803,9049,1,0,0,0,805,9060,1,0,0,0,807,9067,1,0,0,0,809,9077,
+        1,0,0,0,811,9087,1,0,0,0,813,9094,1,0,0,0,815,9106,1,0,0,0,817,9116,
+        1,0,0,0,819,9126,1,0,0,0,821,9132,1,0,0,0,823,9140,1,0,0,0,825,9146,
+        1,0,0,0,827,9163,1,0,0,0,829,9168,1,0,0,0,831,9180,1,0,0,0,833,9188,
+        1,0,0,0,835,9197,1,0,0,0,837,9206,1,0,0,0,839,9217,1,0,0,0,841,9231,
+        1,0,0,0,843,9242,1,0,0,0,845,9252,1,0,0,0,847,9263,1,0,0,0,849,9272,
+        1,0,0,0,851,9284,1,0,0,0,853,9294,1,0,0,0,855,9306,1,0,0,0,857,9318,
+        1,0,0,0,859,9326,1,0,0,0,861,9335,1,0,0,0,863,9364,1,0,0,0,865,9385,
+        1,0,0,0,867,9400,1,0,0,0,869,9413,1,0,0,0,871,9422,1,0,0,0,873,9435,
+        1,0,0,0,875,9443,1,0,0,0,877,9455,1,0,0,0,879,9466,1,0,0,0,881,9471,
+        1,0,0,0,883,9481,1,0,0,0,885,9494,1,0,0,0,887,9500,1,0,0,0,889,9509,
+        1,0,0,0,891,9518,1,0,0,0,893,9532,1,0,0,0,895,9544,1,0,0,0,897,9555,
+        1,0,0,0,899,9559,1,0,0,0,901,9570,1,0,0,0,903,9583,1,0,0,0,905,9595,
+        1,0,0,0,907,9612,1,0,0,0,909,9624,1,0,0,0,911,9633,1,0,0,0,913,9639,
+        1,0,0,0,915,9646,1,0,0,0,917,9651,1,0,0,0,919,9658,1,0,0,0,921,9662,
+        1,0,0,0,923,9668,1,0,0,0,925,9688,1,0,0,0,927,9709,1,0,0,0,929,9727,
+        1,0,0,0,931,9734,1,0,0,0,933,9744,1,0,0,0,935,9757,1,0,0,0,937,9769,
+        1,0,0,0,939,9774,1,0,0,0,941,9785,1,0,0,0,943,9810,1,0,0,0,945,9834,
+        1,0,0,0,947,9839,1,0,0,0,949,9847,1,0,0,0,951,9857,1,0,0,0,953,9860,
+        1,0,0,0,955,9868,1,0,0,0,957,9885,1,0,0,0,959,9910,1,0,0,0,961,9912,
+        1,0,0,0,963,9917,1,0,0,0,965,9929,1,0,0,0,967,9937,1,0,0,0,969,9948,
+        1,0,0,0,971,9957,1,0,0,0,973,9965,1,0,0,0,975,9978,1,0,0,0,977,9993,
+        1,0,0,0,979,10007,1,0,0,0,981,10028,1,0,0,0,983,10033,1,0,0,0,985,
+        10039,1,0,0,0,987,10042,1,0,0,0,989,10051,1,0,0,0,991,10062,1,0,
+        0,0,993,10073,1,0,0,0,995,10079,1,0,0,0,997,10090,1,0,0,0,999,10097,
+        1,0,0,0,1001,10105,1,0,0,0,1003,10125,1,0,0,0,1005,10139,1,0,0,0,
+        1007,10148,1,0,0,0,1009,10157,1,0,0,0,1011,10165,1,0,0,0,1013,10176,
+        1,0,0,0,1015,10198,1,0,0,0,1017,10202,1,0,0,0,1019,10219,1,0,0,0,
+        1021,10226,1,0,0,0,1023,10235,1,0,0,0,1025,10243,1,0,0,0,1027,10251,
+        1,0,0,0,1029,10262,1,0,0,0,1031,10277,1,0,0,0,1033,10283,1,0,0,0,
+        1035,10292,1,0,0,0,1037,10296,1,0,0,0,1039,10311,1,0,0,0,1041,10317,
+        1,0,0,0,1043,10339,1,0,0,0,1045,10346,1,0,0,0,1047,10358,1,0,0,0,
+        1049,10369,1,0,0,0,1051,10376,1,0,0,0,1053,10384,1,0,0,0,1055,10393,
+        1,0,0,0,1057,10398,1,0,0,0,1059,10407,1,0,0,0,1061,10416,1,0,0,0,
+        1063,10427,1,0,0,0,1065,10434,1,0,0,0,1067,10440,1,0,0,0,1069,10447,
+        1,0,0,0,1071,10457,1,0,0,0,1073,10472,1,0,0,0,1075,10483,1,0,0,0,
+        1077,10492,1,0,0,0,1079,10500,1,0,0,0,1081,10510,1,0,0,0,1083,10520,
+        1,0,0,0,1085,10525,1,0,0,0,1087,10533,1,0,0,0,1089,10540,1,0,0,0,
+        1091,10549,1,0,0,0,1093,10556,1,0,0,0,1095,10567,1,0,0,0,1097,10572,
+        1,0,0,0,1099,10593,1,0,0,0,1101,10606,1,0,0,0,1103,10610,1,0,0,0,
+        1105,10617,1,0,0,0,1107,10625,1,0,0,0,1109,10635,1,0,0,0,1111,10642,
+        1,0,0,0,1113,10658,1,0,0,0,1115,10666,1,0,0,0,1117,10674,1,0,0,0,
+        1119,10681,1,0,0,0,1121,10689,1,0,0,0,1123,10698,1,0,0,0,1125,10709,
+        1,0,0,0,1127,10724,1,0,0,0,1129,10732,1,0,0,0,1131,10745,1,0,0,0,
+        1133,10751,1,0,0,0,1135,10760,1,0,0,0,1137,10765,1,0,0,0,1139,10772,
+        1,0,0,0,1141,10787,1,0,0,0,1143,10794,1,0,0,0,1145,10816,1,0,0,0,
+        1147,10826,1,0,0,0,1149,10835,1,0,0,0,1151,10843,1,0,0,0,1153,10849,
+        1,0,0,0,1155,10856,1,0,0,0,1157,10860,1,0,0,0,1159,10865,1,0,0,0,
+        1161,10875,1,0,0,0,1163,10883,1,0,0,0,1165,10891,1,0,0,0,1167,10907,
+        1,0,0,0,1169,10918,1,0,0,0,1171,10930,1,0,0,0,1173,10944,1,0,0,0,
+        1175,10950,1,0,0,0,1177,10956,1,0,0,0,1179,10963,1,0,0,0,1181,10968,
+        1,0,0,0,1183,10986,1,0,0,0,1185,10996,1,0,0,0,1187,11006,1,0,0,0,
+        1189,11030,1,0,0,0,1191,11037,1,0,0,0,1193,11043,1,0,0,0,1195,11048,
+        1,0,0,0,1197,11055,1,0,0,0,1199,11061,1,0,0,0,1201,11068,1,0,0,0,
+        1203,11079,1,0,0,0,1205,11091,1,0,0,0,1207,11097,1,0,0,0,1209,11113,
+        1,0,0,0,1211,11121,1,0,0,0,1213,11131,1,0,0,0,1215,11143,1,0,0,0,
+        1217,11149,1,0,0,0,1219,11154,1,0,0,0,1221,11159,1,0,0,0,1223,11165,
+        1,0,0,0,1225,11171,1,0,0,0,1227,11178,1,0,0,0,1229,11188,1,0,0,0,
+        1231,11196,1,0,0,0,1233,11203,1,0,0,0,1235,11209,1,0,0,0,1237,11233,
+        1,0,0,0,1239,11241,1,0,0,0,1241,11249,1,0,0,0,1243,11253,1,0,0,0,
+        1245,11260,1,0,0,0,1247,11268,1,0,0,0,1249,11284,1,0,0,0,1251,11293,
+        1,0,0,0,1253,11303,1,0,0,0,1255,11313,1,0,0,0,1257,11319,1,0,0,0,
+        1259,11324,1,0,0,0,1261,11332,1,0,0,0,1263,11337,1,0,0,0,1265,11362,
+        1,0,0,0,1267,11371,1,0,0,0,1269,11381,1,0,0,0,1271,11385,1,0,0,0,
+        1273,11387,1,0,0,0,1275,11415,1,0,0,0,1277,11438,1,0,0,0,1279,11454,
+        1,0,0,0,1281,11467,1,0,0,0,1283,11477,1,0,0,0,1285,11481,1,0,0,0,
+        1287,11488,1,0,0,0,1289,11497,1,0,0,0,1291,11509,1,0,0,0,1293,11530,
+        1,0,0,0,1295,11535,1,0,0,0,1297,11541,1,0,0,0,1299,11550,1,0,0,0,
+        1301,11556,1,0,0,0,1303,11565,1,0,0,0,1305,11574,1,0,0,0,1307,11586,
+        1,0,0,0,1309,11593,1,0,0,0,1311,11604,1,0,0,0,1313,11614,1,0,0,0,
+        1315,11620,1,0,0,0,1317,11636,1,0,0,0,1319,11647,1,0,0,0,1321,11655,
+        1,0,0,0,1323,11660,1,0,0,0,1325,11669,1,0,0,0,1327,11677,1,0,0,0,
+        1329,11684,1,0,0,0,1331,11691,1,0,0,0,1333,11696,1,0,0,0,1335,11701,
+        1,0,0,0,1337,11710,1,0,0,0,1339,11719,1,0,0,0,1341,11726,1,0,0,0,
+        1343,11731,1,0,0,0,1345,11742,1,0,0,0,1347,11755,1,0,0,0,1349,11767,
+        1,0,0,0,1351,11777,1,0,0,0,1353,11782,1,0,0,0,1355,11796,1,0,0,0,
+        1357,11808,1,0,0,0,1359,11812,1,0,0,0,1361,11817,1,0,0,0,1363,11823,
+        1,0,0,0,1365,11828,1,0,0,0,1367,11841,1,0,0,0,1369,11848,1,0,0,0,
+        1371,11850,1,0,0,0,1373,11861,1,0,0,0,1375,11872,1,0,0,0,1377,11881,
+        1,0,0,0,1379,11894,1,0,0,0,1381,11897,1,0,0,0,1383,11907,1,0,0,0,
+        1385,11910,1,0,0,0,1387,11917,1,0,0,0,1389,11940,1,0,0,0,1391,11968,
+        1,0,0,0,1393,11995,1,0,0,0,1395,12015,1,0,0,0,1397,12019,1,0,0,0,
+        1399,12029,1,0,0,0,1401,12036,1,0,0,0,1403,12043,1,0,0,0,1405,12052,
+        1,0,0,0,1407,12074,1,0,0,0,1409,12082,1,0,0,0,1411,12098,1,0,0,0,
+        1413,12108,1,0,0,0,1415,12120,1,0,0,0,1417,12130,1,0,0,0,1419,12135,
+        1,0,0,0,1421,12142,1,0,0,0,1423,12152,1,0,0,0,1425,12166,1,0,0,0,
+        1427,12177,1,0,0,0,1429,12185,1,0,0,0,1431,12193,1,0,0,0,1433,12203,
+        1,0,0,0,1435,12216,1,0,0,0,1437,12222,1,0,0,0,1439,12231,1,0,0,0,
+        1441,12242,1,0,0,0,1443,12253,1,0,0,0,1445,12263,1,0,0,0,1447,12276,
+        1,0,0,0,1449,12290,1,0,0,0,1451,12299,1,0,0,0,1453,12310,1,0,0,0,
+        1455,12326,1,0,0,0,1457,12339,1,0,0,0,1459,12353,1,0,0,0,1461,12362,
+        1,0,0,0,1463,12374,1,0,0,0,1465,12384,1,0,0,0,1467,12395,1,0,0,0,
+        1469,12405,1,0,0,0,1471,12413,1,0,0,0,1473,12422,1,0,0,0,1475,12436,
+        1,0,0,0,1477,12444,1,0,0,0,1479,12447,1,0,0,0,1481,12455,1,0,0,0,
+        1483,12463,1,0,0,0,1485,12475,1,0,0,0,1487,12485,1,0,0,0,1489,12494,
+        1,0,0,0,1491,12501,1,0,0,0,1493,12519,1,0,0,0,1495,12528,1,0,0,0,
+        1497,12547,1,0,0,0,1499,12564,1,0,0,0,1501,12570,1,0,0,0,1503,12576,
+        1,0,0,0,1505,12584,1,0,0,0,1507,12596,1,0,0,0,1509,12616,1,0,0,0,
+        1511,12637,1,0,0,0,1513,12652,1,0,0,0,1515,12659,1,0,0,0,1517,12674,
+        1,0,0,0,1519,12690,1,0,0,0,1521,12699,1,0,0,0,1523,12709,1,0,0,0,
+        1525,12722,1,0,0,0,1527,12732,1,0,0,0,1529,12740,1,0,0,0,1531,12747,
+        1,0,0,0,1533,12754,1,0,0,0,1535,12761,1,0,0,0,1537,12768,1,0,0,0,
+        1539,12774,1,0,0,0,1541,12782,1,0,0,0,1543,12794,1,0,0,0,1545,12807,
+        1,0,0,0,1547,12824,1,0,0,0,1549,12837,1,0,0,0,1551,12849,1,0,0,0,
+        1553,12859,1,0,0,0,1555,12868,1,0,0,0,1557,12872,1,0,0,0,1559,12881,
+        1,0,0,0,1561,12886,1,0,0,0,1563,12897,1,0,0,0,1565,12910,1,0,0,0,
+        1567,12920,1,0,0,0,1569,12930,1,0,0,0,1571,12941,1,0,0,0,1573,12944,
+        1,0,0,0,1575,12952,1,0,0,0,1577,12962,1,0,0,0,1579,12978,1,0,0,0,
+        1581,12984,1,0,0,0,1583,12992,1,0,0,0,1585,13009,1,0,0,0,1587,13014,
+        1,0,0,0,1589,13018,1,0,0,0,1591,13023,1,0,0,0,1593,13037,1,0,0,0,
+        1595,13048,1,0,0,0,1597,13059,1,0,0,0,1599,13072,1,0,0,0,1601,13084,
+        1,0,0,0,1603,13092,1,0,0,0,1605,13097,1,0,0,0,1607,13112,1,0,0,0,
+        1609,13124,1,0,0,0,1611,13134,1,0,0,0,1613,13145,1,0,0,0,1615,13160,
+        1,0,0,0,1617,13171,1,0,0,0,1619,13190,1,0,0,0,1621,13208,1,0,0,0,
+        1623,13223,1,0,0,0,1625,13234,1,0,0,0,1627,13236,1,0,0,0,1629,13252,
+        1,0,0,0,1631,13257,1,0,0,0,1633,13266,1,0,0,0,1635,13270,1,0,0,0,
+        1637,13281,1,0,0,0,1639,13289,1,0,0,0,1641,13294,1,0,0,0,1643,13303,
+        1,0,0,0,1645,13308,1,0,0,0,1647,13314,1,0,0,0,1649,13323,1,0,0,0,
+        1651,13332,1,0,0,0,1653,13337,1,0,0,0,1655,13348,1,0,0,0,1657,13356,
+        1,0,0,0,1659,13363,1,0,0,0,1661,13367,1,0,0,0,1663,13373,1,0,0,0,
+        1665,13399,1,0,0,0,1667,13417,1,0,0,0,1669,13440,1,0,0,0,1671,13448,
+        1,0,0,0,1673,13453,1,0,0,0,1675,13462,1,0,0,0,1677,13475,1,0,0,0,
+        1679,13483,1,0,0,0,1681,13488,1,0,0,0,1683,13496,1,0,0,0,1685,13504,
+        1,0,0,0,1687,13512,1,0,0,0,1689,13520,1,0,0,0,1691,13527,1,0,0,0,
+        1693,13532,1,0,0,0,1695,13538,1,0,0,0,1697,13549,1,0,0,0,1699,13556,
+        1,0,0,0,1701,13564,1,0,0,0,1703,13574,1,0,0,0,1705,13579,1,0,0,0,
+        1707,13588,1,0,0,0,1709,13594,1,0,0,0,1711,13600,1,0,0,0,1713,13606,
+        1,0,0,0,1715,13618,1,0,0,0,1717,13623,1,0,0,0,1719,13629,1,0,0,0,
+        1721,13636,1,0,0,0,1723,13642,1,0,0,0,1725,13647,1,0,0,0,1727,13652,
+        1,0,0,0,1729,13659,1,0,0,0,1731,13663,1,0,0,0,1733,13666,1,0,0,0,
+        1735,13672,1,0,0,0,1737,13677,1,0,0,0,1739,13681,1,0,0,0,1741,13689,
+        1,0,0,0,1743,13696,1,0,0,0,1745,13701,1,0,0,0,1747,13715,1,0,0,0,
+        1749,13721,1,0,0,0,1751,13731,1,0,0,0,1753,13746,1,0,0,0,1755,13755,
+        1,0,0,0,1757,13763,1,0,0,0,1759,13772,1,0,0,0,1761,13779,1,0,0,0,
+        1763,13787,1,0,0,0,1765,13792,1,0,0,0,1767,13800,1,0,0,0,1769,13809,
+        1,0,0,0,1771,13817,1,0,0,0,1773,13825,1,0,0,0,1775,13848,1,0,0,0,
+        1777,13874,1,0,0,0,1779,13878,1,0,0,0,1781,13888,1,0,0,0,1783,13895,
+        1,0,0,0,1785,13901,1,0,0,0,1787,13926,1,0,0,0,1789,13931,1,0,0,0,
+        1791,13936,1,0,0,0,1793,13941,1,0,0,0,1795,13947,1,0,0,0,1797,13951,
+        1,0,0,0,1799,13956,1,0,0,0,1801,13963,1,0,0,0,1803,13969,1,0,0,0,
+        1805,13971,1,0,0,0,1807,13976,1,0,0,0,1809,13985,1,0,0,0,1811,13993,
+        1,0,0,0,1813,14000,1,0,0,0,1815,14011,1,0,0,0,1817,14019,1,0,0,0,
+        1819,14029,1,0,0,0,1821,14036,1,0,0,0,1823,14040,1,0,0,0,1825,14048,
+        1,0,0,0,1827,14053,1,0,0,0,1829,14060,1,0,0,0,1831,14068,1,0,0,0,
+        1833,14076,1,0,0,0,1835,14082,1,0,0,0,1837,14095,1,0,0,0,1839,14111,
+        1,0,0,0,1841,14124,1,0,0,0,1843,14136,1,0,0,0,1845,14148,1,0,0,0,
+        1847,14161,1,0,0,0,1849,14172,1,0,0,0,1851,14181,1,0,0,0,1853,14194,
+        1,0,0,0,1855,14206,1,0,0,0,1857,14220,1,0,0,0,1859,14234,1,0,0,0,
+        1861,14255,1,0,0,0,1863,14263,1,0,0,0,1865,14272,1,0,0,0,1867,14281,
+        1,0,0,0,1869,14289,1,0,0,0,1871,14298,1,0,0,0,1873,14305,1,0,0,0,
+        1875,14312,1,0,0,0,1877,14327,1,0,0,0,1879,14346,1,0,0,0,1881,14358,
+        1,0,0,0,1883,14377,1,0,0,0,1885,14389,1,0,0,0,1887,14396,1,0,0,0,
+        1889,14410,1,0,0,0,1891,14419,1,0,0,0,1893,14434,1,0,0,0,1895,14440,
+        1,0,0,0,1897,14449,1,0,0,0,1899,14458,1,0,0,0,1901,14465,1,0,0,0,
+        1903,14473,1,0,0,0,1905,14483,1,0,0,0,1907,14494,1,0,0,0,1909,14503,
+        1,0,0,0,1911,14511,1,0,0,0,1913,14518,1,0,0,0,1915,14524,1,0,0,0,
+        1917,14535,1,0,0,0,1919,14542,1,0,0,0,1921,14550,1,0,0,0,1923,14559,
+        1,0,0,0,1925,14570,1,0,0,0,1927,14580,1,0,0,0,1929,14587,1,0,0,0,
+        1931,14595,1,0,0,0,1933,14604,1,0,0,0,1935,14613,1,0,0,0,1937,14636,
+        1,0,0,0,1939,14664,1,0,0,0,1941,14687,1,0,0,0,1943,14706,1,0,0,0,
+        1945,14712,1,0,0,0,1947,14721,1,0,0,0,1949,14739,1,0,0,0,1951,14749,
+        1,0,0,0,1953,14764,1,0,0,0,1955,14773,1,0,0,0,1957,14778,1,0,0,0,
+        1959,14791,1,0,0,0,1961,14810,1,0,0,0,1963,14817,1,0,0,0,1965,14821,
+        1,0,0,0,1967,14828,1,0,0,0,1969,14839,1,0,0,0,1971,14847,1,0,0,0,
+        1973,14853,1,0,0,0,1975,14868,1,0,0,0,1977,14875,1,0,0,0,1979,14881,
+        1,0,0,0,1981,14891,1,0,0,0,1983,14902,1,0,0,0,1985,14911,1,0,0,0,
+        1987,14916,1,0,0,0,1989,14933,1,0,0,0,1991,14942,1,0,0,0,1993,14951,
+        1,0,0,0,1995,14957,1,0,0,0,1997,14962,1,0,0,0,1999,14972,1,0,0,0,
+        2001,14976,1,0,0,0,2003,14982,1,0,0,0,2005,14991,1,0,0,0,2007,15014,
+        1,0,0,0,2009,15021,1,0,0,0,2011,15029,1,0,0,0,2013,15038,1,0,0,0,
+        2015,15042,1,0,0,0,2017,15051,1,0,0,0,2019,15057,1,0,0,0,2021,15062,
+        1,0,0,0,2023,15068,1,0,0,0,2025,15075,1,0,0,0,2027,15079,1,0,0,0,
+        2029,15086,1,0,0,0,2031,15111,1,0,0,0,2033,15133,1,0,0,0,2035,15149,
+        1,0,0,0,2037,15171,1,0,0,0,2039,15194,1,0,0,0,2041,15202,1,0,0,0,
+        2043,15208,1,0,0,0,2045,15212,1,0,0,0,2047,15220,1,0,0,0,2049,15229,
+        1,0,0,0,2051,15238,1,0,0,0,2053,15243,1,0,0,0,2055,15249,1,0,0,0,
+        2057,15262,1,0,0,0,2059,15279,1,0,0,0,2061,15294,1,0,0,0,2063,15307,
+        1,0,0,0,2065,15320,1,0,0,0,2067,15337,1,0,0,0,2069,15358,1,0,0,0,
+        2071,15373,1,0,0,0,2073,15390,1,0,0,0,2075,15399,1,0,0,0,2077,15412,
+        1,0,0,0,2079,15428,1,0,0,0,2081,15446,1,0,0,0,2083,15458,1,0,0,0,
+        2085,15475,1,0,0,0,2087,15481,1,0,0,0,2089,15490,1,0,0,0,2091,15503,
+        1,0,0,0,2093,15524,1,0,0,0,2095,15534,1,0,0,0,2097,15554,1,0,0,0,
+        2099,15577,1,0,0,0,2101,15586,1,0,0,0,2103,15594,1,0,0,0,2105,15612,
+        1,0,0,0,2107,15626,1,0,0,0,2109,15636,1,0,0,0,2111,15646,1,0,0,0,
+        2113,15663,1,0,0,0,2115,15678,1,0,0,0,2117,15687,1,0,0,0,2119,15700,
+        1,0,0,0,2121,15708,1,0,0,0,2123,15718,1,0,0,0,2125,15737,1,0,0,0,
+        2127,15766,1,0,0,0,2129,15797,1,0,0,0,2131,15811,1,0,0,0,2133,15821,
+        1,0,0,0,2135,15829,1,0,0,0,2137,15837,1,0,0,0,2139,15850,1,0,0,0,
+        2141,15871,1,0,0,0,2143,15891,1,0,0,0,2145,15905,1,0,0,0,2147,15920,
+        1,0,0,0,2149,15935,1,0,0,0,2151,15946,1,0,0,0,2153,15972,1,0,0,0,
+        2155,15997,1,0,0,0,2157,16022,1,0,0,0,2159,16046,1,0,0,0,2161,16070,
+        1,0,0,0,2163,16077,1,0,0,0,2165,16103,1,0,0,0,2167,16118,1,0,0,0,
+        2169,16132,1,0,0,0,2171,16140,1,0,0,0,2173,16165,1,0,0,0,2175,16180,
+        1,0,0,0,2177,16188,1,0,0,0,2179,16199,1,0,0,0,2181,16213,1,0,0,0,
+        2183,16236,1,0,0,0,2185,16263,1,0,0,0,2187,16279,1,0,0,0,2189,16297,
+        1,0,0,0,2191,16314,1,0,0,0,2193,16338,1,0,0,0,2195,16355,1,0,0,0,
+        2197,16379,1,0,0,0,2199,16389,1,0,0,0,2201,16405,1,0,0,0,2203,16414,
+        1,0,0,0,2205,16422,1,0,0,0,2207,16440,1,0,0,0,2209,16453,1,0,0,0,
+        2211,16461,1,0,0,0,2213,16489,1,0,0,0,2215,16520,1,0,0,0,2217,16536,
+        1,0,0,0,2219,16548,1,0,0,0,2221,16561,1,0,0,0,2223,16570,1,0,0,0,
+        2225,16582,1,0,0,0,2227,16594,1,0,0,0,2229,16614,1,0,0,0,2231,16621,
+        1,0,0,0,2233,16629,1,0,0,0,2235,16637,1,0,0,0,2237,16643,1,0,0,0,
+        2239,16653,1,0,0,0,2241,16663,1,0,0,0,2243,16673,1,0,0,0,2245,16684,
+        1,0,0,0,2247,16693,1,0,0,0,2249,16704,1,0,0,0,2251,16715,1,0,0,0,
+        2253,16733,1,0,0,0,2255,16747,1,0,0,0,2257,16760,1,0,0,0,2259,16771,
+        1,0,0,0,2261,16790,1,0,0,0,2263,16816,1,0,0,0,2265,16828,1,0,0,0,
+        2267,16843,1,0,0,0,2269,16848,1,0,0,0,2271,16863,1,0,0,0,2273,16872,
+        1,0,0,0,2275,16888,1,0,0,0,2277,16904,1,0,0,0,2279,16907,1,0,0,0,
+        2281,16917,1,0,0,0,2283,16932,1,0,0,0,2285,16940,1,0,0,0,2287,16957,
+        1,0,0,0,2289,16979,1,0,0,0,2291,17002,1,0,0,0,2293,17013,1,0,0,0,
+        2295,17031,1,0,0,0,2297,17048,1,0,0,0,2299,17060,1,0,0,0,2301,17071,
+        1,0,0,0,2303,17089,1,0,0,0,2305,17105,1,0,0,0,2307,17132,1,0,0,0,
+        2309,17144,1,0,0,0,2311,17162,1,0,0,0,2313,17180,1,0,0,0,2315,17203,
+        1,0,0,0,2317,17213,1,0,0,0,2319,17222,1,0,0,0,2321,17238,1,0,0,0,
+        2323,17249,1,0,0,0,2325,17264,1,0,0,0,2327,17277,1,0,0,0,2329,17290,
+        1,0,0,0,2331,17303,1,0,0,0,2333,17325,1,0,0,0,2335,17343,1,0,0,0,
+        2337,17355,1,0,0,0,2339,17379,1,0,0,0,2341,17394,1,0,0,0,2343,17405,
+        1,0,0,0,2345,17412,1,0,0,0,2347,17421,1,0,0,0,2349,17430,1,0,0,0,
+        2351,17442,1,0,0,0,2353,17458,1,0,0,0,2355,17468,1,0,0,0,2357,17479,
+        1,0,0,0,2359,17489,1,0,0,0,2361,17496,1,0,0,0,2363,17517,1,0,0,0,
+        2365,17535,1,0,0,0,2367,17543,1,0,0,0,2369,17557,1,0,0,0,2371,17567,
+        1,0,0,0,2373,17579,1,0,0,0,2375,17596,1,0,0,0,2377,17611,1,0,0,0,
+        2379,17619,1,0,0,0,2381,17626,1,0,0,0,2383,17645,1,0,0,0,2385,17657,
+        1,0,0,0,2387,17680,1,0,0,0,2389,17701,1,0,0,0,2391,17716,1,0,0,0,
+        2393,17725,1,0,0,0,2395,17745,1,0,0,0,2397,17760,1,0,0,0,2399,17780,
+        1,0,0,0,2401,17789,1,0,0,0,2403,17811,1,0,0,0,2405,17825,1,0,0,0,
+        2407,17833,1,0,0,0,2409,17846,1,0,0,0,2411,17853,1,0,0,0,2413,17857,
+        1,0,0,0,2415,17883,1,0,0,0,2417,17893,1,0,0,0,2419,17905,1,0,0,0,
+        2421,17929,1,0,0,0,2423,17958,1,0,0,0,2425,17970,1,0,0,0,2427,17995,
+        1,0,0,0,2429,18008,1,0,0,0,2431,18018,1,0,0,0,2433,18044,1,0,0,0,
+        2435,18055,1,0,0,0,2437,18080,1,0,0,0,2439,18105,1,0,0,0,2441,18125,
+        1,0,0,0,2443,18132,1,0,0,0,2445,18155,1,0,0,0,2447,18174,1,0,0,0,
+        2449,18204,1,0,0,0,2451,18224,1,0,0,0,2453,18245,1,0,0,0,2455,18256,
+        1,0,0,0,2457,18266,1,0,0,0,2459,18273,1,0,0,0,2461,18278,1,0,0,0,
+        2463,18284,1,0,0,0,2465,18291,1,0,0,0,2467,18299,1,0,0,0,2469,18314,
+        1,0,0,0,2471,18330,1,0,0,0,2473,18346,1,0,0,0,2475,18356,1,0,0,0,
+        2477,18361,1,0,0,0,2479,18372,1,0,0,0,2481,18379,1,0,0,0,2483,18386,
+        1,0,0,0,2485,18392,1,0,0,0,2487,18404,1,0,0,0,2489,18415,1,0,0,0,
+        2491,18423,1,0,0,0,2493,18427,1,0,0,0,2495,18434,1,0,0,0,2497,18437,
+        1,0,0,0,2499,18446,1,0,0,0,2501,18450,1,0,0,0,2503,18455,1,0,0,0,
+        2505,18459,1,0,0,0,2507,18473,1,0,0,0,2509,18477,1,0,0,0,2511,18482,
+        1,0,0,0,2513,18487,1,0,0,0,2515,18491,1,0,0,0,2517,18498,1,0,0,0,
+        2519,18508,1,0,0,0,2521,18513,1,0,0,0,2523,18516,1,0,0,0,2525,18523,
+        1,0,0,0,2527,18540,1,0,0,0,2529,18558,1,0,0,0,2531,18565,1,0,0,0,
+        2533,18570,1,0,0,0,2535,18581,1,0,0,0,2537,18590,1,0,0,0,2539,18603,
+        1,0,0,0,2541,18611,1,0,0,0,2543,18620,1,0,0,0,2545,18646,1,0,0,0,
+        2547,18661,1,0,0,0,2549,18668,1,0,0,0,2551,18679,1,0,0,0,2553,18689,
+        1,0,0,0,2555,18700,1,0,0,0,2557,18714,1,0,0,0,2559,18734,1,0,0,0,
+        2561,18749,1,0,0,0,2563,18757,1,0,0,0,2565,18761,1,0,0,0,2567,18773,
+        1,0,0,0,2569,18787,1,0,0,0,2571,18796,1,0,0,0,2573,18813,1,0,0,0,
+        2575,18829,1,0,0,0,2577,18843,1,0,0,0,2579,18858,1,0,0,0,2581,18877,
+        1,0,0,0,2583,18886,1,0,0,0,2585,18906,1,0,0,0,2587,18924,1,0,0,0,
+        2589,18950,1,0,0,0,2591,18971,1,0,0,0,2593,18986,1,0,0,0,2595,19000,
+        1,0,0,0,2597,19011,1,0,0,0,2599,19026,1,0,0,0,2601,19041,1,0,0,0,
+        2603,19056,1,0,0,0,2605,19071,1,0,0,0,2607,19079,1,0,0,0,2609,19098,
+        1,0,0,0,2611,19104,1,0,0,0,2613,19115,1,0,0,0,2615,19125,1,0,0,0,
+        2617,19138,1,0,0,0,2619,19141,1,0,0,0,2621,19155,1,0,0,0,2623,19163,
+        1,0,0,0,2625,19169,1,0,0,0,2627,19188,1,0,0,0,2629,19208,1,0,0,0,
+        2631,19214,1,0,0,0,2633,19227,1,0,0,0,2635,19235,1,0,0,0,2637,19248,
+        1,0,0,0,2639,19260,1,0,0,0,2641,19264,1,0,0,0,2643,19280,1,0,0,0,
+        2645,19289,1,0,0,0,2647,19298,1,0,0,0,2649,19303,1,0,0,0,2651,19312,
+        1,0,0,0,2653,19323,1,0,0,0,2655,19329,1,0,0,0,2657,19339,1,0,0,0,
+        2659,19343,1,0,0,0,2661,19345,1,0,0,0,2663,19353,1,0,0,0,2665,19362,
+        1,0,0,0,2667,19378,1,0,0,0,2669,19393,1,0,0,0,2671,19402,1,0,0,0,
+        2673,19416,1,0,0,0,2675,19427,1,0,0,0,2677,19433,1,0,0,0,2679,19440,
+        1,0,0,0,2681,19458,1,0,0,0,2683,19477,1,0,0,0,2685,19484,1,0,0,0,
+        2687,19492,1,0,0,0,2689,19505,1,0,0,0,2691,19515,1,0,0,0,2693,19523,
+        1,0,0,0,2695,19547,1,0,0,0,2697,19562,1,0,0,0,2699,19577,1,0,0,0,
+        2701,19587,1,0,0,0,2703,19603,1,0,0,0,2705,19614,1,0,0,0,2707,19628,
+        1,0,0,0,2709,19636,1,0,0,0,2711,19656,1,0,0,0,2713,19675,1,0,0,0,
+        2715,19694,1,0,0,0,2717,19703,1,0,0,0,2719,19722,1,0,0,0,2721,19742,
+        1,0,0,0,2723,19765,1,0,0,0,2725,19790,1,0,0,0,2727,19795,1,0,0,0,
+        2729,19801,1,0,0,0,2731,19806,1,0,0,0,2733,19818,1,0,0,0,2735,19824,
+        1,0,0,0,2737,19832,1,0,0,0,2739,19845,1,0,0,0,2741,19856,1,0,0,0,
+        2743,19864,1,0,0,0,2745,19876,1,0,0,0,2747,19889,1,0,0,0,2749,19897,
+        1,0,0,0,2751,19908,1,0,0,0,2753,19916,1,0,0,0,2755,19929,1,0,0,0,
+        2757,19943,1,0,0,0,2759,19959,1,0,0,0,2761,19967,1,0,0,0,2763,19981,
+        1,0,0,0,2765,19997,1,0,0,0,2767,20012,1,0,0,0,2769,20024,1,0,0,0,
+        2771,20047,1,0,0,0,2773,20068,1,0,0,0,2775,20080,1,0,0,0,2777,20087,
+        1,0,0,0,2779,20097,1,0,0,0,2781,20108,1,0,0,0,2783,20116,1,0,0,0,
+        2785,20120,1,0,0,0,2787,20126,1,0,0,0,2789,20135,1,0,0,0,2791,20141,
+        1,0,0,0,2793,20151,1,0,0,0,2795,20156,1,0,0,0,2797,20163,1,0,0,0,
+        2799,20169,1,0,0,0,2801,20177,1,0,0,0,2803,20192,1,0,0,0,2805,20207,
+        1,0,0,0,2807,20212,1,0,0,0,2809,20229,1,0,0,0,2811,20241,1,0,0,0,
+        2813,20255,1,0,0,0,2815,20271,1,0,0,0,2817,20283,1,0,0,0,2819,20304,
+        1,0,0,0,2821,20319,1,0,0,0,2823,20329,1,0,0,0,2825,20334,1,0,0,0,
+        2827,20340,1,0,0,0,2829,20347,1,0,0,0,2831,20356,1,0,0,0,2833,20364,
+        1,0,0,0,2835,20373,1,0,0,0,2837,20381,1,0,0,0,2839,20389,1,0,0,0,
+        2841,20398,1,0,0,0,2843,20408,1,0,0,0,2845,20417,1,0,0,0,2847,20434,
+        1,0,0,0,2849,20463,1,0,0,0,2851,20477,1,0,0,0,2853,20483,1,0,0,0,
+        2855,20503,1,0,0,0,2857,20517,1,0,0,0,2859,20538,1,0,0,0,2861,20548,
+        1,0,0,0,2863,20555,1,0,0,0,2865,20564,1,0,0,0,2867,20577,1,0,0,0,
+        2869,20585,1,0,0,0,2871,20592,1,0,0,0,2873,20601,1,0,0,0,2875,20610,
+        1,0,0,0,2877,20620,1,0,0,0,2879,20630,1,0,0,0,2881,20650,1,0,0,0,
+        2883,20669,1,0,0,0,2885,20677,1,0,0,0,2887,20685,1,0,0,0,2889,20698,
+        1,0,0,0,2891,20709,1,0,0,0,2893,20717,1,0,0,0,2895,20726,1,0,0,0,
+        2897,20739,1,0,0,0,2899,20748,1,0,0,0,2901,20755,1,0,0,0,2903,20764,
+        1,0,0,0,2905,20769,1,0,0,0,2907,20777,1,0,0,0,2909,20793,1,0,0,0,
+        2911,20802,1,0,0,0,2913,20808,1,0,0,0,2915,20816,1,0,0,0,2917,20828,
+        1,0,0,0,2919,20839,1,0,0,0,2921,20849,1,0,0,0,2923,20860,1,0,0,0,
+        2925,20871,1,0,0,0,2927,20881,1,0,0,0,2929,20889,1,0,0,0,2931,20897,
+        1,0,0,0,2933,20905,1,0,0,0,2935,20913,1,0,0,0,2937,20923,1,0,0,0,
+        2939,20932,1,0,0,0,2941,20942,1,0,0,0,2943,20953,1,0,0,0,2945,20962,
+        1,0,0,0,2947,20968,1,0,0,0,2949,20976,1,0,0,0,2951,20983,1,0,0,0,
+        2953,20993,1,0,0,0,2955,20999,1,0,0,0,2957,21009,1,0,0,0,2959,21019,
+        1,0,0,0,2961,21038,1,0,0,0,2963,21049,1,0,0,0,2965,21064,1,0,0,0,
+        2967,21072,1,0,0,0,2969,21081,1,0,0,0,2971,21093,1,0,0,0,2973,21099,
+        1,0,0,0,2975,21110,1,0,0,0,2977,21116,1,0,0,0,2979,21127,1,0,0,0,
+        2981,21135,1,0,0,0,2983,21142,1,0,0,0,2985,21148,1,0,0,0,2987,21159,
+        1,0,0,0,2989,21165,1,0,0,0,2991,21178,1,0,0,0,2993,21185,1,0,0,0,
+        2995,21191,1,0,0,0,2997,21197,1,0,0,0,2999,21205,1,0,0,0,3001,21209,
+        1,0,0,0,3003,21218,1,0,0,0,3005,21228,1,0,0,0,3007,21232,1,0,0,0,
+        3009,21244,1,0,0,0,3011,21251,1,0,0,0,3013,21256,1,0,0,0,3015,21261,
+        1,0,0,0,3017,21267,1,0,0,0,3019,21276,1,0,0,0,3021,21282,1,0,0,0,
+        3023,21287,1,0,0,0,3025,21297,1,0,0,0,3027,21305,1,0,0,0,3029,21312,
+        1,0,0,0,3031,21320,1,0,0,0,3033,21338,1,0,0,0,3035,21350,1,0,0,0,
+        3037,21358,1,0,0,0,3039,21367,1,0,0,0,3041,21378,1,0,0,0,3043,21386,
+        1,0,0,0,3045,21396,1,0,0,0,3047,21405,1,0,0,0,3049,21410,1,0,0,0,
+        3051,21418,1,0,0,0,3053,21429,1,0,0,0,3055,21448,1,0,0,0,3057,21459,
+        1,0,0,0,3059,21469,1,0,0,0,3061,21480,1,0,0,0,3063,21492,1,0,0,0,
+        3065,21496,1,0,0,0,3067,21504,1,0,0,0,3069,21513,1,0,0,0,3071,21526,
+        1,0,0,0,3073,21539,1,0,0,0,3075,21551,1,0,0,0,3077,21566,1,0,0,0,
+        3079,21580,1,0,0,0,3081,21589,1,0,0,0,3083,21599,1,0,0,0,3085,21609,
+        1,0,0,0,3087,21620,1,0,0,0,3089,21635,1,0,0,0,3091,21643,1,0,0,0,
+        3093,21654,1,0,0,0,3095,21663,1,0,0,0,3097,21672,1,0,0,0,3099,21681,
+        1,0,0,0,3101,21689,1,0,0,0,3103,21696,1,0,0,0,3105,21702,1,0,0,0,
+        3107,21713,1,0,0,0,3109,21723,1,0,0,0,3111,21732,1,0,0,0,3113,21737,
+        1,0,0,0,3115,21747,1,0,0,0,3117,21754,1,0,0,0,3119,21768,1,0,0,0,
+        3121,21775,1,0,0,0,3123,21782,1,0,0,0,3125,21789,1,0,0,0,3127,21796,
+        1,0,0,0,3129,21804,1,0,0,0,3131,21816,1,0,0,0,3133,21825,1,0,0,0,
+        3135,21835,1,0,0,0,3137,21841,1,0,0,0,3139,21848,1,0,0,0,3141,21856,
+        1,0,0,0,3143,21865,1,0,0,0,3145,21874,1,0,0,0,3147,21882,1,0,0,0,
+        3149,21890,1,0,0,0,3151,21911,1,0,0,0,3153,21919,1,0,0,0,3155,21941,
+        1,0,0,0,3157,21952,1,0,0,0,3159,21972,1,0,0,0,3161,21981,1,0,0,0,
+        3163,21994,1,0,0,0,3165,22001,1,0,0,0,3167,22011,1,0,0,0,3169,22018,
+        1,0,0,0,3171,22028,1,0,0,0,3173,22048,1,0,0,0,3175,22058,1,0,0,0,
+        3177,22065,1,0,0,0,3179,22071,1,0,0,0,3181,22079,1,0,0,0,3183,22086,
+        1,0,0,0,3185,22103,1,0,0,0,3187,22111,1,0,0,0,3189,22117,1,0,0,0,
+        3191,22122,1,0,0,0,3193,22130,1,0,0,0,3195,22136,1,0,0,0,3197,22145,
+        1,0,0,0,3199,22153,1,0,0,0,3201,22160,1,0,0,0,3203,22176,1,0,0,0,
+        3205,22196,1,0,0,0,3207,22202,1,0,0,0,3209,22214,1,0,0,0,3211,22227,
+        1,0,0,0,3213,22238,1,0,0,0,3215,22245,1,0,0,0,3217,22249,1,0,0,0,
+        3219,22254,1,0,0,0,3221,22259,1,0,0,0,3223,22265,1,0,0,0,3225,22270,
+        1,0,0,0,3227,22276,1,0,0,0,3229,22284,1,0,0,0,3231,22289,1,0,0,0,
+        3233,22296,1,0,0,0,3235,22314,1,0,0,0,3237,22324,1,0,0,0,3239,22329,
+        1,0,0,0,3241,22333,1,0,0,0,3243,22344,1,0,0,0,3245,22350,1,0,0,0,
+        3247,22365,1,0,0,0,3249,22370,1,0,0,0,3251,22380,1,0,0,0,3253,22392,
+        1,0,0,0,3255,22399,1,0,0,0,3257,22413,1,0,0,0,3259,22417,1,0,0,0,
+        3261,22423,1,0,0,0,3263,22429,1,0,0,0,3265,22436,1,0,0,0,3267,22447,
+        1,0,0,0,3269,22460,1,0,0,0,3271,22473,1,0,0,0,3273,22481,1,0,0,0,
+        3275,22488,1,0,0,0,3277,22495,1,0,0,0,3279,22503,1,0,0,0,3281,22510,
+        1,0,0,0,3283,22525,1,0,0,0,3285,22536,1,0,0,0,3287,22545,1,0,0,0,
+        3289,22550,1,0,0,0,3291,22560,1,0,0,0,3293,22569,1,0,0,0,3295,22577,
+        1,0,0,0,3297,22589,1,0,0,0,3299,22596,1,0,0,0,3301,22601,1,0,0,0,
+        3303,22617,1,0,0,0,3305,22626,1,0,0,0,3307,22640,1,0,0,0,3309,22650,
+        1,0,0,0,3311,22659,1,0,0,0,3313,22672,1,0,0,0,3315,22683,1,0,0,0,
+        3317,22687,1,0,0,0,3319,22693,1,0,0,0,3321,22709,1,0,0,0,3323,22722,
+        1,0,0,0,3325,22740,1,0,0,0,3327,22747,1,0,0,0,3329,22759,1,0,0,0,
+        3331,22780,1,0,0,0,3333,22788,1,0,0,0,3335,22797,1,0,0,0,3337,22820,
+        1,0,0,0,3339,22828,1,0,0,0,3341,22846,1,0,0,0,3343,22862,1,0,0,0,
+        3345,22876,1,0,0,0,3347,22880,1,0,0,0,3349,22885,1,0,0,0,3351,22894,
+        1,0,0,0,3353,22906,1,0,0,0,3355,22913,1,0,0,0,3357,22919,1,0,0,0,
+        3359,22930,1,0,0,0,3361,22942,1,0,0,0,3363,22949,1,0,0,0,3365,22955,
+        1,0,0,0,3367,22963,1,0,0,0,3369,22973,1,0,0,0,3371,22978,1,0,0,0,
+        3373,22985,1,0,0,0,3375,22994,1,0,0,0,3377,23003,1,0,0,0,3379,23007,
+        1,0,0,0,3381,23012,1,0,0,0,3383,23029,1,0,0,0,3385,23045,1,0,0,0,
+        3387,23050,1,0,0,0,3389,23059,1,0,0,0,3391,23074,1,0,0,0,3393,23081,
+        1,0,0,0,3395,23088,1,0,0,0,3397,23099,1,0,0,0,3399,23104,1,0,0,0,
+        3401,23108,1,0,0,0,3403,23113,1,0,0,0,3405,23119,1,0,0,0,3407,23138,
+        1,0,0,0,3409,23143,1,0,0,0,3411,23165,1,0,0,0,3413,23187,1,0,0,0,
+        3415,23197,1,0,0,0,3417,23206,1,0,0,0,3419,23215,1,0,0,0,3421,23220,
+        1,0,0,0,3423,23225,1,0,0,0,3425,23233,1,0,0,0,3427,23255,1,0,0,0,
+        3429,23280,1,0,0,0,3431,23287,1,0,0,0,3433,23293,1,0,0,0,3435,23307,
+        1,0,0,0,3437,23314,1,0,0,0,3439,23320,1,0,0,0,3441,23332,1,0,0,0,
+        3443,23340,1,0,0,0,3445,23349,1,0,0,0,3447,23356,1,0,0,0,3449,23377,
+        1,0,0,0,3451,23379,1,0,0,0,3453,23389,1,0,0,0,3455,23399,1,0,0,0,
+        3457,23423,1,0,0,0,3459,23428,1,0,0,0,3461,23434,1,0,0,0,3463,23445,
+        1,0,0,0,3465,23454,1,0,0,0,3467,23468,1,0,0,0,3469,23491,1,0,0,0,
+        3471,23500,1,0,0,0,3473,23508,1,0,0,0,3475,23513,1,0,0,0,3477,23533,
+        1,0,0,0,3479,23539,1,0,0,0,3481,23547,1,0,0,0,3483,23555,1,0,0,0,
+        3485,23568,1,0,0,0,3487,23586,1,0,0,0,3489,23597,1,0,0,0,3491,23607,
+        1,0,0,0,3493,23613,1,0,0,0,3495,23620,1,0,0,0,3497,23631,1,0,0,0,
+        3499,23651,1,0,0,0,3501,23666,1,0,0,0,3503,23679,1,0,0,0,3505,23693,
+        1,0,0,0,3507,23704,1,0,0,0,3509,23718,1,0,0,0,3511,23738,1,0,0,0,
+        3513,23757,1,0,0,0,3515,23777,1,0,0,0,3517,23794,1,0,0,0,3519,23814,
+        1,0,0,0,3521,23829,1,0,0,0,3523,23840,1,0,0,0,3525,23852,1,0,0,0,
+        3527,23857,1,0,0,0,3529,23865,1,0,0,0,3531,23871,1,0,0,0,3533,23879,
+        1,0,0,0,3535,23886,1,0,0,0,3537,23893,1,0,0,0,3539,23900,1,0,0,0,
+        3541,23915,1,0,0,0,3543,23928,1,0,0,0,3545,23934,1,0,0,0,3547,23944,
+        1,0,0,0,3549,23956,1,0,0,0,3551,23973,1,0,0,0,3553,23987,1,0,0,0,
+        3555,24000,1,0,0,0,3557,24011,1,0,0,0,3559,24028,1,0,0,0,3561,24038,
+        1,0,0,0,3563,24045,1,0,0,0,3565,24059,1,0,0,0,3567,24067,1,0,0,0,
+        3569,24075,1,0,0,0,3571,24083,1,0,0,0,3573,24091,1,0,0,0,3575,24099,
+        1,0,0,0,3577,24110,1,0,0,0,3579,24118,1,0,0,0,3581,24126,1,0,0,0,
+        3583,24139,1,0,0,0,3585,24147,1,0,0,0,3587,24164,1,0,0,0,3589,24175,
+        1,0,0,0,3591,24182,1,0,0,0,3593,24194,1,0,0,0,3595,24199,1,0,0,0,
+        3597,24207,1,0,0,0,3599,24211,1,0,0,0,3601,24218,1,0,0,0,3603,24228,
+        1,0,0,0,3605,24235,1,0,0,0,3607,24245,1,0,0,0,3609,24258,1,0,0,0,
+        3611,24278,1,0,0,0,3613,24298,1,0,0,0,3615,24310,1,0,0,0,3617,24318,
+        1,0,0,0,3619,24325,1,0,0,0,3621,24338,1,0,0,0,3623,24344,1,0,0,0,
+        3625,24358,1,0,0,0,3627,24376,1,0,0,0,3629,24394,1,0,0,0,3631,24410,
+        1,0,0,0,3633,24427,1,0,0,0,3635,24444,1,0,0,0,3637,24464,1,0,0,0,
+        3639,24485,1,0,0,0,3641,24506,1,0,0,0,3643,24526,1,0,0,0,3645,24539,
+        1,0,0,0,3647,24555,1,0,0,0,3649,24570,1,0,0,0,3651,24586,1,0,0,0,
+        3653,24600,1,0,0,0,3655,24614,1,0,0,0,3657,24629,1,0,0,0,3659,24648,
+        1,0,0,0,3661,24667,1,0,0,0,3663,24682,1,0,0,0,3665,24696,1,0,0,0,
+        3667,24705,1,0,0,0,3669,24713,1,0,0,0,3671,24719,1,0,0,0,3673,24738,
+        1,0,0,0,3675,24750,1,0,0,0,3677,24764,1,0,0,0,3679,24774,1,0,0,0,
+        3681,24781,1,0,0,0,3683,24796,1,0,0,0,3685,24811,1,0,0,0,3687,24827,
+        1,0,0,0,3689,24838,1,0,0,0,3691,24853,1,0,0,0,3693,24867,1,0,0,0,
+        3695,24879,1,0,0,0,3697,24904,1,0,0,0,3699,24924,1,0,0,0,3701,24935,
+        1,0,0,0,3703,24947,1,0,0,0,3705,24958,1,0,0,0,3707,24970,1,0,0,0,
+        3709,24991,1,0,0,0,3711,25003,1,0,0,0,3713,25018,1,0,0,0,3715,25034,
+        1,0,0,0,3717,25048,1,0,0,0,3719,25066,1,0,0,0,3721,25077,1,0,0,0,
+        3723,25094,1,0,0,0,3725,25112,1,0,0,0,3727,25126,1,0,0,0,3729,25141,
+        1,0,0,0,3731,25157,1,0,0,0,3733,25168,1,0,0,0,3735,25180,1,0,0,0,
+        3737,25196,1,0,0,0,3739,25221,1,0,0,0,3741,25229,1,0,0,0,3743,25244,
+        1,0,0,0,3745,25260,1,0,0,0,3747,25272,1,0,0,0,3749,25284,1,0,0,0,
+        3751,25295,1,0,0,0,3753,25306,1,0,0,0,3755,25331,1,0,0,0,3757,25361,
+        1,0,0,0,3759,25386,1,0,0,0,3761,25414,1,0,0,0,3763,25436,1,0,0,0,
+        3765,25448,1,0,0,0,3767,25467,1,0,0,0,3769,25486,1,0,0,0,3771,25503,
+        1,0,0,0,3773,25523,1,0,0,0,3775,25541,1,0,0,0,3777,25553,1,0,0,0,
+        3779,25564,1,0,0,0,3781,25579,1,0,0,0,3783,25598,1,0,0,0,3785,25609,
+        1,0,0,0,3787,25626,1,0,0,0,3789,25643,1,0,0,0,3791,25654,1,0,0,0,
+        3793,25665,1,0,0,0,3795,25681,1,0,0,0,3797,25696,1,0,0,0,3799,25712,
+        1,0,0,0,3801,25728,1,0,0,0,3803,25743,1,0,0,0,3805,25756,1,0,0,0,
+        3807,25772,1,0,0,0,3809,25786,1,0,0,0,3811,25797,1,0,0,0,3813,25812,
+        1,0,0,0,3815,25825,1,0,0,0,3817,25836,1,0,0,0,3819,25852,1,0,0,0,
+        3821,25864,1,0,0,0,3823,25875,1,0,0,0,3825,25887,1,0,0,0,3827,25905,
+        1,0,0,0,3829,25916,1,0,0,0,3831,25932,1,0,0,0,3833,25947,1,0,0,0,
+        3835,25958,1,0,0,0,3837,25970,1,0,0,0,3839,25983,1,0,0,0,3841,26001,
+        1,0,0,0,3843,26018,1,0,0,0,3845,26032,1,0,0,0,3847,26046,1,0,0,0,
+        3849,26059,1,0,0,0,3851,26073,1,0,0,0,3853,26088,1,0,0,0,3855,26100,
+        1,0,0,0,3857,26111,1,0,0,0,3859,26134,1,0,0,0,3861,26149,1,0,0,0,
+        3863,26164,1,0,0,0,3865,26178,1,0,0,0,3867,26195,1,0,0,0,3869,26210,
+        1,0,0,0,3871,26229,1,0,0,0,3873,26251,1,0,0,0,3875,26271,1,0,0,0,
+        3877,26288,1,0,0,0,3879,26307,1,0,0,0,3881,26327,1,0,0,0,3883,26347,
+        1,0,0,0,3885,26368,1,0,0,0,3887,26385,1,0,0,0,3889,26400,1,0,0,0,
+        3891,26416,1,0,0,0,3893,26430,1,0,0,0,3895,26444,1,0,0,0,3897,26458,
+        1,0,0,0,3899,26473,1,0,0,0,3901,26488,1,0,0,0,3903,26495,1,0,0,0,
+        3905,26508,1,0,0,0,3907,26519,1,0,0,0,3909,26532,1,0,0,0,3911,26547,
+        1,0,0,0,3913,26563,1,0,0,0,3915,26575,1,0,0,0,3917,26590,1,0,0,0,
+        3919,26601,1,0,0,0,3921,26621,1,0,0,0,3923,26641,1,0,0,0,3925,26654,
+        1,0,0,0,3927,26677,1,0,0,0,3929,26698,1,0,0,0,3931,26723,1,0,0,0,
+        3933,26745,1,0,0,0,3935,26769,1,0,0,0,3937,26792,1,0,0,0,3939,26813,
+        1,0,0,0,3941,26835,1,0,0,0,3943,26856,1,0,0,0,3945,26870,1,0,0,0,
+        3947,26884,1,0,0,0,3949,26901,1,0,0,0,3951,26917,1,0,0,0,3953,26932,
+        1,0,0,0,3955,26950,1,0,0,0,3957,26964,1,0,0,0,3959,26983,1,0,0,0,
+        3961,26999,1,0,0,0,3963,27013,1,0,0,0,3965,27027,1,0,0,0,3967,27040,
+        1,0,0,0,3969,27053,1,0,0,0,3971,27072,1,0,0,0,3973,27082,1,0,0,0,
+        3975,27095,1,0,0,0,3977,27108,1,0,0,0,3979,27121,1,0,0,0,3981,27136,
+        1,0,0,0,3983,27147,1,0,0,0,3985,27157,1,0,0,0,3987,27173,1,0,0,0,
+        3989,27188,1,0,0,0,3991,27202,1,0,0,0,3993,27216,1,0,0,0,3995,27230,
+        1,0,0,0,3997,27242,1,0,0,0,3999,27255,1,0,0,0,4001,27268,1,0,0,0,
+        4003,27280,1,0,0,0,4005,27294,1,0,0,0,4007,27308,1,0,0,0,4009,27319,
+        1,0,0,0,4011,27333,1,0,0,0,4013,27351,1,0,0,0,4015,27363,1,0,0,0,
+        4017,27376,1,0,0,0,4019,27392,1,0,0,0,4021,27408,1,0,0,0,4023,27420,
+        1,0,0,0,4025,27437,1,0,0,0,4027,27450,1,0,0,0,4029,27463,1,0,0,0,
+        4031,27476,1,0,0,0,4033,27490,1,0,0,0,4035,27501,1,0,0,0,4037,27518,
+        1,0,0,0,4039,27534,1,0,0,0,4041,27547,1,0,0,0,4043,27562,1,0,0,0,
+        4045,27578,1,0,0,0,4047,27594,1,0,0,0,4049,27606,1,0,0,0,4051,27620,
+        1,0,0,0,4053,27636,1,0,0,0,4055,27652,1,0,0,0,4057,27669,1,0,0,0,
+        4059,27683,1,0,0,0,4061,27697,1,0,0,0,4063,27711,1,0,0,0,4065,27727,
+        1,0,0,0,4067,27741,1,0,0,0,4069,27755,1,0,0,0,4071,27769,1,0,0,0,
+        4073,27783,1,0,0,0,4075,27797,1,0,0,0,4077,27811,1,0,0,0,4079,27826,
+        1,0,0,0,4081,27840,1,0,0,0,4083,27855,1,0,0,0,4085,27870,1,0,0,0,
+        4087,27884,1,0,0,0,4089,27898,1,0,0,0,4091,27912,1,0,0,0,4093,27926,
+        1,0,0,0,4095,27940,1,0,0,0,4097,27954,1,0,0,0,4099,27968,1,0,0,0,
+        4101,27981,1,0,0,0,4103,27995,1,0,0,0,4105,28009,1,0,0,0,4107,28027,
+        1,0,0,0,4109,28041,1,0,0,0,4111,28057,1,0,0,0,4113,28072,1,0,0,0,
+        4115,28084,1,0,0,0,4117,28101,1,0,0,0,4119,28115,1,0,0,0,4121,28131,
+        1,0,0,0,4123,28145,1,0,0,0,4125,28157,1,0,0,0,4127,28170,1,0,0,0,
+        4129,28183,1,0,0,0,4131,28201,1,0,0,0,4133,28218,1,0,0,0,4135,28233,
+        1,0,0,0,4137,28249,1,0,0,0,4139,28263,1,0,0,0,4141,28279,1,0,0,0,
+        4143,28295,1,0,0,0,4145,28310,1,0,0,0,4147,28324,1,0,0,0,4149,28342,
+        1,0,0,0,4151,28354,1,0,0,0,4153,28370,1,0,0,0,4155,28386,1,0,0,0,
+        4157,28403,1,0,0,0,4159,28405,1,0,0,0,4161,28424,1,0,0,0,4163,28438,
+        1,0,0,0,4165,28449,1,0,0,0,4167,28456,1,0,0,0,4169,28468,1,0,0,0,
+        4171,28474,1,0,0,0,4173,28480,1,0,0,0,4175,28484,1,0,0,0,4177,28489,
+        1,0,0,0,4179,28493,1,0,0,0,4181,28513,1,0,0,0,4183,28522,1,0,0,0,
+        4185,28531,1,0,0,0,4187,28546,1,0,0,0,4189,28556,1,0,0,0,4191,28567,
+        1,0,0,0,4193,28578,1,0,0,0,4195,28583,1,0,0,0,4197,28588,1,0,0,0,
+        4199,28597,1,0,0,0,4201,28602,1,0,0,0,4203,28607,1,0,0,0,4205,28611,
+        1,0,0,0,4207,28617,1,0,0,0,4209,28624,1,0,0,0,4211,28632,1,0,0,0,
+        4213,28637,1,0,0,0,4215,28642,1,0,0,0,4217,28650,1,0,0,0,4219,28678,
+        1,0,0,0,4221,28688,1,0,0,0,4223,28715,1,0,0,0,4225,28739,1,0,0,0,
+        4227,28745,1,0,0,0,4229,28750,1,0,0,0,4231,28759,1,0,0,0,4233,28773,
+        1,0,0,0,4235,28787,1,0,0,0,4237,28803,1,0,0,0,4239,28819,1,0,0,0,
+        4241,28835,1,0,0,0,4243,28845,1,0,0,0,4245,28852,1,0,0,0,4247,28860,
+        1,0,0,0,4249,28867,1,0,0,0,4251,28875,1,0,0,0,4253,28884,1,0,0,0,
+        4255,28901,1,0,0,0,4257,28917,1,0,0,0,4259,28925,1,0,0,0,4261,28933,
+        1,0,0,0,4263,28947,1,0,0,0,4265,28954,1,0,0,0,4267,28968,1,0,0,0,
+        4269,28977,1,0,0,0,4271,28986,1,0,0,0,4273,28996,1,0,0,0,4275,29005,
+        1,0,0,0,4277,29020,1,0,0,0,4279,29033,1,0,0,0,4281,29049,1,0,0,0,
+        4283,29057,1,0,0,0,4285,29068,1,0,0,0,4287,29071,1,0,0,0,4289,29085,
+        1,0,0,0,4291,29091,1,0,0,0,4293,29099,1,0,0,0,4295,29108,1,0,0,0,
+        4297,29117,1,0,0,0,4299,29129,1,0,0,0,4301,29139,1,0,0,0,4303,29150,
+        1,0,0,0,4305,29173,1,0,0,0,4307,29186,1,0,0,0,4309,29197,1,0,0,0,
+        4311,29207,1,0,0,0,4313,29219,1,0,0,0,4315,29225,1,0,0,0,4317,29234,
+        1,0,0,0,4319,29242,1,0,0,0,4321,29247,1,0,0,0,4323,29256,1,0,0,0,
+        4325,29262,1,0,0,0,4327,29270,1,0,0,0,4329,29276,1,0,0,0,4331,29283,
+        1,0,0,0,4333,29286,1,0,0,0,4335,29292,1,0,0,0,4337,29297,1,0,0,0,
+        4339,29307,1,0,0,0,4341,29311,1,0,0,0,4343,29315,1,0,0,0,4345,29320,
+        1,0,0,0,4347,29324,1,0,0,0,4349,29328,1,0,0,0,4351,29339,1,0,0,0,
+        4353,29349,1,0,0,0,4355,29357,1,0,0,0,4357,29371,1,0,0,0,4359,29377,
+        1,0,0,0,4361,29382,1,0,0,0,4363,29389,1,0,0,0,4365,29397,1,0,0,0,
+        4367,29403,1,0,0,0,4369,29413,1,0,0,0,4371,29420,1,0,0,0,4373,29427,
+        1,0,0,0,4375,29437,1,0,0,0,4377,29444,1,0,0,0,4379,29451,1,0,0,0,
+        4381,29461,1,0,0,0,4383,29489,1,0,0,0,4385,29519,1,0,0,0,4387,29537,
+        1,0,0,0,4389,29544,1,0,0,0,4391,29553,1,0,0,0,4393,29561,1,0,0,0,
+        4395,29568,1,0,0,0,4397,29580,1,0,0,0,4399,29590,1,0,0,0,4401,29604,
+        1,0,0,0,4403,29617,1,0,0,0,4405,29626,1,0,0,0,4407,29638,1,0,0,0,
+        4409,29644,1,0,0,0,4411,29653,1,0,0,0,4413,29660,1,0,0,0,4415,29670,
+        1,0,0,0,4417,29678,1,0,0,0,4419,29685,1,0,0,0,4421,29695,1,0,0,0,
+        4423,29707,1,0,0,0,4425,29721,1,0,0,0,4427,29729,1,0,0,0,4429,29735,
+        1,0,0,0,4431,29742,1,0,0,0,4433,29749,1,0,0,0,4435,29756,1,0,0,0,
+        4437,29762,1,0,0,0,4439,29771,1,0,0,0,4441,29782,1,0,0,0,4443,29791,
+        1,0,0,0,4445,29812,1,0,0,0,4447,29838,1,0,0,0,4449,29847,1,0,0,0,
+        4451,29869,1,0,0,0,4453,29891,1,0,0,0,4455,29911,1,0,0,0,4457,29921,
+        1,0,0,0,4459,29928,1,0,0,0,4461,29946,1,0,0,0,4463,29967,1,0,0,0,
+        4465,29977,1,0,0,0,4467,29990,1,0,0,0,4469,29998,1,0,0,0,4471,30008,
+        1,0,0,0,4473,30024,1,0,0,0,4475,30030,1,0,0,0,4477,30047,1,0,0,0,
+        4479,30052,1,0,0,0,4481,30061,1,0,0,0,4483,30081,1,0,0,0,4485,30099,
+        1,0,0,0,4487,30103,1,0,0,0,4489,30126,1,0,0,0,4491,30145,1,0,0,0,
+        4493,30161,1,0,0,0,4495,30176,1,0,0,0,4497,30182,1,0,0,0,4499,30190,
+        1,0,0,0,4501,30198,1,0,0,0,4503,30204,1,0,0,0,4505,30209,1,0,0,0,
+        4507,30212,1,0,0,0,4509,30215,1,0,0,0,4511,30224,1,0,0,0,4513,30244,
+        1,0,0,0,4515,30255,1,0,0,0,4517,30270,1,0,0,0,4519,30277,1,0,0,0,
+        4521,30283,1,0,0,0,4523,30292,1,0,0,0,4525,30300,1,0,0,0,4527,30309,
+        1,0,0,0,4529,30318,1,0,0,0,4531,30325,1,0,0,0,4533,30333,1,0,0,0,
+        4535,30341,1,0,0,0,4537,30349,1,0,0,0,4539,30356,1,0,0,0,4541,30365,
+        1,0,0,0,4543,30373,1,0,0,0,4545,30391,1,0,0,0,4547,30403,1,0,0,0,
+        4549,30425,1,0,0,0,4551,30447,1,0,0,0,4553,30464,1,0,0,0,4555,30473,
+        1,0,0,0,4557,30480,1,0,0,0,4559,30491,1,0,0,0,4561,30507,1,0,0,0,
+        4563,30524,1,0,0,0,4565,30543,1,0,0,0,4567,30561,1,0,0,0,4569,30580,
+        1,0,0,0,4571,30589,1,0,0,0,4573,30602,1,0,0,0,4575,30610,1,0,0,0,
+        4577,30615,1,0,0,0,4579,30625,1,0,0,0,4581,30633,1,0,0,0,4583,30644,
+        1,0,0,0,4585,30652,1,0,0,0,4587,30659,1,0,0,0,4589,30665,1,0,0,0,
+        4591,30670,1,0,0,0,4593,30677,1,0,0,0,4595,30685,1,0,0,0,4597,30691,
+        1,0,0,0,4599,30696,1,0,0,0,4601,30707,1,0,0,0,4603,30716,1,0,0,0,
+        4605,30721,1,0,0,0,4607,30727,1,0,0,0,4609,30733,1,0,0,0,4611,30744,
+        1,0,0,0,4613,30757,1,0,0,0,4615,30764,1,0,0,0,4617,30772,1,0,0,0,
+        4619,30783,1,0,0,0,4621,30788,1,0,0,0,4623,30793,1,0,0,0,4625,30802,
+        1,0,0,0,4627,30810,1,0,0,0,4629,30818,1,0,0,0,4631,30824,1,0,0,0,
+        4633,30844,1,0,0,0,4635,30848,1,0,0,0,4637,30860,1,0,0,0,4639,30864,
+        1,0,0,0,4641,30875,1,0,0,0,4643,30882,1,0,0,0,4645,30896,1,0,0,0,
+        4647,30904,1,0,0,0,4649,30913,1,0,0,0,4651,30926,1,0,0,0,4653,30937,
+        1,0,0,0,4655,30947,1,0,0,0,4657,30955,1,0,0,0,4659,30972,1,0,0,0,
+        4661,30983,1,0,0,0,4663,30994,1,0,0,0,4665,31004,1,0,0,0,4667,31014,
+        1,0,0,0,4669,31023,1,0,0,0,4671,31050,1,0,0,0,4673,31067,1,0,0,0,
+        4675,31088,1,0,0,0,4677,31098,1,0,0,0,4679,31109,1,0,0,0,4681,31123,
+        1,0,0,0,4683,31132,1,0,0,0,4685,31141,1,0,0,0,4687,31147,1,0,0,0,
+        4689,31159,1,0,0,0,4691,31168,1,0,0,0,4693,31176,1,0,0,0,4695,31186,
+        1,0,0,0,4697,31199,1,0,0,0,4699,31208,1,0,0,0,4701,31215,1,0,0,0,
+        4703,31232,1,0,0,0,4705,31245,1,0,0,0,4707,31253,1,0,0,0,4709,31257,
+        1,0,0,0,4711,31268,1,0,0,0,4713,31283,1,0,0,0,4715,31286,1,0,0,0,
+        4717,31297,1,0,0,0,4719,31303,1,0,0,0,4721,31308,1,0,0,0,4723,31322,
+        1,0,0,0,4725,31326,1,0,0,0,4727,31351,1,0,0,0,4729,31359,1,0,0,0,
+        4731,31364,1,0,0,0,4733,31370,1,0,0,0,4735,31381,1,0,0,0,4737,31399,
+        1,0,0,0,4739,31415,1,0,0,0,4741,31434,1,0,0,0,4743,31457,1,0,0,0,
+        4745,31472,1,0,0,0,4747,31483,1,0,0,0,4749,31491,1,0,0,0,4751,31501,
+        1,0,0,0,4753,31512,1,0,0,0,4755,31523,1,0,0,0,4757,31532,1,0,0,0,
+        4759,31540,1,0,0,0,4761,31545,1,0,0,0,4763,31555,1,0,0,0,4765,31571,
+        1,0,0,0,4767,31583,1,0,0,0,4769,31595,1,0,0,0,4771,31609,1,0,0,0,
+        4773,31620,1,0,0,0,4775,31628,1,0,0,0,4777,31633,1,0,0,0,4779,31641,
+        1,0,0,0,4781,31646,1,0,0,0,4783,31652,1,0,0,0,4785,31662,1,0,0,0,
+        4787,31672,1,0,0,0,4789,31683,1,0,0,0,4791,31691,1,0,0,0,4793,31704,
+        1,0,0,0,4795,31720,1,0,0,0,4797,31736,1,0,0,0,4799,31741,1,0,0,0,
+        4801,31745,1,0,0,0,4803,31750,1,0,0,0,4805,31757,1,0,0,0,4807,31764,
+        1,0,0,0,4809,31768,1,0,0,0,4811,31777,1,0,0,0,4813,31794,1,0,0,0,
+        4815,31799,1,0,0,0,4817,31803,1,0,0,0,4819,31810,1,0,0,0,4821,31822,
+        1,0,0,0,4823,31826,1,0,0,0,4825,31832,1,0,0,0,4827,31836,1,0,0,0,
+        4829,31852,1,0,0,0,4831,31858,1,0,0,0,4833,31864,1,0,0,0,4835,31875,
+        1,0,0,0,4837,31882,1,0,0,0,4839,31890,1,0,0,0,4841,31895,1,0,0,0,
+        4843,31899,1,0,0,0,4845,31906,1,0,0,0,4847,31911,1,0,0,0,4849,31920,
+        1,0,0,0,4851,31926,1,0,0,0,4853,31935,1,0,0,0,4855,31943,1,0,0,0,
+        4857,31953,1,0,0,0,4859,31965,1,0,0,0,4861,31974,1,0,0,0,4863,31981,
+        1,0,0,0,4865,31988,1,0,0,0,4867,32000,1,0,0,0,4869,32012,1,0,0,0,
+        4871,32019,1,0,0,0,4873,32023,1,0,0,0,4875,32033,1,0,0,0,4877,32046,
+        1,0,0,0,4879,32062,1,0,0,0,4881,32076,1,0,0,0,4883,32079,1,0,0,0,
+        4885,32082,1,0,0,0,4887,32086,1,0,0,0,4889,32104,1,0,0,0,4891,32116,
+        1,0,0,0,4893,32131,1,0,0,0,4895,32141,1,0,0,0,4897,32143,1,0,0,0,
+        4899,32145,1,0,0,0,4901,32147,1,0,0,0,4903,32149,1,0,0,0,4905,32152,
+        1,0,0,0,4907,32154,1,0,0,0,4909,32156,1,0,0,0,4911,32158,1,0,0,0,
+        4913,32160,1,0,0,0,4915,32162,1,0,0,0,4917,32164,1,0,0,0,4919,32166,
+        1,0,0,0,4921,32169,1,0,0,0,4923,32171,1,0,0,0,4925,32173,1,0,0,0,
+        4927,32175,1,0,0,0,4929,32191,1,0,0,0,4931,32201,1,0,0,0,4933,32203,
+        1,0,0,0,4935,32205,1,0,0,0,4937,32207,1,0,0,0,4939,32209,1,0,0,0,
+        4941,32211,1,0,0,0,4943,32213,1,0,0,0,4945,32215,1,0,0,0,4947,32217,
+        1,0,0,0,4949,32219,1,0,0,0,4951,32221,1,0,0,0,4953,32223,1,0,0,0,
+        4955,32225,1,0,0,0,4957,32227,1,0,0,0,4959,32240,1,0,0,0,4961,32254,
+        1,0,0,0,4963,32277,1,0,0,0,4965,32298,1,0,0,0,4967,32306,1,0,0,0,
+        4969,32316,1,0,0,0,4971,32324,1,0,0,0,4973,32326,1,0,0,0,4975,32328,
+        1,0,0,0,4977,32333,1,0,0,0,4979,32345,1,0,0,0,4981,32349,1,0,0,0,
+        4983,4984,7,0,0,0,4984,4985,7,1,0,0,4985,4986,7,2,0,0,4986,4987,
+        7,3,0,0,4987,4988,7,4,0,0,4988,2,1,0,0,0,4989,4990,7,0,0,0,4990,
+        4991,7,1,0,0,4991,4992,7,5,0,0,4992,4,1,0,0,0,4993,4994,7,0,0,0,
+        4994,4995,7,1,0,0,4995,4996,7,5,0,0,4996,4997,7,6,0,0,4997,4998,
+        7,7,0,0,4998,4999,7,4,0,0,4999,6,1,0,0,0,5000,5001,7,0,0,0,5001,
+        5002,7,8,0,0,5002,5003,7,8,0,0,5003,5004,7,6,0,0,5004,5005,7,5,0,
+        0,5005,5006,7,5,0,0,5006,8,1,0,0,0,5007,5008,7,0,0,0,5008,5009,7,
+        8,0,0,5009,5010,7,8,0,0,5010,5011,7,6,0,0,5011,5012,7,5,0,0,5012,
+        5013,7,5,0,0,5013,5014,7,6,0,0,5014,5015,7,9,0,0,5015,10,1,0,0,0,
+        5016,5017,7,0,0,0,5017,5018,7,8,0,0,5018,5019,7,8,0,0,5019,5020,
+        7,6,0,0,5020,5021,7,5,0,0,5021,5022,7,5,0,0,5022,5023,7,10,0,0,5023,
+        5024,7,1,0,0,5024,5025,7,11,0,0,5025,5026,7,6,0,0,5026,12,1,0,0,
+        0,5027,5028,7,0,0,0,5028,5029,7,8,0,0,5029,5030,7,8,0,0,5030,5031,
+        7,2,0,0,5031,5032,7,12,0,0,5032,5033,7,7,0,0,5033,5034,7,4,0,0,5034,
+        14,1,0,0,0,5035,5036,7,0,0,0,5036,5037,7,8,0,0,5037,5038,7,11,0,
+        0,5038,16,1,0,0,0,5039,5040,7,0,0,0,5040,5041,7,8,0,0,5041,5042,
+        7,2,0,0,5042,5043,7,5,0,0,5043,18,1,0,0,0,5044,5045,7,0,0,0,5045,
+        5046,7,8,0,0,5046,5047,7,3,0,0,5047,5048,7,2,0,0,5048,5049,7,5,0,
+        0,5049,5050,7,5,0,0,5050,20,1,0,0,0,5051,5052,7,0,0,0,5052,5053,
+        7,8,0,0,5053,5054,7,4,0,0,5054,5055,7,10,0,0,5055,5056,7,2,0,0,5056,
+        5057,7,7,0,0,5057,22,1,0,0,0,5058,5059,7,0,0,0,5059,5060,7,8,0,0,
+        5060,5061,7,4,0,0,5061,5062,7,10,0,0,5062,5063,7,2,0,0,5063,5064,
+        7,7,0,0,5064,5065,7,5,0,0,5065,24,1,0,0,0,5066,5067,7,0,0,0,5067,
+        5068,7,8,0,0,5068,5069,7,4,0,0,5069,5070,7,10,0,0,5070,5071,7,13,
+        0,0,5071,5072,7,0,0,0,5072,5073,7,4,0,0,5073,5074,7,6,0,0,5074,26,
+        1,0,0,0,5075,5076,7,0,0,0,5076,5077,7,8,0,0,5077,5078,7,4,0,0,5078,
+        5079,7,10,0,0,5079,5080,7,13,0,0,5080,5081,7,6,0,0,5081,28,1,0,0,
+        0,5082,5083,7,0,0,0,5083,5084,7,8,0,0,5084,5085,7,4,0,0,5085,5086,
+        7,10,0,0,5086,5087,7,13,0,0,5087,5088,7,6,0,0,5088,5089,5,95,0,0,
+        5089,5090,7,8,0,0,5090,5091,7,2,0,0,5091,5092,7,14,0,0,5092,5093,
+        7,15,0,0,5093,5094,7,2,0,0,5094,5095,7,7,0,0,5095,5096,7,6,0,0,5096,
+        5097,7,7,0,0,5097,5098,7,4,0,0,5098,30,1,0,0,0,5099,5100,7,0,0,0,
+        5100,5101,7,8,0,0,5101,5102,7,4,0,0,5102,5103,7,10,0,0,5103,5104,
+        7,13,0,0,5104,5105,7,6,0,0,5105,5106,5,95,0,0,5106,5107,7,9,0,0,
+        5107,5108,7,0,0,0,5108,5109,7,4,0,0,5109,5110,7,0,0,0,5110,32,1,
+        0,0,0,5111,5112,7,0,0,0,5112,5113,7,8,0,0,5113,5114,7,4,0,0,5114,
+        5115,7,10,0,0,5115,5116,7,13,0,0,5116,5117,7,6,0,0,5117,5118,5,95,
+        0,0,5118,5119,7,16,0,0,5119,5120,7,12,0,0,5120,5121,7,7,0,0,5121,
+        5122,7,8,0,0,5122,5123,7,4,0,0,5123,5124,7,10,0,0,5124,5125,7,2,
+        0,0,5125,5126,7,7,0,0,5126,34,1,0,0,0,5127,5128,7,0,0,0,5128,5129,
+        7,8,0,0,5129,5130,7,4,0,0,5130,5131,7,10,0,0,5131,5132,7,13,0,0,
+        5132,5133,7,6,0,0,5133,5134,5,95,0,0,5134,5135,7,4,0,0,5135,5136,
+        7,0,0,0,5136,5137,7,17,0,0,5137,36,1,0,0,0,5138,5139,7,0,0,0,5139,
+        5140,7,8,0,0,5140,5141,7,4,0,0,5141,5142,7,10,0,0,5142,5143,7,13,
+        0,0,5143,5144,7,10,0,0,5144,5145,7,4,0,0,5145,5146,7,18,0,0,5146,
+        38,1,0,0,0,5147,5148,7,0,0,0,5148,5149,7,9,0,0,5149,5150,7,0,0,0,
+        5150,5151,7,15,0,0,5151,5152,7,4,0,0,5152,5153,7,10,0,0,5153,5154,
+        7,13,0,0,5154,5155,7,6,0,0,5155,5156,5,95,0,0,5156,5157,7,15,0,0,
+        5157,5158,7,11,0,0,5158,5159,7,0,0,0,5159,5160,7,7,0,0,5160,40,1,
+        0,0,0,5161,5162,7,0,0,0,5162,5163,7,9,0,0,5163,5164,7,9,0,0,5164,
+        42,1,0,0,0,5165,5166,7,0,0,0,5166,5167,7,9,0,0,5167,5168,7,9,0,0,
+        5168,5169,5,95,0,0,5169,5170,7,8,0,0,5170,5171,7,2,0,0,5171,5172,
+        7,11,0,0,5172,5173,7,12,0,0,5173,5174,7,14,0,0,5174,5175,7,7,0,0,
+        5175,44,1,0,0,0,5176,5177,7,0,0,0,5177,5178,7,9,0,0,5178,5179,7,
+        9,0,0,5179,5180,5,95,0,0,5180,5181,7,17,0,0,5181,5182,7,3,0,0,5182,
+        5183,7,2,0,0,5183,5184,7,12,0,0,5184,5185,7,15,0,0,5185,46,1,0,0,
+        0,5186,5187,7,0,0,0,5187,5188,7,9,0,0,5188,5189,7,9,0,0,5189,5190,
+        5,95,0,0,5190,5191,7,14,0,0,5191,5192,7,2,0,0,5192,5193,7,7,0,0,
+        5193,5194,7,4,0,0,5194,5195,7,19,0,0,5195,5196,7,5,0,0,5196,48,1,
+        0,0,0,5197,5198,7,0,0,0,5198,5199,7,9,0,0,5199,5200,7,20,0,0,5200,
+        5201,5,95,0,0,5201,5202,7,9,0,0,5202,5203,7,0,0,0,5203,5204,7,4,
+        0,0,5204,5205,7,6,0,0,5205,50,1,0,0,0,5206,5207,7,0,0,0,5207,5208,
+        7,9,0,0,5208,5209,7,14,0,0,5209,5210,7,10,0,0,5210,5211,7,7,0,0,
+        5211,52,1,0,0,0,5212,5213,7,0,0,0,5213,5214,7,9,0,0,5214,5215,7,
+        14,0,0,5215,5216,7,10,0,0,5216,5217,7,7,0,0,5217,5218,7,10,0,0,5218,
+        5219,7,5,0,0,5219,5220,7,4,0,0,5220,5221,7,6,0,0,5221,5222,7,3,0,
+        0,5222,54,1,0,0,0,5223,5224,7,0,0,0,5224,5225,7,9,0,0,5225,5226,
+        7,14,0,0,5226,5227,7,10,0,0,5227,5228,7,7,0,0,5228,5229,7,10,0,0,
+        5229,5230,7,5,0,0,5230,5231,7,4,0,0,5231,5232,7,3,0,0,5232,5233,
+        7,0,0,0,5233,5234,7,4,0,0,5234,5235,7,2,0,0,5235,5236,7,3,0,0,5236,
+        56,1,0,0,0,5237,5238,7,0,0,0,5238,5239,7,9,0,0,5239,5240,7,13,0,
+        0,5240,5241,7,0,0,0,5241,5242,7,7,0,0,5242,5243,7,8,0,0,5243,5244,
+        7,6,0,0,5244,5245,7,9,0,0,5245,58,1,0,0,0,5246,5247,7,0,0,0,5247,
+        5248,7,9,0,0,5248,5249,7,13,0,0,5249,5250,7,10,0,0,5250,5251,7,5,
+        0,0,5251,5252,7,6,0,0,5252,60,1,0,0,0,5253,5254,7,0,0,0,5254,5255,
+        7,9,0,0,5255,5256,7,13,0,0,5256,5257,7,10,0,0,5257,5258,7,5,0,0,
+        5258,5259,7,2,0,0,5259,5260,7,3,0,0,5260,62,1,0,0,0,5261,5262,7,
+        0,0,0,5262,5263,7,16,0,0,5263,5264,7,9,0,0,5264,5265,5,95,0,0,5265,
+        5266,7,9,0,0,5266,5267,7,10,0,0,5267,5268,7,5,0,0,5268,5269,7,21,
+        0,0,5269,5270,7,5,0,0,5270,5271,7,4,0,0,5271,5272,7,3,0,0,5272,5273,
+        7,10,0,0,5273,5274,7,7,0,0,5274,5275,7,17,0,0,5275,64,1,0,0,0,5276,
+        5277,7,0,0,0,5277,5278,7,16,0,0,5278,5279,7,4,0,0,5279,5280,7,6,
+        0,0,5280,5281,7,3,0,0,5281,66,1,0,0,0,5282,5283,7,0,0,0,5283,5284,
+        7,17,0,0,5284,5285,7,6,0,0,5285,5286,7,7,0,0,5286,5287,7,4,0,0,5287,
+        68,1,0,0,0,5288,5289,7,0,0,0,5289,5290,7,17,0,0,5290,5291,7,17,0,
+        0,5291,5292,7,3,0,0,5292,5293,7,6,0,0,5293,5294,7,17,0,0,5294,5295,
+        7,0,0,0,5295,5296,7,4,0,0,5296,5297,7,6,0,0,5297,70,1,0,0,0,5298,
+        5299,7,0,0,0,5299,72,1,0,0,0,5300,5301,7,0,0,0,5301,5302,7,11,0,
+        0,5302,5303,7,10,0,0,5303,5304,7,0,0,0,5304,5305,7,5,0,0,5305,74,
+        1,0,0,0,5306,5307,7,0,0,0,5307,5308,7,11,0,0,5308,5309,7,11,0,0,
+        5309,76,1,0,0,0,5310,5311,7,0,0,0,5311,5312,7,11,0,0,5312,5313,7,
+        11,0,0,5313,5314,7,2,0,0,5314,5315,7,8,0,0,5315,5316,7,0,0,0,5316,
+        5317,7,4,0,0,5317,5318,7,6,0,0,5318,78,1,0,0,0,5319,5320,7,0,0,0,
+        5320,5321,7,11,0,0,5321,5322,7,11,0,0,5322,5323,7,2,0,0,5323,5324,
+        7,22,0,0,5324,80,1,0,0,0,5325,5326,7,0,0,0,5326,5327,7,11,0,0,5327,
+        5328,7,11,0,0,5328,5329,5,95,0,0,5329,5330,7,3,0,0,5330,5331,7,2,
+        0,0,5331,5332,7,22,0,0,5332,5333,7,5,0,0,5333,82,1,0,0,0,5334,5335,
+        7,0,0,0,5335,5336,7,11,0,0,5336,5337,7,4,0,0,5337,5338,7,6,0,0,5338,
+        5339,7,3,0,0,5339,84,1,0,0,0,5340,5341,7,0,0,0,5341,5342,7,11,0,
+        0,5342,5343,7,4,0,0,5343,5344,7,6,0,0,5344,5345,7,3,0,0,5345,5346,
+        7,7,0,0,5346,5347,7,0,0,0,5347,5348,7,4,0,0,5348,5349,7,6,0,0,5349,
+        86,1,0,0,0,5350,5351,7,0,0,0,5351,5352,7,11,0,0,5352,5353,7,22,0,
+        0,5353,5354,7,0,0,0,5354,5355,7,18,0,0,5355,5356,7,5,0,0,5356,88,
+        1,0,0,0,5357,5358,7,0,0,0,5358,5359,7,7,0,0,5359,5360,7,0,0,0,5360,
+        5361,7,11,0,0,5361,5362,7,18,0,0,5362,5363,7,4,0,0,5363,5364,7,10,
+        0,0,5364,5365,7,8,0,0,5365,90,1,0,0,0,5366,5367,7,0,0,0,5367,5368,
+        7,7,0,0,5368,5369,7,0,0,0,5369,5370,7,11,0,0,5370,5371,7,18,0,0,
+        5371,5372,7,23,0,0,5372,5373,7,6,0,0,5373,92,1,0,0,0,5374,5375,7,
+        0,0,0,5375,5376,7,7,0,0,5376,5377,7,8,0,0,5377,5378,7,6,0,0,5378,
+        5379,7,5,0,0,5379,5380,7,4,0,0,5380,5381,7,2,0,0,5381,5382,7,3,0,
+        0,5382,94,1,0,0,0,5383,5384,7,0,0,0,5384,5385,7,7,0,0,5385,5386,
+        7,8,0,0,5386,5387,7,10,0,0,5387,5388,7,11,0,0,5388,5389,7,11,0,0,
+        5389,5390,7,0,0,0,5390,5391,7,3,0,0,5391,5392,7,18,0,0,5392,96,1,
+        0,0,0,5393,5394,7,0,0,0,5394,5395,7,7,0,0,5395,5396,7,9,0,0,5396,
+        98,1,0,0,0,5397,5398,7,0,0,0,5398,5399,7,7,0,0,5399,5400,7,9,0,0,
+        5400,5401,5,95,0,0,5401,5402,7,6,0,0,5402,5403,7,24,0,0,5403,5404,
+        7,12,0,0,5404,5405,7,0,0,0,5405,5406,7,11,0,0,5406,100,1,0,0,0,5407,
+        5408,7,0,0,0,5408,5409,7,7,0,0,5409,5410,7,7,0,0,5410,5411,7,2,0,
+        0,5411,5412,7,4,0,0,5412,5413,7,0,0,0,5413,5414,7,4,0,0,5414,5415,
+        7,10,0,0,5415,5416,7,2,0,0,5416,5417,7,7,0,0,5417,5418,7,5,0,0,5418,
+        102,1,0,0,0,5419,5420,7,0,0,0,5420,5421,7,7,0,0,5421,5422,7,2,0,
+        0,5422,5423,7,14,0,0,5423,5424,7,0,0,0,5424,5425,7,11,0,0,5425,5426,
+        7,18,0,0,5426,104,1,0,0,0,5427,5428,7,0,0,0,5428,5429,7,7,0,0,5429,
+        5430,7,5,0,0,5430,5431,7,10,0,0,5431,5432,5,95,0,0,5432,5433,7,3,
+        0,0,5433,5434,7,6,0,0,5434,5435,7,0,0,0,5435,5436,7,3,0,0,5436,5437,
+        7,8,0,0,5437,5438,7,19,0,0,5438,106,1,0,0,0,5439,5440,7,0,0,0,5440,
+        5441,7,7,0,0,5441,5442,7,4,0,0,5442,5443,7,10,0,0,5443,5444,7,20,
+        0,0,5444,5445,7,2,0,0,5445,5446,7,10,0,0,5446,5447,7,7,0,0,5447,
+        108,1,0,0,0,5448,5449,7,0,0,0,5449,5450,7,7,0,0,5450,5451,7,18,0,
+        0,5451,110,1,0,0,0,5452,5453,7,0,0,0,5453,5454,7,7,0,0,5454,5455,
+        7,18,0,0,5455,5456,7,5,0,0,5456,5457,7,8,0,0,5457,5458,7,19,0,0,
+        5458,5459,7,6,0,0,5459,5460,7,14,0,0,5460,5461,7,0,0,0,5461,112,
+        1,0,0,0,5462,5463,7,0,0,0,5463,5464,7,15,0,0,5464,5465,7,15,0,0,
+        5465,5466,7,6,0,0,5466,5467,7,7,0,0,5467,5468,7,9,0,0,5468,114,1,
+        0,0,0,5469,5470,7,0,0,0,5470,5471,7,15,0,0,5471,5472,7,15,0,0,5472,
+        5473,7,6,0,0,5473,5474,7,7,0,0,5474,5475,7,9,0,0,5475,5476,7,8,0,
+        0,5476,5477,7,19,0,0,5477,5478,7,10,0,0,5478,5479,7,11,0,0,5479,
+        5480,7,9,0,0,5480,5481,7,25,0,0,5481,5482,7,14,0,0,5482,5483,7,11,
+        0,0,5483,116,1,0,0,0,5484,5485,7,0,0,0,5485,5486,7,15,0,0,5486,5487,
+        7,15,0,0,5487,5488,7,6,0,0,5488,5489,7,7,0,0,5489,5490,7,9,0,0,5490,
+        5491,5,95,0,0,5491,5492,7,13,0,0,5492,5493,7,0,0,0,5493,5494,7,11,
+        0,0,5494,5495,7,12,0,0,5495,5496,7,6,0,0,5496,5497,7,5,0,0,5497,
+        118,1,0,0,0,5498,5499,7,0,0,0,5499,5500,7,15,0,0,5500,5501,7,15,
+        0,0,5501,5502,7,11,0,0,5502,5503,7,10,0,0,5503,5504,7,8,0,0,5504,
+        5505,7,0,0,0,5505,5506,7,4,0,0,5506,5507,7,10,0,0,5507,5508,7,2,
+        0,0,5508,5509,7,7,0,0,5509,120,1,0,0,0,5510,5511,7,0,0,0,5511,5512,
+        7,15,0,0,5512,5513,7,15,0,0,5513,5514,7,11,0,0,5514,5515,7,18,0,
+        0,5515,122,1,0,0,0,5516,5517,7,0,0,0,5517,5518,7,15,0,0,5518,5519,
+        7,15,0,0,5519,5520,7,3,0,0,5520,5521,7,2,0,0,5521,5522,7,25,0,0,
+        5522,5523,5,95,0,0,5523,5524,7,8,0,0,5524,5525,7,2,0,0,5525,5526,
+        7,12,0,0,5526,5527,7,7,0,0,5527,5528,7,4,0,0,5528,5529,5,95,0,0,
+        5529,5530,7,9,0,0,5530,5531,7,10,0,0,5531,5532,7,5,0,0,5532,5533,
+        7,4,0,0,5533,5534,7,10,0,0,5534,5535,7,7,0,0,5535,5536,7,8,0,0,5536,
+        5537,7,4,0,0,5537,124,1,0,0,0,5538,5539,7,0,0,0,5539,5540,7,3,0,
+        0,5540,5541,7,8,0,0,5541,5542,7,19,0,0,5542,5543,7,10,0,0,5543,5544,
+        7,13,0,0,5544,5545,7,0,0,0,5545,5546,7,11,0,0,5546,126,1,0,0,0,5547,
+        5548,7,0,0,0,5548,5549,7,3,0,0,5549,5550,7,8,0,0,5550,5551,7,19,
+        0,0,5551,5552,7,10,0,0,5552,5553,7,13,0,0,5553,5554,7,6,0,0,5554,
+        128,1,0,0,0,5555,5556,7,0,0,0,5556,5557,7,3,0,0,5557,5558,7,8,0,
+        0,5558,5559,7,19,0,0,5559,5560,7,10,0,0,5560,5561,7,13,0,0,5561,
+        5562,7,6,0,0,5562,5563,7,9,0,0,5563,130,1,0,0,0,5564,5565,7,0,0,
+        0,5565,5566,7,3,0,0,5566,5567,7,8,0,0,5567,5568,7,19,0,0,5568,5569,
+        7,10,0,0,5569,5570,7,13,0,0,5570,5571,7,6,0,0,5571,5572,7,11,0,0,
+        5572,5573,7,2,0,0,5573,5574,7,17,0,0,5574,132,1,0,0,0,5575,5576,
+        7,0,0,0,5576,5577,7,3,0,0,5577,5578,7,6,0,0,5578,134,1,0,0,0,5579,
+        5580,7,0,0,0,5580,5581,7,3,0,0,5581,5582,7,3,0,0,5582,5583,7,0,0,
+        0,5583,5584,7,18,0,0,5584,136,1,0,0,0,5585,5586,7,0,0,0,5586,5587,
+        7,5,0,0,5587,138,1,0,0,0,5588,5589,7,0,0,0,5589,5590,7,5,0,0,5590,
+        5591,7,8,0,0,5591,140,1,0,0,0,5592,5593,7,0,0,0,5593,5594,7,5,0,
+        0,5594,5595,7,8,0,0,5595,5596,7,10,0,0,5596,5597,7,10,0,0,5597,142,
+        1,0,0,0,5598,5599,7,0,0,0,5599,5600,7,5,0,0,5600,5601,7,8,0,0,5601,
+        5602,7,10,0,0,5602,5603,7,10,0,0,5603,5604,7,5,0,0,5604,5605,7,4,
+        0,0,5605,5606,7,3,0,0,5606,144,1,0,0,0,5607,5608,7,0,0,0,5608,5609,
+        7,5,0,0,5609,5610,7,10,0,0,5610,5611,7,7,0,0,5611,146,1,0,0,0,5612,
+        5613,7,0,0,0,5613,5614,7,5,0,0,5614,5615,7,10,0,0,5615,5616,7,5,
+        0,0,5616,148,1,0,0,0,5617,5618,7,0,0,0,5618,5619,7,5,0,0,5619,5620,
+        7,5,0,0,5620,5621,7,6,0,0,5621,5622,7,14,0,0,5622,5623,7,1,0,0,5623,
+        5624,7,11,0,0,5624,5625,7,18,0,0,5625,150,1,0,0,0,5626,5627,7,0,
+        0,0,5627,5628,7,5,0,0,5628,5629,7,5,0,0,5629,5630,7,10,0,0,5630,
+        5631,7,17,0,0,5631,5632,7,7,0,0,5632,152,1,0,0,0,5633,5634,7,0,0,
+        0,5634,5635,7,5,0,0,5635,5636,7,5,0,0,5636,5637,7,2,0,0,5637,5638,
+        7,8,0,0,5638,5639,7,10,0,0,5639,5640,7,0,0,0,5640,5641,7,4,0,0,5641,
+        5642,7,6,0,0,5642,154,1,0,0,0,5643,5644,7,0,0,0,5644,5645,7,5,0,
+        0,5645,5646,7,18,0,0,5646,5647,7,7,0,0,5647,5648,7,8,0,0,5648,156,
+        1,0,0,0,5649,5650,7,0,0,0,5650,5651,7,5,0,0,5651,5652,7,18,0,0,5652,
+        5653,7,7,0,0,5653,5654,7,8,0,0,5654,5655,7,19,0,0,5655,5656,7,3,
+        0,0,5656,5657,7,2,0,0,5657,5658,7,7,0,0,5658,5659,7,2,0,0,5659,5660,
+        7,12,0,0,5660,5661,7,5,0,0,5661,158,1,0,0,0,5662,5663,7,0,0,0,5663,
+        5664,7,4,0,0,5664,5665,7,0,0,0,5665,5666,7,7,0,0,5666,5667,5,50,
+        0,0,5667,160,1,0,0,0,5668,5669,7,0,0,0,5669,5670,7,4,0,0,5670,5671,
+        7,0,0,0,5671,5672,7,7,0,0,5672,162,1,0,0,0,5673,5674,7,0,0,0,5674,
+        5675,7,4,0,0,5675,164,1,0,0,0,5676,5677,7,0,0,0,5677,5678,7,4,0,
+        0,5678,5679,7,4,0,0,5679,5680,7,3,0,0,5680,5681,7,10,0,0,5681,5682,
+        7,1,0,0,5682,5683,7,12,0,0,5683,5684,7,4,0,0,5684,5685,7,6,0,0,5685,
+        166,1,0,0,0,5686,5687,7,0,0,0,5687,5688,7,4,0,0,5688,5689,7,4,0,
+        0,5689,5690,7,3,0,0,5690,5691,7,10,0,0,5691,5692,7,1,0,0,5692,5693,
+        7,12,0,0,5693,5694,7,4,0,0,5694,5695,7,6,0,0,5695,5696,7,5,0,0,5696,
+        168,1,0,0,0,5697,5698,7,0,0,0,5698,5699,7,12,0,0,5699,5700,7,9,0,
+        0,5700,5701,7,10,0,0,5701,5702,7,4,0,0,5702,170,1,0,0,0,5703,5704,
+        7,0,0,0,5704,5705,7,12,0,0,5705,5706,7,4,0,0,5706,5707,7,19,0,0,
+        5707,5708,7,6,0,0,5708,5709,7,7,0,0,5709,5710,7,4,0,0,5710,5711,
+        7,10,0,0,5711,5712,7,8,0,0,5712,5713,7,0,0,0,5713,5714,7,4,0,0,5714,
+        5715,7,6,0,0,5715,5716,7,9,0,0,5716,172,1,0,0,0,5717,5718,7,0,0,
+        0,5718,5719,7,12,0,0,5719,5720,7,4,0,0,5720,5721,7,19,0,0,5721,5722,
+        7,6,0,0,5722,5723,7,7,0,0,5723,5724,7,4,0,0,5724,5725,7,10,0,0,5725,
+        5726,7,8,0,0,5726,5727,7,0,0,0,5727,5728,7,4,0,0,5728,5729,7,10,
+        0,0,5729,5730,7,2,0,0,5730,5731,7,7,0,0,5731,174,1,0,0,0,5732,5733,
+        7,0,0,0,5733,5734,7,12,0,0,5734,5735,7,4,0,0,5735,5736,7,19,0,0,
+        5736,5737,7,10,0,0,5737,5738,7,9,0,0,5738,176,1,0,0,0,5739,5740,
+        7,0,0,0,5740,5741,7,12,0,0,5741,5742,7,4,0,0,5742,5743,7,19,0,0,
+        5743,5744,7,2,0,0,5744,5745,7,3,0,0,5745,5746,7,10,0,0,5746,5747,
+        7,23,0,0,5747,5748,7,0,0,0,5748,5749,7,4,0,0,5749,5750,7,10,0,0,
+        5750,5751,7,2,0,0,5751,5752,7,7,0,0,5752,178,1,0,0,0,5753,5754,7,
+        0,0,0,5754,5755,7,12,0,0,5755,5756,7,4,0,0,5756,5757,7,2,0,0,5757,
+        5758,7,0,0,0,5758,5759,7,11,0,0,5759,5760,7,11,0,0,5760,5761,7,2,
+        0,0,5761,5762,7,8,0,0,5762,5763,7,0,0,0,5763,5764,7,4,0,0,5764,5765,
+        7,6,0,0,5765,180,1,0,0,0,5766,5767,7,0,0,0,5767,5768,7,12,0,0,5768,
+        5769,7,4,0,0,5769,5770,7,2,0,0,5770,182,1,0,0,0,5771,5772,7,0,0,
+        0,5772,5773,7,12,0,0,5773,5774,7,4,0,0,5774,5775,7,2,0,0,5775,5776,
+        7,1,0,0,5776,5777,7,0,0,0,5777,5778,7,8,0,0,5778,5779,7,21,0,0,5779,
+        5780,7,12,0,0,5780,5781,7,15,0,0,5781,184,1,0,0,0,5782,5783,7,0,
+        0,0,5783,5784,7,12,0,0,5784,5785,7,4,0,0,5785,5786,7,2,0,0,5786,
+        5787,7,6,0,0,5787,5788,7,25,0,0,5788,5789,7,4,0,0,5789,5790,7,6,
+        0,0,5790,5791,7,7,0,0,5791,5792,7,9,0,0,5792,186,1,0,0,0,5793,5794,
+        7,0,0,0,5794,5795,7,12,0,0,5795,5796,7,4,0,0,5796,5797,7,2,0,0,5797,
+        5798,5,95,0,0,5798,5799,7,11,0,0,5799,5800,7,2,0,0,5800,5801,7,17,
+        0,0,5801,5802,7,10,0,0,5802,5803,7,7,0,0,5803,188,1,0,0,0,5804,5805,
+        7,0,0,0,5805,5806,7,12,0,0,5806,5807,7,4,0,0,5807,5808,7,2,0,0,5808,
+        5809,7,14,0,0,5809,5810,7,0,0,0,5810,5811,7,4,0,0,5811,5812,7,10,
+        0,0,5812,5813,7,8,0,0,5813,190,1,0,0,0,5814,5815,7,0,0,0,5815,5816,
+        7,12,0,0,5816,5817,7,4,0,0,5817,5818,7,2,0,0,5818,5819,7,7,0,0,5819,
+        5820,7,2,0,0,5820,5821,7,14,0,0,5821,5822,7,2,0,0,5822,5823,7,12,
+        0,0,5823,5824,7,5,0,0,5824,5825,5,95,0,0,5825,5826,7,4,0,0,5826,
+        5827,7,3,0,0,5827,5828,7,0,0,0,5828,5829,7,7,0,0,5829,5830,7,5,0,
+        0,5830,5831,7,0,0,0,5831,5832,7,8,0,0,5832,5833,7,4,0,0,5833,5834,
+        7,10,0,0,5834,5835,7,2,0,0,5835,5836,7,7,0,0,5836,192,1,0,0,0,5837,
+        5838,7,0,0,0,5838,5839,7,12,0,0,5839,5840,7,4,0,0,5840,5841,7,2,
+        0,0,5841,5842,5,95,0,0,5842,5843,7,3,0,0,5843,5844,7,6,0,0,5844,
+        5845,7,2,0,0,5845,5846,7,15,0,0,5846,5847,7,4,0,0,5847,5848,7,10,
+        0,0,5848,5849,7,14,0,0,5849,5850,7,10,0,0,5850,5851,7,23,0,0,5851,
+        5852,7,6,0,0,5852,194,1,0,0,0,5853,5854,7,0,0,0,5854,5855,7,13,0,
+        0,5855,5856,7,0,0,0,5856,5857,7,10,0,0,5857,5858,7,11,0,0,5858,5859,
+        7,0,0,0,5859,5860,7,1,0,0,5860,5861,7,10,0,0,5861,5862,7,11,0,0,
+        5862,5863,7,10,0,0,5863,5864,7,4,0,0,5864,5865,7,18,0,0,5865,196,
+        1,0,0,0,5866,5867,7,0,0,0,5867,5868,7,13,0,0,5868,5869,7,3,0,0,5869,
+        5870,7,2,0,0,5870,198,1,0,0,0,5871,5872,7,1,0,0,5872,5873,7,0,0,
+        0,5873,5874,7,8,0,0,5874,5875,7,21,0,0,5875,5876,7,17,0,0,5876,5877,
+        7,3,0,0,5877,5878,7,2,0,0,5878,5879,7,12,0,0,5879,5880,7,7,0,0,5880,
+        5881,7,9,0,0,5881,200,1,0,0,0,5882,5883,7,1,0,0,5883,5884,7,0,0,
+        0,5884,5885,7,8,0,0,5885,5886,7,21,0,0,5886,5887,7,10,0,0,5887,5888,
+        7,7,0,0,5888,5889,7,17,0,0,5889,5890,7,16,0,0,5890,5891,7,10,0,0,
+        5891,5892,7,11,0,0,5892,5893,7,6,0,0,5893,202,1,0,0,0,5894,5895,
+        7,1,0,0,5895,5896,7,0,0,0,5896,5897,7,8,0,0,5897,5898,7,21,0,0,5898,
+        5899,7,12,0,0,5899,5900,7,15,0,0,5900,204,1,0,0,0,5901,5902,7,1,
+        0,0,5902,5903,7,0,0,0,5903,5904,7,8,0,0,5904,5905,7,21,0,0,5905,
+        5906,7,12,0,0,5906,5907,7,15,0,0,5907,5908,7,5,0,0,5908,206,1,0,
+        0,0,5909,5910,7,1,0,0,5910,5911,7,0,0,0,5911,5912,7,8,0,0,5912,5913,
+        7,21,0,0,5913,5914,7,12,0,0,5914,5915,7,15,0,0,5915,5916,7,5,0,0,
+        5916,5917,7,6,0,0,5917,5918,7,4,0,0,5918,208,1,0,0,0,5919,5920,7,
+        1,0,0,5920,5921,7,0,0,0,5921,5922,7,9,0,0,5922,5923,7,16,0,0,5923,
+        5924,7,10,0,0,5924,5925,7,11,0,0,5925,5926,7,6,0,0,5926,210,1,0,
+        0,0,5927,5928,7,1,0,0,5928,5929,7,0,0,0,5929,5930,7,5,0,0,5930,5931,
+        7,10,0,0,5931,5932,7,8,0,0,5932,212,1,0,0,0,5933,5934,7,1,0,0,5934,
+        5935,7,0,0,0,5935,5936,7,5,0,0,5936,5937,7,10,0,0,5937,5938,7,8,
+        0,0,5938,5939,7,16,0,0,5939,5940,7,10,0,0,5940,5941,7,11,0,0,5941,
+        5942,7,6,0,0,5942,214,1,0,0,0,5943,5944,7,1,0,0,5944,5945,7,0,0,
+        0,5945,5946,7,4,0,0,5946,5947,7,8,0,0,5947,5948,7,19,0,0,5948,216,
+        1,0,0,0,5949,5950,7,1,0,0,5950,5951,7,0,0,0,5951,5952,7,4,0,0,5952,
+        5953,7,8,0,0,5953,5954,7,19,0,0,5954,5955,7,5,0,0,5955,5956,7,10,
+        0,0,5956,5957,7,23,0,0,5957,5958,7,6,0,0,5958,218,1,0,0,0,5959,5960,
+        7,1,0,0,5960,5961,7,0,0,0,5961,5962,7,4,0,0,5962,5963,7,8,0,0,5963,
+        5964,7,19,0,0,5964,5965,5,95,0,0,5965,5966,7,4,0,0,5966,5967,7,0,
+        0,0,5967,5968,7,1,0,0,5968,5969,7,11,0,0,5969,5970,7,6,0,0,5970,
+        5971,5,95,0,0,5971,5972,7,0,0,0,5972,5973,7,8,0,0,5973,5974,7,8,
+        0,0,5974,5975,7,6,0,0,5975,5976,7,5,0,0,5976,5977,7,5,0,0,5977,5978,
+        5,95,0,0,5978,5979,7,1,0,0,5979,5980,7,18,0,0,5980,5981,5,95,0,0,
+        5981,5982,7,3,0,0,5982,5983,7,2,0,0,5983,5984,7,22,0,0,5984,5985,
+        7,10,0,0,5985,5986,7,9,0,0,5986,220,1,0,0,0,5987,5988,7,1,0,0,5988,
+        5989,7,6,0,0,5989,5990,7,8,0,0,5990,5991,7,2,0,0,5991,5992,7,14,
+        0,0,5992,5993,7,6,0,0,5993,222,1,0,0,0,5994,5995,7,1,0,0,5995,5996,
+        7,6,0,0,5996,5997,7,16,0,0,5997,5998,7,2,0,0,5998,5999,7,3,0,0,5999,
+        6000,7,6,0,0,6000,224,1,0,0,0,6001,6002,7,1,0,0,6002,6003,7,6,0,
+        0,6003,6004,7,17,0,0,6004,6005,7,10,0,0,6005,6006,7,7,0,0,6006,226,
+        1,0,0,0,6007,6008,7,1,0,0,6008,6009,7,6,0,0,6009,6010,7,17,0,0,6010,
+        6011,7,10,0,0,6011,6012,7,7,0,0,6012,6013,7,7,0,0,6013,6014,7,10,
+        0,0,6014,6015,7,7,0,0,6015,6016,7,17,0,0,6016,228,1,0,0,0,6017,6018,
+        7,1,0,0,6018,6019,7,6,0,0,6019,6020,7,17,0,0,6020,6021,7,10,0,0,
+        6021,6022,7,7,0,0,6022,6023,5,95,0,0,6023,6024,7,2,0,0,6024,6025,
+        7,12,0,0,6025,6026,7,4,0,0,6026,6027,7,11,0,0,6027,6028,7,10,0,0,
+        6028,6029,7,7,0,0,6029,6030,7,6,0,0,6030,6031,5,95,0,0,6031,6032,
+        7,9,0,0,6032,6033,7,0,0,0,6033,6034,7,4,0,0,6034,6035,7,0,0,0,6035,
+        230,1,0,0,0,6036,6037,7,1,0,0,6037,6038,7,6,0,0,6038,6039,7,19,0,
+        0,6039,6040,7,0,0,0,6040,6041,7,11,0,0,6041,6042,7,16,0,0,6042,232,
+        1,0,0,0,6043,6044,7,1,0,0,6044,6045,7,6,0,0,6045,6046,7,24,0,0,6046,
+        6047,7,12,0,0,6047,6048,7,6,0,0,6048,6049,7,0,0,0,6049,6050,7,4,
+        0,0,6050,6051,7,19,0,0,6051,234,1,0,0,0,6052,6053,7,1,0,0,6053,6054,
+        7,6,0,0,6054,6055,7,4,0,0,6055,6056,7,22,0,0,6056,6057,7,6,0,0,6057,
+        6058,7,6,0,0,6058,6059,7,7,0,0,6059,236,1,0,0,0,6060,6061,7,1,0,
+        0,6061,6062,7,16,0,0,6062,6063,7,10,0,0,6063,6064,7,11,0,0,6064,
+        6065,7,6,0,0,6065,238,1,0,0,0,6066,6067,7,1,0,0,6067,6068,7,16,0,
+        0,6068,6069,7,10,0,0,6069,6070,7,11,0,0,6070,6071,7,6,0,0,6071,6072,
+        7,7,0,0,6072,6073,7,0,0,0,6073,6074,7,14,0,0,6074,6075,7,6,0,0,6075,
+        240,1,0,0,0,6076,6077,7,1,0,0,6077,6078,7,10,0,0,6078,6079,7,17,
+        0,0,6079,242,1,0,0,0,6080,6081,7,1,0,0,6081,6082,7,10,0,0,6082,6083,
+        7,17,0,0,6083,6084,7,16,0,0,6084,6085,7,10,0,0,6085,6086,7,11,0,
+        0,6086,6087,7,6,0,0,6087,244,1,0,0,0,6088,6089,7,1,0,0,6089,6090,
+        7,10,0,0,6090,6091,7,17,0,0,6091,6092,7,10,0,0,6092,6093,7,7,0,0,
+        6093,6094,7,4,0,0,6094,246,1,0,0,0,6095,6096,7,1,0,0,6096,6097,7,
+        10,0,0,6097,6098,7,7,0,0,6098,6099,7,0,0,0,6099,6100,7,3,0,0,6100,
+        6101,7,18,0,0,6101,248,1,0,0,0,6102,6103,7,1,0,0,6103,6104,7,10,
+        0,0,6104,6105,7,7,0,0,6105,6106,7,0,0,0,6106,6107,7,3,0,0,6107,6108,
+        7,18,0,0,6108,6109,5,95,0,0,6109,6110,7,9,0,0,6110,6111,7,2,0,0,
+        6111,6112,7,12,0,0,6112,6113,7,1,0,0,6113,6114,7,11,0,0,6114,6115,
+        7,6,0,0,6115,250,1,0,0,0,6116,6117,7,1,0,0,6117,6118,7,10,0,0,6118,
+        6119,7,7,0,0,6119,6120,7,0,0,0,6120,6121,7,3,0,0,6121,6122,7,18,
+        0,0,6122,6123,5,95,0,0,6123,6124,7,9,0,0,6124,6125,7,2,0,0,6125,
+        6126,7,12,0,0,6126,6127,7,1,0,0,6127,6128,7,11,0,0,6128,6129,7,6,
+        0,0,6129,6130,5,95,0,0,6130,6131,7,10,0,0,6131,6132,7,7,0,0,6132,
+        6133,7,16,0,0,6133,6134,7,10,0,0,6134,6135,7,7,0,0,6135,6136,7,10,
+        0,0,6136,6137,7,4,0,0,6137,6138,7,18,0,0,6138,252,1,0,0,0,6139,6140,
+        7,1,0,0,6140,6141,7,10,0,0,6141,6142,7,7,0,0,6142,6143,7,0,0,0,6143,
+        6144,7,3,0,0,6144,6145,7,18,0,0,6145,6146,5,95,0,0,6146,6147,7,9,
+        0,0,6147,6148,7,2,0,0,6148,6149,7,12,0,0,6149,6150,7,1,0,0,6150,
+        6151,7,11,0,0,6151,6152,7,6,0,0,6152,6153,5,95,0,0,6153,6154,7,7,
+        0,0,6154,6155,7,0,0,0,6155,6156,7,7,0,0,6156,254,1,0,0,0,6157,6158,
+        7,1,0,0,6158,6159,7,10,0,0,6159,6160,7,7,0,0,6160,6161,7,0,0,0,6161,
+        6162,7,3,0,0,6162,6163,7,18,0,0,6163,6164,5,95,0,0,6164,6165,7,16,
+        0,0,6165,6166,7,11,0,0,6166,6167,7,2,0,0,6167,6168,7,0,0,0,6168,
+        6169,7,4,0,0,6169,256,1,0,0,0,6170,6171,7,1,0,0,6171,6172,7,10,0,
+        0,6172,6173,7,7,0,0,6173,6174,7,0,0,0,6174,6175,7,3,0,0,6175,6176,
+        7,18,0,0,6176,6177,5,95,0,0,6177,6178,7,16,0,0,6178,6179,7,11,0,
+        0,6179,6180,7,2,0,0,6180,6181,7,0,0,0,6181,6182,7,4,0,0,6182,6183,
+        5,95,0,0,6183,6184,7,10,0,0,6184,6185,7,7,0,0,6185,6186,7,16,0,0,
+        6186,6187,7,10,0,0,6187,6188,7,7,0,0,6188,6189,7,10,0,0,6189,6190,
+        7,4,0,0,6190,6191,7,18,0,0,6191,258,1,0,0,0,6192,6193,7,1,0,0,6193,
+        6194,7,10,0,0,6194,6195,7,7,0,0,6195,6196,7,0,0,0,6196,6197,7,3,
+        0,0,6197,6198,7,18,0,0,6198,6199,5,95,0,0,6199,6200,7,16,0,0,6200,
+        6201,7,11,0,0,6201,6202,7,2,0,0,6202,6203,7,0,0,0,6203,6204,7,4,
+        0,0,6204,6205,5,95,0,0,6205,6206,7,7,0,0,6206,6207,7,0,0,0,6207,
+        6208,7,7,0,0,6208,260,1,0,0,0,6209,6210,7,1,0,0,6210,6211,7,10,0,
+        0,6211,6212,7,7,0,0,6212,6213,7,0,0,0,6213,6214,7,3,0,0,6214,6215,
+        7,18,0,0,6215,6216,5,95,0,0,6216,6217,7,10,0,0,6217,6218,7,7,0,0,
+        6218,6219,7,4,0,0,6219,6220,7,6,0,0,6220,6221,7,17,0,0,6221,6222,
+        7,6,0,0,6222,6223,7,3,0,0,6223,262,1,0,0,0,6224,6225,7,1,0,0,6225,
+        6226,7,10,0,0,6226,6227,7,7,0,0,6227,6228,7,9,0,0,6228,6229,5,95,
+        0,0,6229,6230,7,0,0,0,6230,6231,7,22,0,0,6231,6232,7,0,0,0,6232,
+        6233,7,3,0,0,6233,6234,7,6,0,0,6234,264,1,0,0,0,6235,6236,7,1,0,
+        0,6236,6237,7,10,0,0,6237,6238,7,7,0,0,6238,6239,7,9,0,0,6239,6240,
+        7,10,0,0,6240,6241,7,7,0,0,6241,6242,7,17,0,0,6242,266,1,0,0,0,6243,
+        6244,7,1,0,0,6244,6245,7,10,0,0,6245,6246,7,7,0,0,6246,6247,5,95,
+        0,0,6247,6248,7,4,0,0,6248,6249,7,2,0,0,6249,6250,5,95,0,0,6250,
+        6251,7,7,0,0,6251,6252,7,12,0,0,6252,6253,7,14,0,0,6253,268,1,0,
+        0,0,6254,6255,7,1,0,0,6255,6256,7,10,0,0,6256,6257,7,4,0,0,6257,
+        6258,7,0,0,0,6258,6259,7,7,0,0,6259,6260,7,9,0,0,6260,270,1,0,0,
+        0,6261,6262,7,1,0,0,6262,6263,7,10,0,0,6263,6264,7,4,0,0,6264,6265,
+        7,14,0,0,6265,6266,7,0,0,0,6266,6267,7,15,0,0,6267,6268,5,95,0,0,
+        6268,6269,7,0,0,0,6269,6270,7,7,0,0,6270,6271,7,9,0,0,6271,272,1,
+        0,0,0,6272,6273,7,1,0,0,6273,6274,7,10,0,0,6274,6275,7,4,0,0,6275,
+        6276,7,14,0,0,6276,6277,7,0,0,0,6277,6278,7,15,0,0,6278,274,1,0,
+        0,0,6279,6280,7,1,0,0,6280,6281,7,10,0,0,6281,6282,7,4,0,0,6282,
+        6283,7,14,0,0,6283,6284,7,0,0,0,6284,6285,7,15,0,0,6285,6286,7,5,
+        0,0,6286,276,1,0,0,0,6287,6288,7,1,0,0,6288,6289,7,10,0,0,6289,6290,
+        7,4,0,0,6290,6291,7,14,0,0,6291,6292,7,0,0,0,6292,6293,7,15,0,0,
+        6293,6294,5,95,0,0,6294,6295,7,4,0,0,6295,6296,7,3,0,0,6296,6297,
+        7,6,0,0,6297,6298,7,6,0,0,6298,278,1,0,0,0,6299,6300,7,1,0,0,6300,
+        6301,7,10,0,0,6301,6302,7,4,0,0,6302,6303,7,5,0,0,6303,280,1,0,0,
+        0,6304,6305,7,1,0,0,6305,6306,7,11,0,0,6306,6307,7,0,0,0,6307,6308,
+        7,7,0,0,6308,6309,7,21,0,0,6309,6310,7,5,0,0,6310,282,1,0,0,0,6311,
+        6312,7,1,0,0,6312,6313,7,11,0,0,6313,6314,7,2,0,0,6314,6315,7,1,
+        0,0,6315,284,1,0,0,0,6316,6317,7,1,0,0,6317,6318,7,11,0,0,6318,6319,
+        7,2,0,0,6319,6320,7,8,0,0,6320,6321,7,21,0,0,6321,286,1,0,0,0,6322,
+        6323,7,1,0,0,6323,6324,7,11,0,0,6324,6325,7,2,0,0,6325,6326,7,8,
+        0,0,6326,6327,7,21,0,0,6327,6328,5,95,0,0,6328,6329,7,3,0,0,6329,
+        6330,7,0,0,0,6330,6331,7,7,0,0,6331,6332,7,17,0,0,6332,6333,7,6,
+        0,0,6333,288,1,0,0,0,6334,6335,7,1,0,0,6335,6336,7,11,0,0,6336,6337,
+        7,2,0,0,6337,6338,7,8,0,0,6338,6339,7,21,0,0,6339,6340,7,5,0,0,6340,
+        290,1,0,0,0,6341,6342,7,1,0,0,6342,6343,7,11,0,0,6343,6344,7,2,0,
+        0,6344,6345,7,8,0,0,6345,6346,7,21,0,0,6346,6347,7,5,0,0,6347,6348,
+        7,10,0,0,6348,6349,7,23,0,0,6349,6350,7,6,0,0,6350,292,1,0,0,0,6351,
+        6352,7,1,0,0,6352,6353,7,2,0,0,6353,6354,7,9,0,0,6354,6355,7,18,
+        0,0,6355,294,1,0,0,0,6356,6357,7,1,0,0,6357,6358,7,2,0,0,6358,6359,
+        7,2,0,0,6359,6360,7,11,0,0,6360,6361,7,6,0,0,6361,6362,7,0,0,0,6362,
+        6363,7,7,0,0,6363,296,1,0,0,0,6364,6365,7,1,0,0,6365,6366,7,2,0,
+        0,6366,6367,7,4,0,0,6367,6368,7,19,0,0,6368,298,1,0,0,0,6369,6370,
+        7,1,0,0,6370,6371,7,2,0,0,6371,6372,7,12,0,0,6372,6373,7,7,0,0,6373,
+        6374,7,9,0,0,6374,300,1,0,0,0,6375,6376,7,1,0,0,6376,6377,7,3,0,
+        0,6377,6378,7,0,0,0,6378,6379,7,7,0,0,6379,6380,7,8,0,0,6380,6381,
+        7,19,0,0,6381,302,1,0,0,0,6382,6383,7,1,0,0,6383,6384,7,3,0,0,6384,
+        6385,7,6,0,0,6385,6386,7,0,0,0,6386,6387,7,9,0,0,6387,6388,7,4,0,
+        0,6388,6389,7,19,0,0,6389,304,1,0,0,0,6390,6391,7,1,0,0,6391,6392,
+        7,3,0,0,6392,6393,7,2,0,0,6393,6394,7,0,0,0,6394,6395,7,9,0,0,6395,
+        6396,7,8,0,0,6396,6397,7,0,0,0,6397,6398,7,5,0,0,6398,6399,7,4,0,
+        0,6399,306,1,0,0,0,6400,6401,7,1,0,0,6401,6402,7,5,0,0,6402,6403,
+        7,2,0,0,6403,6404,7,7,0,0,6404,308,1,0,0,0,6405,6406,7,1,0,0,6406,
+        6407,7,12,0,0,6407,6408,7,16,0,0,6408,6409,7,16,0,0,6409,6410,7,
+        6,0,0,6410,6411,7,3,0,0,6411,310,1,0,0,0,6412,6413,7,1,0,0,6413,
+        6414,7,12,0,0,6414,6415,7,16,0,0,6415,6416,7,16,0,0,6416,6417,7,
+        6,0,0,6417,6418,7,3,0,0,6418,6419,5,95,0,0,6419,6420,7,8,0,0,6420,
+        6421,7,0,0,0,6421,6422,7,8,0,0,6422,6423,7,19,0,0,6423,6424,7,6,
+        0,0,6424,312,1,0,0,0,6425,6426,7,1,0,0,6426,6427,7,12,0,0,6427,6428,
+        7,16,0,0,6428,6429,7,16,0,0,6429,6430,7,6,0,0,6430,6431,7,3,0,0,
+        6431,6432,5,95,0,0,6432,6433,7,15,0,0,6433,6434,7,2,0,0,6434,6435,
+        7,2,0,0,6435,6436,7,11,0,0,6436,314,1,0,0,0,6437,6438,7,1,0,0,6438,
+        6439,7,12,0,0,6439,6440,7,10,0,0,6440,6441,7,11,0,0,6441,6442,7,
+        9,0,0,6442,316,1,0,0,0,6443,6444,7,1,0,0,6444,6445,7,12,0,0,6445,
+        6446,7,11,0,0,6446,6447,7,21,0,0,6447,318,1,0,0,0,6448,6449,7,1,
+        0,0,6449,6450,7,18,0,0,6450,320,1,0,0,0,6451,6452,7,1,0,0,6452,6453,
+        7,18,0,0,6453,6454,7,15,0,0,6454,6455,7,0,0,0,6455,6456,7,5,0,0,
+        6456,6457,7,5,0,0,6457,6458,5,95,0,0,6458,6459,7,3,0,0,6459,6460,
+        7,6,0,0,6460,6461,7,8,0,0,6461,6462,7,12,0,0,6462,6463,7,3,0,0,6463,
+        6464,7,5,0,0,6464,6465,7,10,0,0,6465,6466,7,13,0,0,6466,6467,7,6,
+        0,0,6467,6468,5,95,0,0,6468,6469,7,8,0,0,6469,6470,7,19,0,0,6470,
+        6471,7,6,0,0,6471,6472,7,8,0,0,6472,6473,7,21,0,0,6473,322,1,0,0,
+        0,6474,6475,7,1,0,0,6475,6476,7,18,0,0,6476,6477,7,15,0,0,6477,6478,
+        7,0,0,0,6478,6479,7,5,0,0,6479,6480,7,5,0,0,6480,6481,5,95,0,0,6481,
+        6482,7,12,0,0,6482,6483,7,20,0,0,6483,6484,7,13,0,0,6484,6485,7,
+        8,0,0,6485,324,1,0,0,0,6486,6487,7,1,0,0,6487,6488,7,18,0,0,6488,
+        6489,7,4,0,0,6489,6490,7,6,0,0,6490,326,1,0,0,0,6491,6492,7,1,0,
+        0,6492,6493,7,18,0,0,6493,6494,7,4,0,0,6494,6495,7,6,0,0,6495,6496,
+        7,5,0,0,6496,328,1,0,0,0,6497,6498,7,1,0,0,6498,6499,7,18,0,0,6499,
+        6500,7,4,0,0,6500,6501,7,6,0,0,6501,6502,7,2,0,0,6502,6503,7,3,0,
+        0,6503,6504,7,9,0,0,6504,6505,7,6,0,0,6505,6506,7,3,0,0,6506,6507,
+        7,14,0,0,6507,6508,7,0,0,0,6508,6509,7,3,0,0,6509,6510,7,21,0,0,
+        6510,330,1,0,0,0,6511,6512,7,8,0,0,6512,6513,7,0,0,0,6513,6514,7,
+        8,0,0,6514,6515,7,19,0,0,6515,6516,7,6,0,0,6516,332,1,0,0,0,6517,
+        6518,7,8,0,0,6518,6519,7,0,0,0,6519,6520,7,8,0,0,6520,6521,7,19,
+        0,0,6521,6522,7,6,0,0,6522,6523,5,95,0,0,6523,6524,7,8,0,0,6524,
+        6525,7,1,0,0,6525,334,1,0,0,0,6526,6527,7,8,0,0,6527,6528,7,0,0,
+        0,6528,6529,7,8,0,0,6529,6530,7,19,0,0,6530,6531,7,6,0,0,6531,6532,
+        5,95,0,0,6532,6533,7,10,0,0,6533,6534,7,7,0,0,6534,6535,7,5,0,0,
+        6535,6536,7,4,0,0,6536,6537,7,0,0,0,6537,6538,7,7,0,0,6538,6539,
+        7,8,0,0,6539,6540,7,6,0,0,6540,6541,7,5,0,0,6541,336,1,0,0,0,6542,
+        6543,7,8,0,0,6543,6544,7,0,0,0,6544,6545,7,8,0,0,6545,6546,7,19,
+        0,0,6546,6547,7,6,0,0,6547,6548,5,95,0,0,6548,6549,7,4,0,0,6549,
+        6550,7,6,0,0,6550,6551,7,14,0,0,6551,6552,7,15,0,0,6552,6553,5,95,
+        0,0,6553,6554,7,4,0,0,6554,6555,7,0,0,0,6555,6556,7,1,0,0,6556,6557,
+        7,11,0,0,6557,6558,7,6,0,0,6558,338,1,0,0,0,6559,6560,7,8,0,0,6560,
+        6561,7,0,0,0,6561,6562,7,8,0,0,6562,6563,7,19,0,0,6563,6564,7,10,
+        0,0,6564,6565,7,7,0,0,6565,6566,7,17,0,0,6566,340,1,0,0,0,6567,6568,
+        7,8,0,0,6568,6569,7,0,0,0,6569,6570,7,11,0,0,6570,6571,7,8,0,0,6571,
+        6572,7,12,0,0,6572,6573,7,11,0,0,6573,6574,7,0,0,0,6574,6575,7,4,
+        0,0,6575,6576,7,6,0,0,6576,6577,7,9,0,0,6577,342,1,0,0,0,6578,6579,
+        7,8,0,0,6579,6580,7,0,0,0,6580,6581,7,11,0,0,6581,6582,7,11,0,0,
+        6582,6583,7,1,0,0,6583,6584,7,0,0,0,6584,6585,7,8,0,0,6585,6586,
+        7,21,0,0,6586,344,1,0,0,0,6587,6588,7,8,0,0,6588,6589,7,0,0,0,6589,
+        6590,7,11,0,0,6590,6591,7,11,0,0,6591,346,1,0,0,0,6592,6593,7,8,
+        0,0,6593,6594,7,0,0,0,6594,6595,7,7,0,0,6595,6596,7,8,0,0,6596,6597,
+        7,6,0,0,6597,6598,7,11,0,0,6598,348,1,0,0,0,6599,6600,7,8,0,0,6600,
+        6601,7,0,0,0,6601,6602,7,7,0,0,6602,6603,7,2,0,0,6603,6604,7,7,0,
+        0,6604,6605,7,10,0,0,6605,6606,7,8,0,0,6606,6607,7,0,0,0,6607,6608,
+        7,11,0,0,6608,350,1,0,0,0,6609,6610,7,8,0,0,6610,6611,7,0,0,0,6611,
+        6612,7,15,0,0,6612,6613,7,0,0,0,6613,6614,7,8,0,0,6614,6615,7,10,
+        0,0,6615,6616,7,4,0,0,6616,6617,7,18,0,0,6617,352,1,0,0,0,6618,6619,
+        7,8,0,0,6619,6620,7,0,0,0,6620,6621,7,15,0,0,6621,6622,7,4,0,0,6622,
+        6623,7,10,0,0,6623,6624,7,2,0,0,6624,6625,7,7,0,0,6625,354,1,0,0,
+        0,6626,6627,7,8,0,0,6627,6628,7,0,0,0,6628,6629,7,3,0,0,6629,6630,
+        7,9,0,0,6630,6631,7,10,0,0,6631,6632,7,7,0,0,6632,6633,7,0,0,0,6633,
+        6634,7,11,0,0,6634,6635,7,10,0,0,6635,6636,7,4,0,0,6636,6637,7,18,
+        0,0,6637,356,1,0,0,0,6638,6639,7,8,0,0,6639,6640,7,0,0,0,6640,6641,
+        7,5,0,0,6641,6642,7,8,0,0,6642,6643,7,0,0,0,6643,6644,7,9,0,0,6644,
+        6645,7,6,0,0,6645,358,1,0,0,0,6646,6647,7,8,0,0,6647,6648,7,0,0,
+        0,6648,6649,7,5,0,0,6649,6650,7,6,0,0,6650,360,1,0,0,0,6651,6652,
+        7,8,0,0,6652,6653,7,0,0,0,6653,6654,7,5,0,0,6654,6655,7,4,0,0,6655,
+        362,1,0,0,0,6656,6657,7,8,0,0,6657,6658,7,0,0,0,6658,6659,7,5,0,
+        0,6659,6660,7,6,0,0,6660,6661,5,45,0,0,6661,6662,7,5,0,0,6662,6663,
+        7,6,0,0,6663,6664,7,7,0,0,6664,6665,7,5,0,0,6665,6666,7,10,0,0,6666,
+        6667,7,4,0,0,6667,6668,7,10,0,0,6668,6669,7,13,0,0,6669,6670,7,6,
+        0,0,6670,364,1,0,0,0,6671,6672,7,8,0,0,6672,6673,7,0,0,0,6673,6674,
+        7,4,0,0,6674,6675,7,6,0,0,6675,6676,7,17,0,0,6676,6677,7,2,0,0,6677,
+        6678,7,3,0,0,6678,6679,7,18,0,0,6679,366,1,0,0,0,6680,6681,7,8,0,
+        0,6681,6682,7,9,0,0,6682,6683,7,1,0,0,6683,6684,5,36,0,0,6684,6685,
+        7,9,0,0,6685,6686,7,6,0,0,6686,6687,7,16,0,0,6687,6688,7,0,0,0,6688,
+        6689,7,12,0,0,6689,6690,7,11,0,0,6690,6691,7,4,0,0,6691,368,1,0,
+        0,0,6692,6693,7,8,0,0,6693,6694,7,6,0,0,6694,6695,7,10,0,0,6695,
+        6696,7,11,0,0,6696,370,1,0,0,0,6697,6698,7,8,0,0,6698,6699,7,6,0,
+        0,6699,6700,7,11,0,0,6700,6701,7,11,0,0,6701,6702,5,95,0,0,6702,
+        6703,7,16,0,0,6703,6704,7,11,0,0,6704,6705,7,0,0,0,6705,6706,7,5,
+        0,0,6706,6707,7,19,0,0,6707,6708,5,95,0,0,6708,6709,7,8,0,0,6709,
+        6710,7,0,0,0,6710,6711,7,8,0,0,6711,6712,7,19,0,0,6712,6713,7,6,
+        0,0,6713,372,1,0,0,0,6714,6715,7,8,0,0,6715,6716,7,6,0,0,6716,6717,
+        7,3,0,0,6717,6718,7,4,0,0,6718,6719,7,10,0,0,6719,6720,7,16,0,0,
+        6720,6721,7,10,0,0,6721,6722,7,8,0,0,6722,6723,7,0,0,0,6723,6724,
+        7,4,0,0,6724,6725,7,6,0,0,6725,374,1,0,0,0,6726,6727,7,8,0,0,6727,
+        6728,7,16,0,0,6728,6729,7,10,0,0,6729,6730,7,11,0,0,6730,6731,7,
+        6,0,0,6731,376,1,0,0,0,6732,6733,7,8,0,0,6733,6734,7,19,0,0,6734,
+        6735,7,0,0,0,6735,6736,7,10,0,0,6736,6737,7,7,0,0,6737,6738,7,6,
+        0,0,6738,6739,7,9,0,0,6739,378,1,0,0,0,6740,6741,7,8,0,0,6741,6742,
+        7,19,0,0,6742,6743,7,0,0,0,6743,6744,7,7,0,0,6744,6745,7,17,0,0,
+        6745,6746,7,6,0,0,6746,380,1,0,0,0,6747,6748,7,8,0,0,6748,6749,7,
+        19,0,0,6749,6750,7,0,0,0,6750,6751,7,7,0,0,6751,6752,7,17,0,0,6752,
+        6753,7,6,0,0,6753,6754,7,4,0,0,6754,6755,7,3,0,0,6755,6756,7,0,0,
+        0,6756,6757,7,8,0,0,6757,6758,7,21,0,0,6758,6759,7,10,0,0,6759,6760,
+        7,7,0,0,6760,6761,7,17,0,0,6761,382,1,0,0,0,6762,6763,7,8,0,0,6763,
+        6764,7,19,0,0,6764,6765,7,0,0,0,6765,6766,7,7,0,0,6766,6767,7,17,
+        0,0,6767,6768,7,6,0,0,6768,6769,5,95,0,0,6769,6770,7,9,0,0,6770,
+        6771,7,12,0,0,6771,6772,7,15,0,0,6772,6773,7,21,0,0,6773,6774,7,
+        6,0,0,6774,6775,7,18,0,0,6775,6776,5,95,0,0,6776,6777,7,6,0,0,6777,
+        6778,7,3,0,0,6778,6779,7,3,0,0,6779,6780,7,2,0,0,6780,6781,7,3,0,
+        0,6781,6782,5,95,0,0,6782,6783,7,10,0,0,6783,6784,7,7,0,0,6784,6785,
+        7,9,0,0,6785,6786,7,6,0,0,6786,6787,7,25,0,0,6787,384,1,0,0,0,6788,
+        6789,7,8,0,0,6789,6790,7,19,0,0,6790,6791,7,0,0,0,6791,6792,7,3,
+        0,0,6792,6793,7,0,0,0,6793,6794,7,8,0,0,6794,6795,7,4,0,0,6795,6796,
+        7,6,0,0,6796,6797,7,3,0,0,6797,386,1,0,0,0,6798,6799,7,8,0,0,6799,
+        6800,7,19,0,0,6800,6801,7,0,0,0,6801,6802,7,3,0,0,6802,6803,7,0,
+        0,0,6803,6804,7,8,0,0,6804,6805,7,4,0,0,6805,6806,7,6,0,0,6806,6807,
+        7,3,0,0,6807,6808,7,5,0,0,6808,388,1,0,0,0,6809,6810,7,8,0,0,6810,
+        6811,7,19,0,0,6811,6812,7,0,0,0,6812,6813,7,3,0,0,6813,6814,7,0,
+        0,0,6814,6815,7,8,0,0,6815,6816,7,4,0,0,6816,6817,7,6,0,0,6817,6818,
+        7,3,0,0,6818,6819,7,5,0,0,6819,6820,7,6,0,0,6820,6821,7,4,0,0,6821,
+        390,1,0,0,0,6822,6823,7,8,0,0,6823,6824,7,19,0,0,6824,6825,7,0,0,
+        0,6825,6826,7,3,0,0,6826,392,1,0,0,0,6827,6828,7,8,0,0,6828,6829,
+        7,19,0,0,6829,6830,7,0,0,0,6830,6831,7,3,0,0,6831,6832,5,95,0,0,
+        6832,6833,7,8,0,0,6833,6834,7,5,0,0,6834,394,1,0,0,0,6835,6836,7,
+        8,0,0,6836,6837,7,19,0,0,6837,6838,7,0,0,0,6838,6839,7,3,0,0,6839,
+        6840,7,4,0,0,6840,6841,7,2,0,0,6841,6842,7,3,0,0,6842,6843,7,2,0,
+        0,6843,6844,7,22,0,0,6844,6845,7,10,0,0,6845,6846,7,9,0,0,6846,396,
+        1,0,0,0,6847,6848,7,8,0,0,6848,6849,7,19,0,0,6849,6850,7,6,0,0,6850,
+        6851,7,8,0,0,6851,6852,7,21,0,0,6852,6853,5,95,0,0,6853,6854,7,0,
+        0,0,6854,6855,7,8,0,0,6855,6856,7,11,0,0,6856,6857,5,95,0,0,6857,
+        6858,7,3,0,0,6858,6859,7,6,0,0,6859,6860,7,22,0,0,6860,6861,7,3,
+        0,0,6861,6862,7,10,0,0,6862,6863,7,4,0,0,6863,6864,7,6,0,0,6864,
+        398,1,0,0,0,6865,6866,7,8,0,0,6866,6867,7,19,0,0,6867,6868,7,6,0,
+        0,6868,6869,7,8,0,0,6869,6870,7,21,0,0,6870,400,1,0,0,0,6871,6872,
+        7,8,0,0,6872,6873,7,19,0,0,6873,6874,7,6,0,0,6874,6875,7,8,0,0,6875,
+        6876,7,21,0,0,6876,6877,7,15,0,0,6877,6878,7,2,0,0,6878,6879,7,10,
+        0,0,6879,6880,7,7,0,0,6880,6881,7,4,0,0,6881,402,1,0,0,0,6882,6883,
+        7,8,0,0,6883,6884,7,19,0,0,6884,6885,7,10,0,0,6885,6886,7,11,0,0,
+        6886,6887,7,9,0,0,6887,404,1,0,0,0,6888,6889,7,8,0,0,6889,6890,7,
+        19,0,0,6890,6891,7,2,0,0,6891,6892,7,2,0,0,6892,6893,7,5,0,0,6893,
+        6894,7,6,0,0,6894,406,1,0,0,0,6895,6896,7,8,0,0,6896,6897,7,19,0,
+        0,6897,6898,7,3,0,0,6898,408,1,0,0,0,6899,6900,7,8,0,0,6900,6901,
+        7,19,0,0,6901,6902,7,12,0,0,6902,6903,7,7,0,0,6903,6904,7,21,0,0,
+        6904,410,1,0,0,0,6905,6906,7,8,0,0,6906,6907,7,11,0,0,6907,6908,
+        7,0,0,0,6908,6909,7,5,0,0,6909,6910,7,5,0,0,6910,412,1,0,0,0,6911,
+        6912,7,8,0,0,6912,6913,7,11,0,0,6913,6914,7,0,0,0,6914,6915,7,5,
+        0,0,6915,6916,7,5,0,0,6916,6917,7,10,0,0,6917,6918,7,16,0,0,6918,
+        6919,7,10,0,0,6919,6920,7,8,0,0,6920,6921,7,0,0,0,6921,6922,7,4,
+        0,0,6922,6923,7,10,0,0,6923,6924,7,2,0,0,6924,6925,7,7,0,0,6925,
+        414,1,0,0,0,6926,6927,7,8,0,0,6927,6928,7,11,0,0,6928,6929,7,0,0,
+        0,6929,6930,7,5,0,0,6930,6931,7,5,0,0,6931,6932,7,10,0,0,6932,6933,
+        7,16,0,0,6933,6934,7,10,0,0,6934,6935,7,6,0,0,6935,6936,7,3,0,0,
+        6936,416,1,0,0,0,6937,6938,7,8,0,0,6938,6939,7,11,0,0,6939,6940,
+        7,0,0,0,6940,6941,7,12,0,0,6941,6942,7,5,0,0,6942,6943,7,6,0,0,6943,
+        418,1,0,0,0,6944,6945,7,8,0,0,6945,6946,7,11,0,0,6946,6947,7,6,0,
+        0,6947,6948,7,0,0,0,6948,6949,7,7,0,0,6949,420,1,0,0,0,6950,6951,
+        7,8,0,0,6951,6952,7,11,0,0,6952,6953,7,6,0,0,6953,6954,7,0,0,0,6954,
+        6955,7,7,0,0,6955,6956,7,12,0,0,6956,6957,7,15,0,0,6957,422,1,0,
+        0,0,6958,6959,7,8,0,0,6959,6960,7,11,0,0,6960,6961,7,6,0,0,6961,
+        6962,7,0,0,0,6962,6963,7,3,0,0,6963,424,1,0,0,0,6964,6965,7,8,0,
+        0,6965,426,1,0,0,0,6966,6967,7,8,0,0,6967,6968,7,11,0,0,6968,6969,
+        7,10,0,0,6969,6970,7,6,0,0,6970,6971,7,7,0,0,6971,6972,7,4,0,0,6972,
+        428,1,0,0,0,6973,6974,7,8,0,0,6974,6975,7,11,0,0,6975,6976,7,2,0,
+        0,6976,6977,7,1,0,0,6977,430,1,0,0,0,6978,6979,7,8,0,0,6979,6980,
+        7,11,0,0,6980,6981,7,2,0,0,6981,6982,7,7,0,0,6982,6983,7,6,0,0,6983,
+        432,1,0,0,0,6984,6985,7,8,0,0,6985,6986,7,11,0,0,6986,6987,7,2,0,
+        0,6987,6988,7,5,0,0,6988,6989,7,6,0,0,6989,6990,5,95,0,0,6990,6991,
+        7,8,0,0,6991,6992,7,0,0,0,6992,6993,7,8,0,0,6993,6994,7,19,0,0,6994,
+        6995,7,6,0,0,6995,6996,7,9,0,0,6996,6997,5,95,0,0,6997,6998,7,2,
+        0,0,6998,6999,7,15,0,0,6999,7000,7,6,0,0,7000,7001,7,7,0,0,7001,
+        7002,5,95,0,0,7002,7003,7,8,0,0,7003,7004,7,12,0,0,7004,7005,7,3,
+        0,0,7005,7006,7,5,0,0,7006,7007,7,2,0,0,7007,7008,7,3,0,0,7008,7009,
+        7,5,0,0,7009,434,1,0,0,0,7010,7011,7,8,0,0,7011,7012,7,11,0,0,7012,
+        7013,7,2,0,0,7013,7014,7,5,0,0,7014,7015,7,6,0,0,7015,436,1,0,0,
+        0,7016,7017,7,8,0,0,7017,7018,7,11,0,0,7018,7019,7,12,0,0,7019,7020,
+        7,5,0,0,7020,7021,7,4,0,0,7021,7022,7,6,0,0,7022,7023,7,3,0,0,7023,
+        7024,5,95,0,0,7024,7025,7,1,0,0,7025,7026,7,18,0,0,7026,7027,5,95,
+        0,0,7027,7028,7,3,0,0,7028,7029,7,2,0,0,7029,7030,7,22,0,0,7030,
+        7031,7,10,0,0,7031,7032,7,9,0,0,7032,438,1,0,0,0,7033,7034,7,8,0,
+        0,7034,7035,7,11,0,0,7035,7036,7,12,0,0,7036,7037,7,5,0,0,7037,7038,
+        7,4,0,0,7038,7039,7,6,0,0,7039,7040,7,3,0,0,7040,440,1,0,0,0,7041,
+        7042,7,8,0,0,7042,7043,7,11,0,0,7043,7044,7,12,0,0,7044,7045,7,5,
+        0,0,7045,7046,7,4,0,0,7046,7047,7,6,0,0,7047,7048,7,3,0,0,7048,7049,
+        5,95,0,0,7049,7050,7,9,0,0,7050,7051,7,6,0,0,7051,7052,7,4,0,0,7052,
+        7053,7,0,0,0,7053,7054,7,10,0,0,7054,7055,7,11,0,0,7055,7056,7,5,
+        0,0,7056,442,1,0,0,0,7057,7058,7,8,0,0,7058,7059,7,11,0,0,7059,7060,
+        7,12,0,0,7060,7061,7,5,0,0,7061,7062,7,4,0,0,7062,7063,7,6,0,0,7063,
+        7064,7,3,0,0,7064,7065,5,95,0,0,7065,7066,7,9,0,0,7066,7067,7,10,
+        0,0,7067,7068,7,5,0,0,7068,7069,7,4,0,0,7069,7070,7,0,0,0,7070,7071,
+        7,7,0,0,7071,7072,7,8,0,0,7072,7073,7,6,0,0,7073,444,1,0,0,0,7074,
+        7075,7,8,0,0,7075,7076,7,11,0,0,7076,7077,7,12,0,0,7077,7078,7,5,
+        0,0,7078,7079,7,4,0,0,7079,7080,7,6,0,0,7080,7081,7,3,0,0,7081,7082,
+        5,95,0,0,7082,7083,7,10,0,0,7083,7084,7,9,0,0,7084,446,1,0,0,0,7085,
+        7086,7,8,0,0,7086,7087,7,11,0,0,7087,7088,7,12,0,0,7088,7089,7,5,
+        0,0,7089,7090,7,4,0,0,7090,7091,7,6,0,0,7091,7092,7,3,0,0,7092,7093,
+        7,10,0,0,7093,7094,7,7,0,0,7094,7095,7,17,0,0,7095,448,1,0,0,0,7096,
+        7097,7,8,0,0,7097,7098,7,11,0,0,7098,7099,7,12,0,0,7099,7100,7,5,
+        0,0,7100,7101,7,4,0,0,7101,7102,7,6,0,0,7102,7103,7,3,0,0,7103,7104,
+        7,10,0,0,7104,7105,7,7,0,0,7105,7106,7,17,0,0,7106,7107,5,95,0,0,
+        7107,7108,7,16,0,0,7108,7109,7,0,0,0,7109,7110,7,8,0,0,7110,7111,
+        7,4,0,0,7111,7112,7,2,0,0,7112,7113,7,3,0,0,7113,450,1,0,0,0,7114,
+        7115,7,8,0,0,7115,7116,7,11,0,0,7116,7117,7,12,0,0,7117,7118,7,5,
+        0,0,7118,7119,7,4,0,0,7119,7120,7,6,0,0,7120,7121,7,3,0,0,7121,7122,
+        5,95,0,0,7122,7123,7,15,0,0,7123,7124,7,3,0,0,7124,7125,7,2,0,0,
+        7125,7126,7,1,0,0,7126,7127,7,0,0,0,7127,7128,7,1,0,0,7128,7129,
+        7,10,0,0,7129,7130,7,11,0,0,7130,7131,7,10,0,0,7131,7132,7,4,0,0,
+        7132,7133,7,18,0,0,7133,452,1,0,0,0,7134,7135,7,8,0,0,7135,7136,
+        7,11,0,0,7136,7137,7,12,0,0,7137,7138,7,5,0,0,7138,7139,7,4,0,0,
+        7139,7140,7,6,0,0,7140,7141,7,3,0,0,7141,7142,5,95,0,0,7142,7143,
+        7,5,0,0,7143,7144,7,6,0,0,7144,7145,7,4,0,0,7145,454,1,0,0,0,7146,
+        7147,7,8,0,0,7147,7148,7,2,0,0,7148,7149,7,0,0,0,7149,7150,7,11,
+        0,0,7150,7151,7,6,0,0,7151,7152,7,5,0,0,7152,7153,7,8,0,0,7153,7154,
+        7,6,0,0,7154,456,1,0,0,0,7155,7156,7,8,0,0,7156,7157,7,2,0,0,7157,
+        7158,7,0,0,0,7158,7159,7,11,0,0,7159,7160,7,6,0,0,7160,7161,7,5,
+        0,0,7161,7162,7,8,0,0,7162,7163,7,6,0,0,7163,7164,5,95,0,0,7164,
+        7165,7,5,0,0,7165,7166,7,24,0,0,7166,458,1,0,0,0,7167,7168,7,8,0,
+        0,7168,7169,7,2,0,0,7169,7170,7,0,0,0,7170,7171,7,3,0,0,7171,7172,
+        7,5,0,0,7172,7173,7,6,0,0,7173,460,1,0,0,0,7174,7175,7,8,0,0,7175,
+        7176,7,2,0,0,7176,7177,5,95,0,0,7177,7178,7,0,0,0,7178,7179,7,12,
+        0,0,7179,7180,7,4,0,0,7180,7181,7,19,0,0,7181,7182,5,95,0,0,7182,
+        7183,7,10,0,0,7183,7184,7,7,0,0,7184,7185,7,9,0,0,7185,462,1,0,0,
+        0,7186,7187,7,8,0,0,7187,7188,7,2,0,0,7188,7189,7,11,0,0,7189,7190,
+        7,9,0,0,7190,464,1,0,0,0,7191,7192,7,8,0,0,7192,7193,7,2,0,0,7193,
+        7194,7,11,0,0,7194,7195,7,11,0,0,7195,7196,7,6,0,0,7196,7197,7,8,
+        0,0,7197,7198,7,4,0,0,7198,466,1,0,0,0,7199,7200,7,8,0,0,7200,7201,
+        7,2,0,0,7201,7202,7,11,0,0,7202,7203,7,11,0,0,7203,7204,7,6,0,0,
+        7204,7205,7,8,0,0,7205,7206,7,4,0,0,7206,7207,7,10,0,0,7207,7208,
+        7,2,0,0,7208,7209,7,7,0,0,7209,468,1,0,0,0,7210,7211,7,8,0,0,7211,
+        7212,7,2,0,0,7212,7213,7,11,0,0,7213,7214,7,12,0,0,7214,7215,7,14,
+        0,0,7215,7216,7,7,0,0,7216,7217,7,0,0,0,7217,7218,7,3,0,0,7218,470,
+        1,0,0,0,7219,7220,7,8,0,0,7220,7221,7,2,0,0,7221,7222,7,11,0,0,7222,
+        7223,7,12,0,0,7223,7224,7,14,0,0,7224,7225,7,7,0,0,7225,7226,5,95,
+        0,0,7226,7227,7,0,0,0,7227,7228,7,12,0,0,7228,7229,7,4,0,0,7229,
+        7230,7,19,0,0,7230,7231,5,95,0,0,7231,7232,7,10,0,0,7232,7233,7,
+        7,0,0,7233,7234,7,9,0,0,7234,7235,7,10,0,0,7235,7236,7,8,0,0,7236,
+        7237,7,0,0,0,7237,7238,7,4,0,0,7238,7239,7,2,0,0,7239,7240,7,3,0,
+        0,7240,472,1,0,0,0,7241,7242,7,8,0,0,7242,7243,7,2,0,0,7243,7244,
+        7,11,0,0,7244,7245,7,12,0,0,7245,7246,7,14,0,0,7246,7247,7,7,0,0,
+        7247,474,1,0,0,0,7248,7249,7,8,0,0,7249,7250,7,2,0,0,7250,7251,7,
+        11,0,0,7251,7252,7,12,0,0,7252,7253,7,14,0,0,7253,7254,7,7,0,0,7254,
+        7255,7,5,0,0,7255,476,1,0,0,0,7256,7257,7,8,0,0,7257,7258,7,2,0,
+        0,7258,7259,7,11,0,0,7259,7260,7,12,0,0,7260,7261,7,14,0,0,7261,
+        7262,7,7,0,0,7262,7263,5,95,0,0,7263,7264,7,5,0,0,7264,7265,7,4,
+        0,0,7265,7266,7,0,0,0,7266,7267,7,4,0,0,7267,7268,7,5,0,0,7268,478,
+        1,0,0,0,7269,7270,7,8,0,0,7270,7271,7,2,0,0,7271,7272,7,11,0,0,7272,
+        7273,7,12,0,0,7273,7274,7,14,0,0,7274,7275,7,7,0,0,7275,7276,5,95,
+        0,0,7276,7277,7,13,0,0,7277,7278,7,0,0,0,7278,7279,7,11,0,0,7279,
+        7280,7,12,0,0,7280,7281,7,6,0,0,7281,480,1,0,0,0,7282,7283,7,8,0,
+        0,7283,7284,7,2,0,0,7284,7285,7,14,0,0,7285,7286,7,14,0,0,7286,7287,
+        7,6,0,0,7287,7288,7,7,0,0,7288,7289,7,4,0,0,7289,482,1,0,0,0,7290,
+        7291,7,8,0,0,7291,7292,7,2,0,0,7292,7293,7,14,0,0,7293,7294,7,14,
+        0,0,7294,7295,7,10,0,0,7295,7296,7,4,0,0,7296,484,1,0,0,0,7297,7298,
+        7,8,0,0,7298,7299,7,2,0,0,7299,7300,7,14,0,0,7300,7301,7,14,0,0,
+        7301,7302,7,10,0,0,7302,7303,7,4,0,0,7303,7304,7,4,0,0,7304,7305,
+        7,6,0,0,7305,7306,7,9,0,0,7306,486,1,0,0,0,7307,7308,7,8,0,0,7308,
+        7309,7,2,0,0,7309,7310,7,14,0,0,7310,7311,7,14,0,0,7311,7312,7,2,
+        0,0,7312,7313,7,7,0,0,7313,488,1,0,0,0,7314,7315,7,8,0,0,7315,7316,
+        7,2,0,0,7316,7317,7,14,0,0,7317,7318,7,14,0,0,7318,7319,7,2,0,0,
+        7319,7320,7,7,0,0,7320,7321,5,95,0,0,7321,7322,7,9,0,0,7322,7323,
+        7,0,0,0,7323,7324,7,4,0,0,7324,7325,7,0,0,0,7325,490,1,0,0,0,7326,
+        7327,7,8,0,0,7327,7328,7,2,0,0,7328,7329,7,14,0,0,7329,7330,7,15,
+        0,0,7330,7331,7,0,0,0,7331,7332,7,8,0,0,7332,7333,7,4,0,0,7333,492,
+        1,0,0,0,7334,7335,7,8,0,0,7335,7336,7,2,0,0,7336,7337,7,14,0,0,7337,
+        7338,7,15,0,0,7338,7339,7,0,0,0,7339,7340,7,4,0,0,7340,7341,7,10,
+        0,0,7341,7342,7,1,0,0,7342,7343,7,11,0,0,7343,7344,7,6,0,0,7344,
+        494,1,0,0,0,7345,7346,7,8,0,0,7346,7347,7,2,0,0,7347,7348,7,14,0,
+        0,7348,7349,7,15,0,0,7349,7350,7,0,0,0,7350,7351,7,4,0,0,7351,7352,
+        7,10,0,0,7352,7353,7,1,0,0,7353,7354,7,10,0,0,7354,7355,7,11,0,0,
+        7355,7356,7,10,0,0,7356,7357,7,4,0,0,7357,7358,7,18,0,0,7358,496,
+        1,0,0,0,7359,7360,7,8,0,0,7360,7361,7,2,0,0,7361,7362,7,14,0,0,7362,
+        7363,7,15,0,0,7363,7364,7,10,0,0,7364,7365,7,11,0,0,7365,7366,7,
+        6,0,0,7366,498,1,0,0,0,7367,7368,7,8,0,0,7368,7369,7,2,0,0,7369,
+        7370,7,14,0,0,7370,7371,7,15,0,0,7371,7372,7,11,0,0,7372,7373,7,
+        6,0,0,7373,7374,7,4,0,0,7374,7375,7,6,0,0,7375,500,1,0,0,0,7376,
+        7377,7,8,0,0,7377,7378,7,2,0,0,7378,7379,7,14,0,0,7379,7380,7,15,
+        0,0,7380,7381,7,11,0,0,7381,7382,7,10,0,0,7382,7383,7,0,0,0,7383,
+        7384,7,7,0,0,7384,7385,7,8,0,0,7385,7386,7,6,0,0,7386,502,1,0,0,
+        0,7387,7388,7,8,0,0,7388,7389,7,2,0,0,7389,7390,7,14,0,0,7390,7391,
+        7,15,0,0,7391,7392,7,2,0,0,7392,7393,7,7,0,0,7393,7394,7,6,0,0,7394,
+        7395,7,7,0,0,7395,7396,7,4,0,0,7396,504,1,0,0,0,7397,7398,7,8,0,
+        0,7398,7399,7,2,0,0,7399,7400,7,14,0,0,7400,7401,7,15,0,0,7401,7402,
+        7,2,0,0,7402,7403,7,7,0,0,7403,7404,7,6,0,0,7404,7405,7,7,0,0,7405,
+        7406,7,4,0,0,7406,7407,7,5,0,0,7407,506,1,0,0,0,7408,7409,7,8,0,
+        0,7409,7410,7,2,0,0,7410,7411,7,14,0,0,7411,7412,7,15,0,0,7412,7413,
+        7,2,0,0,7413,7414,7,5,0,0,7414,7415,7,6,0,0,7415,508,1,0,0,0,7416,
+        7417,7,8,0,0,7417,7418,7,2,0,0,7418,7419,7,14,0,0,7419,7420,7,15,
+        0,0,7420,7421,7,2,0,0,7421,7422,7,5,0,0,7422,7423,7,10,0,0,7423,
+        7424,7,4,0,0,7424,7425,7,6,0,0,7425,510,1,0,0,0,7426,7427,7,8,0,
+        0,7427,7428,7,2,0,0,7428,7429,7,14,0,0,7429,7430,7,15,0,0,7430,7431,
+        7,2,0,0,7431,7432,7,5,0,0,7432,7433,7,10,0,0,7433,7434,7,4,0,0,7434,
+        7435,7,6,0,0,7435,7436,5,95,0,0,7436,7437,7,11,0,0,7437,7438,7,10,
+        0,0,7438,7439,7,14,0,0,7439,7440,7,10,0,0,7440,7441,7,4,0,0,7441,
+        512,1,0,0,0,7442,7443,7,8,0,0,7443,7444,7,2,0,0,7444,7445,7,14,0,
+        0,7445,7446,7,15,0,0,7446,7447,7,2,0,0,7447,7448,7,12,0,0,7448,7449,
+        7,7,0,0,7449,7450,7,9,0,0,7450,514,1,0,0,0,7451,7452,7,8,0,0,7452,
+        7453,7,2,0,0,7453,7454,7,14,0,0,7454,7455,7,15,0,0,7455,7456,7,3,
+        0,0,7456,7457,7,6,0,0,7457,7458,7,5,0,0,7458,7459,7,5,0,0,7459,516,
+        1,0,0,0,7460,7461,7,8,0,0,7461,7462,7,2,0,0,7462,7463,7,14,0,0,7463,
+        7464,7,15,0,0,7464,7465,7,3,0,0,7465,7466,7,6,0,0,7466,7467,7,5,
+        0,0,7467,7468,7,5,0,0,7468,7469,7,10,0,0,7469,7470,7,2,0,0,7470,
+        7471,7,7,0,0,7471,518,1,0,0,0,7472,7473,7,8,0,0,7473,7474,7,2,0,
+        0,7474,7475,7,14,0,0,7475,7476,7,15,0,0,7476,7477,7,12,0,0,7477,
+        7478,7,4,0,0,7478,7479,7,6,0,0,7479,520,1,0,0,0,7480,7481,7,8,0,
+        0,7481,7482,7,2,0,0,7482,7483,7,14,0,0,7483,7484,7,15,0,0,7484,7485,
+        7,12,0,0,7485,7486,7,4,0,0,7486,7487,7,0,0,0,7487,7488,7,4,0,0,7488,
+        7489,7,10,0,0,7489,7490,7,2,0,0,7490,7491,7,7,0,0,7491,522,1,0,0,
+        0,7492,7493,7,8,0,0,7493,7494,7,2,0,0,7494,7495,7,7,0,0,7495,7496,
+        7,8,0,0,7496,7497,7,0,0,0,7497,7498,7,4,0,0,7498,524,1,0,0,0,7499,
+        7500,7,8,0,0,7500,7501,7,2,0,0,7501,7502,7,7,0,0,7502,7503,7,8,0,
+        0,7503,7504,7,12,0,0,7504,7505,7,3,0,0,7505,7506,7,3,0,0,7506,7507,
+        7,6,0,0,7507,7508,7,7,0,0,7508,7509,7,4,0,0,7509,526,1,0,0,0,7510,
+        7511,7,8,0,0,7511,7512,7,2,0,0,7512,7513,7,7,0,0,7513,7514,5,95,
+        0,0,7514,7515,7,9,0,0,7515,7516,7,1,0,0,7516,7517,7,10,0,0,7517,
+        7518,7,9,0,0,7518,7519,5,95,0,0,7519,7520,7,4,0,0,7520,7521,7,2,
+        0,0,7521,7522,5,95,0,0,7522,7523,7,10,0,0,7523,7524,7,9,0,0,7524,
+        528,1,0,0,0,7525,7526,7,8,0,0,7526,7527,7,2,0,0,7527,7528,7,7,0,
+        0,7528,7529,7,9,0,0,7529,7530,7,10,0,0,7530,7531,7,4,0,0,7531,7532,
+        7,10,0,0,7532,7533,7,2,0,0,7533,7534,7,7,0,0,7534,7535,7,0,0,0,7535,
+        7536,7,11,0,0,7536,530,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,9,0,0,7541,7542,7,10,0,0,7542,7543,
+        7,4,0,0,7543,7544,7,10,0,0,7544,7545,7,2,0,0,7545,7546,7,7,0,0,7546,
+        532,1,0,0,0,7547,7548,7,8,0,0,7548,7549,7,2,0,0,7549,7550,7,7,0,
+        0,7550,7551,7,16,0,0,7551,7552,7,10,0,0,7552,7553,7,3,0,0,7553,7554,
+        7,14,0,0,7554,534,1,0,0,0,7555,7556,7,8,0,0,7556,7557,7,2,0,0,7557,
+        7558,7,7,0,0,7558,7559,7,16,0,0,7559,7560,7,2,0,0,7560,7561,7,3,
+        0,0,7561,7562,7,14,0,0,7562,7563,7,10,0,0,7563,7564,7,7,0,0,7564,
+        7565,7,17,0,0,7565,536,1,0,0,0,7566,7567,7,8,0,0,7567,7568,7,2,0,
+        0,7568,7569,7,7,0,0,7569,7570,5,95,0,0,7570,7571,7,17,0,0,7571,7572,
+        7,12,0,0,7572,7573,7,10,0,0,7573,7574,7,9,0,0,7574,7575,5,95,0,0,
+        7575,7576,7,4,0,0,7576,7577,7,2,0,0,7577,7578,5,95,0,0,7578,7579,
+        7,10,0,0,7579,7580,7,9,0,0,7580,538,1,0,0,0,7581,7582,7,8,0,0,7582,
+        7583,7,2,0,0,7583,7584,7,7,0,0,7584,7585,5,95,0,0,7585,7586,7,10,
+        0,0,7586,7587,7,9,0,0,7587,540,1,0,0,0,7588,7589,7,8,0,0,7589,7590,
+        7,2,0,0,7590,7591,7,7,0,0,7591,7592,5,95,0,0,7592,7593,7,7,0,0,7593,
+        7594,7,0,0,0,7594,7595,7,14,0,0,7595,7596,7,6,0,0,7596,7597,5,95,
+        0,0,7597,7598,7,4,0,0,7598,7599,7,2,0,0,7599,7600,5,95,0,0,7600,
+        7601,7,10,0,0,7601,7602,7,9,0,0,7602,542,1,0,0,0,7603,7604,7,8,0,
+        0,7604,7605,7,2,0,0,7605,7606,7,7,0,0,7606,7607,7,7,0,0,7607,7608,
+        7,6,0,0,7608,7609,7,8,0,0,7609,7610,7,4,0,0,7610,7611,5,95,0,0,7611,
+        7612,7,1,0,0,7612,7613,7,18,0,0,7613,7614,5,95,0,0,7614,7615,7,8,
+        0,0,7615,7616,7,1,0,0,7616,7617,5,95,0,0,7617,7618,7,22,0,0,7618,
+        7619,7,19,0,0,7619,7620,7,3,0,0,7620,7621,5,95,0,0,7621,7622,7,2,
+        0,0,7622,7623,7,7,0,0,7623,7624,7,11,0,0,7624,7625,7,18,0,0,7625,
+        544,1,0,0,0,7626,7627,7,8,0,0,7627,7628,7,2,0,0,7628,7629,7,7,0,
+        0,7629,7630,7,7,0,0,7630,7631,7,6,0,0,7631,7632,7,8,0,0,7632,7633,
+        7,4,0,0,7633,7634,5,95,0,0,7634,7635,7,1,0,0,7635,7636,7,18,0,0,
+        7636,7637,5,95,0,0,7637,7638,7,8,0,0,7638,7639,7,2,0,0,7639,7640,
+        7,14,0,0,7640,7641,7,1,0,0,7641,7642,7,10,0,0,7642,7643,7,7,0,0,
+        7643,7644,7,6,0,0,7644,7645,5,95,0,0,7645,7646,7,5,0,0,7646,7647,
+        7,22,0,0,7647,546,1,0,0,0,7648,7649,7,8,0,0,7649,7650,7,2,0,0,7650,
+        7651,7,7,0,0,7651,7652,7,7,0,0,7652,7653,7,6,0,0,7653,7654,7,8,0,
+        0,7654,7655,7,4,0,0,7655,7656,5,95,0,0,7656,7657,7,1,0,0,7657,7658,
+        7,18,0,0,7658,7659,5,95,0,0,7659,7660,7,8,0,0,7660,7661,7,2,0,0,
+        7661,7662,7,5,0,0,7662,7663,7,4,0,0,7663,7664,5,95,0,0,7664,7665,
+        7,1,0,0,7665,7666,7,0,0,0,7666,7667,7,5,0,0,7667,7668,7,6,0,0,7668,
+        7669,7,9,0,0,7669,548,1,0,0,0,7670,7671,7,8,0,0,7671,7672,7,2,0,
+        0,7672,7673,7,7,0,0,7673,7674,7,7,0,0,7674,7675,7,6,0,0,7675,7676,
+        7,8,0,0,7676,7677,7,4,0,0,7677,7678,5,95,0,0,7678,7679,7,1,0,0,7679,
+        7680,7,18,0,0,7680,7681,5,95,0,0,7681,7682,7,6,0,0,7682,7683,7,11,
+        0,0,7683,7684,7,10,0,0,7684,7685,7,14,0,0,7685,7686,5,95,0,0,7686,
+        7687,7,9,0,0,7687,7688,7,12,0,0,7688,7689,7,15,0,0,7689,7690,7,5,
+        0,0,7690,550,1,0,0,0,7691,7692,7,8,0,0,7692,7693,7,2,0,0,7693,7694,
+        7,7,0,0,7694,7695,7,7,0,0,7695,7696,7,6,0,0,7696,7697,7,8,0,0,7697,
+        7698,7,4,0,0,7698,7699,5,95,0,0,7699,7700,7,1,0,0,7700,7701,7,18,
+        0,0,7701,7702,5,95,0,0,7702,7703,7,16,0,0,7703,7704,7,10,0,0,7704,
+        7705,7,11,0,0,7705,7706,7,4,0,0,7706,7707,7,6,0,0,7707,7708,7,3,
+        0,0,7708,7709,7,10,0,0,7709,7710,7,7,0,0,7710,7711,7,17,0,0,7711,
+        552,1,0,0,0,7712,7713,7,8,0,0,7713,7714,7,2,0,0,7714,7715,7,7,0,
+        0,7715,7716,7,7,0,0,7716,7717,7,6,0,0,7717,7718,7,8,0,0,7718,7719,
+        7,4,0,0,7719,7720,5,95,0,0,7720,7721,7,1,0,0,7721,7722,7,18,0,0,
+        7722,7723,5,95,0,0,7723,7724,7,10,0,0,7724,7725,7,5,0,0,7725,7726,
+        7,8,0,0,7726,7727,7,18,0,0,7727,7728,7,8,0,0,7728,7729,7,11,0,0,
+        7729,7730,7,6,0,0,7730,554,1,0,0,0,7731,7732,7,8,0,0,7732,7733,7,
+        2,0,0,7733,7734,7,7,0,0,7734,7735,7,7,0,0,7735,7736,7,6,0,0,7736,
+        7737,7,8,0,0,7737,7738,7,4,0,0,7738,7739,5,95,0,0,7739,7740,7,1,
+        0,0,7740,7741,7,18,0,0,7741,7742,5,95,0,0,7742,7743,7,10,0,0,7743,
+        7744,7,5,0,0,7744,7745,7,11,0,0,7745,7746,7,6,0,0,7746,7747,7,0,
+        0,0,7747,7748,7,16,0,0,7748,556,1,0,0,0,7749,7750,7,8,0,0,7750,7751,
+        7,2,0,0,7751,7752,7,7,0,0,7752,7753,7,7,0,0,7753,7754,7,6,0,0,7754,
+        7755,7,8,0,0,7755,7756,7,4,0,0,7756,7757,5,95,0,0,7757,7758,7,1,
+        0,0,7758,7759,7,18,0,0,7759,7760,5,95,0,0,7760,7761,7,3,0,0,7761,
+        7762,7,2,0,0,7762,7763,7,2,0,0,7763,7764,7,4,0,0,7764,558,1,0,0,
+        0,7765,7766,7,8,0,0,7766,7767,7,2,0,0,7767,7768,7,7,0,0,7768,7769,
+        7,7,0,0,7769,7770,7,6,0,0,7770,7771,7,8,0,0,7771,7772,7,4,0,0,7772,
+        560,1,0,0,0,7773,7774,7,8,0,0,7774,7775,7,2,0,0,7775,7776,7,7,0,
+        0,7776,7777,7,7,0,0,7777,7778,7,6,0,0,7778,7779,7,8,0,0,7779,7780,
+        7,4,0,0,7780,7781,5,95,0,0,7781,7782,7,4,0,0,7782,7783,7,10,0,0,
+        7783,7784,7,14,0,0,7784,7785,7,6,0,0,7785,562,1,0,0,0,7786,7787,
+        7,8,0,0,7787,7788,7,2,0,0,7788,7789,7,7,0,0,7789,7790,7,5,0,0,7790,
+        7791,7,10,0,0,7791,7792,7,9,0,0,7792,7793,7,6,0,0,7793,7794,7,3,
+        0,0,7794,564,1,0,0,0,7795,7796,7,8,0,0,7796,7797,7,2,0,0,7797,7798,
+        7,7,0,0,7798,7799,7,5,0,0,7799,7800,7,10,0,0,7800,7801,7,5,0,0,7801,
+        7802,7,4,0,0,7802,7803,7,6,0,0,7803,7804,7,7,0,0,7804,7805,7,4,0,
+        0,7805,566,1,0,0,0,7806,7807,7,8,0,0,7807,7808,7,2,0,0,7808,7809,
+        7,7,0,0,7809,7810,7,5,0,0,7810,7811,7,4,0,0,7811,7812,7,0,0,0,7812,
+        7813,7,7,0,0,7813,7814,7,4,0,0,7814,568,1,0,0,0,7815,7816,7,8,0,
+        0,7816,7817,7,2,0,0,7817,7818,7,7,0,0,7818,7819,7,5,0,0,7819,7820,
+        7,4,0,0,7820,570,1,0,0,0,7821,7822,7,8,0,0,7822,7823,7,2,0,0,7823,
+        7824,7,7,0,0,7824,7825,7,5,0,0,7825,7826,7,4,0,0,7826,7827,7,3,0,
+        0,7827,7828,7,0,0,0,7828,7829,7,10,0,0,7829,7830,7,7,0,0,7830,7831,
+        7,4,0,0,7831,572,1,0,0,0,7832,7833,7,8,0,0,7833,7834,7,2,0,0,7834,
+        7835,7,7,0,0,7835,7836,7,5,0,0,7836,7837,7,4,0,0,7837,7838,7,3,0,
+        0,7838,7839,7,0,0,0,7839,7840,7,10,0,0,7840,7841,7,7,0,0,7841,7842,
+        7,4,0,0,7842,7843,7,5,0,0,7843,574,1,0,0,0,7844,7845,7,8,0,0,7845,
+        7846,7,2,0,0,7846,7847,7,7,0,0,7847,7848,7,5,0,0,7848,7849,7,4,0,
+        0,7849,7850,7,3,0,0,7850,7851,7,12,0,0,7851,7852,7,8,0,0,7852,7853,
+        7,4,0,0,7853,7854,7,2,0,0,7854,7855,7,3,0,0,7855,576,1,0,0,0,7856,
+        7857,7,8,0,0,7857,7858,7,2,0,0,7858,7859,7,7,0,0,7859,7860,7,4,0,
+        0,7860,7861,7,0,0,0,7861,7862,7,10,0,0,7862,7863,7,7,0,0,7863,7864,
+        7,6,0,0,7864,7865,7,3,0,0,7865,578,1,0,0,0,7866,7867,7,8,0,0,7867,
+        7868,7,2,0,0,7868,7869,7,7,0,0,7869,7870,7,4,0,0,7870,7871,7,0,0,
+        0,7871,7872,7,10,0,0,7872,7873,7,7,0,0,7873,7874,7,6,0,0,7874,7875,
+        7,3,0,0,7875,7876,7,5,0,0,7876,580,1,0,0,0,7877,7878,7,8,0,0,7878,
+        7879,7,2,0,0,7879,7880,7,7,0,0,7880,7881,7,4,0,0,7881,7882,7,0,0,
+        0,7882,7883,7,10,0,0,7883,7884,7,7,0,0,7884,7885,7,6,0,0,7885,7886,
+        7,3,0,0,7886,7887,7,5,0,0,7887,7888,5,95,0,0,7888,7889,7,9,0,0,7889,
+        7890,7,6,0,0,7890,7891,7,16,0,0,7891,7892,7,0,0,0,7892,7893,7,12,
+        0,0,7893,7894,7,11,0,0,7894,7895,7,4,0,0,7895,582,1,0,0,0,7896,7897,
+        7,8,0,0,7897,7898,7,2,0,0,7898,7899,7,7,0,0,7899,7900,7,4,0,0,7900,
+        7901,7,0,0,0,7901,7902,7,10,0,0,7902,7903,7,7,0,0,7903,7904,7,6,
+        0,0,7904,7905,7,3,0,0,7905,7906,5,95,0,0,7906,7907,7,9,0,0,7907,
+        7908,7,0,0,0,7908,7909,7,4,0,0,7909,7910,7,0,0,0,7910,584,1,0,0,
+        0,7911,7912,7,8,0,0,7912,7913,7,2,0,0,7913,7914,7,7,0,0,7914,7915,
+        7,4,0,0,7915,7916,7,0,0,0,7916,7917,7,10,0,0,7917,7918,7,7,0,0,7918,
+        7919,7,6,0,0,7919,7920,7,3,0,0,7920,7921,5,95,0,0,7921,7922,7,14,
+        0,0,7922,7923,7,0,0,0,7923,7924,7,15,0,0,7924,586,1,0,0,0,7925,7926,
+        7,8,0,0,7926,7927,7,2,0,0,7927,7928,7,7,0,0,7928,7929,7,4,0,0,7929,
+        7930,7,6,0,0,7930,7931,7,7,0,0,7931,7932,7,4,0,0,7932,588,1,0,0,
+        0,7933,7934,7,8,0,0,7934,7935,7,2,0,0,7935,7936,7,7,0,0,7936,7937,
+        7,4,0,0,7937,7938,7,6,0,0,7938,7939,7,7,0,0,7939,7940,7,4,0,0,7940,
+        7941,7,5,0,0,7941,590,1,0,0,0,7942,7943,7,8,0,0,7943,7944,7,2,0,
+        0,7944,7945,7,7,0,0,7945,7946,7,4,0,0,7946,7947,7,6,0,0,7947,7948,
+        7,25,0,0,7948,7949,7,4,0,0,7949,592,1,0,0,0,7950,7951,7,8,0,0,7951,
+        7952,7,2,0,0,7952,7953,7,7,0,0,7953,7954,7,4,0,0,7954,7955,7,10,
+        0,0,7955,7956,7,7,0,0,7956,7957,7,12,0,0,7957,7958,7,6,0,0,7958,
+        594,1,0,0,0,7959,7960,7,8,0,0,7960,7961,7,2,0,0,7961,7962,7,7,0,
+        0,7962,7963,7,4,0,0,7963,7964,7,3,0,0,7964,7965,7,2,0,0,7965,7966,
+        7,11,0,0,7966,7967,7,16,0,0,7967,7968,7,10,0,0,7968,7969,7,11,0,
+        0,7969,7970,7,6,0,0,7970,596,1,0,0,0,7971,7972,7,8,0,0,7972,7973,
+        7,2,0,0,7973,7974,7,7,0,0,7974,7975,5,95,0,0,7975,7976,7,12,0,0,
+        7976,7977,7,10,0,0,7977,7978,7,9,0,0,7978,7979,5,95,0,0,7979,7980,
+        7,4,0,0,7980,7981,7,2,0,0,7981,7982,5,95,0,0,7982,7983,7,10,0,0,
+        7983,7984,7,9,0,0,7984,598,1,0,0,0,7985,7986,7,8,0,0,7986,7987,7,
+        2,0,0,7987,7988,7,7,0,0,7988,7989,7,13,0,0,7989,7990,7,6,0,0,7990,
+        7991,7,3,0,0,7991,7992,7,4,0,0,7992,600,1,0,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,5,0,0,8000,8001,7,10,0,0,8001,
+        8002,7,2,0,0,8002,8003,7,7,0,0,8003,602,1,0,0,0,8004,8005,7,8,0,
+        0,8005,8006,7,2,0,0,8006,8007,7,2,0,0,8007,8008,7,21,0,0,8008,8009,
+        7,10,0,0,8009,8010,7,6,0,0,8010,604,1,0,0,0,8011,8012,7,8,0,0,8012,
+        8013,7,2,0,0,8013,8014,7,15,0,0,8014,8015,7,18,0,0,8015,606,1,0,
+        0,0,8016,8017,7,8,0,0,8017,8018,7,2,0,0,8018,8019,7,3,0,0,8019,8020,
+        7,3,0,0,8020,8021,5,95,0,0,8021,8022,7,21,0,0,8022,608,1,0,0,0,8023,
+        8024,7,8,0,0,8024,8025,7,2,0,0,8025,8026,7,3,0,0,8026,8027,7,3,0,
+        0,8027,8028,5,95,0,0,8028,8029,7,5,0,0,8029,610,1,0,0,0,8030,8031,
+        7,8,0,0,8031,8032,7,2,0,0,8032,8033,7,3,0,0,8033,8034,7,3,0,0,8034,
+        8035,7,12,0,0,8035,8036,7,15,0,0,8036,8037,7,4,0,0,8037,8038,7,10,
+        0,0,8038,8039,7,2,0,0,8039,8040,7,7,0,0,8040,612,1,0,0,0,8041,8042,
+        7,8,0,0,8042,8043,7,2,0,0,8043,8044,7,3,0,0,8044,8045,7,3,0,0,8045,
+        8046,7,12,0,0,8046,8047,7,15,0,0,8047,8048,7,4,0,0,8048,8049,5,95,
+        0,0,8049,8050,7,25,0,0,8050,8051,7,10,0,0,8051,8052,7,9,0,0,8052,
+        8053,5,95,0,0,8053,8054,7,0,0,0,8054,8055,7,11,0,0,8055,8056,7,11,
+        0,0,8056,614,1,0,0,0,8057,8058,7,8,0,0,8058,8059,7,2,0,0,8059,8060,
+        7,3,0,0,8060,8061,7,3,0,0,8061,8062,7,12,0,0,8062,8063,7,15,0,0,
+        8063,8064,7,4,0,0,8064,8065,5,95,0,0,8065,8066,7,25,0,0,8066,8067,
+        7,10,0,0,8067,8068,7,9,0,0,8068,616,1,0,0,0,8069,8070,7,8,0,0,8070,
+        8071,7,2,0,0,8071,8072,7,5,0,0,8072,618,1,0,0,0,8073,8074,7,8,0,
+        0,8074,8075,7,2,0,0,8075,8076,7,5,0,0,8076,8077,7,19,0,0,8077,620,
+        1,0,0,0,8078,8079,7,8,0,0,8079,8080,7,2,0,0,8080,8081,7,5,0,0,8081,
+        8082,7,4,0,0,8082,622,1,0,0,0,8083,8084,7,8,0,0,8084,8085,7,2,0,
+        0,8085,8086,7,5,0,0,8086,8087,7,4,0,0,8087,8088,5,95,0,0,8088,8089,
+        7,25,0,0,8089,8090,7,14,0,0,8090,8091,7,11,0,0,8091,8092,5,95,0,
+        0,8092,8093,7,24,0,0,8093,8094,7,12,0,0,8094,8095,7,6,0,0,8095,8096,
+        7,3,0,0,8096,8097,7,18,0,0,8097,8098,5,95,0,0,8098,8099,7,3,0,0,
+        8099,8100,7,6,0,0,8100,8101,7,22,0,0,8101,8102,7,3,0,0,8102,8103,
+        7,10,0,0,8103,8104,7,4,0,0,8104,8105,7,6,0,0,8105,624,1,0,0,0,8106,
+        8107,7,8,0,0,8107,8108,7,2,0,0,8108,8109,7,12,0,0,8109,8110,7,7,
+        0,0,8110,8111,7,4,0,0,8111,626,1,0,0,0,8112,8113,7,8,0,0,8113,8114,
+        7,2,0,0,8114,8115,7,12,0,0,8115,8116,7,7,0,0,8116,8117,7,4,0,0,8117,
+        8118,7,6,0,0,8118,8119,7,9,0,0,8119,628,1,0,0,0,8120,8121,7,8,0,
+        0,8121,8122,7,2,0,0,8122,8123,7,13,0,0,8123,8124,7,0,0,0,8124,8125,
+        7,3,0,0,8125,8126,5,95,0,0,8126,8127,7,15,0,0,8127,8128,7,2,0,0,
+        8128,8129,7,15,0,0,8129,630,1,0,0,0,8130,8131,7,8,0,0,8131,8132,
+        7,2,0,0,8132,8133,7,13,0,0,8133,8134,7,0,0,0,8134,8135,7,3,0,0,8135,
+        8136,5,95,0,0,8136,8137,7,5,0,0,8137,8138,7,0,0,0,8138,8139,7,14,
+        0,0,8139,8140,7,15,0,0,8140,632,1,0,0,0,8141,8142,7,8,0,0,8142,8143,
+        7,15,0,0,8143,8144,7,12,0,0,8144,8145,5,95,0,0,8145,8146,7,8,0,0,
+        8146,8147,7,2,0,0,8147,8148,7,5,0,0,8148,8149,7,4,0,0,8149,8150,
+        7,10,0,0,8150,8151,7,7,0,0,8151,8152,7,17,0,0,8152,634,1,0,0,0,8153,
+        8154,7,8,0,0,8154,8155,7,15,0,0,8155,8156,7,12,0,0,8156,8157,5,95,
+        0,0,8157,8158,7,15,0,0,8158,8159,7,6,0,0,8159,8160,7,3,0,0,8160,
+        8161,5,95,0,0,8161,8162,7,8,0,0,8162,8163,7,0,0,0,8163,8164,7,11,
+        0,0,8164,8165,7,11,0,0,8165,636,1,0,0,0,8166,8167,7,8,0,0,8167,8168,
+        7,15,0,0,8168,8169,7,12,0,0,8169,8170,5,95,0,0,8170,8171,7,15,0,
+        0,8171,8172,7,6,0,0,8172,8173,7,3,0,0,8173,8174,5,95,0,0,8174,8175,
+        7,5,0,0,8175,8176,7,6,0,0,8176,8177,7,5,0,0,8177,8178,7,5,0,0,8178,
+        8179,7,10,0,0,8179,8180,7,2,0,0,8180,8181,7,7,0,0,8181,638,1,0,0,
+        0,8182,8183,7,8,0,0,8183,8184,7,3,0,0,8184,8185,7,0,0,0,8185,8186,
+        7,5,0,0,8186,8187,7,19,0,0,8187,640,1,0,0,0,8188,8189,7,8,0,0,8189,
+        8190,7,3,0,0,8190,8191,7,6,0,0,8191,8192,7,0,0,0,8192,8193,7,4,0,
+        0,8193,8194,7,6,0,0,8194,642,1,0,0,0,8195,8196,7,8,0,0,8196,8197,
+        7,3,0,0,8197,8198,7,6,0,0,8198,8199,7,0,0,0,8199,8200,7,4,0,0,8200,
+        8201,7,6,0,0,8201,8202,5,95,0,0,8202,8203,7,16,0,0,8203,8204,7,10,
+        0,0,8204,8205,7,11,0,0,8205,8206,7,6,0,0,8206,8207,5,95,0,0,8207,
+        8208,7,9,0,0,8208,8209,7,6,0,0,8209,8210,7,5,0,0,8210,8211,7,4,0,
+        0,8211,644,1,0,0,0,8212,8213,7,8,0,0,8213,8214,7,3,0,0,8214,8215,
+        7,6,0,0,8215,8216,7,0,0,0,8216,8217,7,4,0,0,8217,8218,7,6,0,0,8218,
+        8219,5,95,0,0,8219,8220,7,5,0,0,8220,8221,7,4,0,0,8221,8222,7,2,
+        0,0,8222,8223,7,3,0,0,8223,8224,7,6,0,0,8224,8225,7,9,0,0,8225,8226,
+        5,95,0,0,8226,8227,7,2,0,0,8227,8228,7,12,0,0,8228,8229,7,4,0,0,
+        8229,8230,7,11,0,0,8230,8231,7,10,0,0,8231,8232,7,7,0,0,8232,8233,
+        7,6,0,0,8233,8234,7,5,0,0,8234,646,1,0,0,0,8235,8236,7,8,0,0,8236,
+        8237,7,3,0,0,8237,8238,7,6,0,0,8238,8239,7,0,0,0,8239,8240,7,4,0,
+        0,8240,8241,7,10,0,0,8241,8242,7,2,0,0,8242,8243,7,7,0,0,8243,648,
+        1,0,0,0,8244,8245,7,8,0,0,8245,8246,7,3,0,0,8246,8247,7,6,0,0,8247,
+        8248,7,9,0,0,8248,8249,7,6,0,0,8249,8250,7,7,0,0,8250,8251,7,4,0,
+        0,8251,8252,7,10,0,0,8252,8253,7,0,0,0,8253,8254,7,11,0,0,8254,650,
+        1,0,0,0,8255,8256,7,8,0,0,8256,8257,7,3,0,0,8257,8258,7,10,0,0,8258,
+        8259,7,4,0,0,8259,8260,7,10,0,0,8260,8261,7,8,0,0,8261,8262,7,0,
+        0,0,8262,8263,7,11,0,0,8263,652,1,0,0,0,8264,8265,7,8,0,0,8265,8266,
+        7,3,0,0,8266,8267,7,2,0,0,8267,8268,7,5,0,0,8268,8269,7,5,0,0,8269,
+        654,1,0,0,0,8270,8271,7,8,0,0,8271,8272,7,3,0,0,8272,8273,7,2,0,
+        0,8273,8274,7,5,0,0,8274,8275,7,5,0,0,8275,8276,7,6,0,0,8276,8277,
+        7,9,0,0,8277,8278,7,10,0,0,8278,8279,7,4,0,0,8279,8280,7,10,0,0,
+        8280,8281,7,2,0,0,8281,8282,7,7,0,0,8282,656,1,0,0,0,8283,8284,7,
+        8,0,0,8284,8285,7,5,0,0,8285,8286,7,8,0,0,8286,8287,7,2,0,0,8287,
+        8288,7,7,0,0,8288,8289,7,13,0,0,8289,8290,7,6,0,0,8290,8291,7,3,
+        0,0,8291,8292,7,4,0,0,8292,658,1,0,0,0,8293,8294,7,8,0,0,8294,8295,
+        7,5,0,0,8295,8296,7,13,0,0,8296,660,1,0,0,0,8297,8298,7,8,0,0,8298,
+        8299,7,12,0,0,8299,8300,7,1,0,0,8300,8301,7,6,0,0,8301,8302,5,95,
+        0,0,8302,8303,7,0,0,0,8303,8304,7,20,0,0,8304,662,1,0,0,0,8305,8306,
+        7,8,0,0,8306,8307,7,12,0,0,8307,8308,7,1,0,0,8308,8309,7,6,0,0,8309,
+        664,1,0,0,0,8310,8311,7,8,0,0,8311,8312,7,12,0,0,8312,8313,7,1,0,
+        0,8313,8314,7,6,0,0,8314,8315,5,95,0,0,8315,8316,7,17,0,0,8316,8317,
+        7,1,0,0,8317,666,1,0,0,0,8318,8319,7,8,0,0,8319,8320,7,12,0,0,8320,
+        8321,7,1,0,0,8321,8322,7,6,0,0,8322,8323,5,95,0,0,8323,8324,7,5,
+        0,0,8324,8325,7,20,0,0,8325,668,1,0,0,0,8326,8327,7,8,0,0,8327,8328,
+        7,12,0,0,8328,8329,7,14,0,0,8329,8330,7,6,0,0,8330,8331,5,95,0,0,
+        8331,8332,7,9,0,0,8332,8333,7,10,0,0,8333,8334,7,5,0,0,8334,8335,
+        7,4,0,0,8335,8336,7,14,0,0,8336,670,1,0,0,0,8337,8338,7,8,0,0,8338,
+        8339,7,12,0,0,8339,8340,7,3,0,0,8340,8341,7,3,0,0,8341,8342,7,6,
+        0,0,8342,8343,7,7,0,0,8343,8344,7,4,0,0,8344,672,1,0,0,0,8345,8346,
+        7,8,0,0,8346,8347,7,12,0,0,8347,8348,7,3,0,0,8348,8349,7,3,0,0,8349,
+        8350,7,6,0,0,8350,8351,7,7,0,0,8351,8352,7,4,0,0,8352,8353,5,95,
+        0,0,8353,8354,7,9,0,0,8354,8355,7,0,0,0,8355,8356,7,4,0,0,8356,8357,
+        7,6,0,0,8357,674,1,0,0,0,8358,8359,7,8,0,0,8359,8360,7,12,0,0,8360,
+        8361,7,3,0,0,8361,8362,7,3,0,0,8362,8363,7,6,0,0,8363,8364,7,7,0,
+        0,8364,8365,7,4,0,0,8365,8366,5,95,0,0,8366,8367,7,5,0,0,8367,8368,
+        7,8,0,0,8368,8369,7,19,0,0,8369,8370,7,6,0,0,8370,8371,7,14,0,0,
+        8371,8372,7,0,0,0,8372,676,1,0,0,0,8373,8374,7,8,0,0,8374,8375,7,
+        12,0,0,8375,8376,7,3,0,0,8376,8377,7,3,0,0,8377,8378,7,6,0,0,8378,
+        8379,7,7,0,0,8379,8380,7,4,0,0,8380,8381,5,95,0,0,8381,8382,7,4,
+        0,0,8382,8383,7,10,0,0,8383,8384,7,14,0,0,8384,8385,7,6,0,0,8385,
+        678,1,0,0,0,8386,8387,7,8,0,0,8387,8388,7,12,0,0,8388,8389,7,3,0,
+        0,8389,8390,7,3,0,0,8390,8391,7,6,0,0,8391,8392,7,7,0,0,8392,8393,
+        7,4,0,0,8393,8394,5,95,0,0,8394,8395,7,4,0,0,8395,8396,7,10,0,0,
+        8396,8397,7,14,0,0,8397,8398,7,6,0,0,8398,8399,7,5,0,0,8399,8400,
+        7,4,0,0,8400,8401,7,0,0,0,8401,8402,7,14,0,0,8402,8403,7,15,0,0,
+        8403,680,1,0,0,0,8404,8405,7,8,0,0,8405,8406,7,12,0,0,8406,8407,
+        7,3,0,0,8407,8408,7,3,0,0,8408,8409,7,6,0,0,8409,8410,7,7,0,0,8410,
+        8411,7,4,0,0,8411,8412,5,95,0,0,8412,8413,7,12,0,0,8413,8414,7,5,
+        0,0,8414,8415,7,6,0,0,8415,8416,7,3,0,0,8416,682,1,0,0,0,8417,8418,
+        7,8,0,0,8418,8419,7,12,0,0,8419,8420,7,3,0,0,8420,8421,7,3,0,0,8421,
+        8422,7,6,0,0,8422,8423,7,7,0,0,8423,8424,7,4,0,0,8424,8425,7,13,
+        0,0,8425,684,1,0,0,0,8426,8427,7,8,0,0,8427,8428,7,12,0,0,8428,8429,
+        7,3,0,0,8429,8430,7,5,0,0,8430,8431,7,2,0,0,8431,8432,7,3,0,0,8432,
+        686,1,0,0,0,8433,8434,7,8,0,0,8434,8435,7,12,0,0,8435,8436,7,3,0,
+        0,8436,8437,7,5,0,0,8437,8438,7,2,0,0,8438,8439,7,3,0,0,8439,8440,
+        5,95,0,0,8440,8441,7,5,0,0,8441,8442,7,19,0,0,8442,8443,7,0,0,0,
+        8443,8444,7,3,0,0,8444,8445,7,10,0,0,8445,8446,7,7,0,0,8446,8447,
+        7,17,0,0,8447,8448,5,95,0,0,8448,8449,7,6,0,0,8449,8450,7,25,0,0,
+        8450,8451,7,0,0,0,8451,8452,7,8,0,0,8452,8453,7,4,0,0,8453,688,1,
+        0,0,0,8454,8455,7,8,0,0,8455,8456,7,12,0,0,8456,8457,7,3,0,0,8457,
+        8458,7,5,0,0,8458,8459,7,2,0,0,8459,8460,7,3,0,0,8460,8461,5,95,
+        0,0,8461,8462,7,5,0,0,8462,8463,7,15,0,0,8463,8464,7,6,0,0,8464,
+        8465,7,8,0,0,8465,8466,7,10,0,0,8466,8467,7,16,0,0,8467,8468,7,10,
+        0,0,8468,8469,7,8,0,0,8469,8470,5,95,0,0,8470,8471,7,5,0,0,8471,
+        8472,7,6,0,0,8472,8473,7,17,0,0,8473,8474,7,14,0,0,8474,8475,7,6,
+        0,0,8475,8476,7,7,0,0,8476,8477,7,4,0,0,8477,690,1,0,0,0,8478,8479,
+        7,8,0,0,8479,8480,7,12,0,0,8480,8481,7,5,0,0,8481,8482,7,4,0,0,8482,
+        8483,7,2,0,0,8483,8484,7,14,0,0,8484,8485,7,9,0,0,8485,8486,7,0,
+        0,0,8486,8487,7,4,0,0,8487,8488,7,12,0,0,8488,8489,7,14,0,0,8489,
+        692,1,0,0,0,8490,8491,7,8,0,0,8491,8492,7,13,0,0,8492,694,1,0,0,
+        0,8493,8494,7,8,0,0,8494,8495,7,18,0,0,8495,8496,7,8,0,0,8496,8497,
+        7,11,0,0,8497,8498,7,6,0,0,8498,696,1,0,0,0,8499,8500,7,9,0,0,8500,
+        8501,7,0,0,0,8501,8502,7,7,0,0,8502,8503,7,17,0,0,8503,8504,7,11,
+        0,0,8504,8505,7,10,0,0,8505,8506,7,7,0,0,8506,8507,7,17,0,0,8507,
+        698,1,0,0,0,8508,8509,7,9,0,0,8509,8510,7,0,0,0,8510,8511,7,4,0,
+        0,8511,8512,7,0,0,0,8512,8513,7,1,0,0,8513,8514,7,0,0,0,8514,8515,
+        7,5,0,0,8515,8516,7,6,0,0,8516,700,1,0,0,0,8517,8518,7,9,0,0,8518,
+        8519,7,0,0,0,8519,8520,7,4,0,0,8520,8521,7,0,0,0,8521,702,1,0,0,
+        0,8522,8523,7,9,0,0,8523,8524,7,0,0,0,8524,8525,7,4,0,0,8525,8526,
+        7,0,0,0,8526,8527,7,16,0,0,8527,8528,7,10,0,0,8528,8529,7,11,0,0,
+        8529,8530,7,6,0,0,8530,704,1,0,0,0,8531,8532,7,9,0,0,8532,8533,7,
+        0,0,0,8533,8534,7,4,0,0,8534,8535,7,0,0,0,8535,8536,7,16,0,0,8536,
+        8537,7,10,0,0,8537,8538,7,11,0,0,8538,8539,7,6,0,0,8539,8540,7,5,
+        0,0,8540,706,1,0,0,0,8541,8542,7,9,0,0,8542,8543,7,0,0,0,8543,8544,
+        7,4,0,0,8544,8545,7,0,0,0,8545,8546,7,17,0,0,8546,8547,7,12,0,0,
+        8547,8548,7,0,0,0,8548,8549,7,3,0,0,8549,8550,7,9,0,0,8550,8551,
+        7,8,0,0,8551,8552,7,2,0,0,8552,8553,7,7,0,0,8553,8554,7,16,0,0,8554,
+        8555,7,10,0,0,8555,8556,7,17,0,0,8556,708,1,0,0,0,8557,8558,7,9,
+        0,0,8558,8559,7,0,0,0,8559,8560,7,4,0,0,8560,8561,7,0,0,0,8561,8562,
+        7,14,0,0,8562,8563,7,2,0,0,8563,8564,7,13,0,0,8564,8565,7,6,0,0,
+        8565,8566,7,14,0,0,8566,8567,7,6,0,0,8567,8568,7,7,0,0,8568,8569,
+        7,4,0,0,8569,710,1,0,0,0,8570,8571,7,9,0,0,8571,8572,7,0,0,0,8572,
+        8573,7,4,0,0,8573,8574,7,0,0,0,8574,8575,7,2,0,0,8575,8576,7,1,0,
+        0,8576,8577,7,20,0,0,8577,8578,7,7,0,0,8578,8579,7,2,0,0,8579,712,
+        1,0,0,0,8580,8581,7,9,0,0,8581,8582,7,0,0,0,8582,8583,7,4,0,0,8583,
+        8584,7,0,0,0,8584,8585,7,2,0,0,8585,8586,7,1,0,0,8586,8587,7,20,
+        0,0,8587,8588,5,95,0,0,8588,8589,7,4,0,0,8589,8590,7,2,0,0,8590,
+        8591,5,95,0,0,8591,8592,7,14,0,0,8592,8593,7,0,0,0,8593,8594,7,4,
+        0,0,8594,8595,5,95,0,0,8595,8596,7,15,0,0,8596,8597,7,0,0,0,8597,
+        8598,7,3,0,0,8598,8599,7,4,0,0,8599,8600,7,10,0,0,8600,8601,7,4,
+        0,0,8601,8602,7,10,0,0,8602,8603,7,2,0,0,8603,8604,7,7,0,0,8604,
+        714,1,0,0,0,8605,8606,7,9,0,0,8606,8607,7,0,0,0,8607,8608,7,4,0,
+        0,8608,8609,7,0,0,0,8609,8610,7,2,0,0,8610,8611,7,1,0,0,8611,8612,
+        7,20,0,0,8612,8613,5,95,0,0,8613,8614,7,4,0,0,8614,8615,7,2,0,0,
+        8615,8616,5,95,0,0,8616,8617,7,15,0,0,8617,8618,7,0,0,0,8618,8619,
+        7,3,0,0,8619,8620,7,4,0,0,8620,8621,7,10,0,0,8621,8622,7,4,0,0,8622,
+        8623,7,10,0,0,8623,8624,7,2,0,0,8624,8625,7,7,0,0,8625,716,1,0,0,
+        0,8626,8627,7,9,0,0,8627,8628,7,0,0,0,8628,8629,7,4,0,0,8629,8630,
+        7,0,0,0,8630,8631,7,15,0,0,8631,8632,7,12,0,0,8632,8633,7,14,0,0,
+        8633,8634,7,15,0,0,8634,718,1,0,0,0,8635,8636,7,9,0,0,8636,8637,
+        7,0,0,0,8637,8638,7,4,0,0,8638,8639,7,0,0,0,8639,8640,5,95,0,0,8640,
+        8641,7,5,0,0,8641,8642,7,6,0,0,8642,8643,7,8,0,0,8643,8644,7,12,
+        0,0,8644,8645,7,3,0,0,8645,8646,7,10,0,0,8646,8647,7,4,0,0,8647,
+        8648,7,18,0,0,8648,8649,5,95,0,0,8649,8650,7,3,0,0,8650,8651,7,6,
+        0,0,8651,8652,7,22,0,0,8652,8653,7,3,0,0,8653,8654,7,10,0,0,8654,
+        8655,7,4,0,0,8655,8656,7,6,0,0,8656,8657,5,95,0,0,8657,8658,7,11,
+        0,0,8658,8659,7,10,0,0,8659,8660,7,14,0,0,8660,8661,7,10,0,0,8661,
+        8662,7,4,0,0,8662,720,1,0,0,0,8663,8664,7,9,0,0,8664,8665,7,0,0,
+        0,8665,8666,7,4,0,0,8666,8667,7,6,0,0,8667,722,1,0,0,0,8668,8669,
+        7,9,0,0,8669,8670,7,0,0,0,8670,8671,7,4,0,0,8671,8672,7,6,0,0,8672,
+        8673,5,95,0,0,8673,8674,7,8,0,0,8674,8675,7,0,0,0,8675,8676,7,8,
+        0,0,8676,8677,7,19,0,0,8677,8678,7,6,0,0,8678,724,1,0,0,0,8679,8680,
+        7,9,0,0,8680,8681,7,0,0,0,8681,8682,7,4,0,0,8682,8683,7,6,0,0,8683,
+        8684,5,95,0,0,8684,8685,7,16,0,0,8685,8686,7,2,0,0,8686,8687,7,3,
+        0,0,8687,8688,7,14,0,0,8688,8689,7,0,0,0,8689,8690,7,4,0,0,8690,
+        726,1,0,0,0,8691,8692,7,9,0,0,8692,8693,7,0,0,0,8693,8694,7,4,0,
+        0,8694,8695,7,6,0,0,8695,8696,5,95,0,0,8696,8697,7,14,0,0,8697,8698,
+        7,2,0,0,8698,8699,7,9,0,0,8699,8700,7,6,0,0,8700,728,1,0,0,0,8701,
+        8702,7,9,0,0,8702,8703,7,0,0,0,8703,8704,7,18,0,0,8704,730,1,0,0,
+        0,8705,8706,7,9,0,0,8706,8707,7,0,0,0,8707,8708,7,18,0,0,8708,8709,
+        7,5,0,0,8709,732,1,0,0,0,8710,8711,7,9,0,0,8711,8712,7,0,0,0,8712,
+        8713,7,18,0,0,8713,8714,5,95,0,0,8714,8715,7,4,0,0,8715,8716,7,2,
+        0,0,8716,8717,5,95,0,0,8717,8718,7,5,0,0,8718,8719,7,6,0,0,8719,
+        8720,7,8,0,0,8720,8721,7,2,0,0,8721,8722,7,7,0,0,8722,8723,7,9,0,
+        0,8723,734,1,0,0,0,8724,8725,7,9,0,0,8725,8726,7,1,0,0,8726,8727,
+        7,0,0,0,8727,736,1,0,0,0,8728,8729,7,9,0,0,8729,8730,7,1,0,0,8730,
+        8731,7,0,0,0,8731,8732,5,95,0,0,8732,8733,7,3,0,0,8733,8734,7,6,
+        0,0,8734,8735,7,8,0,0,8735,8736,7,18,0,0,8736,8737,7,8,0,0,8737,
+        8738,7,11,0,0,8738,8739,7,6,0,0,8739,8740,7,1,0,0,8740,8741,7,10,
+        0,0,8741,8742,7,7,0,0,8742,738,1,0,0,0,8743,8744,7,9,0,0,8744,8745,
+        7,1,0,0,8745,8746,7,11,0,0,8746,8747,7,10,0,0,8747,8748,7,7,0,0,
+        8748,8749,7,21,0,0,8749,740,1,0,0,0,8750,8751,7,9,0,0,8751,8752,
+        7,1,0,0,8752,8753,7,14,0,0,8753,8754,7,5,0,0,8754,8755,5,95,0,0,
+        8755,8756,7,5,0,0,8756,8757,7,4,0,0,8757,8758,7,0,0,0,8758,8759,
+        7,4,0,0,8759,8760,7,5,0,0,8760,742,1,0,0,0,8761,8762,7,9,0,0,8762,
+        8763,7,1,0,0,8763,8764,5,95,0,0,8764,8765,7,3,0,0,8765,8766,7,2,
+        0,0,8766,8767,7,11,0,0,8767,8768,7,6,0,0,8768,8769,5,95,0,0,8769,
+        8770,7,8,0,0,8770,8771,7,19,0,0,8771,8772,7,0,0,0,8772,8773,7,7,
+        0,0,8773,8774,7,17,0,0,8774,8775,7,6,0,0,8775,744,1,0,0,0,8776,8777,
+        7,9,0,0,8777,8778,7,1,0,0,8778,8779,7,4,0,0,8779,8780,7,10,0,0,8780,
+        8781,7,14,0,0,8781,8782,7,6,0,0,8782,8783,7,23,0,0,8783,8784,7,2,
+        0,0,8784,8785,7,7,0,0,8785,8786,7,6,0,0,8786,746,1,0,0,0,8787,8788,
+        7,9,0,0,8788,8789,7,1,0,0,8789,8790,5,95,0,0,8790,8791,7,12,0,0,
+        8791,8792,7,7,0,0,8792,8793,7,10,0,0,8793,8794,7,24,0,0,8794,8795,
+        7,12,0,0,8795,8796,7,6,0,0,8796,8797,5,95,0,0,8797,8798,7,7,0,0,
+        8798,8799,7,0,0,0,8799,8800,7,14,0,0,8800,8801,7,6,0,0,8801,748,
+        1,0,0,0,8802,8803,7,9,0,0,8803,8804,7,1,0,0,8804,8805,5,95,0,0,8805,
+        8806,7,13,0,0,8806,8807,7,6,0,0,8807,8808,7,3,0,0,8808,8809,7,5,
+        0,0,8809,8810,7,10,0,0,8810,8811,7,2,0,0,8811,8812,7,7,0,0,8812,
+        750,1,0,0,0,8813,8814,7,9,0,0,8814,8815,7,9,0,0,8815,8816,7,11,0,
+        0,8816,752,1,0,0,0,8817,8818,7,9,0,0,8818,8819,7,6,0,0,8819,8820,
+        7,0,0,0,8820,8821,7,11,0,0,8821,8822,7,11,0,0,8822,8823,7,2,0,0,
+        8823,8824,7,8,0,0,8824,8825,7,0,0,0,8825,8826,7,4,0,0,8826,8827,
+        7,6,0,0,8827,754,1,0,0,0,8828,8829,7,9,0,0,8829,8830,7,6,0,0,8830,
+        8831,7,1,0,0,8831,8832,7,12,0,0,8832,8833,7,17,0,0,8833,756,1,0,
+        0,0,8834,8835,7,9,0,0,8835,8836,7,6,0,0,8836,8837,7,1,0,0,8837,8838,
+        7,12,0,0,8838,8839,7,17,0,0,8839,8840,7,17,0,0,8840,8841,7,6,0,0,
+        8841,8842,7,3,0,0,8842,758,1,0,0,0,8843,8844,7,9,0,0,8844,8845,7,
+        6,0,0,8845,8846,7,8,0,0,8846,760,1,0,0,0,8847,8848,7,9,0,0,8848,
+        8849,7,6,0,0,8849,8850,7,8,0,0,8850,8851,7,10,0,0,8851,8852,7,14,
+        0,0,8852,8853,7,0,0,0,8853,8854,7,11,0,0,8854,762,1,0,0,0,8855,8856,
+        7,9,0,0,8856,8857,7,6,0,0,8857,8858,7,8,0,0,8858,8859,7,11,0,0,8859,
+        8860,7,0,0,0,8860,8861,7,3,0,0,8861,8862,7,6,0,0,8862,764,1,0,0,
+        0,8863,8864,7,9,0,0,8864,8865,7,6,0,0,8865,8866,7,8,0,0,8866,8867,
+        7,2,0,0,8867,8868,7,14,0,0,8868,8869,7,15,0,0,8869,8870,7,2,0,0,
+        8870,8871,7,5,0,0,8871,8872,7,6,0,0,8872,766,1,0,0,0,8873,8874,7,
+        9,0,0,8874,8875,7,6,0,0,8875,8876,7,8,0,0,8876,8877,7,2,0,0,8877,
+        8878,7,3,0,0,8878,8879,7,3,0,0,8879,8880,7,6,0,0,8880,8881,7,11,
+        0,0,8881,8882,7,0,0,0,8882,8883,7,4,0,0,8883,8884,7,6,0,0,8884,768,
+        1,0,0,0,8885,8886,7,9,0,0,8886,8887,7,6,0,0,8887,8888,7,8,0,0,8888,
+        8889,7,3,0,0,8889,770,1,0,0,0,8890,8891,7,9,0,0,8891,8892,7,6,0,
+        0,8892,8893,7,8,0,0,8893,8894,7,3,0,0,8894,8895,7,6,0,0,8895,8896,
+        7,14,0,0,8896,8897,7,6,0,0,8897,8898,7,7,0,0,8898,8899,7,4,0,0,8899,
+        772,1,0,0,0,8900,8901,7,9,0,0,8901,8902,7,6,0,0,8902,8903,7,8,0,
+        0,8903,8904,7,3,0,0,8904,8905,7,18,0,0,8905,8906,7,15,0,0,8906,8907,
+        7,4,0,0,8907,774,1,0,0,0,8908,8909,7,9,0,0,8909,8910,7,6,0,0,8910,
+        8911,7,9,0,0,8911,8912,7,12,0,0,8912,8913,7,15,0,0,8913,8914,7,11,
+        0,0,8914,8915,7,10,0,0,8915,8916,7,8,0,0,8916,8917,7,0,0,0,8917,
+        8918,7,4,0,0,8918,8919,7,6,0,0,8919,776,1,0,0,0,8920,8921,7,9,0,
+        0,8921,8922,7,6,0,0,8922,8923,7,16,0,0,8923,8924,7,0,0,0,8924,8925,
+        7,12,0,0,8925,8926,7,11,0,0,8926,8927,7,4,0,0,8927,778,1,0,0,0,8928,
+        8929,7,9,0,0,8929,8930,7,6,0,0,8930,8931,7,16,0,0,8931,8932,7,0,
+        0,0,8932,8933,7,12,0,0,8933,8934,7,11,0,0,8934,8935,7,4,0,0,8935,
+        8936,7,10,0,0,8936,8937,7,16,0,0,8937,780,1,0,0,0,8938,8939,7,9,
+        0,0,8939,8940,7,6,0,0,8940,8941,7,16,0,0,8941,8942,7,0,0,0,8942,
+        8943,7,12,0,0,8943,8944,7,11,0,0,8944,8945,7,4,0,0,8945,8946,7,5,
+        0,0,8946,782,1,0,0,0,8947,8948,7,9,0,0,8948,8949,7,6,0,0,8949,8950,
+        7,16,0,0,8950,8951,7,0,0,0,8951,8952,7,12,0,0,8952,8953,7,11,0,0,
+        8953,8954,7,4,0,0,8954,8955,5,95,0,0,8955,8956,7,8,0,0,8956,8957,
+        7,2,0,0,8957,8958,7,11,0,0,8958,8959,7,11,0,0,8959,8960,7,0,0,0,
+        8960,8961,7,4,0,0,8961,8962,7,10,0,0,8962,8963,7,2,0,0,8963,8964,
+        7,7,0,0,8964,784,1,0,0,0,8965,8966,7,9,0,0,8966,8967,7,6,0,0,8967,
+        8968,7,16,0,0,8968,8969,7,0,0,0,8969,8970,7,12,0,0,8970,8971,7,11,
+        0,0,8971,8972,7,4,0,0,8972,8973,5,95,0,0,8973,8974,7,8,0,0,8974,
+        8975,7,3,0,0,8975,8976,7,6,0,0,8976,8977,7,9,0,0,8977,8978,7,6,0,
+        0,8978,8979,7,7,0,0,8979,8980,7,4,0,0,8980,8981,7,10,0,0,8981,8982,
+        7,0,0,0,8982,8983,7,11,0,0,8983,786,1,0,0,0,8984,8985,7,9,0,0,8985,
+        8986,7,6,0,0,8986,8987,7,16,0,0,8987,8988,7,6,0,0,8988,8989,7,3,
+        0,0,8989,8990,7,3,0,0,8990,8991,7,0,0,0,8991,8992,7,1,0,0,8992,8993,
+        7,11,0,0,8993,8994,7,6,0,0,8994,788,1,0,0,0,8995,8996,7,9,0,0,8996,
+        8997,7,6,0,0,8997,8998,7,16,0,0,8998,8999,7,6,0,0,8999,9000,7,3,
+        0,0,9000,9001,7,3,0,0,9001,9002,7,6,0,0,9002,9003,7,9,0,0,9003,790,
+        1,0,0,0,9004,9005,7,9,0,0,9005,9006,7,6,0,0,9006,9007,7,16,0,0,9007,
+        9008,7,10,0,0,9008,9009,7,7,0,0,9009,9010,7,6,0,0,9010,9011,7,9,
+        0,0,9011,792,1,0,0,0,9012,9013,7,9,0,0,9013,9014,7,6,0,0,9014,9015,
+        7,16,0,0,9015,9016,7,10,0,0,9016,9017,7,7,0,0,9017,9018,7,6,0,0,
+        9018,794,1,0,0,0,9019,9020,7,9,0,0,9020,9021,7,6,0,0,9021,9022,7,
+        16,0,0,9022,9023,7,10,0,0,9023,9024,7,7,0,0,9024,9025,7,6,0,0,9025,
+        9026,7,3,0,0,9026,796,1,0,0,0,9027,9028,7,9,0,0,9028,9029,7,6,0,
+        0,9029,9030,7,17,0,0,9030,9031,7,3,0,0,9031,9032,7,6,0,0,9032,9033,
+        7,6,0,0,9033,798,1,0,0,0,9034,9035,7,9,0,0,9035,9036,7,6,0,0,9036,
+        9037,7,11,0,0,9037,9038,7,0,0,0,9038,9039,7,18,0,0,9039,800,1,0,
+        0,0,9040,9041,7,9,0,0,9041,9042,7,6,0,0,9042,9043,7,11,0,0,9043,
+        9044,7,6,0,0,9044,9045,7,17,0,0,9045,9046,7,0,0,0,9046,9047,7,4,
+        0,0,9047,9048,7,6,0,0,9048,802,1,0,0,0,9049,9050,7,9,0,0,9050,9051,
+        7,6,0,0,9051,9052,7,11,0,0,9052,9053,7,6,0,0,9053,9054,7,4,0,0,9054,
+        9055,7,6,0,0,9055,9056,5,95,0,0,9056,9057,7,0,0,0,9057,9058,7,11,
+        0,0,9058,9059,7,11,0,0,9059,804,1,0,0,0,9060,9061,7,9,0,0,9061,9062,
+        7,6,0,0,9062,9063,7,11,0,0,9063,9064,7,6,0,0,9064,9065,7,4,0,0,9065,
+        9066,7,6,0,0,9066,806,1,0,0,0,9067,9068,7,9,0,0,9068,9069,7,6,0,
+        0,9069,9070,7,11,0,0,9070,9071,7,6,0,0,9071,9072,7,4,0,0,9072,9073,
+        7,6,0,0,9073,9074,7,25,0,0,9074,9075,7,14,0,0,9075,9076,7,11,0,0,
+        9076,808,1,0,0,0,9077,9078,7,9,0,0,9078,9079,7,6,0,0,9079,9080,7,
+        11,0,0,9080,9081,7,10,0,0,9081,9082,7,14,0,0,9082,9083,7,10,0,0,
+        9083,9084,7,4,0,0,9084,9085,7,6,0,0,9085,9086,7,9,0,0,9086,810,1,
+        0,0,0,9087,9088,7,9,0,0,9088,9089,7,6,0,0,9089,9090,7,14,0,0,9090,
+        9091,7,0,0,0,9091,9092,7,7,0,0,9092,9093,7,9,0,0,9093,812,1,0,0,
+        0,9094,9095,7,9,0,0,9095,9096,7,6,0,0,9096,9097,7,7,0,0,9097,9098,
+        7,5,0,0,9098,9099,7,6,0,0,9099,9100,5,95,0,0,9100,9101,7,3,0,0,9101,
+        9102,7,0,0,0,9102,9103,7,7,0,0,9103,9104,7,21,0,0,9104,9105,7,14,
+        0,0,9105,814,1,0,0,0,9106,9107,7,9,0,0,9107,9108,7,6,0,0,9108,9109,
+        7,15,0,0,9109,9110,7,6,0,0,9110,9111,7,7,0,0,9111,9112,7,9,0,0,9112,
+        9113,7,6,0,0,9113,9114,7,7,0,0,9114,9115,7,4,0,0,9115,816,1,0,0,
+        0,9116,9117,7,9,0,0,9117,9118,7,6,0,0,9118,9119,7,15,0,0,9119,9120,
+        7,3,0,0,9120,9121,7,6,0,0,9121,9122,7,8,0,0,9122,9123,7,0,0,0,9123,
+        9124,7,4,0,0,9124,9125,7,6,0,0,9125,818,1,0,0,0,9126,9127,7,9,0,
+        0,9127,9128,7,6,0,0,9128,9129,7,15,0,0,9129,9130,7,4,0,0,9130,9131,
+        7,19,0,0,9131,820,1,0,0,0,9132,9133,7,9,0,0,9133,9134,7,6,0,0,9134,
+        9135,7,24,0,0,9135,9136,7,12,0,0,9136,9137,7,6,0,0,9137,9138,7,12,
+        0,0,9138,9139,7,6,0,0,9139,822,1,0,0,0,9140,9141,7,9,0,0,9141,9142,
+        7,6,0,0,9142,9143,7,3,0,0,9143,9144,7,6,0,0,9144,9145,7,16,0,0,9145,
+        824,1,0,0,0,9146,9147,7,9,0,0,9147,9148,7,6,0,0,9148,9149,7,3,0,
+        0,9149,9150,7,6,0,0,9150,9151,7,16,0,0,9151,9152,5,95,0,0,9152,9153,
+        7,7,0,0,9153,9154,7,2,0,0,9154,9155,5,95,0,0,9155,9156,7,3,0,0,9156,
+        9157,7,6,0,0,9157,9158,7,22,0,0,9158,9159,7,3,0,0,9159,9160,7,10,
+        0,0,9160,9161,7,4,0,0,9161,9162,7,6,0,0,9162,826,1,0,0,0,9163,9164,
+        7,9,0,0,9164,9165,7,6,0,0,9165,9166,7,5,0,0,9166,9167,7,8,0,0,9167,
+        828,1,0,0,0,9168,9169,7,9,0,0,9169,9170,7,6,0,0,9170,9171,7,5,0,
+        0,9171,9172,7,8,0,0,9172,9173,7,3,0,0,9173,9174,7,10,0,0,9174,9175,
+        7,15,0,0,9175,9176,7,4,0,0,9176,9177,7,10,0,0,9177,9178,7,2,0,0,
+        9178,9179,7,7,0,0,9179,830,1,0,0,0,9180,9181,7,9,0,0,9181,9182,7,
+        6,0,0,9182,9183,7,5,0,0,9183,9184,7,4,0,0,9184,9185,7,3,0,0,9185,
+        9186,7,2,0,0,9186,9187,7,18,0,0,9187,832,1,0,0,0,9188,9189,7,9,0,
+        0,9189,9190,7,6,0,0,9190,9191,7,4,0,0,9191,9192,7,0,0,0,9192,9193,
+        7,8,0,0,9193,9194,7,19,0,0,9194,9195,7,6,0,0,9195,9196,7,9,0,0,9196,
+        834,1,0,0,0,9197,9198,7,9,0,0,9198,9199,7,6,0,0,9199,9200,7,4,0,
+        0,9200,9201,7,6,0,0,9201,9202,7,8,0,0,9202,9203,7,4,0,0,9203,9204,
+        7,6,0,0,9204,9205,7,9,0,0,9205,836,1,0,0,0,9206,9207,7,9,0,0,9207,
+        9208,7,6,0,0,9208,9209,7,4,0,0,9209,9210,7,6,0,0,9210,9211,7,3,0,
+        0,9211,9212,7,14,0,0,9212,9213,7,10,0,0,9213,9214,7,7,0,0,9214,9215,
+        7,6,0,0,9215,9216,7,5,0,0,9216,838,1,0,0,0,9217,9218,7,9,0,0,9218,
+        9219,7,6,0,0,9219,9220,7,4,0,0,9220,9221,7,6,0,0,9221,9222,7,3,0,
+        0,9222,9223,7,14,0,0,9223,9224,7,10,0,0,9224,9225,7,7,0,0,9225,9226,
+        7,10,0,0,9226,9227,7,5,0,0,9227,9228,7,4,0,0,9228,9229,7,10,0,0,
+        9229,9230,7,8,0,0,9230,840,1,0,0,0,9231,9232,7,9,0,0,9232,9233,7,
+        10,0,0,9233,9234,7,8,0,0,9234,9235,7,4,0,0,9235,9236,7,10,0,0,9236,
+        9237,7,2,0,0,9237,9238,7,7,0,0,9238,9239,7,0,0,0,9239,9240,7,3,0,
+        0,9240,9241,7,18,0,0,9241,842,1,0,0,0,9242,9243,7,9,0,0,9243,9244,
+        7,10,0,0,9244,9245,7,14,0,0,9245,9246,7,6,0,0,9246,9247,7,7,0,0,
+        9247,9248,7,5,0,0,9248,9249,7,10,0,0,9249,9250,7,2,0,0,9250,9251,
+        7,7,0,0,9251,844,1,0,0,0,9252,9253,7,9,0,0,9253,9254,7,10,0,0,9254,
+        9255,7,14,0,0,9255,9256,7,6,0,0,9256,9257,7,7,0,0,9257,9258,7,5,
+        0,0,9258,9259,7,10,0,0,9259,9260,7,2,0,0,9260,9261,7,7,0,0,9261,
+        9262,7,5,0,0,9262,846,1,0,0,0,9263,9264,7,9,0,0,9264,9265,7,10,0,
+        0,9265,9266,7,3,0,0,9266,9267,7,6,0,0,9267,9268,7,8,0,0,9268,9269,
+        7,4,0,0,9269,9270,7,10,0,0,9270,9271,7,2,0,0,9271,848,1,0,0,0,9272,
+        9273,7,9,0,0,9273,9274,7,10,0,0,9274,9275,7,3,0,0,9275,9276,7,6,
+        0,0,9276,9277,7,8,0,0,9277,9278,7,4,0,0,9278,9279,5,95,0,0,9279,
+        9280,7,11,0,0,9280,9281,7,2,0,0,9281,9282,7,0,0,0,9282,9283,7,9,
+        0,0,9283,850,1,0,0,0,9284,9285,7,9,0,0,9285,9286,7,10,0,0,9286,9287,
+        7,3,0,0,9287,9288,7,6,0,0,9288,9289,7,8,0,0,9289,9290,7,4,0,0,9290,
+        9291,7,2,0,0,9291,9292,7,3,0,0,9292,9293,7,18,0,0,9293,852,1,0,0,
+        0,9294,9295,7,9,0,0,9295,9296,7,10,0,0,9296,9297,7,3,0,0,9297,9298,
+        7,6,0,0,9298,9299,7,8,0,0,9299,9300,7,4,0,0,9300,9301,5,95,0,0,9301,
+        9302,7,15,0,0,9302,9303,7,0,0,0,9303,9304,7,4,0,0,9304,9305,7,19,
+        0,0,9305,854,1,0,0,0,9306,9307,7,9,0,0,9307,9308,7,10,0,0,9308,9309,
+        7,5,0,0,9309,9310,7,0,0,0,9310,9311,7,1,0,0,9311,9312,7,11,0,0,9312,
+        9313,7,6,0,0,9313,9314,5,95,0,0,9314,9315,7,0,0,0,9315,9316,7,11,
+        0,0,9316,9317,7,11,0,0,9317,856,1,0,0,0,9318,9319,7,9,0,0,9319,9320,
+        7,10,0,0,9320,9321,7,5,0,0,9321,9322,7,0,0,0,9322,9323,7,1,0,0,9323,
+        9324,7,11,0,0,9324,9325,7,6,0,0,9325,858,1,0,0,0,9326,9327,7,9,0,
+        0,9327,9328,7,10,0,0,9328,9329,7,5,0,0,9329,9330,7,0,0,0,9330,9331,
+        7,1,0,0,9331,9332,7,11,0,0,9332,9333,7,6,0,0,9333,9334,7,9,0,0,9334,
+        860,1,0,0,0,9335,9336,7,9,0,0,9336,9337,7,10,0,0,9337,9338,7,5,0,
+        0,9338,9339,7,0,0,0,9339,9340,7,1,0,0,9340,9341,7,11,0,0,9341,9342,
+        7,6,0,0,9342,9343,5,95,0,0,9343,9344,7,9,0,0,9344,9345,7,10,0,0,
+        9345,9346,7,3,0,0,9346,9347,7,6,0,0,9347,9348,7,8,0,0,9348,9349,
+        7,4,0,0,9349,9350,7,2,0,0,9350,9351,7,3,0,0,9351,9352,7,18,0,0,9352,
+        9353,5,95,0,0,9353,9354,7,11,0,0,9354,9355,7,10,0,0,9355,9356,7,
+        7,0,0,9356,9357,7,21,0,0,9357,9358,5,95,0,0,9358,9359,7,8,0,0,9359,
+        9360,7,19,0,0,9360,9361,7,6,0,0,9361,9362,7,8,0,0,9362,9363,7,21,
+        0,0,9363,862,1,0,0,0,9364,9365,7,9,0,0,9365,9366,7,10,0,0,9366,9367,
+        7,5,0,0,9367,9368,7,0,0,0,9368,9369,7,1,0,0,9369,9370,7,11,0,0,9370,
+        9371,7,6,0,0,9371,9372,5,95,0,0,9372,9373,7,15,0,0,9373,9374,7,0,
+        0,0,9374,9375,7,3,0,0,9375,9376,7,0,0,0,9376,9377,7,11,0,0,9377,
+        9378,7,11,0,0,9378,9379,7,6,0,0,9379,9380,7,11,0,0,9380,9381,5,95,
+        0,0,9381,9382,7,9,0,0,9382,9383,7,14,0,0,9383,9384,7,11,0,0,9384,
+        864,1,0,0,0,9385,9386,7,9,0,0,9386,9387,7,10,0,0,9387,9388,7,5,0,
+        0,9388,9389,7,0,0,0,9389,9390,7,1,0,0,9390,9391,7,11,0,0,9391,9392,
+        7,6,0,0,9392,9393,5,95,0,0,9393,9394,7,15,0,0,9394,9395,7,3,0,0,
+        9395,9396,7,6,0,0,9396,9397,7,5,0,0,9397,9398,7,6,0,0,9398,9399,
+        7,4,0,0,9399,866,1,0,0,0,9400,9401,7,9,0,0,9401,9402,7,10,0,0,9402,
+        9403,7,5,0,0,9403,9404,7,0,0,0,9404,9405,7,1,0,0,9405,9406,7,11,
+        0,0,9406,9407,7,6,0,0,9407,9408,5,95,0,0,9408,9409,7,3,0,0,9409,
+        9410,7,15,0,0,9410,9411,7,21,0,0,9411,9412,7,6,0,0,9412,868,1,0,
+        0,0,9413,9414,7,9,0,0,9414,9415,7,10,0,0,9415,9416,7,5,0,0,9416,
+        9417,7,0,0,0,9417,9418,7,11,0,0,9418,9419,7,11,0,0,9419,9420,7,2,
+        0,0,9420,9421,7,22,0,0,9421,870,1,0,0,0,9422,9423,7,9,0,0,9423,9424,
+        7,10,0,0,9424,9425,7,5,0,0,9425,9426,7,0,0,0,9426,9427,7,5,0,0,9427,
+        9428,7,5,0,0,9428,9429,7,2,0,0,9429,9430,7,8,0,0,9430,9431,7,10,
+        0,0,9431,9432,7,0,0,0,9432,9433,7,4,0,0,9433,9434,7,6,0,0,9434,872,
+        1,0,0,0,9435,9436,7,9,0,0,9436,9437,7,10,0,0,9437,9438,7,5,0,0,9438,
+        9439,7,8,0,0,9439,9440,7,0,0,0,9440,9441,7,3,0,0,9441,9442,7,9,0,
+        0,9442,874,1,0,0,0,9443,9444,7,9,0,0,9444,9445,7,10,0,0,9445,9446,
+        7,5,0,0,9446,9447,7,8,0,0,9447,9448,7,0,0,0,9448,9449,7,3,0,0,9449,
+        9450,7,9,0,0,9450,9451,7,16,0,0,9451,9452,7,10,0,0,9452,9453,7,11,
+        0,0,9453,9454,7,6,0,0,9454,876,1,0,0,0,9455,9456,7,9,0,0,9456,9457,
+        7,10,0,0,9457,9458,7,5,0,0,9458,9459,7,8,0,0,9459,9460,7,2,0,0,9460,
+        9461,7,7,0,0,9461,9462,7,7,0,0,9462,9463,7,6,0,0,9463,9464,7,8,0,
+        0,9464,9465,7,4,0,0,9465,878,1,0,0,0,9466,9467,7,9,0,0,9467,9468,
+        7,10,0,0,9468,9469,7,5,0,0,9469,9470,7,21,0,0,9470,880,1,0,0,0,9471,
+        9472,7,9,0,0,9472,9473,7,10,0,0,9473,9474,7,5,0,0,9474,9475,7,21,
+        0,0,9475,9476,7,17,0,0,9476,9477,7,3,0,0,9477,9478,7,2,0,0,9478,
+        9479,7,12,0,0,9479,9480,7,15,0,0,9480,882,1,0,0,0,9481,9482,5,39,
+        0,0,9482,9483,5,43,0,0,9483,9484,5,32,0,0,9484,9485,7,9,0,0,9485,
+        9486,7,10,0,0,9486,9487,7,5,0,0,9487,9488,7,21,0,0,9488,9489,7,17,
+        0,0,9489,9490,7,3,0,0,9490,9491,7,2,0,0,9491,9492,7,12,0,0,9492,
+        9493,7,15,0,0,9493,884,1,0,0,0,9494,9495,7,9,0,0,9495,9496,7,10,
+        0,0,9496,9497,7,5,0,0,9497,9498,7,21,0,0,9498,9499,7,5,0,0,9499,
+        886,1,0,0,0,9500,9501,7,9,0,0,9501,9502,7,10,0,0,9502,9503,7,5,0,
+        0,9503,9504,7,14,0,0,9504,9505,7,2,0,0,9505,9506,7,12,0,0,9506,9507,
+        7,7,0,0,9507,9508,7,4,0,0,9508,888,1,0,0,0,9509,9510,7,9,0,0,9510,
+        9511,7,10,0,0,9511,9512,7,5,0,0,9512,9513,7,4,0,0,9513,9514,7,10,
+        0,0,9514,9515,7,7,0,0,9515,9516,7,8,0,0,9516,9517,7,4,0,0,9517,890,
+        1,0,0,0,9518,9519,7,9,0,0,9519,9520,7,10,0,0,9520,9521,7,5,0,0,9521,
+        9522,7,4,0,0,9522,9523,7,10,0,0,9523,9524,7,7,0,0,9524,9525,7,17,
+        0,0,9525,9526,7,12,0,0,9526,9527,7,10,0,0,9527,9528,7,5,0,0,9528,
+        9529,7,19,0,0,9529,9530,7,6,0,0,9530,9531,7,9,0,0,9531,892,1,0,0,
+        0,9532,9533,7,9,0,0,9533,9534,7,10,0,0,9534,9535,7,5,0,0,9535,9536,
+        7,4,0,0,9536,9537,7,3,0,0,9537,9538,7,10,0,0,9538,9539,7,1,0,0,9539,
+        9540,7,12,0,0,9540,9541,7,4,0,0,9541,9542,7,6,0,0,9542,9543,7,9,
+        0,0,9543,894,1,0,0,0,9544,9545,7,9,0,0,9545,9546,7,10,0,0,9546,9547,
+        7,5,0,0,9547,9548,7,4,0,0,9548,9549,7,3,0,0,9549,9550,7,10,0,0,9550,
+        9551,7,1,0,0,9551,9552,7,12,0,0,9552,9553,7,4,0,0,9553,9554,7,6,
+        0,0,9554,896,1,0,0,0,9555,9556,7,9,0,0,9556,9557,7,14,0,0,9557,9558,
+        7,11,0,0,9558,898,1,0,0,0,9559,9560,7,9,0,0,9560,9561,7,14,0,0,9561,
+        9562,7,11,0,0,9562,9563,5,95,0,0,9563,9564,7,12,0,0,9564,9565,7,
+        15,0,0,9565,9566,7,9,0,0,9566,9567,7,0,0,0,9567,9568,7,4,0,0,9568,
+        9569,7,6,0,0,9569,900,1,0,0,0,9570,9571,7,9,0,0,9571,9572,7,7,0,
+        0,9572,9573,7,16,0,0,9573,9574,7,5,0,0,9574,9575,5,95,0,0,9575,9576,
+        7,9,0,0,9576,9577,7,10,0,0,9577,9578,7,5,0,0,9578,9579,7,0,0,0,9579,
+        9580,7,1,0,0,9580,9581,7,11,0,0,9581,9582,7,6,0,0,9582,902,1,0,0,
+        0,9583,9584,7,9,0,0,9584,9585,7,7,0,0,9585,9586,7,16,0,0,9586,9587,
+        7,5,0,0,9587,9588,5,95,0,0,9588,9589,7,6,0,0,9589,9590,7,7,0,0,9590,
+        9591,7,0,0,0,9591,9592,7,1,0,0,9592,9593,7,11,0,0,9593,9594,7,6,
+        0,0,9594,904,1,0,0,0,9595,9596,7,9,0,0,9596,9597,7,7,0,0,9597,9598,
+        7,16,0,0,9598,9599,7,5,0,0,9599,9600,5,95,0,0,9600,9601,7,3,0,0,
+        9601,9602,7,6,0,0,9602,9603,7,0,0,0,9603,9604,7,9,0,0,9604,9605,
+        7,1,0,0,9605,9606,7,12,0,0,9606,9607,7,16,0,0,9607,9608,7,16,0,0,
+        9608,9609,7,6,0,0,9609,9610,7,3,0,0,9610,9611,7,5,0,0,9611,906,1,
+        0,0,0,9612,9613,7,9,0,0,9613,9614,7,2,0,0,9614,9615,7,8,0,0,9615,
+        9616,7,16,0,0,9616,9617,7,10,0,0,9617,9618,7,9,0,0,9618,9619,7,6,
+        0,0,9619,9620,7,11,0,0,9620,9621,7,10,0,0,9621,9622,7,4,0,0,9622,
+        9623,7,18,0,0,9623,908,1,0,0,0,9624,9625,7,9,0,0,9625,9626,7,2,0,
+        0,9626,9627,7,8,0,0,9627,9628,7,12,0,0,9628,9629,7,14,0,0,9629,9630,
+        7,6,0,0,9630,9631,7,7,0,0,9631,9632,7,4,0,0,9632,910,1,0,0,0,9633,
+        9634,5,36,0,0,9634,9635,7,6,0,0,9635,9636,7,11,0,0,9636,9637,7,5,
+        0,0,9637,9638,7,6,0,0,9638,912,1,0,0,0,9639,9640,5,36,0,0,9640,9641,
+        7,6,0,0,9641,9642,7,11,0,0,9642,9643,7,5,0,0,9643,9644,7,10,0,0,
+        9644,9645,7,16,0,0,9645,914,1,0,0,0,9646,9647,5,36,0,0,9647,9648,
+        7,6,0,0,9648,9649,7,7,0,0,9649,9650,7,9,0,0,9650,916,1,0,0,0,9651,
+        9652,5,36,0,0,9652,9653,7,6,0,0,9653,9654,7,3,0,0,9654,9655,7,3,
+        0,0,9655,9656,7,2,0,0,9656,9657,7,3,0,0,9657,918,1,0,0,0,9658,9659,
+        5,36,0,0,9659,9660,7,10,0,0,9660,9661,7,16,0,0,9661,920,1,0,0,0,
+        9662,9663,5,36,0,0,9663,9664,7,4,0,0,9664,9665,7,19,0,0,9665,9666,
+        7,6,0,0,9666,9667,7,7,0,0,9667,922,1,0,0,0,9668,9669,7,9,0,0,9669,
+        9670,7,2,0,0,9670,9671,7,14,0,0,9671,9672,7,0,0,0,9672,9673,7,10,
+        0,0,9673,9674,7,7,0,0,9674,9675,5,95,0,0,9675,9676,7,10,0,0,9676,
+        9677,7,7,0,0,9677,9678,7,9,0,0,9678,9679,7,6,0,0,9679,9680,7,25,
+        0,0,9680,9681,5,95,0,0,9681,9682,7,16,0,0,9682,9683,7,10,0,0,9683,
+        9684,7,11,0,0,9684,9685,7,4,0,0,9685,9686,7,6,0,0,9686,9687,7,3,
+        0,0,9687,924,1,0,0,0,9688,9689,7,9,0,0,9689,9690,7,2,0,0,9690,9691,
+        7,14,0,0,9691,9692,7,0,0,0,9692,9693,7,10,0,0,9693,9694,7,7,0,0,
+        9694,9695,5,95,0,0,9695,9696,7,10,0,0,9696,9697,7,7,0,0,9697,9698,
+        7,9,0,0,9698,9699,7,6,0,0,9699,9700,7,25,0,0,9700,9701,5,95,0,0,
+        9701,9702,7,7,0,0,9702,9703,7,2,0,0,9703,9704,5,95,0,0,9704,9705,
+        7,5,0,0,9705,9706,7,2,0,0,9706,9707,7,3,0,0,9707,9708,7,4,0,0,9708,
+        926,1,0,0,0,9709,9710,7,9,0,0,9710,9711,7,2,0,0,9711,9712,7,14,0,
+        0,9712,9713,7,0,0,0,9713,9714,7,10,0,0,9714,9715,7,7,0,0,9715,9716,
+        5,95,0,0,9716,9717,7,10,0,0,9717,9718,7,7,0,0,9718,9719,7,9,0,0,
+        9719,9720,7,6,0,0,9720,9721,7,25,0,0,9721,9722,5,95,0,0,9722,9723,
+        7,5,0,0,9723,9724,7,2,0,0,9724,9725,7,3,0,0,9725,9726,7,4,0,0,9726,
+        928,1,0,0,0,9727,9728,7,9,0,0,9728,9729,7,2,0,0,9729,9730,7,12,0,
+        0,9730,9731,7,1,0,0,9731,9732,7,11,0,0,9732,9733,7,6,0,0,9733,930,
+        1,0,0,0,9734,9735,7,9,0,0,9735,9736,7,2,0,0,9736,9737,7,22,0,0,9737,
+        9738,7,7,0,0,9738,9739,7,17,0,0,9739,9740,7,3,0,0,9740,9741,7,0,
+        0,0,9741,9742,7,9,0,0,9742,9743,7,6,0,0,9743,932,1,0,0,0,9744,9745,
+        7,9,0,0,9745,9746,7,3,0,0,9746,9747,7,10,0,0,9747,9748,7,13,0,0,
+        9748,9749,7,10,0,0,9749,9750,7,7,0,0,9750,9751,7,17,0,0,9751,9752,
+        5,95,0,0,9752,9753,7,5,0,0,9753,9754,7,10,0,0,9754,9755,7,4,0,0,
+        9755,9756,7,6,0,0,9756,934,1,0,0,0,9757,9758,7,9,0,0,9758,9759,7,
+        3,0,0,9759,9760,7,2,0,0,9760,9761,7,15,0,0,9761,9762,5,95,0,0,9762,
+        9763,7,8,0,0,9763,9764,7,2,0,0,9764,9765,7,11,0,0,9765,9766,7,12,
+        0,0,9766,9767,7,14,0,0,9767,9768,7,7,0,0,9768,936,1,0,0,0,9769,9770,
+        7,9,0,0,9770,9771,7,3,0,0,9771,9772,7,2,0,0,9772,9773,7,15,0,0,9773,
+        938,1,0,0,0,9774,9775,7,9,0,0,9775,9776,7,3,0,0,9776,9777,7,2,0,
+        0,9777,9778,7,15,0,0,9778,9779,5,95,0,0,9779,9780,7,17,0,0,9780,
+        9781,7,3,0,0,9781,9782,7,2,0,0,9782,9783,7,12,0,0,9783,9784,7,15,
+        0,0,9784,940,1,0,0,0,9785,9786,7,9,0,0,9786,9787,7,5,0,0,9787,9788,
+        7,10,0,0,9788,9789,7,7,0,0,9789,9790,7,4,0,0,9790,9791,7,6,0,0,9791,
+        9792,7,3,0,0,9792,9793,7,13,0,0,9793,9794,7,0,0,0,9794,9795,7,11,
+        0,0,9795,9796,5,95,0,0,9796,9797,7,12,0,0,9797,9798,7,7,0,0,9798,
+        9799,7,8,0,0,9799,9800,7,2,0,0,9800,9801,7,7,0,0,9801,9802,7,5,0,
+        0,9802,9803,7,4,0,0,9803,9804,7,3,0,0,9804,9805,7,0,0,0,9805,9806,
+        7,10,0,0,9806,9807,7,7,0,0,9807,9808,7,6,0,0,9808,9809,7,9,0,0,9809,
+        942,1,0,0,0,9810,9811,7,9,0,0,9811,9812,7,5,0,0,9812,9813,7,4,0,
+        0,9813,9814,5,95,0,0,9814,9815,7,12,0,0,9815,9816,7,15,0,0,9816,
+        9817,7,17,0,0,9817,9818,7,3,0,0,9818,9819,7,0,0,0,9819,9820,7,9,
+        0,0,9820,9821,7,6,0,0,9821,9822,5,95,0,0,9822,9823,7,10,0,0,9823,
+        9824,7,7,0,0,9824,9825,7,5,0,0,9825,9826,7,6,0,0,9826,9827,7,3,0,
+        0,9827,9828,7,4,0,0,9828,9829,5,95,0,0,9829,9830,7,8,0,0,9830,9831,
+        7,2,0,0,9831,9832,7,7,0,0,9832,9833,7,13,0,0,9833,944,1,0,0,0,9834,
+        9835,7,9,0,0,9835,9836,7,12,0,0,9836,9837,7,14,0,0,9837,9838,7,15,
+        0,0,9838,946,1,0,0,0,9839,9840,7,9,0,0,9840,9841,7,12,0,0,9841,9842,
+        7,14,0,0,9842,9843,7,15,0,0,9843,9844,7,5,0,0,9844,9845,7,6,0,0,
+        9845,9846,7,4,0,0,9846,948,1,0,0,0,9847,9848,7,9,0,0,9848,9849,7,
+        12,0,0,9849,9850,7,15,0,0,9850,9851,7,11,0,0,9851,9852,7,10,0,0,
+        9852,9853,7,8,0,0,9853,9854,7,0,0,0,9854,9855,7,4,0,0,9855,9856,
+        7,6,0,0,9856,950,1,0,0,0,9857,9858,7,9,0,0,9858,9859,7,13,0,0,9859,
+        952,1,0,0,0,9860,9861,7,9,0,0,9861,9862,7,18,0,0,9862,9863,7,7,0,
+        0,9863,9864,7,0,0,0,9864,9865,7,14,0,0,9865,9866,7,10,0,0,9866,9867,
+        7,8,0,0,9867,954,1,0,0,0,9868,9869,7,9,0,0,9869,9870,7,18,0,0,9870,
+        9871,7,7,0,0,9871,9872,7,0,0,0,9872,9873,7,14,0,0,9873,9874,7,10,
+        0,0,9874,9875,7,8,0,0,9875,9876,5,95,0,0,9876,9877,7,5,0,0,9877,
+        9878,7,0,0,0,9878,9879,7,14,0,0,9879,9880,7,15,0,0,9880,9881,7,11,
+        0,0,9881,9882,7,10,0,0,9882,9883,7,7,0,0,9883,9884,7,17,0,0,9884,
+        956,1,0,0,0,9885,9886,7,9,0,0,9886,9887,7,18,0,0,9887,9888,7,7,0,
+        0,9888,9889,7,0,0,0,9889,9890,7,14,0,0,9890,9891,7,10,0,0,9891,9892,
+        7,8,0,0,9892,9893,5,95,0,0,9893,9894,7,5,0,0,9894,9895,7,0,0,0,9895,
+        9896,7,14,0,0,9896,9897,7,15,0,0,9897,9898,7,11,0,0,9898,9899,7,
+        10,0,0,9899,9900,7,7,0,0,9900,9901,7,17,0,0,9901,9902,5,95,0,0,9902,
+        9903,7,6,0,0,9903,9904,7,5,0,0,9904,9905,7,4,0,0,9905,9906,5,95,
+        0,0,9906,9907,7,8,0,0,9907,9908,7,9,0,0,9908,9909,7,7,0,0,9909,958,
+        1,0,0,0,9910,9911,7,6,0,0,9911,960,1,0,0,0,9912,9913,7,6,0,0,9913,
+        9914,7,0,0,0,9914,9915,7,8,0,0,9915,9916,7,19,0,0,9916,962,1,0,0,
+        0,9917,9918,7,6,0,0,9918,9919,7,9,0,0,9919,9920,7,10,0,0,9920,9921,
+        7,4,0,0,9921,9922,7,10,0,0,9922,9923,7,2,0,0,9923,9924,7,7,0,0,9924,
+        9925,7,0,0,0,9925,9926,7,1,0,0,9926,9927,7,11,0,0,9927,9928,7,6,
+        0,0,9928,964,1,0,0,0,9929,9930,7,6,0,0,9930,9931,7,9,0,0,9931,9932,
+        7,10,0,0,9932,9933,7,4,0,0,9933,9934,7,10,0,0,9934,9935,7,2,0,0,
+        9935,9936,7,7,0,0,9936,966,1,0,0,0,9937,9938,7,6,0,0,9938,9939,7,
+        9,0,0,9939,9940,7,10,0,0,9940,9941,7,4,0,0,9941,9942,7,10,0,0,9942,
+        9943,7,2,0,0,9943,9944,7,7,0,0,9944,9945,7,10,0,0,9945,9946,7,7,
+        0,0,9946,9947,7,17,0,0,9947,968,1,0,0,0,9948,9949,7,6,0,0,9949,9950,
+        7,9,0,0,9950,9951,7,10,0,0,9951,9952,7,4,0,0,9952,9953,7,10,0,0,
+        9953,9954,7,2,0,0,9954,9955,7,7,0,0,9955,9956,7,5,0,0,9956,970,1,
+        0,0,0,9957,9958,7,6,0,0,9958,9959,7,11,0,0,9959,9960,7,6,0,0,9960,
+        9961,7,14,0,0,9961,9962,7,6,0,0,9962,9963,7,7,0,0,9963,9964,7,4,
+        0,0,9964,972,1,0,0,0,9965,9966,7,6,0,0,9966,9967,7,11,0,0,9967,9968,
+        7,10,0,0,9968,9969,7,14,0,0,9969,9970,5,95,0,0,9970,9971,7,17,0,
+        0,9971,9972,7,3,0,0,9972,9973,7,2,0,0,9973,9974,7,12,0,0,9974,9975,
+        7,15,0,0,9975,9976,7,1,0,0,9976,9977,7,18,0,0,9977,974,1,0,0,0,9978,
+        9979,7,6,0,0,9979,9980,7,11,0,0,9980,9981,7,10,0,0,9981,9982,7,14,
+        0,0,9982,9983,7,10,0,0,9983,9984,7,7,0,0,9984,9985,7,0,0,0,9985,
+        9986,7,4,0,0,9986,9987,7,6,0,0,9987,9988,5,95,0,0,9988,9989,7,20,
+        0,0,9989,9990,7,2,0,0,9990,9991,7,10,0,0,9991,9992,7,7,0,0,9992,
+        976,1,0,0,0,9993,9994,7,6,0,0,9994,9995,7,11,0,0,9995,9996,7,10,
+        0,0,9996,9997,7,14,0,0,9997,9998,7,10,0,0,9998,9999,7,7,0,0,9999,
+        10000,7,0,0,0,10000,10001,7,4,0,0,10001,10002,7,6,0,0,10002,10003,
+        5,95,0,0,10003,10004,7,2,0,0,10004,10005,7,1,0,0,10005,10006,7,18,
+        0,0,10006,978,1,0,0,0,10007,10008,7,6,0,0,10008,10009,7,11,0,0,10009,
+        10010,7,10,0,0,10010,10011,7,14,0,0,10011,10012,7,10,0,0,10012,10013,
+        7,7,0,0,10013,10014,7,0,0,0,10014,10015,7,4,0,0,10015,10016,7,6,
+        0,0,10016,10017,5,95,0,0,10017,10018,7,2,0,0,10018,10019,7,12,0,
+        0,10019,10020,7,4,0,0,10020,10021,7,6,0,0,10021,10022,7,3,0,0,10022,
+        10023,5,95,0,0,10023,10024,7,20,0,0,10024,10025,7,2,0,0,10025,10026,
+        7,10,0,0,10026,10027,7,7,0,0,10027,980,1,0,0,0,10028,10029,7,6,0,
+        0,10029,10030,7,11,0,0,10030,10031,7,5,0,0,10031,10032,7,6,0,0,10032,
+        982,1,0,0,0,10033,10034,7,6,0,0,10034,10035,7,11,0,0,10035,10036,
+        7,5,0,0,10036,10037,7,10,0,0,10037,10038,7,16,0,0,10038,984,1,0,
+        0,0,10039,10040,7,6,0,0,10040,10041,7,14,0,0,10041,986,1,0,0,0,10042,
+        10043,7,6,0,0,10043,10044,7,14,0,0,10044,10045,7,1,0,0,10045,10046,
+        7,6,0,0,10046,10047,7,9,0,0,10047,10048,7,9,0,0,10048,10049,7,6,
+        0,0,10049,10050,7,9,0,0,10050,988,1,0,0,0,10051,10052,7,6,0,0,10052,
+        10053,7,14,0,0,10053,10054,7,15,0,0,10054,10055,7,4,0,0,10055,10056,
+        7,18,0,0,10056,10057,5,95,0,0,10057,10058,7,1,0,0,10058,10059,7,
+        11,0,0,10059,10060,7,2,0,0,10060,10061,7,1,0,0,10061,990,1,0,0,0,
+        10062,10063,7,6,0,0,10063,10064,7,14,0,0,10064,10065,7,15,0,0,10065,
+        10066,7,4,0,0,10066,10067,7,18,0,0,10067,10068,5,95,0,0,10068,10069,
+        7,8,0,0,10069,10070,7,11,0,0,10070,10071,7,2,0,0,10071,10072,7,1,
+        0,0,10072,992,1,0,0,0,10073,10074,7,6,0,0,10074,10075,7,14,0,0,10075,
+        10076,7,15,0,0,10076,10077,7,4,0,0,10077,10078,7,18,0,0,10078,994,
+        1,0,0,0,10079,10080,7,6,0,0,10080,10081,7,7,0,0,10081,10082,7,0,
+        0,0,10082,10083,7,1,0,0,10083,10084,7,11,0,0,10084,10085,7,6,0,0,
+        10085,10086,5,95,0,0,10086,10087,7,0,0,0,10087,10088,7,11,0,0,10088,
+        10089,7,11,0,0,10089,996,1,0,0,0,10090,10091,7,6,0,0,10091,10092,
+        7,7,0,0,10092,10093,7,0,0,0,10093,10094,7,1,0,0,10094,10095,7,11,
+        0,0,10095,10096,7,6,0,0,10096,998,1,0,0,0,10097,10098,7,6,0,0,10098,
+        10099,7,7,0,0,10099,10100,7,0,0,0,10100,10101,7,1,0,0,10101,10102,
+        7,11,0,0,10102,10103,7,6,0,0,10103,10104,7,9,0,0,10104,1000,1,0,
+        0,0,10105,10106,7,6,0,0,10106,10107,7,7,0,0,10107,10108,7,0,0,0,
+        10108,10109,7,1,0,0,10109,10110,7,11,0,0,10110,10111,7,6,0,0,10111,
+        10112,5,95,0,0,10112,10113,7,15,0,0,10113,10114,7,0,0,0,10114,10115,
+        7,3,0,0,10115,10116,7,0,0,0,10116,10117,7,11,0,0,10117,10118,7,11,
+        0,0,10118,10119,7,6,0,0,10119,10120,7,11,0,0,10120,10121,5,95,0,
+        0,10121,10122,7,9,0,0,10122,10123,7,14,0,0,10123,10124,7,11,0,0,
+        10124,1002,1,0,0,0,10125,10126,7,6,0,0,10126,10127,7,7,0,0,10127,
+        10128,7,0,0,0,10128,10129,7,1,0,0,10129,10130,7,11,0,0,10130,10131,
+        7,6,0,0,10131,10132,5,95,0,0,10132,10133,7,15,0,0,10133,10134,7,
+        3,0,0,10134,10135,7,6,0,0,10135,10136,7,5,0,0,10136,10137,7,6,0,
+        0,10137,10138,7,4,0,0,10138,1004,1,0,0,0,10139,10140,7,6,0,0,10140,
+        10141,7,7,0,0,10141,10142,7,8,0,0,10142,10143,7,11,0,0,10143,10144,
+        7,2,0,0,10144,10145,7,5,0,0,10145,10146,7,6,0,0,10146,10147,7,9,
+        0,0,10147,1006,1,0,0,0,10148,10149,7,6,0,0,10149,10150,7,7,0,0,10150,
+        10151,7,8,0,0,10151,10152,7,2,0,0,10152,10153,7,9,0,0,10153,10154,
+        7,10,0,0,10154,10155,7,7,0,0,10155,10156,7,17,0,0,10156,1008,1,0,
+        0,0,10157,10158,7,6,0,0,10158,10159,7,7,0,0,10159,10160,7,8,0,0,
+        10160,10161,7,3,0,0,10161,10162,7,18,0,0,10162,10163,7,15,0,0,10163,
+        10164,7,4,0,0,10164,1010,1,0,0,0,10165,10166,7,6,0,0,10166,10167,
+        7,7,0,0,10167,10168,7,8,0,0,10168,10169,7,3,0,0,10169,10170,7,18,
+        0,0,10170,10171,7,15,0,0,10171,10172,7,4,0,0,10172,10173,7,10,0,
+        0,10173,10174,7,2,0,0,10174,10175,7,7,0,0,10175,1012,1,0,0,0,10176,
+        10177,7,6,0,0,10177,10178,7,7,0,0,10178,10179,7,8,0,0,10179,10180,
+        7,3,0,0,10180,10181,7,18,0,0,10181,10182,7,15,0,0,10182,10183,7,
+        4,0,0,10183,10184,7,15,0,0,10184,10185,7,0,0,0,10185,10186,7,5,0,
+        0,10186,10187,7,5,0,0,10187,10188,7,22,0,0,10188,10189,7,2,0,0,10189,
+        10190,7,3,0,0,10190,10191,7,9,0,0,10191,10192,7,10,0,0,10192,10193,
+        7,5,0,0,10193,10194,7,7,0,0,10194,10195,7,12,0,0,10195,10196,7,11,
+        0,0,10196,10197,7,11,0,0,10197,1014,1,0,0,0,10198,10199,7,6,0,0,
+        10199,10200,7,7,0,0,10200,10201,7,9,0,0,10201,1016,1,0,0,0,10202,
+        10203,7,6,0,0,10203,10204,7,7,0,0,10204,10205,7,9,0,0,10205,10206,
+        5,95,0,0,10206,10207,7,2,0,0,10207,10208,7,12,0,0,10208,10209,7,
+        4,0,0,10209,10210,7,11,0,0,10210,10211,7,10,0,0,10211,10212,7,7,
+        0,0,10212,10213,7,6,0,0,10213,10214,5,95,0,0,10214,10215,7,9,0,0,
+        10215,10216,7,0,0,0,10216,10217,7,4,0,0,10217,10218,7,0,0,0,10218,
+        1018,1,0,0,0,10219,10220,7,6,0,0,10220,10221,7,7,0,0,10221,10222,
+        7,9,0,0,10222,10223,7,10,0,0,10223,10224,7,0,0,0,10224,10225,7,7,
+        0,0,10225,1020,1,0,0,0,10226,10227,7,6,0,0,10227,10228,7,7,0,0,10228,
+        10229,7,16,0,0,10229,10230,7,2,0,0,10230,10231,7,3,0,0,10231,10232,
+        7,8,0,0,10232,10233,7,6,0,0,10233,10234,7,9,0,0,10234,1022,1,0,0,
+        0,10235,10236,7,6,0,0,10236,10237,7,7,0,0,10237,10238,7,16,0,0,10238,
+        10239,7,2,0,0,10239,10240,7,3,0,0,10240,10241,7,8,0,0,10241,10242,
+        7,6,0,0,10242,1024,1,0,0,0,10243,10244,7,6,0,0,10244,10245,7,7,0,
+        0,10245,10246,7,24,0,0,10246,10247,7,12,0,0,10247,10248,7,6,0,0,
+        10248,10249,7,12,0,0,10249,10250,7,6,0,0,10250,1026,1,0,0,0,10251,
+        10252,7,6,0,0,10252,10253,7,7,0,0,10253,10254,7,4,0,0,10254,10255,
+        7,6,0,0,10255,10256,7,3,0,0,10256,10257,7,15,0,0,10257,10258,7,3,
+        0,0,10258,10259,7,10,0,0,10259,10260,7,5,0,0,10260,10261,7,6,0,0,
+        10261,1028,1,0,0,0,10262,10263,7,6,0,0,10263,10264,7,7,0,0,10264,
+        10265,7,4,0,0,10265,10266,7,10,0,0,10266,10267,7,4,0,0,10267,10268,
+        7,18,0,0,10268,10269,7,6,0,0,10269,10270,7,5,0,0,10270,10271,7,8,
+        0,0,10271,10272,7,0,0,0,10272,10273,7,15,0,0,10273,10274,7,10,0,
+        0,10274,10275,7,7,0,0,10275,10276,7,17,0,0,10276,1030,1,0,0,0,10277,
+        10278,7,6,0,0,10278,10279,7,7,0,0,10279,10280,7,4,0,0,10280,10281,
+        7,3,0,0,10281,10282,7,18,0,0,10282,1032,1,0,0,0,10283,10284,7,6,
+        0,0,10284,10285,7,24,0,0,10285,10286,7,12,0,0,10286,10287,7,10,0,
+        0,10287,10288,7,15,0,0,10288,10289,7,0,0,0,10289,10290,7,3,0,0,10290,
+        10291,7,4,0,0,10291,1034,1,0,0,0,10292,10293,7,6,0,0,10293,10294,
+        7,3,0,0,10294,10295,7,3,0,0,10295,1036,1,0,0,0,10296,10297,7,6,0,
+        0,10297,10298,7,3,0,0,10298,10299,7,3,0,0,10299,10300,7,2,0,0,10300,
+        10301,7,3,0,0,10301,10302,5,95,0,0,10302,10303,7,0,0,0,10303,10304,
+        7,3,0,0,10304,10305,7,17,0,0,10305,10306,7,12,0,0,10306,10307,7,
+        14,0,0,10307,10308,7,6,0,0,10308,10309,7,7,0,0,10309,10310,7,4,0,
+        0,10310,1038,1,0,0,0,10311,10312,7,6,0,0,10312,10313,7,3,0,0,10313,
+        10314,7,3,0,0,10314,10315,7,2,0,0,10315,10316,7,3,0,0,10316,1040,
+        1,0,0,0,10317,10318,7,6,0,0,10318,10319,7,3,0,0,10319,10320,7,3,
+        0,0,10320,10321,7,2,0,0,10321,10322,7,3,0,0,10322,10323,5,95,0,0,
+        10323,10324,7,2,0,0,10324,10325,7,7,0,0,10325,10326,5,95,0,0,10326,
+        10327,7,2,0,0,10327,10328,7,13,0,0,10328,10329,7,6,0,0,10329,10330,
+        7,3,0,0,10330,10331,7,11,0,0,10331,10332,7,0,0,0,10332,10333,7,15,
+        0,0,10333,10334,5,95,0,0,10334,10335,7,4,0,0,10335,10336,7,10,0,
+        0,10336,10337,7,14,0,0,10337,10338,7,6,0,0,10338,1042,1,0,0,0,10339,
+        10340,7,6,0,0,10340,10341,7,3,0,0,10341,10342,7,3,0,0,10342,10343,
+        7,2,0,0,10343,10344,7,3,0,0,10344,10345,7,5,0,0,10345,1044,1,0,0,
+        0,10346,10347,7,6,0,0,10347,10348,7,3,0,0,10348,10349,7,3,0,0,10349,
+        10350,7,2,0,0,10350,10351,7,3,0,0,10351,10352,5,95,0,0,10352,10353,
+        7,10,0,0,10353,10354,7,7,0,0,10354,10355,7,9,0,0,10355,10356,7,6,
+        0,0,10356,10357,7,25,0,0,10357,1046,1,0,0,0,10358,10359,7,6,0,0,
+        10359,10360,7,3,0,0,10360,10361,7,3,0,0,10361,10362,7,2,0,0,10362,
+        10363,7,3,0,0,10363,10364,5,95,0,0,10364,10365,7,8,0,0,10365,10366,
+        7,2,0,0,10366,10367,7,9,0,0,10367,10368,7,6,0,0,10368,1048,1,0,0,
+        0,10369,10370,7,6,0,0,10370,10371,7,5,0,0,10371,10372,7,8,0,0,10372,
+        10373,7,0,0,0,10373,10374,7,15,0,0,10374,10375,7,6,0,0,10375,1050,
+        1,0,0,0,10376,10377,7,6,0,0,10377,10378,7,5,0,0,10378,10379,7,8,
+        0,0,10379,10380,7,0,0,0,10380,10381,7,15,0,0,10381,10382,7,6,0,0,
+        10382,10383,7,9,0,0,10383,1052,1,0,0,0,10384,10385,7,6,0,0,10385,
+        10386,7,5,0,0,10386,10387,7,4,0,0,10387,10388,7,10,0,0,10388,10389,
+        7,14,0,0,10389,10390,7,0,0,0,10390,10391,7,4,0,0,10391,10392,7,6,
+        0,0,10392,1054,1,0,0,0,10393,10394,7,6,0,0,10394,10395,7,13,0,0,
+        10395,10396,7,0,0,0,10396,10397,7,11,0,0,10397,1056,1,0,0,0,10398,
+        10399,7,6,0,0,10399,10400,7,13,0,0,10400,10401,7,0,0,0,10401,10402,
+        7,11,0,0,10402,10403,7,7,0,0,10403,10404,7,0,0,0,10404,10405,7,14,
+        0,0,10405,10406,7,6,0,0,10406,1058,1,0,0,0,10407,10408,7,6,0,0,10408,
+        10409,7,13,0,0,10409,10410,7,0,0,0,10410,10411,7,11,0,0,10411,10412,
+        7,12,0,0,10412,10413,7,0,0,0,10413,10414,7,4,0,0,10414,10415,7,6,
+        0,0,10415,1060,1,0,0,0,10416,10417,7,6,0,0,10417,10418,7,13,0,0,
+        10418,10419,7,0,0,0,10419,10420,7,11,0,0,10420,10421,7,12,0,0,10421,
+        10422,7,0,0,0,10422,10423,7,4,0,0,10423,10424,7,10,0,0,10424,10425,
+        7,2,0,0,10425,10426,7,7,0,0,10426,1062,1,0,0,0,10427,10428,7,6,0,
+        0,10428,10429,7,13,0,0,10429,10430,7,6,0,0,10430,10431,7,7,0,0,10431,
+        10432,7,4,0,0,10432,10433,7,5,0,0,10433,1064,1,0,0,0,10434,10435,
+        7,6,0,0,10435,10436,7,13,0,0,10436,10437,7,6,0,0,10437,10438,7,3,
+        0,0,10438,10439,7,18,0,0,10439,1066,1,0,0,0,10440,10441,7,6,0,0,
+        10441,10442,7,25,0,0,10442,10443,7,8,0,0,10443,10444,7,6,0,0,10444,
+        10445,7,15,0,0,10445,10446,7,4,0,0,10446,1068,1,0,0,0,10447,10448,
+        7,6,0,0,10448,10449,7,25,0,0,10449,10450,7,8,0,0,10450,10451,7,6,
+        0,0,10451,10452,7,15,0,0,10452,10453,7,4,0,0,10453,10454,7,10,0,
+        0,10454,10455,7,2,0,0,10455,10456,7,7,0,0,10456,1070,1,0,0,0,10457,
+        10458,7,6,0,0,10458,10459,7,25,0,0,10459,10460,7,8,0,0,10460,10461,
+        7,6,0,0,10461,10462,7,15,0,0,10462,10463,7,4,0,0,10463,10464,7,10,
+        0,0,10464,10465,7,2,0,0,10465,10466,7,7,0,0,10466,10467,5,95,0,0,
+        10467,10468,7,10,0,0,10468,10469,7,7,0,0,10469,10470,7,10,0,0,10470,
+        10471,7,4,0,0,10471,1072,1,0,0,0,10472,10473,7,6,0,0,10473,10474,
+        7,25,0,0,10474,10475,7,8,0,0,10475,10476,7,6,0,0,10476,10477,7,15,
+        0,0,10477,10478,7,4,0,0,10478,10479,7,10,0,0,10479,10480,7,2,0,0,
+        10480,10481,7,7,0,0,10481,10482,7,5,0,0,10482,1074,1,0,0,0,10483,
+        10484,7,6,0,0,10484,10485,7,25,0,0,10485,10486,7,8,0,0,10486,10487,
+        7,19,0,0,10487,10488,7,0,0,0,10488,10489,7,7,0,0,10489,10490,7,17,
+        0,0,10490,10491,7,6,0,0,10491,1076,1,0,0,0,10492,10493,7,6,0,0,10493,
+        10494,7,25,0,0,10494,10495,7,8,0,0,10495,10496,7,11,0,0,10496,10497,
+        7,12,0,0,10497,10498,7,9,0,0,10498,10499,7,6,0,0,10499,1078,1,0,
+        0,0,10500,10501,7,6,0,0,10501,10502,7,25,0,0,10502,10503,7,8,0,0,
+        10503,10504,7,11,0,0,10504,10505,7,12,0,0,10505,10506,7,9,0,0,10506,
+        10507,7,10,0,0,10507,10508,7,7,0,0,10508,10509,7,17,0,0,10509,1080,
+        1,0,0,0,10510,10511,7,6,0,0,10511,10512,7,25,0,0,10512,10513,7,8,
+        0,0,10513,10514,7,11,0,0,10514,10515,7,12,0,0,10515,10516,7,5,0,
+        0,10516,10517,7,10,0,0,10517,10518,7,13,0,0,10518,10519,7,6,0,0,
+        10519,1082,1,0,0,0,10520,10521,7,6,0,0,10521,10522,7,25,0,0,10522,
+        10523,7,6,0,0,10523,10524,7,8,0,0,10524,1084,1,0,0,0,10525,10526,
+        7,6,0,0,10526,10527,7,25,0,0,10527,10528,7,6,0,0,10528,10529,7,8,
+        0,0,10529,10530,7,12,0,0,10530,10531,7,4,0,0,10531,10532,7,6,0,0,
+        10532,1086,1,0,0,0,10533,10534,7,6,0,0,10534,10535,7,25,0,0,10535,
+        10536,7,6,0,0,10536,10537,7,14,0,0,10537,10538,7,15,0,0,10538,10539,
+        7,4,0,0,10539,1088,1,0,0,0,10540,10541,7,6,0,0,10541,10542,7,25,
+        0,0,10542,10543,7,10,0,0,10543,10544,7,5,0,0,10544,10545,7,4,0,0,
+        10545,10546,7,10,0,0,10546,10547,7,7,0,0,10547,10548,7,17,0,0,10548,
+        1090,1,0,0,0,10549,10550,7,6,0,0,10550,10551,7,25,0,0,10551,10552,
+        7,10,0,0,10552,10553,7,5,0,0,10553,10554,7,4,0,0,10554,10555,7,5,
+        0,0,10555,1092,1,0,0,0,10556,10557,7,6,0,0,10557,10558,7,25,0,0,
+        10558,10559,7,10,0,0,10559,10560,7,5,0,0,10560,10561,7,4,0,0,10561,
+        10562,7,5,0,0,10562,10563,7,7,0,0,10563,10564,7,2,0,0,10564,10565,
+        7,9,0,0,10565,10566,7,6,0,0,10566,1094,1,0,0,0,10567,10568,7,6,0,
+        0,10568,10569,7,25,0,0,10569,10570,7,10,0,0,10570,10571,7,4,0,0,
+        10571,1096,1,0,0,0,10572,10573,7,6,0,0,10573,10574,7,25,0,0,10574,
+        10575,7,15,0,0,10575,10576,7,0,0,0,10576,10577,7,7,0,0,10577,10578,
+        7,9,0,0,10578,10579,5,95,0,0,10579,10580,7,17,0,0,10580,10581,7,
+        5,0,0,10581,10582,7,6,0,0,10582,10583,7,4,0,0,10583,10584,5,95,0,
+        0,10584,10585,7,4,0,0,10585,10586,7,2,0,0,10586,10587,5,95,0,0,10587,
+        10588,7,12,0,0,10588,10589,7,7,0,0,10589,10590,7,10,0,0,10590,10591,
+        7,2,0,0,10591,10592,7,7,0,0,10592,1098,1,0,0,0,10593,10594,7,6,0,
+        0,10594,10595,7,25,0,0,10595,10596,7,15,0,0,10596,10597,7,0,0,0,
+        10597,10598,7,7,0,0,10598,10599,7,9,0,0,10599,10600,5,95,0,0,10600,
+        10601,7,4,0,0,10601,10602,7,0,0,0,10602,10603,7,1,0,0,10603,10604,
+        7,11,0,0,10604,10605,7,6,0,0,10605,1100,1,0,0,0,10606,10607,7,6,
+        0,0,10607,10608,7,25,0,0,10608,10609,7,15,0,0,10609,1102,1,0,0,0,
+        10610,10611,7,6,0,0,10611,10612,7,25,0,0,10612,10613,7,15,0,0,10613,
+        10614,7,10,0,0,10614,10615,7,3,0,0,10615,10616,7,6,0,0,10616,1104,
+        1,0,0,0,10617,10618,7,6,0,0,10618,10619,7,25,0,0,10619,10620,7,15,
+        0,0,10620,10621,7,11,0,0,10621,10622,7,0,0,0,10622,10623,7,10,0,
+        0,10623,10624,7,7,0,0,10624,1106,1,0,0,0,10625,10626,7,6,0,0,10626,
+        10627,7,25,0,0,10627,10628,7,15,0,0,10628,10629,7,11,0,0,10629,10630,
+        7,2,0,0,10630,10631,7,5,0,0,10631,10632,7,10,0,0,10632,10633,7,2,
+        0,0,10633,10634,7,7,0,0,10634,1108,1,0,0,0,10635,10636,7,6,0,0,10636,
+        10637,7,25,0,0,10637,10638,7,15,0,0,10638,10639,7,2,0,0,10639,10640,
+        7,3,0,0,10640,10641,7,4,0,0,10641,1110,1,0,0,0,10642,10643,7,6,0,
+        0,10643,10644,7,25,0,0,10644,10645,7,15,0,0,10645,10646,7,3,0,0,
+        10646,10647,5,95,0,0,10647,10648,7,8,0,0,10648,10649,7,2,0,0,10649,
+        10650,7,3,0,0,10650,10651,7,3,0,0,10651,10652,5,95,0,0,10652,10653,
+        7,8,0,0,10653,10654,7,19,0,0,10654,10655,7,6,0,0,10655,10656,7,8,
+        0,0,10656,10657,7,21,0,0,10657,1112,1,0,0,0,10658,10659,7,6,0,0,
+        10659,10660,7,25,0,0,10660,10661,7,15,0,0,10661,10662,7,3,0,0,10662,
+        10663,7,6,0,0,10663,10664,7,5,0,0,10664,10665,7,5,0,0,10665,1114,
+        1,0,0,0,10666,10667,7,6,0,0,10667,10668,7,25,0,0,10668,10669,7,4,
+        0,0,10669,10670,7,6,0,0,10670,10671,7,7,0,0,10671,10672,7,9,0,0,
+        10672,10673,7,5,0,0,10673,1116,1,0,0,0,10674,10675,7,6,0,0,10675,
+        10676,7,25,0,0,10676,10677,7,4,0,0,10677,10678,7,6,0,0,10678,10679,
+        7,7,0,0,10679,10680,7,4,0,0,10680,1118,1,0,0,0,10681,10682,7,6,0,
+        0,10682,10683,7,25,0,0,10683,10684,7,4,0,0,10684,10685,7,6,0,0,10685,
+        10686,7,7,0,0,10686,10687,7,4,0,0,10687,10688,7,5,0,0,10688,1120,
+        1,0,0,0,10689,10690,7,6,0,0,10690,10691,7,25,0,0,10691,10692,7,4,
+        0,0,10692,10693,7,6,0,0,10693,10694,7,3,0,0,10694,10695,7,7,0,0,
+        10695,10696,7,0,0,0,10696,10697,7,11,0,0,10697,1122,1,0,0,0,10698,
+        10699,7,6,0,0,10699,10700,7,25,0,0,10700,10701,7,4,0,0,10701,10702,
+        7,6,0,0,10702,10703,7,3,0,0,10703,10704,7,7,0,0,10704,10705,7,0,
+        0,0,10705,10706,7,11,0,0,10706,10707,7,11,0,0,10707,10708,7,18,0,
+        0,10708,1124,1,0,0,0,10709,10710,7,6,0,0,10710,10711,7,25,0,0,10711,
+        10712,7,4,0,0,10712,10713,7,3,0,0,10713,10714,7,0,0,0,10714,10715,
+        7,8,0,0,10715,10716,7,4,0,0,10716,10717,7,8,0,0,10717,10718,7,11,
+        0,0,10718,10719,7,2,0,0,10719,10720,7,1,0,0,10720,10721,7,25,0,0,
+        10721,10722,7,14,0,0,10722,10723,7,11,0,0,10723,1126,1,0,0,0,10724,
+        10725,7,6,0,0,10725,10726,7,25,0,0,10726,10727,7,4,0,0,10727,10728,
+        7,3,0,0,10728,10729,7,0,0,0,10729,10730,7,8,0,0,10730,10731,7,4,
+        0,0,10731,1128,1,0,0,0,10732,10733,7,6,0,0,10733,10734,7,25,0,0,
+        10734,10735,7,4,0,0,10735,10736,7,3,0,0,10736,10737,7,0,0,0,10737,
+        10738,7,8,0,0,10738,10739,7,4,0,0,10739,10740,7,13,0,0,10740,10741,
+        7,0,0,0,10741,10742,7,11,0,0,10742,10743,7,12,0,0,10743,10744,7,
+        6,0,0,10744,1130,1,0,0,0,10745,10746,7,6,0,0,10746,10747,7,25,0,
+        0,10747,10748,7,4,0,0,10748,10749,7,3,0,0,10749,10750,7,0,0,0,10750,
+        1132,1,0,0,0,10751,10752,7,16,0,0,10752,10753,7,0,0,0,10753,10754,
+        7,8,0,0,10754,10755,7,10,0,0,10755,10756,7,11,0,0,10756,10757,7,
+        10,0,0,10757,10758,7,4,0,0,10758,10759,7,18,0,0,10759,1134,1,0,0,
+        0,10760,10761,7,16,0,0,10761,10762,7,0,0,0,10762,10763,7,8,0,0,10763,
+        10764,7,4,0,0,10764,1136,1,0,0,0,10765,10766,7,16,0,0,10766,10767,
+        7,0,0,0,10767,10768,7,8,0,0,10768,10769,7,4,0,0,10769,10770,7,2,
+        0,0,10770,10771,7,3,0,0,10771,1138,1,0,0,0,10772,10773,7,16,0,0,
+        10773,10774,7,0,0,0,10774,10775,7,8,0,0,10775,10776,7,4,0,0,10776,
+        10777,7,2,0,0,10777,10778,7,3,0,0,10778,10779,7,10,0,0,10779,10780,
+        7,23,0,0,10780,10781,7,6,0,0,10781,10782,5,95,0,0,10782,10783,7,
+        20,0,0,10783,10784,7,2,0,0,10784,10785,7,10,0,0,10785,10786,7,7,
+        0,0,10786,1140,1,0,0,0,10787,10788,7,16,0,0,10788,10789,7,0,0,0,
+        10789,10790,7,10,0,0,10790,10791,7,11,0,0,10791,10792,7,6,0,0,10792,
+        10793,7,9,0,0,10793,1142,1,0,0,0,10794,10795,7,16,0,0,10795,10796,
+        7,0,0,0,10796,10797,7,10,0,0,10797,10798,7,11,0,0,10798,10799,7,
+        6,0,0,10799,10800,7,9,0,0,10800,10801,5,95,0,0,10801,10802,7,11,
+        0,0,10802,10803,7,2,0,0,10803,10804,7,17,0,0,10804,10805,7,10,0,
+        0,10805,10806,7,7,0,0,10806,10807,5,95,0,0,10807,10808,7,0,0,0,10808,
+        10809,7,4,0,0,10809,10810,7,4,0,0,10810,10811,7,6,0,0,10811,10812,
+        7,14,0,0,10812,10813,7,15,0,0,10813,10814,7,4,0,0,10814,10815,7,
+        5,0,0,10815,1144,1,0,0,0,10816,10817,7,16,0,0,10817,10818,7,0,0,
+        0,10818,10819,7,10,0,0,10819,10820,7,11,0,0,10820,10821,7,17,0,0,
+        10821,10822,7,3,0,0,10822,10823,7,2,0,0,10823,10824,7,12,0,0,10824,
+        10825,7,15,0,0,10825,1146,1,0,0,0,10826,10827,7,16,0,0,10827,10828,
+        7,0,0,0,10828,10829,7,10,0,0,10829,10830,7,11,0,0,10830,10831,7,
+        2,0,0,10831,10832,7,13,0,0,10832,10833,7,6,0,0,10833,10834,7,3,0,
+        0,10834,1148,1,0,0,0,10835,10836,7,16,0,0,10836,10837,7,0,0,0,10837,
+        10838,7,10,0,0,10838,10839,7,11,0,0,10839,10840,7,12,0,0,10840,10841,
+        7,3,0,0,10841,10842,7,6,0,0,10842,1150,1,0,0,0,10843,10844,7,16,
+        0,0,10844,10845,7,0,0,0,10845,10846,7,11,0,0,10846,10847,7,5,0,0,
+        10847,10848,7,6,0,0,10848,1152,1,0,0,0,10849,10850,7,16,0,0,10850,
+        10851,7,0,0,0,10851,10852,7,14,0,0,10852,10853,7,10,0,0,10853,10854,
+        7,11,0,0,10854,10855,7,18,0,0,10855,1154,1,0,0,0,10856,10857,7,16,
+        0,0,10857,10858,7,0,0,0,10858,10859,7,3,0,0,10859,1156,1,0,0,0,10860,
+        10861,7,16,0,0,10861,10862,7,0,0,0,10862,10863,7,5,0,0,10863,10864,
+        7,4,0,0,10864,1158,1,0,0,0,10865,10866,7,16,0,0,10866,10867,7,0,
+        0,0,10867,10868,7,5,0,0,10868,10869,7,4,0,0,10869,10870,7,5,0,0,
+        10870,10871,7,4,0,0,10871,10872,7,0,0,0,10872,10873,7,3,0,0,10873,
+        10874,7,4,0,0,10874,1160,1,0,0,0,10875,10876,7,16,0,0,10876,10877,
+        7,1,0,0,10877,10878,7,4,0,0,10878,10879,7,5,0,0,10879,10880,7,8,
+        0,0,10880,10881,7,0,0,0,10881,10882,7,7,0,0,10882,1162,1,0,0,0,10883,
+        10884,7,16,0,0,10884,10885,7,6,0,0,10885,10886,7,0,0,0,10886,10887,
+        7,4,0,0,10887,10888,7,12,0,0,10888,10889,7,3,0,0,10889,10890,7,6,
+        0,0,10890,1164,1,0,0,0,10891,10892,7,16,0,0,10892,10893,7,6,0,0,
+        10893,10894,7,0,0,0,10894,10895,7,4,0,0,10895,10896,7,12,0,0,10896,
+        10897,7,3,0,0,10897,10898,7,6,0,0,10898,10899,5,95,0,0,10899,10900,
+        7,9,0,0,10900,10901,7,6,0,0,10901,10902,7,4,0,0,10902,10903,7,0,
+        0,0,10903,10904,7,10,0,0,10904,10905,7,11,0,0,10905,10906,7,5,0,
+        0,10906,1166,1,0,0,0,10907,10908,7,16,0,0,10908,10909,7,6,0,0,10909,
+        10910,7,0,0,0,10910,10911,7,4,0,0,10911,10912,7,12,0,0,10912,10913,
+        7,3,0,0,10913,10914,7,6,0,0,10914,10915,5,95,0,0,10915,10916,7,10,
+        0,0,10916,10917,7,9,0,0,10917,1168,1,0,0,0,10918,10919,7,16,0,0,
+        10919,10920,7,6,0,0,10920,10921,7,0,0,0,10921,10922,7,4,0,0,10922,
+        10923,7,12,0,0,10923,10924,7,3,0,0,10924,10925,7,6,0,0,10925,10926,
+        5,95,0,0,10926,10927,7,5,0,0,10927,10928,7,6,0,0,10928,10929,7,4,
+        0,0,10929,1170,1,0,0,0,10930,10931,7,16,0,0,10931,10932,7,6,0,0,
+        10932,10933,7,0,0,0,10933,10934,7,4,0,0,10934,10935,7,12,0,0,10935,
+        10936,7,3,0,0,10936,10937,7,6,0,0,10937,10938,5,95,0,0,10938,10939,
+        7,13,0,0,10939,10940,7,0,0,0,10940,10941,7,11,0,0,10941,10942,7,
+        12,0,0,10942,10943,7,6,0,0,10943,1172,1,0,0,0,10944,10945,7,16,0,
+        0,10945,10946,7,6,0,0,10946,10947,7,4,0,0,10947,10948,7,8,0,0,10948,
+        10949,7,19,0,0,10949,1174,1,0,0,0,10950,10951,7,16,0,0,10951,10952,
+        7,10,0,0,10952,10953,7,6,0,0,10953,10954,7,11,0,0,10954,10955,7,
+        9,0,0,10955,1176,1,0,0,0,10956,10957,7,16,0,0,10957,10958,7,10,0,
+        0,10958,10959,7,6,0,0,10959,10960,7,11,0,0,10960,10961,7,9,0,0,10961,
+        10962,7,5,0,0,10962,1178,1,0,0,0,10963,10964,7,16,0,0,10964,10965,
+        7,10,0,0,10965,10966,7,11,0,0,10966,10967,7,6,0,0,10967,1180,1,0,
+        0,0,10968,10969,7,16,0,0,10969,10970,7,10,0,0,10970,10971,7,11,0,
+        0,10971,10972,7,6,0,0,10972,10973,5,95,0,0,10973,10974,7,7,0,0,10974,
+        10975,7,0,0,0,10975,10976,7,14,0,0,10976,10977,7,6,0,0,10977,10978,
+        5,95,0,0,10978,10979,7,8,0,0,10979,10980,7,2,0,0,10980,10981,7,7,
+        0,0,10981,10982,7,13,0,0,10982,10983,7,6,0,0,10983,10984,7,3,0,0,
+        10984,10985,7,4,0,0,10985,1182,1,0,0,0,10986,10987,7,16,0,0,10987,
+        10988,7,10,0,0,10988,10989,7,11,0,0,10989,10990,7,6,0,0,10990,10991,
+        7,17,0,0,10991,10992,7,3,0,0,10992,10993,7,2,0,0,10993,10994,7,12,
+        0,0,10994,10995,7,15,0,0,10995,1184,1,0,0,0,10996,10997,7,16,0,0,
+        10997,10998,7,10,0,0,10998,10999,7,11,0,0,10999,11000,7,6,0,0,11000,
+        11001,7,5,0,0,11001,11002,7,4,0,0,11002,11003,7,2,0,0,11003,11004,
+        7,3,0,0,11004,11005,7,6,0,0,11005,1186,1,0,0,0,11006,11007,7,16,
+        0,0,11007,11008,7,10,0,0,11008,11009,7,11,0,0,11009,11010,7,6,0,
+        0,11010,11011,7,5,0,0,11011,11012,7,18,0,0,11012,11013,7,5,0,0,11013,
+        11014,7,4,0,0,11014,11015,7,6,0,0,11015,11016,7,14,0,0,11016,11017,
+        5,95,0,0,11017,11018,7,11,0,0,11018,11019,7,10,0,0,11019,11020,7,
+        21,0,0,11020,11021,7,6,0,0,11021,11022,5,95,0,0,11022,11023,7,11,
+        0,0,11023,11024,7,2,0,0,11024,11025,7,17,0,0,11025,11026,7,17,0,
+        0,11026,11027,7,10,0,0,11027,11028,7,7,0,0,11028,11029,7,17,0,0,
+        11029,1188,1,0,0,0,11030,11031,7,16,0,0,11031,11032,7,10,0,0,11032,
+        11033,7,11,0,0,11033,11034,7,4,0,0,11034,11035,7,6,0,0,11035,11036,
+        7,3,0,0,11036,1190,1,0,0,0,11037,11038,7,16,0,0,11038,11039,7,10,
+        0,0,11039,11040,7,7,0,0,11040,11041,7,0,0,0,11041,11042,7,11,0,0,
+        11042,1192,1,0,0,0,11043,11044,7,16,0,0,11044,11045,7,10,0,0,11045,
+        11046,7,7,0,0,11046,11047,7,6,0,0,11047,1194,1,0,0,0,11048,11049,
+        7,16,0,0,11049,11050,7,10,0,0,11050,11051,7,7,0,0,11051,11052,7,
+        10,0,0,11052,11053,7,5,0,0,11053,11054,7,19,0,0,11054,1196,1,0,0,
+        0,11055,11056,7,16,0,0,11056,11057,7,10,0,0,11057,11058,7,3,0,0,
+        11058,11059,7,5,0,0,11059,11060,7,4,0,0,11060,1198,1,0,0,0,11061,
+        11062,7,16,0,0,11062,11063,7,10,0,0,11063,11064,7,3,0,0,11064,11065,
+        7,5,0,0,11065,11066,7,4,0,0,11066,11067,7,14,0,0,11067,1200,1,0,
+        0,0,11068,11069,7,16,0,0,11069,11070,7,10,0,0,11070,11071,7,3,0,
+        0,11071,11072,7,5,0,0,11072,11073,7,4,0,0,11073,11074,5,95,0,0,11074,
+        11075,7,3,0,0,11075,11076,7,2,0,0,11076,11077,7,22,0,0,11077,11078,
+        7,5,0,0,11078,1202,1,0,0,0,11079,11080,7,16,0,0,11080,11081,7,10,
+        0,0,11081,11082,7,3,0,0,11082,11083,7,5,0,0,11083,11084,7,4,0,0,
+        11084,11085,5,95,0,0,11085,11086,7,13,0,0,11086,11087,7,0,0,0,11087,
+        11088,7,11,0,0,11088,11089,7,12,0,0,11089,11090,7,6,0,0,11090,1204,
+        1,0,0,0,11091,11092,7,16,0,0,11092,11093,7,10,0,0,11093,11094,7,
+        25,0,0,11094,11095,7,6,0,0,11095,11096,7,9,0,0,11096,1206,1,0,0,
+        0,11097,11098,7,16,0,0,11098,11099,7,10,0,0,11099,11100,7,25,0,0,
+        11100,11101,7,6,0,0,11101,11102,7,9,0,0,11102,11103,5,95,0,0,11103,
+        11104,7,13,0,0,11104,11105,7,10,0,0,11105,11106,7,6,0,0,11106,11107,
+        7,22,0,0,11107,11108,5,95,0,0,11108,11109,7,9,0,0,11109,11110,7,
+        0,0,0,11110,11111,7,4,0,0,11111,11112,7,0,0,0,11112,1208,1,0,0,0,
+        11113,11114,7,16,0,0,11114,11115,7,11,0,0,11115,11116,7,0,0,0,11116,
+        11117,7,17,0,0,11117,11118,7,17,0,0,11118,11119,7,6,0,0,11119,11120,
+        7,3,0,0,11120,1210,1,0,0,0,11121,11122,7,16,0,0,11122,11123,7,11,
+        0,0,11123,11124,7,0,0,0,11124,11125,7,5,0,0,11125,11126,7,19,0,0,
+        11126,11127,7,1,0,0,11127,11128,7,0,0,0,11128,11129,7,8,0,0,11129,
+        11130,7,21,0,0,11130,1212,1,0,0,0,11131,11132,7,16,0,0,11132,11133,
+        7,11,0,0,11133,11134,7,0,0,0,11134,11135,7,5,0,0,11135,11136,7,19,
+        0,0,11136,11137,5,95,0,0,11137,11138,7,8,0,0,11138,11139,7,0,0,0,
+        11139,11140,7,8,0,0,11140,11141,7,19,0,0,11141,11142,7,6,0,0,11142,
+        1214,1,0,0,0,11143,11144,7,16,0,0,11144,11145,7,11,0,0,11145,11146,
+        7,2,0,0,11146,11147,7,0,0,0,11147,11148,7,4,0,0,11148,1216,1,0,0,
+        0,11149,11150,7,16,0,0,11150,11151,7,11,0,0,11151,11152,7,2,0,0,
+        11152,11153,7,1,0,0,11153,1218,1,0,0,0,11154,11155,7,16,0,0,11155,
+        11156,7,11,0,0,11156,11157,7,6,0,0,11157,11158,7,25,0,0,11158,1220,
+        1,0,0,0,11159,11160,7,16,0,0,11160,11161,7,11,0,0,11161,11162,7,
+        2,0,0,11162,11163,7,2,0,0,11163,11164,7,3,0,0,11164,1222,1,0,0,0,
+        11165,11166,7,16,0,0,11166,11167,7,11,0,0,11167,11168,7,12,0,0,11168,
+        11169,7,5,0,0,11169,11170,7,19,0,0,11170,1224,1,0,0,0,11171,11172,
+        7,16,0,0,11172,11173,7,2,0,0,11173,11174,7,11,0,0,11174,11175,7,
+        9,0,0,11175,11176,7,6,0,0,11176,11177,7,3,0,0,11177,1226,1,0,0,0,
+        11178,11179,7,16,0,0,11179,11180,7,2,0,0,11180,11181,7,11,0,0,11181,
+        11182,7,11,0,0,11182,11183,7,2,0,0,11183,11184,7,22,0,0,11184,11185,
+        7,10,0,0,11185,11186,7,7,0,0,11186,11187,7,17,0,0,11187,1228,1,0,
+        0,0,11188,11189,7,16,0,0,11189,11190,7,2,0,0,11190,11191,7,11,0,
+        0,11191,11192,7,11,0,0,11192,11193,7,2,0,0,11193,11194,7,22,0,0,
+        11194,11195,7,5,0,0,11195,1230,1,0,0,0,11196,11197,7,16,0,0,11197,
+        11198,7,2,0,0,11198,11199,7,3,0,0,11199,11200,7,0,0,0,11200,11201,
+        7,11,0,0,11201,11202,7,11,0,0,11202,1232,1,0,0,0,11203,11204,7,16,
+        0,0,11204,11205,7,2,0,0,11205,11206,7,3,0,0,11206,11207,7,8,0,0,
+        11207,11208,7,6,0,0,11208,1234,1,0,0,0,11209,11210,7,16,0,0,11210,
+        11211,7,2,0,0,11211,11212,7,3,0,0,11212,11213,7,8,0,0,11213,11214,
+        7,6,0,0,11214,11215,5,95,0,0,11215,11216,7,25,0,0,11216,11217,7,
+        14,0,0,11217,11218,7,11,0,0,11218,11219,5,95,0,0,11219,11220,7,24,
+        0,0,11220,11221,7,12,0,0,11221,11222,7,6,0,0,11222,11223,7,3,0,0,
+        11223,11224,7,18,0,0,11224,11225,5,95,0,0,11225,11226,7,3,0,0,11226,
+        11227,7,6,0,0,11227,11228,7,22,0,0,11228,11229,7,3,0,0,11229,11230,
+        7,10,0,0,11230,11231,7,4,0,0,11231,11232,7,6,0,0,11232,1236,1,0,
+        0,0,11233,11234,7,16,0,0,11234,11235,7,2,0,0,11235,11236,7,3,0,0,
+        11236,11237,7,6,0,0,11237,11238,7,10,0,0,11238,11239,7,17,0,0,11239,
+        11240,7,7,0,0,11240,1238,1,0,0,0,11241,11242,7,16,0,0,11242,11243,
+        7,2,0,0,11243,11244,7,3,0,0,11244,11245,7,6,0,0,11245,11246,7,13,
+        0,0,11246,11247,7,6,0,0,11247,11248,7,3,0,0,11248,1240,1,0,0,0,11249,
+        11250,7,16,0,0,11250,11251,7,2,0,0,11251,11252,7,3,0,0,11252,1242,
+        1,0,0,0,11253,11254,7,16,0,0,11254,11255,7,2,0,0,11255,11256,7,3,
+        0,0,11256,11257,7,14,0,0,11257,11258,7,0,0,0,11258,11259,7,4,0,0,
+        11259,1244,1,0,0,0,11260,11261,7,16,0,0,11261,11262,7,2,0,0,11262,
+        11263,7,3,0,0,11263,11264,7,22,0,0,11264,11265,7,0,0,0,11265,11266,
+        7,3,0,0,11266,11267,7,9,0,0,11267,1246,1,0,0,0,11268,11269,7,16,
+        0,0,11269,11270,7,3,0,0,11270,11271,7,0,0,0,11271,11272,7,17,0,0,
+        11272,11273,7,14,0,0,11273,11274,7,6,0,0,11274,11275,7,7,0,0,11275,
+        11276,7,4,0,0,11276,11277,5,95,0,0,11277,11278,7,7,0,0,11278,11279,
+        7,12,0,0,11279,11280,7,14,0,0,11280,11281,7,1,0,0,11281,11282,7,
+        6,0,0,11282,11283,7,3,0,0,11283,1248,1,0,0,0,11284,11285,7,16,0,
+        0,11285,11286,7,3,0,0,11286,11287,7,6,0,0,11287,11288,7,6,0,0,11288,
+        11289,7,11,0,0,11289,11290,7,10,0,0,11290,11291,7,5,0,0,11291,11292,
+        7,4,0,0,11292,1250,1,0,0,0,11293,11294,7,16,0,0,11294,11295,7,3,
+        0,0,11295,11296,7,6,0,0,11296,11297,7,6,0,0,11297,11298,7,11,0,0,
+        11298,11299,7,10,0,0,11299,11300,7,5,0,0,11300,11301,7,4,0,0,11301,
+        11302,7,5,0,0,11302,1252,1,0,0,0,11303,11304,7,16,0,0,11304,11305,
+        7,3,0,0,11305,11306,7,6,0,0,11306,11307,7,6,0,0,11307,11308,7,15,
+        0,0,11308,11309,7,2,0,0,11309,11310,7,2,0,0,11310,11311,7,11,0,0,
+        11311,11312,7,5,0,0,11312,1254,1,0,0,0,11313,11314,7,16,0,0,11314,
+        11315,7,3,0,0,11315,11316,7,6,0,0,11316,11317,7,5,0,0,11317,11318,
+        7,19,0,0,11318,1256,1,0,0,0,11319,11320,7,16,0,0,11320,11321,7,3,
+        0,0,11321,11322,7,2,0,0,11322,11323,7,14,0,0,11323,1258,1,0,0,0,
+        11324,11325,7,16,0,0,11325,11326,7,3,0,0,11326,11327,7,2,0,0,11327,
+        11328,7,14,0,0,11328,11329,5,95,0,0,11329,11330,7,4,0,0,11330,11331,
+        7,23,0,0,11331,1260,1,0,0,0,11332,11333,7,16,0,0,11333,11334,7,12,
+        0,0,11334,11335,7,11,0,0,11335,11336,7,11,0,0,11336,1262,1,0,0,0,
+        11337,11338,7,16,0,0,11338,11339,7,12,0,0,11339,11340,7,11,0,0,11340,
+        11341,7,11,0,0,11341,11342,5,95,0,0,11342,11343,7,2,0,0,11343,11344,
+        7,12,0,0,11344,11345,7,4,0,0,11345,11346,7,6,0,0,11346,11347,7,3,
+        0,0,11347,11348,5,95,0,0,11348,11349,7,20,0,0,11349,11350,7,2,0,
+        0,11350,11351,7,10,0,0,11351,11352,7,7,0,0,11352,11353,5,95,0,0,
+        11353,11354,7,4,0,0,11354,11355,7,2,0,0,11355,11356,5,95,0,0,11356,
+        11357,7,2,0,0,11357,11358,7,12,0,0,11358,11359,7,4,0,0,11359,11360,
+        7,6,0,0,11360,11361,7,3,0,0,11361,1264,1,0,0,0,11362,11363,7,16,
+        0,0,11363,11364,7,12,0,0,11364,11365,7,7,0,0,11365,11366,7,8,0,0,
+        11366,11367,7,4,0,0,11367,11368,7,10,0,0,11368,11369,7,2,0,0,11369,
+        11370,7,7,0,0,11370,1266,1,0,0,0,11371,11372,7,16,0,0,11372,11373,
+        7,12,0,0,11373,11374,7,7,0,0,11374,11375,7,8,0,0,11375,11376,7,4,
+        0,0,11376,11377,7,10,0,0,11377,11378,7,2,0,0,11378,11379,7,7,0,0,
+        11379,11380,7,5,0,0,11380,1268,1,0,0,0,11381,11382,7,16,0,0,11382,
+        11383,7,4,0,0,11383,11384,7,15,0,0,11384,1270,1,0,0,0,11385,11386,
+        7,17,0,0,11386,1272,1,0,0,0,11387,11388,7,17,0,0,11388,11389,7,0,
+        0,0,11389,11390,7,4,0,0,11390,11391,7,19,0,0,11391,11392,7,6,0,0,
+        11392,11393,7,3,0,0,11393,11394,5,95,0,0,11394,11395,7,2,0,0,11395,
+        11396,7,15,0,0,11396,11397,7,4,0,0,11397,11398,7,10,0,0,11398,11399,
+        7,14,0,0,11399,11400,7,10,0,0,11400,11401,7,23,0,0,11401,11402,7,
+        6,0,0,11402,11403,7,3,0,0,11403,11404,5,95,0,0,11404,11405,7,5,0,
+        0,11405,11406,7,4,0,0,11406,11407,7,0,0,0,11407,11408,7,4,0,0,11408,
+        11409,7,10,0,0,11409,11410,7,5,0,0,11410,11411,7,4,0,0,11411,11412,
+        7,10,0,0,11412,11413,7,8,0,0,11413,11414,7,5,0,0,11414,1274,1,0,
+        0,0,11415,11416,7,17,0,0,11416,11417,7,0,0,0,11417,11418,7,4,0,0,
+        11418,11419,7,19,0,0,11419,11420,7,6,0,0,11420,11421,7,3,0,0,11421,
+        11422,5,95,0,0,11422,11423,7,15,0,0,11423,11424,7,11,0,0,11424,11425,
+        7,0,0,0,11425,11426,7,7,0,0,11426,11427,5,95,0,0,11427,11428,7,5,
+        0,0,11428,11429,7,4,0,0,11429,11430,7,0,0,0,11430,11431,7,4,0,0,
+        11431,11432,7,10,0,0,11432,11433,7,5,0,0,11433,11434,7,4,0,0,11434,
+        11435,7,10,0,0,11435,11436,7,8,0,0,11436,11437,7,5,0,0,11437,1276,
+        1,0,0,0,11438,11439,7,17,0,0,11439,11440,7,1,0,0,11440,11441,7,18,
+        0,0,11441,11442,5,95,0,0,11442,11443,7,8,0,0,11443,11444,7,2,0,0,
+        11444,11445,7,7,0,0,11445,11446,7,8,0,0,11446,11447,5,95,0,0,11447,
+        11448,7,3,0,0,11448,11449,7,2,0,0,11449,11450,7,11,0,0,11450,11451,
+        7,11,0,0,11451,11452,7,12,0,0,11452,11453,7,15,0,0,11453,1278,1,
+        0,0,0,11454,11455,7,17,0,0,11455,11456,7,1,0,0,11456,11457,7,18,
+        0,0,11457,11458,5,95,0,0,11458,11459,7,15,0,0,11459,11460,7,12,0,
+        0,11460,11461,7,5,0,0,11461,11462,7,19,0,0,11462,11463,7,9,0,0,11463,
+        11464,7,2,0,0,11464,11465,7,22,0,0,11465,11466,7,7,0,0,11466,1280,
+        1,0,0,0,11467,11468,7,17,0,0,11468,11469,7,6,0,0,11469,11470,7,7,
+        0,0,11470,11471,7,6,0,0,11471,11472,7,3,0,0,11472,11473,7,0,0,0,
+        11473,11474,7,4,0,0,11474,11475,7,6,0,0,11475,11476,7,9,0,0,11476,
+        1282,1,0,0,0,11477,11478,7,17,0,0,11478,11479,7,6,0,0,11479,11480,
+        7,4,0,0,11480,1284,1,0,0,0,11481,11482,7,17,0,0,11482,11483,7,11,
+        0,0,11483,11484,7,2,0,0,11484,11485,7,1,0,0,11485,11486,7,0,0,0,
+        11486,11487,7,11,0,0,11487,1286,1,0,0,0,11488,11489,7,17,0,0,11489,
+        11490,7,11,0,0,11490,11491,7,2,0,0,11491,11492,7,1,0,0,11492,11493,
+        7,0,0,0,11493,11494,7,11,0,0,11494,11495,7,11,0,0,11495,11496,7,
+        18,0,0,11496,1288,1,0,0,0,11497,11498,7,17,0,0,11498,11499,7,11,
+        0,0,11499,11500,7,2,0,0,11500,11501,7,1,0,0,11501,11502,7,0,0,0,
+        11502,11503,7,11,0,0,11503,11504,5,95,0,0,11504,11505,7,7,0,0,11505,
+        11506,7,0,0,0,11506,11507,7,14,0,0,11507,11508,7,6,0,0,11508,1290,
+        1,0,0,0,11509,11510,7,17,0,0,11510,11511,7,11,0,0,11511,11512,7,
+        2,0,0,11512,11513,7,1,0,0,11513,11514,7,0,0,0,11514,11515,7,11,0,
+        0,11515,11516,5,95,0,0,11516,11517,7,4,0,0,11517,11518,7,2,0,0,11518,
+        11519,7,15,0,0,11519,11520,7,10,0,0,11520,11521,7,8,0,0,11521,11522,
+        5,95,0,0,11522,11523,7,6,0,0,11523,11524,7,7,0,0,11524,11525,7,0,
+        0,0,11525,11526,7,1,0,0,11526,11527,7,11,0,0,11527,11528,7,6,0,0,
+        11528,11529,7,9,0,0,11529,1292,1,0,0,0,11530,11531,7,17,0,0,11531,
+        11532,7,2,0,0,11532,11533,7,4,0,0,11533,11534,7,2,0,0,11534,1294,
+        1,0,0,0,11535,11536,7,17,0,0,11536,11537,7,3,0,0,11537,11538,7,0,
+        0,0,11538,11539,7,7,0,0,11539,11540,7,4,0,0,11540,1296,1,0,0,0,11541,
+        11542,7,17,0,0,11542,11543,7,3,0,0,11543,11544,7,2,0,0,11544,11545,
+        7,12,0,0,11545,11546,7,15,0,0,11546,11547,5,95,0,0,11547,11548,7,
+        1,0,0,11548,11549,7,18,0,0,11549,1298,1,0,0,0,11550,11551,7,17,0,
+        0,11551,11552,7,3,0,0,11552,11553,7,2,0,0,11553,11554,7,12,0,0,11554,
+        11555,7,15,0,0,11555,1300,1,0,0,0,11556,11557,7,17,0,0,11557,11558,
+        7,3,0,0,11558,11559,7,2,0,0,11559,11560,7,12,0,0,11560,11561,7,15,
+        0,0,11561,11562,5,95,0,0,11562,11563,7,10,0,0,11563,11564,7,9,0,
+        0,11564,1302,1,0,0,0,11565,11566,7,17,0,0,11566,11567,7,3,0,0,11567,
+        11568,7,2,0,0,11568,11569,7,12,0,0,11569,11570,7,15,0,0,11570,11571,
+        7,10,0,0,11571,11572,7,7,0,0,11572,11573,7,17,0,0,11573,1304,1,0,
+        0,0,11574,11575,7,17,0,0,11575,11576,7,3,0,0,11576,11577,7,2,0,0,
+        11577,11578,7,12,0,0,11578,11579,7,15,0,0,11579,11580,7,10,0,0,11580,
+        11581,7,7,0,0,11581,11582,7,17,0,0,11582,11583,5,95,0,0,11583,11584,
+        7,10,0,0,11584,11585,7,9,0,0,11585,1306,1,0,0,0,11586,11587,7,17,
+        0,0,11587,11588,7,3,0,0,11588,11589,7,2,0,0,11589,11590,7,12,0,0,
+        11590,11591,7,15,0,0,11591,11592,7,5,0,0,11592,1308,1,0,0,0,11593,
+        11594,7,17,0,0,11594,11595,7,12,0,0,11595,11596,7,0,0,0,11596,11597,
+        7,3,0,0,11597,11598,7,0,0,0,11598,11599,7,7,0,0,11599,11600,7,4,
+        0,0,11600,11601,7,6,0,0,11601,11602,7,6,0,0,11602,11603,7,9,0,0,
+        11603,1310,1,0,0,0,11604,11605,7,17,0,0,11605,11606,7,12,0,0,11606,
+        11607,7,0,0,0,11607,11608,7,3,0,0,11608,11609,7,0,0,0,11609,11610,
+        7,7,0,0,11610,11611,7,4,0,0,11611,11612,7,6,0,0,11612,11613,7,6,
+        0,0,11613,1312,1,0,0,0,11614,11615,7,17,0,0,11615,11616,7,12,0,0,
+        11616,11617,7,0,0,0,11617,11618,7,3,0,0,11618,11619,7,9,0,0,11619,
+        1314,1,0,0,0,11620,11621,7,19,0,0,11621,11622,7,0,0,0,11622,11623,
+        7,9,0,0,11623,11624,7,2,0,0,11624,11625,7,2,0,0,11625,11626,7,15,
+        0,0,11626,11627,5,95,0,0,11627,11628,7,4,0,0,11628,11629,7,3,0,0,
+        11629,11630,7,0,0,0,11630,11631,7,10,0,0,11631,11632,7,11,0,0,11632,
+        11633,7,6,0,0,11633,11634,7,3,0,0,11634,11635,7,5,0,0,11635,1316,
+        1,0,0,0,11636,11637,7,19,0,0,11637,11638,7,0,0,0,11638,11639,7,11,
+        0,0,11639,11640,7,16,0,0,11640,11641,5,95,0,0,11641,11642,7,18,0,
+        0,11642,11643,7,6,0,0,11643,11644,7,0,0,0,11644,11645,7,3,0,0,11645,
+        11646,7,5,0,0,11646,1318,1,0,0,0,11647,11648,7,19,0,0,11648,11649,
+        7,0,0,0,11649,11650,7,5,0,0,11650,11651,7,19,0,0,11651,11652,5,95,
+        0,0,11652,11653,7,0,0,0,11653,11654,7,20,0,0,11654,1320,1,0,0,0,
+        11655,11656,7,19,0,0,11656,11657,7,0,0,0,11657,11658,7,5,0,0,11658,
+        11659,7,19,0,0,11659,1322,1,0,0,0,11660,11661,7,19,0,0,11661,11662,
+        7,0,0,0,11662,11663,7,5,0,0,11663,11664,7,19,0,0,11664,11665,7,21,
+        0,0,11665,11666,7,6,0,0,11666,11667,7,18,0,0,11667,11668,7,5,0,0,
+        11668,1324,1,0,0,0,11669,11670,7,19,0,0,11670,11671,7,0,0,0,11671,
+        11672,7,5,0,0,11672,11673,7,19,0,0,11673,11674,5,95,0,0,11674,11675,
+        7,5,0,0,11675,11676,7,20,0,0,11676,1326,1,0,0,0,11677,11678,7,19,
+        0,0,11678,11679,7,0,0,0,11679,11680,7,13,0,0,11680,11681,7,10,0,
+        0,11681,11682,7,7,0,0,11682,11683,7,17,0,0,11683,1328,1,0,0,0,11684,
+        11685,7,19,0,0,11685,11686,7,6,0,0,11686,11687,7,0,0,0,11687,11688,
+        7,9,0,0,11688,11689,7,6,0,0,11689,11690,7,3,0,0,11690,1330,1,0,0,
+        0,11691,11692,7,19,0,0,11692,11693,7,6,0,0,11693,11694,7,0,0,0,11694,
+        11695,7,15,0,0,11695,1332,1,0,0,0,11696,11697,7,19,0,0,11697,11698,
+        7,6,0,0,11698,11699,7,11,0,0,11699,11700,7,15,0,0,11700,1334,1,0,
+        0,0,11701,11702,7,19,0,0,11702,11703,7,6,0,0,11703,11704,7,25,0,
+        0,11704,11705,7,4,0,0,11705,11706,7,2,0,0,11706,11707,7,3,0,0,11707,
+        11708,7,0,0,0,11708,11709,7,22,0,0,11709,1336,1,0,0,0,11710,11711,
+        7,19,0,0,11711,11712,7,6,0,0,11712,11713,7,25,0,0,11713,11714,7,
+        4,0,0,11714,11715,7,2,0,0,11715,11716,7,3,0,0,11716,11717,7,6,0,
+        0,11717,11718,7,16,0,0,11718,1338,1,0,0,0,11719,11720,7,19,0,0,11720,
+        11721,7,10,0,0,11721,11722,7,9,0,0,11722,11723,7,9,0,0,11723,11724,
+        7,6,0,0,11724,11725,7,7,0,0,11725,1340,1,0,0,0,11726,11727,7,19,
+        0,0,11727,11728,7,10,0,0,11728,11729,7,9,0,0,11729,11730,7,6,0,0,
+        11730,1342,1,0,0,0,11731,11732,7,19,0,0,11732,11733,7,10,0,0,11733,
+        11734,7,6,0,0,11734,11735,7,3,0,0,11735,11736,5,95,0,0,11736,11737,
+        7,2,0,0,11737,11738,7,3,0,0,11738,11739,7,9,0,0,11739,11740,7,6,
+        0,0,11740,11741,7,3,0,0,11741,1344,1,0,0,0,11742,11743,7,19,0,0,
+        11743,11744,7,10,0,0,11744,11745,7,6,0,0,11745,11746,7,3,0,0,11746,
+        11747,7,0,0,0,11747,11748,7,3,0,0,11748,11749,7,8,0,0,11749,11750,
+        7,19,0,0,11750,11751,7,10,0,0,11751,11752,7,8,0,0,11752,11753,7,
+        0,0,0,11753,11754,7,11,0,0,11754,1346,1,0,0,0,11755,11756,7,19,0,
+        0,11756,11757,7,10,0,0,11757,11758,7,6,0,0,11758,11759,7,3,0,0,11759,
+        11760,7,0,0,0,11760,11761,7,3,0,0,11761,11762,7,8,0,0,11762,11763,
+        7,19,0,0,11763,11764,7,10,0,0,11764,11765,7,6,0,0,11765,11766,7,
+        5,0,0,11766,1348,1,0,0,0,11767,11768,7,19,0,0,11768,11769,7,10,0,
+        0,11769,11770,7,6,0,0,11770,11771,7,3,0,0,11771,11772,7,0,0,0,11772,
+        11773,7,3,0,0,11773,11774,7,8,0,0,11774,11775,7,19,0,0,11775,11776,
+        7,18,0,0,11776,1350,1,0,0,0,11777,11778,7,19,0,0,11778,11779,7,10,
+        0,0,11779,11780,7,17,0,0,11780,11781,7,19,0,0,11781,1352,1,0,0,0,
+        11782,11783,7,19,0,0,11783,11784,7,10,0,0,11784,11785,7,7,0,0,11785,
+        11786,7,4,0,0,11786,11787,7,5,0,0,11787,11788,7,6,0,0,11788,11789,
+        7,4,0,0,11789,11790,5,95,0,0,11790,11791,7,1,0,0,11791,11792,7,6,
+        0,0,11792,11793,7,17,0,0,11793,11794,7,10,0,0,11794,11795,7,7,0,
+        0,11795,1354,1,0,0,0,11796,11797,7,19,0,0,11797,11798,7,10,0,0,11798,
+        11799,7,7,0,0,11799,11800,7,4,0,0,11800,11801,7,5,0,0,11801,11802,
+        7,6,0,0,11802,11803,7,4,0,0,11803,11804,5,95,0,0,11804,11805,7,6,
+        0,0,11805,11806,7,7,0,0,11806,11807,7,9,0,0,11807,1356,1,0,0,0,11808,
+        11809,7,19,0,0,11809,11810,7,2,0,0,11810,11811,7,4,0,0,11811,1358,
+        1,0,0,0,11812,11813,7,19,0,0,11813,11814,7,2,0,0,11814,11815,7,12,
+        0,0,11815,11816,7,3,0,0,11816,1360,1,0,0,0,11817,11818,7,19,0,0,
+        11818,11819,7,2,0,0,11819,11820,7,12,0,0,11820,11821,7,3,0,0,11821,
+        11822,7,5,0,0,11822,1362,1,0,0,0,11823,11824,7,19,0,0,11824,11825,
+        7,4,0,0,11825,11826,7,4,0,0,11826,11827,7,15,0,0,11827,1364,1,0,
+        0,0,11828,11829,7,19,0,0,11829,11830,7,22,0,0,11830,11831,7,14,0,
+        0,11831,11832,5,95,0,0,11832,11833,7,1,0,0,11833,11834,7,3,0,0,11834,
+        11835,7,2,0,0,11835,11836,7,21,0,0,11836,11837,7,6,0,0,11837,11838,
+        7,3,0,0,11838,11839,7,6,0,0,11839,11840,7,9,0,0,11840,1366,1,0,0,
+        0,11841,11842,7,19,0,0,11842,11843,7,18,0,0,11843,11844,7,1,0,0,
+        11844,11845,7,3,0,0,11845,11846,7,10,0,0,11846,11847,7,9,0,0,11847,
+        1368,1,0,0,0,11848,11849,7,19,0,0,11849,1370,1,0,0,0,11850,11851,
+        7,10,0,0,11851,11852,7,9,0,0,11852,11853,7,6,0,0,11853,11854,7,7,
+        0,0,11854,11855,7,4,0,0,11855,11856,7,10,0,0,11856,11857,7,16,0,
+        0,11857,11858,7,10,0,0,11858,11859,7,6,0,0,11859,11860,7,9,0,0,11860,
+        1372,1,0,0,0,11861,11862,7,10,0,0,11862,11863,7,9,0,0,11863,11864,
+        7,6,0,0,11864,11865,7,7,0,0,11865,11866,7,4,0,0,11866,11867,7,10,
+        0,0,11867,11868,7,16,0,0,11868,11869,7,10,0,0,11869,11870,7,6,0,
+        0,11870,11871,7,3,0,0,11871,1374,1,0,0,0,11872,11873,7,10,0,0,11873,
+        11874,7,9,0,0,11874,11875,7,6,0,0,11875,11876,7,7,0,0,11876,11877,
+        7,4,0,0,11877,11878,7,10,0,0,11878,11879,7,4,0,0,11879,11880,7,18,
+        0,0,11880,1376,1,0,0,0,11881,11882,7,10,0,0,11882,11883,7,9,0,0,
+        11883,11884,7,17,0,0,11884,11885,7,6,0,0,11885,11886,7,7,0,0,11886,
+        11887,7,6,0,0,11887,11888,7,3,0,0,11888,11889,7,0,0,0,11889,11890,
+        7,4,0,0,11890,11891,7,2,0,0,11891,11892,7,3,0,0,11892,11893,7,5,
+        0,0,11893,1378,1,0,0,0,11894,11895,7,10,0,0,11895,11896,7,9,0,0,
+        11896,1380,1,0,0,0,11897,11898,7,10,0,0,11898,11899,7,9,0,0,11899,
+        11900,7,11,0,0,11900,11901,7,6,0,0,11901,11902,5,95,0,0,11902,11903,
+        7,4,0,0,11903,11904,7,10,0,0,11904,11905,7,14,0,0,11905,11906,7,
+        6,0,0,11906,1382,1,0,0,0,11907,11908,7,10,0,0,11908,11909,7,16,0,
+        0,11909,1384,1,0,0,0,11910,11911,7,10,0,0,11911,11912,7,17,0,0,11912,
+        11913,7,7,0,0,11913,11914,7,2,0,0,11914,11915,7,3,0,0,11915,11916,
+        7,6,0,0,11916,1386,1,0,0,0,11917,11918,7,10,0,0,11918,11919,7,17,
+        0,0,11919,11920,7,7,0,0,11920,11921,7,2,0,0,11921,11922,7,3,0,0,
+        11922,11923,7,6,0,0,11923,11924,5,95,0,0,11924,11925,7,8,0,0,11925,
+        11926,7,19,0,0,11926,11927,7,0,0,0,11927,11928,7,3,0,0,11928,11929,
+        7,5,0,0,11929,11930,5,95,0,0,11930,11931,7,0,0,0,11931,11932,7,16,
+        0,0,11932,11933,7,4,0,0,11933,11934,7,6,0,0,11934,11935,7,3,0,0,
+        11935,11936,5,95,0,0,11936,11937,7,6,0,0,11937,11938,7,2,0,0,11938,
+        11939,7,3,0,0,11939,1388,1,0,0,0,11940,11941,7,10,0,0,11941,11942,
+        7,17,0,0,11942,11943,7,7,0,0,11943,11944,7,2,0,0,11944,11945,7,3,
+        0,0,11945,11946,7,6,0,0,11946,11947,5,95,0,0,11947,11948,7,2,0,0,
+        11948,11949,7,15,0,0,11949,11950,7,4,0,0,11950,11951,7,10,0,0,11951,
+        11952,7,14,0,0,11952,11953,5,95,0,0,11953,11954,7,6,0,0,11954,11955,
+        7,14,0,0,11955,11956,7,1,0,0,11956,11957,7,6,0,0,11957,11958,7,9,
+        0,0,11958,11959,7,9,0,0,11959,11960,7,6,0,0,11960,11961,7,9,0,0,
+        11961,11962,5,95,0,0,11962,11963,7,19,0,0,11963,11964,7,10,0,0,11964,
+        11965,7,7,0,0,11965,11966,7,4,0,0,11966,11967,7,5,0,0,11967,1390,
+        1,0,0,0,11968,11969,7,10,0,0,11969,11970,7,17,0,0,11970,11971,7,
+        7,0,0,11971,11972,7,2,0,0,11972,11973,7,3,0,0,11973,11974,7,6,0,
+        0,11974,11975,5,95,0,0,11975,11976,7,3,0,0,11976,11977,7,2,0,0,11977,
+        11978,7,22,0,0,11978,11979,5,95,0,0,11979,11980,7,2,0,0,11980,11981,
+        7,7,0,0,11981,11982,5,95,0,0,11982,11983,7,9,0,0,11983,11984,7,12,
+        0,0,11984,11985,7,15,0,0,11985,11986,7,21,0,0,11986,11987,7,6,0,
+        0,11987,11988,7,18,0,0,11988,11989,5,95,0,0,11989,11990,7,10,0,0,
+        11990,11991,7,7,0,0,11991,11992,7,9,0,0,11992,11993,7,6,0,0,11993,
+        11994,7,25,0,0,11994,1392,1,0,0,0,11995,11996,7,10,0,0,11996,11997,
+        7,17,0,0,11997,11998,7,7,0,0,11998,11999,7,2,0,0,11999,12000,7,3,
+        0,0,12000,12001,7,6,0,0,12001,12002,5,95,0,0,12002,12003,7,22,0,
+        0,12003,12004,7,19,0,0,12004,12005,7,6,0,0,12005,12006,7,3,0,0,12006,
+        12007,7,6,0,0,12007,12008,5,95,0,0,12008,12009,7,8,0,0,12009,12010,
+        7,11,0,0,12010,12011,7,0,0,0,12011,12012,7,12,0,0,12012,12013,7,
+        5,0,0,12013,12014,7,6,0,0,12014,1394,1,0,0,0,12015,12016,7,10,0,
+        0,12016,12017,7,11,0,0,12017,12018,7,14,0,0,12018,1396,1,0,0,0,12019,
+        12020,7,10,0,0,12020,12021,7,14,0,0,12021,12022,7,14,0,0,12022,12023,
+        7,6,0,0,12023,12024,7,9,0,0,12024,12025,7,10,0,0,12025,12026,7,0,
+        0,0,12026,12027,7,4,0,0,12027,12028,7,6,0,0,12028,1398,1,0,0,0,12029,
+        12030,7,10,0,0,12030,12031,7,14,0,0,12031,12032,7,15,0,0,12032,12033,
+        7,0,0,0,12033,12034,7,8,0,0,12034,12035,7,4,0,0,12035,1400,1,0,0,
+        0,12036,12037,7,10,0,0,12037,12038,7,14,0,0,12038,12039,7,15,0,0,
+        12039,12040,7,2,0,0,12040,12041,7,3,0,0,12041,12042,7,4,0,0,12042,
+        1402,1,0,0,0,12043,12044,7,10,0,0,12044,12045,7,7,0,0,12045,12046,
+        7,0,0,0,12046,12047,7,8,0,0,12047,12048,7,4,0,0,12048,12049,7,10,
+        0,0,12049,12050,7,13,0,0,12050,12051,7,6,0,0,12051,1404,1,0,0,0,
+        12052,12053,7,10,0,0,12053,12054,7,7,0,0,12054,12055,7,0,0,0,12055,
+        12056,7,8,0,0,12056,12057,7,4,0,0,12057,12058,7,10,0,0,12058,12059,
+        7,13,0,0,12059,12060,7,6,0,0,12060,12061,5,95,0,0,12061,12062,7,
+        0,0,0,12062,12063,7,8,0,0,12063,12064,7,8,0,0,12064,12065,7,2,0,
+        0,12065,12066,7,12,0,0,12066,12067,7,7,0,0,12067,12068,7,4,0,0,12068,
+        12069,5,95,0,0,12069,12070,7,4,0,0,12070,12071,7,10,0,0,12071,12072,
+        7,14,0,0,12072,12073,7,6,0,0,12073,1406,1,0,0,0,12074,12075,7,10,
+        0,0,12075,12076,7,7,0,0,12076,12077,7,8,0,0,12077,12078,7,11,0,0,
+        12078,12079,7,12,0,0,12079,12080,7,9,0,0,12080,12081,7,6,0,0,12081,
+        1408,1,0,0,0,12082,12083,7,10,0,0,12083,12084,7,7,0,0,12084,12085,
+        7,8,0,0,12085,12086,7,11,0,0,12086,12087,7,12,0,0,12087,12088,7,
+        9,0,0,12088,12089,7,6,0,0,12089,12090,5,95,0,0,12090,12091,7,13,
+        0,0,12091,12092,7,6,0,0,12092,12093,7,3,0,0,12093,12094,7,5,0,0,
+        12094,12095,7,10,0,0,12095,12096,7,2,0,0,12096,12097,7,7,0,0,12097,
+        1410,1,0,0,0,12098,12099,7,10,0,0,12099,12100,7,7,0,0,12100,12101,
+        7,8,0,0,12101,12102,7,11,0,0,12102,12103,7,12,0,0,12103,12104,7,
+        9,0,0,12104,12105,7,10,0,0,12105,12106,7,7,0,0,12106,12107,7,17,
+        0,0,12107,1412,1,0,0,0,12108,12109,7,10,0,0,12109,12110,7,7,0,0,
+        12110,12111,7,8,0,0,12111,12112,7,3,0,0,12112,12113,7,6,0,0,12113,
+        12114,7,14,0,0,12114,12115,7,6,0,0,12115,12116,7,7,0,0,12116,12117,
+        7,4,0,0,12117,12118,7,0,0,0,12118,12119,7,11,0,0,12119,1414,1,0,
+        0,0,12120,12121,7,10,0,0,12121,12122,7,7,0,0,12122,12123,7,8,0,0,
+        12123,12124,7,3,0,0,12124,12125,7,6,0,0,12125,12126,7,14,0,0,12126,
+        12127,7,6,0,0,12127,12128,7,7,0,0,12128,12129,7,4,0,0,12129,1416,
+        1,0,0,0,12130,12131,7,10,0,0,12131,12132,7,7,0,0,12132,12133,7,8,
+        0,0,12133,12134,7,3,0,0,12134,1418,1,0,0,0,12135,12136,7,10,0,0,
+        12136,12137,7,7,0,0,12137,12138,7,9,0,0,12138,12139,7,6,0,0,12139,
+        12140,7,7,0,0,12140,12141,7,4,0,0,12141,1420,1,0,0,0,12142,12143,
+        7,10,0,0,12143,12144,7,7,0,0,12144,12145,7,9,0,0,12145,12146,7,6,
+        0,0,12146,12147,7,25,0,0,12147,12148,5,95,0,0,12148,12149,7,0,0,
+        0,12149,12150,7,5,0,0,12150,12151,7,8,0,0,12151,1422,1,0,0,0,12152,
+        12153,7,10,0,0,12153,12154,7,7,0,0,12154,12155,7,9,0,0,12155,12156,
+        7,6,0,0,12156,12157,7,25,0,0,12157,12158,5,95,0,0,12158,12159,7,
+        8,0,0,12159,12160,7,2,0,0,12160,12161,7,14,0,0,12161,12162,7,1,0,
+        0,12162,12163,7,10,0,0,12163,12164,7,7,0,0,12164,12165,7,6,0,0,12165,
+        1424,1,0,0,0,12166,12167,7,10,0,0,12167,12168,7,7,0,0,12168,12169,
+        7,9,0,0,12169,12170,7,6,0,0,12170,12171,7,25,0,0,12171,12172,5,95,
+        0,0,12172,12173,7,9,0,0,12173,12174,7,6,0,0,12174,12175,7,5,0,0,
+        12175,12176,7,8,0,0,12176,1426,1,0,0,0,12177,12178,7,10,0,0,12178,
+        12179,7,7,0,0,12179,12180,7,9,0,0,12180,12181,7,6,0,0,12181,12182,
+        7,25,0,0,12182,12183,7,6,0,0,12183,12184,7,9,0,0,12184,1428,1,0,
+        0,0,12185,12186,7,10,0,0,12186,12187,7,7,0,0,12187,12188,7,9,0,0,
+        12188,12189,7,6,0,0,12189,12190,7,25,0,0,12190,12191,7,6,0,0,12191,
+        12192,7,5,0,0,12192,1430,1,0,0,0,12193,12194,7,10,0,0,12194,12195,
+        7,7,0,0,12195,12196,7,9,0,0,12196,12197,7,6,0,0,12197,12198,7,25,
+        0,0,12198,12199,5,95,0,0,12199,12200,7,16,0,0,12200,12201,7,16,0,
+        0,12201,12202,7,5,0,0,12202,1432,1,0,0,0,12203,12204,7,10,0,0,12204,
+        12205,7,7,0,0,12205,12206,7,9,0,0,12206,12207,7,6,0,0,12207,12208,
+        7,25,0,0,12208,12209,5,95,0,0,12209,12210,7,16,0,0,12210,12211,7,
+        10,0,0,12211,12212,7,11,0,0,12212,12213,7,4,0,0,12213,12214,7,6,
+        0,0,12214,12215,7,3,0,0,12215,1434,1,0,0,0,12216,12217,7,10,0,0,
+        12217,12218,7,7,0,0,12218,12219,7,9,0,0,12219,12220,7,6,0,0,12220,
+        12221,7,25,0,0,12221,1436,1,0,0,0,12222,12223,7,10,0,0,12223,12224,
+        7,7,0,0,12224,12225,7,9,0,0,12225,12226,7,6,0,0,12226,12227,7,25,
+        0,0,12227,12228,7,10,0,0,12228,12229,7,7,0,0,12229,12230,7,17,0,
+        0,12230,1438,1,0,0,0,12231,12232,7,10,0,0,12232,12233,7,7,0,0,12233,
+        12234,7,9,0,0,12234,12235,7,6,0,0,12235,12236,7,25,0,0,12236,12237,
+        5,95,0,0,12237,12238,7,20,0,0,12238,12239,7,2,0,0,12239,12240,7,
+        10,0,0,12240,12241,7,7,0,0,12241,1440,1,0,0,0,12242,12243,7,10,0,
+        0,12243,12244,7,7,0,0,12244,12245,7,9,0,0,12245,12246,7,6,0,0,12246,
+        12247,7,25,0,0,12247,12248,5,95,0,0,12248,12249,7,3,0,0,12249,12250,
+        7,2,0,0,12250,12251,7,22,0,0,12251,12252,7,5,0,0,12252,1442,1,0,
+        0,0,12253,12254,7,10,0,0,12254,12255,7,7,0,0,12255,12256,7,9,0,0,
+        12256,12257,7,6,0,0,12257,12258,7,25,0,0,12258,12259,5,95,0,0,12259,
+        12260,7,3,0,0,12260,12261,7,3,0,0,12261,12262,7,5,0,0,12262,1444,
+        1,0,0,0,12263,12264,7,10,0,0,12264,12265,7,7,0,0,12265,12266,7,9,
+        0,0,12266,12267,7,6,0,0,12267,12268,7,25,0,0,12268,12269,5,95,0,
+        0,12269,12270,7,3,0,0,12270,12271,7,5,0,0,12271,12272,5,95,0,0,12272,
+        12273,7,0,0,0,12273,12274,7,5,0,0,12274,12275,7,8,0,0,12275,1446,
+        1,0,0,0,12276,12277,7,10,0,0,12277,12278,7,7,0,0,12278,12279,7,9,
+        0,0,12279,12280,7,6,0,0,12280,12281,7,25,0,0,12281,12282,5,95,0,
+        0,12282,12283,7,3,0,0,12283,12284,7,5,0,0,12284,12285,5,95,0,0,12285,
+        12286,7,9,0,0,12286,12287,7,6,0,0,12287,12288,7,5,0,0,12288,12289,
+        7,8,0,0,12289,1448,1,0,0,0,12290,12291,7,10,0,0,12291,12292,7,7,
+        0,0,12292,12293,7,9,0,0,12293,12294,7,6,0,0,12294,12295,7,25,0,0,
+        12295,12296,5,95,0,0,12296,12297,7,3,0,0,12297,12298,7,5,0,0,12298,
+        1450,1,0,0,0,12299,12300,7,10,0,0,12300,12301,7,7,0,0,12301,12302,
+        7,9,0,0,12302,12303,7,6,0,0,12303,12304,7,25,0,0,12304,12305,5,95,
+        0,0,12305,12306,7,5,0,0,12306,12307,7,8,0,0,12307,12308,7,0,0,0,
+        12308,12309,7,7,0,0,12309,1452,1,0,0,0,12310,12311,7,10,0,0,12311,
+        12312,7,7,0,0,12312,12313,7,9,0,0,12313,12314,7,6,0,0,12314,12315,
+        7,25,0,0,12315,12316,5,95,0,0,12316,12317,7,5,0,0,12317,12318,7,
+        21,0,0,12318,12319,7,10,0,0,12319,12320,7,15,0,0,12320,12321,5,95,
+        0,0,12321,12322,7,5,0,0,12322,12323,7,8,0,0,12323,12324,7,0,0,0,
+        12324,12325,7,7,0,0,12325,1454,1,0,0,0,12326,12327,7,10,0,0,12327,
+        12328,7,7,0,0,12328,12329,7,9,0,0,12329,12330,7,6,0,0,12330,12331,
+        7,25,0,0,12331,12332,5,95,0,0,12332,12333,7,5,0,0,12333,12334,7,
+        5,0,0,12334,12335,5,95,0,0,12335,12336,7,0,0,0,12336,12337,7,5,0,
+        0,12337,12338,7,8,0,0,12338,1456,1,0,0,0,12339,12340,7,10,0,0,12340,
+        12341,7,7,0,0,12341,12342,7,9,0,0,12342,12343,7,6,0,0,12343,12344,
+        7,25,0,0,12344,12345,5,95,0,0,12345,12346,7,5,0,0,12346,12347,7,
+        5,0,0,12347,12348,5,95,0,0,12348,12349,7,9,0,0,12349,12350,7,6,0,
+        0,12350,12351,7,5,0,0,12351,12352,7,8,0,0,12352,1458,1,0,0,0,12353,
+        12354,7,10,0,0,12354,12355,7,7,0,0,12355,12356,7,9,0,0,12356,12357,
+        7,6,0,0,12357,12358,7,25,0,0,12358,12359,5,95,0,0,12359,12360,7,
+        5,0,0,12360,12361,7,5,0,0,12361,1460,1,0,0,0,12362,12363,7,10,0,
+        0,12363,12364,7,7,0,0,12364,12365,7,9,0,0,12365,12366,7,6,0,0,12366,
+        12367,7,25,0,0,12367,12368,5,95,0,0,12368,12369,7,5,0,0,12369,12370,
+        7,4,0,0,12370,12371,7,0,0,0,12371,12372,7,4,0,0,12372,12373,7,5,
+        0,0,12373,1462,1,0,0,0,12374,12375,7,10,0,0,12375,12376,7,7,0,0,
+        12376,12377,7,9,0,0,12377,12378,7,6,0,0,12378,12379,7,25,0,0,12379,
+        12380,7,4,0,0,12380,12381,7,18,0,0,12381,12382,7,15,0,0,12382,12383,
+        7,6,0,0,12383,1464,1,0,0,0,12384,12385,7,10,0,0,12385,12386,7,7,
+        0,0,12386,12387,7,9,0,0,12387,12388,7,6,0,0,12388,12389,7,25,0,0,
+        12389,12390,7,4,0,0,12390,12391,7,18,0,0,12391,12392,7,15,0,0,12392,
+        12393,7,6,0,0,12393,12394,7,5,0,0,12394,1466,1,0,0,0,12395,12396,
+        7,10,0,0,12396,12397,7,7,0,0,12397,12398,7,9,0,0,12398,12399,7,10,
+        0,0,12399,12400,7,8,0,0,12400,12401,7,0,0,0,12401,12402,7,4,0,0,
+        12402,12403,7,2,0,0,12403,12404,7,3,0,0,12404,1468,1,0,0,0,12405,
+        12406,7,10,0,0,12406,12407,7,7,0,0,12407,12408,7,9,0,0,12408,12409,
+        7,10,0,0,12409,12410,7,8,0,0,12410,12411,7,6,0,0,12411,12412,7,5,
+        0,0,12412,1470,1,0,0,0,12413,12414,7,10,0,0,12414,12415,7,7,0,0,
+        12415,12416,7,16,0,0,12416,12417,7,10,0,0,12417,12418,7,7,0,0,12418,
+        12419,7,10,0,0,12419,12420,7,4,0,0,12420,12421,7,6,0,0,12421,1472,
+        1,0,0,0,12422,12423,7,10,0,0,12423,12424,7,7,0,0,12424,12425,7,16,
+        0,0,12425,12426,7,2,0,0,12426,12427,7,3,0,0,12427,12428,7,14,0,0,
+        12428,12429,7,0,0,0,12429,12430,7,4,0,0,12430,12431,7,10,0,0,12431,
+        12432,7,2,0,0,12432,12433,7,7,0,0,12433,12434,7,0,0,0,12434,12435,
+        7,11,0,0,12435,1474,1,0,0,0,12436,12437,7,10,0,0,12437,12438,7,7,
+        0,0,12438,12439,7,19,0,0,12439,12440,7,6,0,0,12440,12441,7,3,0,0,
+        12441,12442,7,10,0,0,12442,12443,7,4,0,0,12443,1476,1,0,0,0,12444,
+        12445,7,10,0,0,12445,12446,7,7,0,0,12446,1478,1,0,0,0,12447,12448,
+        7,10,0,0,12448,12449,7,7,0,0,12449,12450,7,10,0,0,12450,12451,7,
+        4,0,0,12451,12452,7,8,0,0,12452,12453,7,0,0,0,12453,12454,7,15,0,
+        0,12454,1480,1,0,0,0,12455,12456,7,10,0,0,12456,12457,7,7,0,0,12457,
+        12458,7,10,0,0,12458,12459,7,4,0,0,12459,12460,7,10,0,0,12460,12461,
+        7,0,0,0,12461,12462,7,11,0,0,12462,1482,1,0,0,0,12463,12464,7,10,
+        0,0,12464,12465,7,7,0,0,12465,12466,7,10,0,0,12466,12467,7,4,0,0,
+        12467,12468,7,10,0,0,12468,12469,7,0,0,0,12469,12470,7,11,0,0,12470,
+        12471,7,10,0,0,12471,12472,7,23,0,0,12472,12473,7,6,0,0,12473,12474,
+        7,9,0,0,12474,1484,1,0,0,0,12475,12476,7,10,0,0,12476,12477,7,7,
+        0,0,12477,12478,7,10,0,0,12478,12479,7,4,0,0,12479,12480,7,10,0,
+        0,12480,12481,7,0,0,0,12481,12482,7,11,0,0,12482,12483,7,11,0,0,
+        12483,12484,7,18,0,0,12484,1486,1,0,0,0,12485,12486,7,10,0,0,12486,
+        12487,7,7,0,0,12487,12488,7,10,0,0,12488,12489,7,4,0,0,12489,12490,
+        7,3,0,0,12490,12491,7,0,0,0,12491,12492,7,7,0,0,12492,12493,7,5,
+        0,0,12493,1488,1,0,0,0,12494,12495,7,10,0,0,12495,12496,7,7,0,0,
+        12496,12497,7,11,0,0,12497,12498,7,10,0,0,12498,12499,7,7,0,0,12499,
+        12500,7,6,0,0,12500,1490,1,0,0,0,12501,12502,7,10,0,0,12502,12503,
+        7,7,0,0,12503,12504,7,11,0,0,12504,12505,7,10,0,0,12505,12506,7,
+        7,0,0,12506,12507,7,6,0,0,12507,12508,5,95,0,0,12508,12509,7,25,
+        0,0,12509,12510,7,14,0,0,12510,12511,7,11,0,0,12511,12512,7,4,0,
+        0,12512,12513,7,18,0,0,12513,12514,7,15,0,0,12514,12515,7,6,0,0,
+        12515,12516,5,95,0,0,12516,12517,7,7,0,0,12517,12518,7,4,0,0,12518,
+        1492,1,0,0,0,12519,12520,7,10,0,0,12520,12521,7,7,0,0,12521,12522,
+        7,14,0,0,12522,12523,7,6,0,0,12523,12524,7,14,0,0,12524,12525,7,
+        2,0,0,12525,12526,7,3,0,0,12526,12527,7,18,0,0,12527,1494,1,0,0,
+        0,12528,12529,7,10,0,0,12529,12530,7,7,0,0,12530,12531,5,95,0,0,
+        12531,12532,7,14,0,0,12532,12533,7,6,0,0,12533,12534,7,14,0,0,12534,
+        12535,7,2,0,0,12535,12536,7,3,0,0,12536,12537,7,18,0,0,12537,12538,
+        5,95,0,0,12538,12539,7,14,0,0,12539,12540,7,6,0,0,12540,12541,7,
+        4,0,0,12541,12542,7,0,0,0,12542,12543,7,9,0,0,12543,12544,7,0,0,
+        0,12544,12545,7,4,0,0,12545,12546,7,0,0,0,12546,1496,1,0,0,0,12547,
+        12548,7,10,0,0,12548,12549,7,7,0,0,12549,12550,7,14,0,0,12550,12551,
+        7,6,0,0,12551,12552,7,14,0,0,12552,12553,7,2,0,0,12553,12554,7,3,
+        0,0,12554,12555,7,18,0,0,12555,12556,5,95,0,0,12556,12557,7,15,0,
+        0,12557,12558,7,3,0,0,12558,12559,7,12,0,0,12559,12560,7,7,0,0,12560,
+        12561,7,10,0,0,12561,12562,7,7,0,0,12562,12563,7,17,0,0,12563,1498,
+        1,0,0,0,12564,12565,7,10,0,0,12565,12566,7,7,0,0,12566,12567,7,7,
+        0,0,12567,12568,7,6,0,0,12568,12569,7,3,0,0,12569,1500,1,0,0,0,12570,
+        12571,7,10,0,0,12571,12572,7,7,0,0,12572,12573,7,2,0,0,12573,12574,
+        7,12,0,0,12574,12575,7,4,0,0,12575,1502,1,0,0,0,12576,12577,7,10,
+        0,0,12577,12578,7,7,0,0,12578,12579,7,15,0,0,12579,12580,7,11,0,
+        0,12580,12581,7,0,0,0,12581,12582,7,8,0,0,12582,12583,7,6,0,0,12583,
+        1504,1,0,0,0,12584,12585,7,10,0,0,12585,12586,7,7,0,0,12586,12587,
+        7,15,0,0,12587,12588,7,12,0,0,12588,12589,7,4,0,0,12589,12590,7,
+        16,0,0,12590,12591,7,2,0,0,12591,12592,7,3,0,0,12592,12593,7,14,
+        0,0,12593,12594,7,0,0,0,12594,12595,7,4,0,0,12595,1506,1,0,0,0,12596,
+        12597,7,10,0,0,12597,12598,7,7,0,0,12598,12599,7,5,0,0,12599,12600,
+        7,6,0,0,12600,12601,7,3,0,0,12601,12602,7,4,0,0,12602,12603,7,8,
+        0,0,12603,12604,7,19,0,0,12604,12605,7,10,0,0,12605,12606,7,11,0,
+        0,12606,12607,7,9,0,0,12607,12608,7,25,0,0,12608,12609,7,14,0,0,
+        12609,12610,7,11,0,0,12610,12611,7,0,0,0,12611,12612,7,16,0,0,12612,
+        12613,7,4,0,0,12613,12614,7,6,0,0,12614,12615,7,3,0,0,12615,1508,
+        1,0,0,0,12616,12617,7,10,0,0,12617,12618,7,7,0,0,12618,12619,7,5,
+        0,0,12619,12620,7,6,0,0,12620,12621,7,3,0,0,12621,12622,7,4,0,0,
+        12622,12623,7,8,0,0,12623,12624,7,19,0,0,12624,12625,7,10,0,0,12625,
+        12626,7,11,0,0,12626,12627,7,9,0,0,12627,12628,7,25,0,0,12628,12629,
+        7,14,0,0,12629,12630,7,11,0,0,12630,12631,7,1,0,0,12631,12632,7,
+        6,0,0,12632,12633,7,16,0,0,12633,12634,7,2,0,0,12634,12635,7,3,0,
+        0,12635,12636,7,6,0,0,12636,1510,1,0,0,0,12637,12638,7,10,0,0,12638,
+        12639,7,7,0,0,12639,12640,7,5,0,0,12640,12641,7,6,0,0,12641,12642,
+        7,3,0,0,12642,12643,7,4,0,0,12643,12644,7,8,0,0,12644,12645,7,19,
+        0,0,12645,12646,7,10,0,0,12646,12647,7,11,0,0,12647,12648,7,9,0,
+        0,12648,12649,7,25,0,0,12649,12650,7,14,0,0,12650,12651,7,11,0,0,
+        12651,1512,1,0,0,0,12652,12653,7,10,0,0,12653,12654,7,7,0,0,12654,
+        12655,7,5,0,0,12655,12656,7,6,0,0,12656,12657,7,3,0,0,12657,12658,
+        7,4,0,0,12658,1514,1,0,0,0,12659,12660,7,10,0,0,12660,12661,7,7,
+        0,0,12661,12662,7,5,0,0,12662,12663,7,6,0,0,12663,12664,7,3,0,0,
+        12664,12665,7,4,0,0,12665,12666,7,25,0,0,12666,12667,7,14,0,0,12667,
+        12668,7,11,0,0,12668,12669,7,0,0,0,12669,12670,7,16,0,0,12670,12671,
+        7,4,0,0,12671,12672,7,6,0,0,12672,12673,7,3,0,0,12673,1516,1,0,0,
+        0,12674,12675,7,10,0,0,12675,12676,7,7,0,0,12676,12677,7,5,0,0,12677,
+        12678,7,6,0,0,12678,12679,7,3,0,0,12679,12680,7,4,0,0,12680,12681,
+        7,25,0,0,12681,12682,7,14,0,0,12682,12683,7,11,0,0,12683,12684,7,
+        1,0,0,12684,12685,7,6,0,0,12685,12686,7,16,0,0,12686,12687,7,2,0,
+        0,12687,12688,7,3,0,0,12688,12689,7,6,0,0,12689,1518,1,0,0,0,12690,
+        12691,7,10,0,0,12691,12692,7,7,0,0,12692,12693,7,5,0,0,12693,12694,
+        7,4,0,0,12694,12695,7,0,0,0,12695,12696,7,7,0,0,12696,12697,7,8,
+        0,0,12697,12698,7,6,0,0,12698,1520,1,0,0,0,12699,12700,7,10,0,0,
+        12700,12701,7,7,0,0,12701,12702,7,5,0,0,12702,12703,7,4,0,0,12703,
+        12704,7,0,0,0,12704,12705,7,7,0,0,12705,12706,7,8,0,0,12706,12707,
+        7,6,0,0,12707,12708,7,5,0,0,12708,1522,1,0,0,0,12709,12710,7,10,
+        0,0,12710,12711,7,7,0,0,12711,12712,7,5,0,0,12712,12713,7,4,0,0,
+        12713,12714,7,0,0,0,12714,12715,7,7,0,0,12715,12716,7,4,0,0,12716,
+        12717,7,10,0,0,12717,12718,7,0,0,0,12718,12719,7,1,0,0,12719,12720,
+        7,11,0,0,12720,12721,7,6,0,0,12721,1524,1,0,0,0,12722,12723,7,10,
+        0,0,12723,12724,7,7,0,0,12724,12725,7,5,0,0,12725,12726,7,4,0,0,
+        12726,12727,7,0,0,0,12727,12728,7,7,0,0,12728,12729,7,4,0,0,12729,
+        12730,7,11,0,0,12730,12731,7,18,0,0,12731,1526,1,0,0,0,12732,12733,
+        7,10,0,0,12733,12734,7,7,0,0,12734,12735,7,5,0,0,12735,12736,7,4,
+        0,0,12736,12737,7,6,0,0,12737,12738,7,0,0,0,12738,12739,7,9,0,0,
+        12739,1528,1,0,0,0,12740,12741,7,10,0,0,12741,12742,7,7,0,0,12742,
+        12743,7,5,0,0,12743,12744,7,4,0,0,12744,12745,7,3,0,0,12745,12746,
+        5,50,0,0,12746,1530,1,0,0,0,12747,12748,7,10,0,0,12748,12749,7,7,
+        0,0,12749,12750,7,5,0,0,12750,12751,7,4,0,0,12751,12752,7,3,0,0,
+        12752,12753,5,52,0,0,12753,1532,1,0,0,0,12754,12755,7,10,0,0,12755,
+        12756,7,7,0,0,12756,12757,7,5,0,0,12757,12758,7,4,0,0,12758,12759,
+        7,3,0,0,12759,12760,7,1,0,0,12760,1534,1,0,0,0,12761,12762,7,10,
+        0,0,12762,12763,7,7,0,0,12763,12764,7,5,0,0,12764,12765,7,4,0,0,
+        12765,12766,7,3,0,0,12766,12767,7,8,0,0,12767,1536,1,0,0,0,12768,
+        12769,7,10,0,0,12769,12770,7,7,0,0,12770,12771,7,5,0,0,12771,12772,
+        7,4,0,0,12772,12773,7,3,0,0,12773,1538,1,0,0,0,12774,12775,7,10,
+        0,0,12775,12776,7,7,0,0,12776,12777,7,4,0,0,12777,12778,7,6,0,0,
+        12778,12779,7,17,0,0,12779,12780,7,6,0,0,12780,12781,7,3,0,0,12781,
+        1540,1,0,0,0,12782,12783,7,10,0,0,12783,12784,7,7,0,0,12784,12785,
+        7,4,0,0,12785,12786,7,6,0,0,12786,12787,7,3,0,0,12787,12788,7,11,
+        0,0,12788,12789,7,6,0,0,12789,12790,7,0,0,0,12790,12791,7,13,0,0,
+        12791,12792,7,6,0,0,12792,12793,7,9,0,0,12793,1542,1,0,0,0,12794,
+        12795,7,10,0,0,12795,12796,7,7,0,0,12796,12797,7,4,0,0,12797,12798,
+        7,6,0,0,12798,12799,7,3,0,0,12799,12800,7,14,0,0,12800,12801,7,6,
+        0,0,12801,12802,7,9,0,0,12802,12803,7,10,0,0,12803,12804,7,0,0,0,
+        12804,12805,7,4,0,0,12805,12806,7,6,0,0,12806,1544,1,0,0,0,12807,
+        12808,7,10,0,0,12808,12809,7,7,0,0,12809,12810,7,4,0,0,12810,12811,
+        7,6,0,0,12811,12812,7,3,0,0,12812,12813,7,7,0,0,12813,12814,7,0,
+        0,0,12814,12815,7,11,0,0,12815,12816,5,95,0,0,12816,12817,7,8,0,
+        0,12817,12818,7,2,0,0,12818,12819,7,7,0,0,12819,12820,7,13,0,0,12820,
+        12821,7,6,0,0,12821,12822,7,3,0,0,12822,12823,7,4,0,0,12823,1546,
+        1,0,0,0,12824,12825,7,10,0,0,12825,12826,7,7,0,0,12826,12827,7,4,
+        0,0,12827,12828,7,6,0,0,12828,12829,7,3,0,0,12829,12830,7,7,0,0,
+        12830,12831,7,0,0,0,12831,12832,7,11,0,0,12832,12833,5,95,0,0,12833,
+        12834,7,12,0,0,12834,12835,7,5,0,0,12835,12836,7,6,0,0,12836,1548,
+        1,0,0,0,12837,12838,7,10,0,0,12838,12839,7,7,0,0,12839,12840,7,4,
+        0,0,12840,12841,7,6,0,0,12841,12842,7,3,0,0,12842,12843,7,15,0,0,
+        12843,12844,7,3,0,0,12844,12845,7,6,0,0,12845,12846,7,4,0,0,12846,
+        12847,7,6,0,0,12847,12848,7,9,0,0,12848,1550,1,0,0,0,12849,12850,
+        7,10,0,0,12850,12851,7,7,0,0,12851,12852,7,4,0,0,12852,12853,7,6,
+        0,0,12853,12854,7,3,0,0,12854,12855,7,5,0,0,12855,12856,7,6,0,0,
+        12856,12857,7,8,0,0,12857,12858,7,4,0,0,12858,1552,1,0,0,0,12859,
+        12860,7,10,0,0,12860,12861,7,7,0,0,12861,12862,7,4,0,0,12862,12863,
+        7,6,0,0,12863,12864,7,3,0,0,12864,12865,7,13,0,0,12865,12866,7,0,
+        0,0,12866,12867,7,11,0,0,12867,1554,1,0,0,0,12868,12869,7,10,0,0,
+        12869,12870,7,7,0,0,12870,12871,7,4,0,0,12871,1556,1,0,0,0,12872,
+        12873,7,10,0,0,12873,12874,7,7,0,0,12874,12875,7,4,0,0,12875,12876,
+        7,6,0,0,12876,12877,7,3,0,0,12877,12878,7,7,0,0,12878,12879,7,0,
+        0,0,12879,12880,7,11,0,0,12880,1558,1,0,0,0,12881,12882,7,10,0,0,
+        12882,12883,7,7,0,0,12883,12884,7,4,0,0,12884,12885,7,2,0,0,12885,
+        1560,1,0,0,0,12886,12887,7,10,0,0,12887,12888,7,7,0,0,12888,12889,
+        7,13,0,0,12889,12890,7,0,0,0,12890,12891,7,11,0,0,12891,12892,7,
+        10,0,0,12892,12893,7,9,0,0,12893,12894,7,0,0,0,12894,12895,7,4,0,
+        0,12895,12896,7,6,0,0,12896,1562,1,0,0,0,12897,12898,7,10,0,0,12898,
+        12899,7,7,0,0,12899,12900,7,13,0,0,12900,12901,7,0,0,0,12901,12902,
+        7,11,0,0,12902,12903,7,10,0,0,12903,12904,7,9,0,0,12904,12905,7,
+        0,0,0,12905,12906,7,4,0,0,12906,12907,7,10,0,0,12907,12908,7,2,0,
+        0,12908,12909,7,7,0,0,12909,1564,1,0,0,0,12910,12911,7,10,0,0,12911,
+        12912,7,7,0,0,12912,12913,7,13,0,0,12913,12914,7,10,0,0,12914,12915,
+        7,5,0,0,12915,12916,7,10,0,0,12916,12917,7,1,0,0,12917,12918,7,11,
+        0,0,12918,12919,7,6,0,0,12919,1566,1,0,0,0,12920,12921,7,10,0,0,
+        12921,12922,7,7,0,0,12922,12923,5,95,0,0,12923,12924,7,25,0,0,12924,
+        12925,7,24,0,0,12925,12926,7,12,0,0,12926,12927,7,6,0,0,12927,12928,
+        7,3,0,0,12928,12929,7,18,0,0,12929,1568,1,0,0,0,12930,12931,7,10,
+        0,0,12931,12932,7,2,0,0,12932,12933,5,95,0,0,12933,12934,7,2,0,0,
+        12934,12935,7,15,0,0,12935,12936,7,4,0,0,12936,12937,7,10,0,0,12937,
+        12938,7,2,0,0,12938,12939,7,7,0,0,12939,12940,7,5,0,0,12940,1570,
+        1,0,0,0,12941,12942,7,10,0,0,12942,12943,7,5,0,0,12943,1572,1,0,
+        0,0,12944,12945,7,10,0,0,12945,12946,7,5,0,0,12946,12947,5,95,0,
+        0,12947,12948,7,11,0,0,12948,12949,7,6,0,0,12949,12950,7,0,0,0,12950,
+        12951,7,16,0,0,12951,1574,1,0,0,0,12952,12953,7,10,0,0,12953,12954,
+        7,5,0,0,12954,12955,7,2,0,0,12955,12956,7,11,0,0,12956,12957,7,0,
+        0,0,12957,12958,7,4,0,0,12958,12959,7,10,0,0,12959,12960,7,2,0,0,
+        12960,12961,7,7,0,0,12961,1576,1,0,0,0,12962,12963,7,10,0,0,12963,
+        12964,7,5,0,0,12964,12965,7,2,0,0,12965,12966,7,11,0,0,12966,12967,
+        7,0,0,0,12967,12968,7,4,0,0,12968,12969,7,10,0,0,12969,12970,7,2,
+        0,0,12970,12971,7,7,0,0,12971,12972,5,95,0,0,12972,12973,7,11,0,
+        0,12973,12974,7,6,0,0,12974,12975,7,13,0,0,12975,12976,7,6,0,0,12976,
+        12977,7,11,0,0,12977,1578,1,0,0,0,12978,12979,7,10,0,0,12979,12980,
+        7,4,0,0,12980,12981,7,6,0,0,12981,12982,7,14,0,0,12982,12983,7,5,
+        0,0,12983,1580,1,0,0,0,12984,12985,7,10,0,0,12985,12986,7,4,0,0,
+        12986,12987,7,6,0,0,12987,12988,7,3,0,0,12988,12989,7,0,0,0,12989,
+        12990,7,4,0,0,12990,12991,7,6,0,0,12991,1582,1,0,0,0,12992,12993,
+        7,10,0,0,12993,12994,7,4,0,0,12994,12995,7,6,0,0,12995,12996,7,3,
+        0,0,12996,12997,7,0,0,0,12997,12998,7,4,0,0,12998,12999,7,10,0,0,
+        12999,13000,7,2,0,0,13000,13001,7,7,0,0,13001,13002,5,95,0,0,13002,
+        13003,7,7,0,0,13003,13004,7,12,0,0,13004,13005,7,14,0,0,13005,13006,
+        7,1,0,0,13006,13007,7,6,0,0,13007,13008,7,3,0,0,13008,1584,1,0,0,
+        0,13009,13010,7,20,0,0,13010,13011,7,0,0,0,13011,13012,7,13,0,0,
+        13012,13013,7,0,0,0,13013,1586,1,0,0,0,13014,13015,7,20,0,0,13015,
+        13016,7,2,0,0,13016,13017,7,1,0,0,13017,1588,1,0,0,0,13018,13019,
+        7,20,0,0,13019,13020,7,2,0,0,13020,13021,7,10,0,0,13021,13022,7,
+        7,0,0,13022,1590,1,0,0,0,13023,13024,7,20,0,0,13024,13025,7,5,0,
+        0,13025,13026,7,2,0,0,13026,13027,7,7,0,0,13027,13028,5,95,0,0,13028,
+        13029,7,0,0,0,13029,13030,7,3,0,0,13030,13031,7,3,0,0,13031,13032,
+        7,0,0,0,13032,13033,7,18,0,0,13033,13034,7,0,0,0,13034,13035,7,17,
+        0,0,13035,13036,7,17,0,0,13036,1592,1,0,0,0,13037,13038,7,20,0,0,
+        13038,13039,7,5,0,0,13039,13040,7,2,0,0,13040,13041,7,7,0,0,13041,
+        13042,5,95,0,0,13042,13043,7,0,0,0,13043,13044,7,3,0,0,13044,13045,
+        7,3,0,0,13045,13046,7,0,0,0,13046,13047,7,18,0,0,13047,1594,1,0,
+        0,0,13048,13049,7,20,0,0,13049,13050,7,5,0,0,13050,13051,7,2,0,0,
+        13051,13052,7,7,0,0,13052,13053,5,95,0,0,13053,13054,7,6,0,0,13054,
+        13055,7,24,0,0,13055,13056,7,12,0,0,13056,13057,7,0,0,0,13057,13058,
+        7,11,0,0,13058,1596,1,0,0,0,13059,13060,7,20,0,0,13060,13061,7,5,
+        0,0,13061,13062,7,2,0,0,13062,13063,7,7,0,0,13063,13064,5,95,0,0,
+        13064,13065,7,6,0,0,13065,13066,7,25,0,0,13066,13067,7,10,0,0,13067,
+        13068,7,5,0,0,13068,13069,7,4,0,0,13069,13070,7,5,0,0,13070,13071,
+        5,50,0,0,13071,1598,1,0,0,0,13072,13073,7,20,0,0,13073,13074,7,5,
+        0,0,13074,13075,7,2,0,0,13075,13076,7,7,0,0,13076,13077,5,95,0,0,
+        13077,13078,7,6,0,0,13078,13079,7,25,0,0,13079,13080,7,10,0,0,13080,
+        13081,7,5,0,0,13081,13082,7,4,0,0,13082,13083,7,5,0,0,13083,1600,
+        1,0,0,0,13084,13085,7,20,0,0,13085,13086,7,5,0,0,13086,13087,7,2,
+        0,0,13087,13088,7,7,0,0,13088,13089,7,17,0,0,13089,13090,7,6,0,0,
+        13090,13091,7,4,0,0,13091,1602,1,0,0,0,13092,13093,7,20,0,0,13093,
+        13094,7,5,0,0,13094,13095,7,2,0,0,13095,13096,7,7,0,0,13096,1604,
+        1,0,0,0,13097,13098,7,20,0,0,13098,13099,7,5,0,0,13099,13100,7,2,
+        0,0,13100,13101,7,7,0,0,13101,13102,5,95,0,0,13102,13103,7,2,0,0,
+        13103,13104,7,1,0,0,13104,13105,7,20,0,0,13105,13106,7,6,0,0,13106,
+        13107,7,8,0,0,13107,13108,7,4,0,0,13108,13109,7,0,0,0,13109,13110,
+        7,17,0,0,13110,13111,7,17,0,0,13111,1606,1,0,0,0,13112,13113,7,20,
+        0,0,13113,13114,7,5,0,0,13114,13115,7,2,0,0,13115,13116,7,7,0,0,
+        13116,13117,5,95,0,0,13117,13118,7,2,0,0,13118,13119,7,1,0,0,13119,
+        13120,7,20,0,0,13120,13121,7,6,0,0,13121,13122,7,8,0,0,13122,13123,
+        7,4,0,0,13123,1608,1,0,0,0,13124,13125,7,20,0,0,13125,13126,7,5,
+        0,0,13126,13127,7,2,0,0,13127,13128,7,7,0,0,13128,13129,7,15,0,0,
+        13129,13130,7,0,0,0,13130,13131,7,3,0,0,13131,13132,7,5,0,0,13132,
+        13133,7,6,0,0,13133,1610,1,0,0,0,13134,13135,7,20,0,0,13135,13136,
+        7,5,0,0,13136,13137,7,2,0,0,13137,13138,7,7,0,0,13138,13139,5,95,
+        0,0,13139,13140,7,24,0,0,13140,13141,7,12,0,0,13141,13142,7,6,0,
+        0,13142,13143,7,3,0,0,13143,13144,7,18,0,0,13144,1612,1,0,0,0,13145,
+        13146,7,20,0,0,13146,13147,7,5,0,0,13147,13148,7,2,0,0,13148,13149,
+        7,7,0,0,13149,13150,5,95,0,0,13150,13151,7,5,0,0,13151,13152,7,6,
+        0,0,13152,13153,7,3,0,0,13153,13154,7,10,0,0,13154,13155,7,0,0,0,
+        13155,13156,7,11,0,0,13156,13157,7,10,0,0,13157,13158,7,23,0,0,13158,
+        13159,7,6,0,0,13159,1614,1,0,0,0,13160,13161,7,20,0,0,13161,13162,
+        7,5,0,0,13162,13163,7,2,0,0,13163,13164,7,7,0,0,13164,13165,5,95,
+        0,0,13165,13166,7,4,0,0,13166,13167,7,0,0,0,13167,13168,7,1,0,0,
+        13168,13169,7,11,0,0,13169,13170,7,6,0,0,13170,1616,1,0,0,0,13171,
+        13172,7,20,0,0,13172,13173,7,5,0,0,13173,13174,7,2,0,0,13174,13175,
+        7,7,0,0,13175,13176,5,95,0,0,13176,13177,7,4,0,0,13177,13178,7,6,
+        0,0,13178,13179,7,25,0,0,13179,13180,7,4,0,0,13180,13181,7,8,0,0,
+        13181,13182,7,2,0,0,13182,13183,7,7,0,0,13183,13184,7,4,0,0,13184,
+        13185,7,0,0,0,13185,13186,7,10,0,0,13186,13187,7,7,0,0,13187,13188,
+        7,5,0,0,13188,13189,5,50,0,0,13189,1618,1,0,0,0,13190,13191,7,20,
+        0,0,13191,13192,7,5,0,0,13192,13193,7,2,0,0,13193,13194,7,7,0,0,
+        13194,13195,5,95,0,0,13195,13196,7,4,0,0,13196,13197,7,6,0,0,13197,
+        13198,7,25,0,0,13198,13199,7,4,0,0,13199,13200,7,8,0,0,13200,13201,
+        7,2,0,0,13201,13202,7,7,0,0,13202,13203,7,4,0,0,13203,13204,7,0,
+        0,0,13204,13205,7,10,0,0,13205,13206,7,7,0,0,13206,13207,7,5,0,0,
+        13207,1620,1,0,0,0,13208,13209,7,20,0,0,13209,13210,7,5,0,0,13210,
+        13211,7,2,0,0,13211,13212,7,7,0,0,13212,13213,5,95,0,0,13213,13214,
+        7,4,0,0,13214,13215,7,3,0,0,13215,13216,7,0,0,0,13216,13217,7,7,
+        0,0,13217,13218,7,5,0,0,13218,13219,7,16,0,0,13219,13220,7,2,0,0,
+        13220,13221,7,3,0,0,13221,13222,7,14,0,0,13222,1622,1,0,0,0,13223,
+        13224,7,20,0,0,13224,13225,7,5,0,0,13225,13226,7,2,0,0,13226,13227,
+        7,7,0,0,13227,13228,5,95,0,0,13228,13229,7,13,0,0,13229,13230,7,
+        0,0,0,13230,13231,7,11,0,0,13231,13232,7,12,0,0,13232,13233,7,6,
+        0,0,13233,1624,1,0,0,0,13234,13235,7,21,0,0,13235,1626,1,0,0,0,13236,
+        13237,7,21,0,0,13237,13238,7,6,0,0,13238,13239,7,6,0,0,13239,13240,
+        7,15,0,0,13240,13241,5,95,0,0,13241,13242,7,9,0,0,13242,13243,7,
+        12,0,0,13243,13244,7,15,0,0,13244,13245,7,11,0,0,13245,13246,7,10,
+        0,0,13246,13247,7,8,0,0,13247,13248,7,0,0,0,13248,13249,7,4,0,0,
+        13249,13250,7,6,0,0,13250,13251,7,5,0,0,13251,1628,1,0,0,0,13252,
+        13253,7,21,0,0,13253,13254,7,6,0,0,13254,13255,7,6,0,0,13255,13256,
+        7,15,0,0,13256,1630,1,0,0,0,13257,13258,7,21,0,0,13258,13259,7,6,
+        0,0,13259,13260,7,3,0,0,13260,13261,7,1,0,0,13261,13262,7,6,0,0,
+        13262,13263,7,3,0,0,13263,13264,7,2,0,0,13264,13265,7,5,0,0,13265,
+        1632,1,0,0,0,13266,13267,7,21,0,0,13267,13268,7,6,0,0,13268,13269,
+        7,18,0,0,13269,1634,1,0,0,0,13270,13271,7,21,0,0,13271,13272,7,6,
+        0,0,13272,13273,7,18,0,0,13273,13274,5,95,0,0,13274,13275,7,11,0,
+        0,13275,13276,7,6,0,0,13276,13277,7,7,0,0,13277,13278,7,17,0,0,13278,
+        13279,7,4,0,0,13279,13280,7,19,0,0,13280,1636,1,0,0,0,13281,13282,
+        7,21,0,0,13282,13283,7,6,0,0,13283,13284,7,18,0,0,13284,13285,7,
+        5,0,0,13285,13286,7,10,0,0,13286,13287,7,23,0,0,13287,13288,7,6,
+        0,0,13288,1638,1,0,0,0,13289,13290,7,21,0,0,13290,13291,7,6,0,0,
+        13291,13292,7,18,0,0,13292,13293,7,5,0,0,13293,1640,1,0,0,0,13294,
+        13295,7,21,0,0,13295,13296,7,6,0,0,13296,13297,7,18,0,0,13297,13298,
+        7,5,0,0,13298,13299,7,4,0,0,13299,13300,7,2,0,0,13300,13301,7,3,
+        0,0,13301,13302,7,6,0,0,13302,1642,1,0,0,0,13303,13304,7,21,0,0,
+        13304,13305,7,10,0,0,13305,13306,7,11,0,0,13306,13307,7,11,0,0,13307,
+        1644,1,0,0,0,13308,13309,7,11,0,0,13309,13310,7,0,0,0,13310,13311,
+        7,1,0,0,13311,13312,7,6,0,0,13312,13313,7,11,0,0,13313,1646,1,0,
+        0,0,13314,13315,7,11,0,0,13315,13316,7,0,0,0,13316,13317,7,7,0,0,
+        13317,13318,7,17,0,0,13318,13319,7,12,0,0,13319,13320,7,0,0,0,13320,
+        13321,7,17,0,0,13321,13322,7,6,0,0,13322,1648,1,0,0,0,13323,13324,
+        7,11,0,0,13324,13325,7,0,0,0,13325,13326,7,5,0,0,13326,13327,7,4,
+        0,0,13327,13328,5,95,0,0,13328,13329,7,9,0,0,13329,13330,7,0,0,0,
+        13330,13331,7,18,0,0,13331,1650,1,0,0,0,13332,13333,7,11,0,0,13333,
+        13334,7,0,0,0,13334,13335,7,5,0,0,13335,13336,7,4,0,0,13336,1652,
+        1,0,0,0,13337,13338,7,11,0,0,13338,13339,7,0,0,0,13339,13340,7,5,
+        0,0,13340,13341,7,4,0,0,13341,13342,5,95,0,0,13342,13343,7,13,0,
+        0,13343,13344,7,0,0,0,13344,13345,7,11,0,0,13345,13346,7,12,0,0,
+        13346,13347,7,6,0,0,13347,1654,1,0,0,0,13348,13349,7,11,0,0,13349,
+        13350,7,0,0,0,13350,13351,7,4,0,0,13351,13352,7,6,0,0,13352,13353,
+        7,3,0,0,13353,13354,7,0,0,0,13354,13355,7,11,0,0,13355,1656,1,0,
+        0,0,13356,13357,7,11,0,0,13357,13358,7,0,0,0,13358,13359,7,4,0,0,
+        13359,13360,7,6,0,0,13360,13361,7,5,0,0,13361,13362,7,4,0,0,13362,
+        1658,1,0,0,0,13363,13364,7,11,0,0,13364,13365,7,0,0,0,13365,13366,
+        7,25,0,0,13366,1660,1,0,0,0,13367,13368,7,11,0,0,13368,13369,7,0,
+        0,0,13369,13370,7,18,0,0,13370,13371,7,6,0,0,13371,13372,7,3,0,0,
+        13372,1662,1,0,0,0,13373,13374,7,11,0,0,13374,13375,7,9,0,0,13375,
+        13376,7,0,0,0,13376,13377,7,15,0,0,13377,13378,5,95,0,0,13378,13379,
+        7,3,0,0,13379,13380,7,6,0,0,13380,13381,7,17,0,0,13381,13382,7,10,
+        0,0,13382,13383,7,5,0,0,13383,13384,7,4,0,0,13384,13385,7,3,0,0,
+        13385,13386,7,0,0,0,13386,13387,7,4,0,0,13387,13388,7,10,0,0,13388,
+        13389,7,2,0,0,13389,13390,7,7,0,0,13390,13391,5,95,0,0,13391,13392,
+        7,6,0,0,13392,13393,7,7,0,0,13393,13394,7,0,0,0,13394,13395,7,1,
+        0,0,13395,13396,7,11,0,0,13396,13397,7,6,0,0,13397,13398,7,9,0,0,
+        13398,1664,1,0,0,0,13399,13400,7,11,0,0,13400,13401,7,9,0,0,13401,
+        13402,7,0,0,0,13402,13403,7,15,0,0,13403,13404,5,95,0,0,13404,13405,
+        7,3,0,0,13405,13406,7,6,0,0,13406,13407,7,17,0,0,13407,13408,7,10,
+        0,0,13408,13409,7,5,0,0,13409,13410,7,4,0,0,13410,13411,7,3,0,0,
+        13411,13412,7,0,0,0,13412,13413,7,4,0,0,13413,13414,7,10,0,0,13414,
+        13415,7,2,0,0,13415,13416,7,7,0,0,13416,1666,1,0,0,0,13417,13418,
+        7,11,0,0,13418,13419,7,9,0,0,13419,13420,7,0,0,0,13420,13421,7,15,
+        0,0,13421,13422,5,95,0,0,13422,13423,7,3,0,0,13423,13424,7,6,0,0,
+        13424,13425,7,17,0,0,13425,13426,5,95,0,0,13426,13427,7,5,0,0,13427,
+        13428,7,18,0,0,13428,13429,7,7,0,0,13429,13430,7,8,0,0,13430,13431,
+        5,95,0,0,13431,13432,7,10,0,0,13432,13433,7,7,0,0,13433,13434,7,
+        4,0,0,13434,13435,7,6,0,0,13435,13436,7,3,0,0,13436,13437,7,13,0,
+        0,13437,13438,7,0,0,0,13438,13439,7,11,0,0,13439,1668,1,0,0,0,13440,
+        13441,7,11,0,0,13441,13442,7,9,0,0,13442,13443,7,3,0,0,13443,13444,
+        7,4,0,0,13444,13445,7,3,0,0,13445,13446,7,10,0,0,13446,13447,7,14,
+        0,0,13447,1670,1,0,0,0,13448,13449,7,11,0,0,13449,13450,7,6,0,0,
+        13450,13451,7,0,0,0,13451,13452,7,16,0,0,13452,1672,1,0,0,0,13453,
+        13454,7,11,0,0,13454,13455,7,6,0,0,13455,13456,7,0,0,0,13456,13457,
+        7,9,0,0,13457,13458,5,95,0,0,13458,13459,7,8,0,0,13459,13460,7,9,
+        0,0,13460,13461,7,1,0,0,13461,1674,1,0,0,0,13462,13463,7,11,0,0,
+        13463,13464,7,6,0,0,13464,13465,7,0,0,0,13465,13466,7,9,0,0,13466,
+        13467,5,95,0,0,13467,13468,7,8,0,0,13468,13469,7,9,0,0,13469,13470,
+        7,1,0,0,13470,13471,5,95,0,0,13471,13472,7,12,0,0,13472,13473,7,
+        3,0,0,13473,13474,7,10,0,0,13474,1676,1,0,0,0,13475,13476,7,11,0,
+        0,13476,13477,7,6,0,0,13477,13478,7,0,0,0,13478,13479,7,9,0,0,13479,
+        13480,7,10,0,0,13480,13481,7,7,0,0,13481,13482,7,17,0,0,13482,1678,
+        1,0,0,0,13483,13484,7,11,0,0,13484,13485,7,6,0,0,13485,13486,7,16,
+        0,0,13486,13487,7,4,0,0,13487,1680,1,0,0,0,13488,13489,7,11,0,0,
+        13489,13490,7,6,0,0,13490,13491,7,7,0,0,13491,13492,7,17,0,0,13492,
+        13493,7,4,0,0,13493,13494,7,19,0,0,13494,13495,5,50,0,0,13495,1682,
+        1,0,0,0,13496,13497,7,11,0,0,13497,13498,7,6,0,0,13498,13499,7,7,
+        0,0,13499,13500,7,17,0,0,13500,13501,7,4,0,0,13501,13502,7,19,0,
+        0,13502,13503,5,52,0,0,13503,1684,1,0,0,0,13504,13505,7,11,0,0,13505,
+        13506,7,6,0,0,13506,13507,7,7,0,0,13507,13508,7,17,0,0,13508,13509,
+        7,4,0,0,13509,13510,7,19,0,0,13510,13511,7,1,0,0,13511,1686,1,0,
+        0,0,13512,13513,7,11,0,0,13513,13514,7,6,0,0,13514,13515,7,7,0,0,
+        13515,13516,7,17,0,0,13516,13517,7,4,0,0,13517,13518,7,19,0,0,13518,
+        13519,7,8,0,0,13519,1688,1,0,0,0,13520,13521,7,11,0,0,13521,13522,
+        7,6,0,0,13522,13523,7,7,0,0,13523,13524,7,17,0,0,13524,13525,7,4,
+        0,0,13525,13526,7,19,0,0,13526,1690,1,0,0,0,13527,13528,7,11,0,0,
+        13528,13529,7,6,0,0,13529,13530,7,5,0,0,13530,13531,7,5,0,0,13531,
+        1692,1,0,0,0,13532,13533,7,11,0,0,13533,13534,7,6,0,0,13534,13535,
+        7,13,0,0,13535,13536,7,6,0,0,13536,13537,7,11,0,0,13537,1694,1,0,
+        0,0,13538,13539,7,11,0,0,13539,13540,7,6,0,0,13540,13541,7,13,0,
+        0,13541,13542,7,6,0,0,13542,13543,7,11,0,0,13543,13544,5,95,0,0,
+        13544,13545,7,7,0,0,13545,13546,7,0,0,0,13546,13547,7,14,0,0,13547,
+        13548,7,6,0,0,13548,1696,1,0,0,0,13549,13550,7,11,0,0,13550,13551,
+        7,6,0,0,13551,13552,7,13,0,0,13552,13553,7,6,0,0,13553,13554,7,11,
+        0,0,13554,13555,7,5,0,0,13555,1698,1,0,0,0,13556,13557,7,11,0,0,
+        13557,13558,7,10,0,0,13558,13559,7,1,0,0,13559,13560,7,3,0,0,13560,
+        13561,7,0,0,0,13561,13562,7,3,0,0,13562,13563,7,18,0,0,13563,1700,
+        1,0,0,0,13564,13565,7,11,0,0,13565,13566,7,10,0,0,13566,13567,7,
+        16,0,0,13567,13568,7,6,0,0,13568,13569,7,8,0,0,13569,13570,7,18,
+        0,0,13570,13571,7,8,0,0,13571,13572,7,11,0,0,13572,13573,7,6,0,0,
+        13573,1702,1,0,0,0,13574,13575,7,11,0,0,13575,13576,7,10,0,0,13576,
+        13577,7,16,0,0,13577,13578,7,6,0,0,13578,1704,1,0,0,0,13579,13580,
+        7,11,0,0,13580,13581,7,10,0,0,13581,13582,7,16,0,0,13582,13583,7,
+        6,0,0,13583,13584,7,4,0,0,13584,13585,7,10,0,0,13585,13586,7,14,
+        0,0,13586,13587,7,6,0,0,13587,1706,1,0,0,0,13588,13589,7,11,0,0,
+        13589,13590,7,10,0,0,13590,13591,7,21,0,0,13591,13592,7,6,0,0,13592,
+        13593,5,50,0,0,13593,1708,1,0,0,0,13594,13595,7,11,0,0,13595,13596,
+        7,10,0,0,13596,13597,7,21,0,0,13597,13598,7,6,0,0,13598,13599,5,
+        52,0,0,13599,1710,1,0,0,0,13600,13601,7,11,0,0,13601,13602,7,10,
+        0,0,13602,13603,7,21,0,0,13603,13604,7,6,0,0,13604,13605,7,8,0,0,
+        13605,1712,1,0,0,0,13606,13607,7,11,0,0,13607,13608,7,10,0,0,13608,
+        13609,7,21,0,0,13609,13610,7,6,0,0,13610,13611,5,95,0,0,13611,13612,
+        7,6,0,0,13612,13613,7,25,0,0,13613,13614,7,15,0,0,13614,13615,7,
+        0,0,0,13615,13616,7,7,0,0,13616,13617,7,9,0,0,13617,1714,1,0,0,0,
+        13618,13619,7,11,0,0,13619,13620,7,10,0,0,13620,13621,7,21,0,0,13621,
+        13622,7,6,0,0,13622,1716,1,0,0,0,13623,13624,7,11,0,0,13624,13625,
+        7,10,0,0,13625,13626,7,14,0,0,13626,13627,7,10,0,0,13627,13628,7,
+        4,0,0,13628,1718,1,0,0,0,13629,13630,7,11,0,0,13630,13631,7,10,0,
+        0,13631,13632,7,7,0,0,13632,13633,7,6,0,0,13633,13634,7,0,0,0,13634,
+        13635,7,3,0,0,13635,1720,1,0,0,0,13636,13637,7,11,0,0,13637,13638,
+        7,10,0,0,13638,13639,7,7,0,0,13639,13640,7,6,0,0,13640,13641,7,5,
+        0,0,13641,1722,1,0,0,0,13642,13643,7,11,0,0,13643,13644,7,10,0,0,
+        13644,13645,7,7,0,0,13645,13646,7,21,0,0,13646,1724,1,0,0,0,13647,
+        13648,7,11,0,0,13648,13649,7,10,0,0,13649,13650,7,5,0,0,13650,13651,
+        7,4,0,0,13651,1726,1,0,0,0,13652,13653,7,11,0,0,13653,13654,7,10,
+        0,0,13654,13655,7,4,0,0,13655,13656,7,4,0,0,13656,13657,7,11,0,0,
+        13657,13658,7,6,0,0,13658,1728,1,0,0,0,13659,13660,7,11,0,0,13660,
+        13661,7,11,0,0,13661,13662,7,5,0,0,13662,1730,1,0,0,0,13663,13664,
+        7,11,0,0,13664,13665,7,7,0,0,13665,1732,1,0,0,0,13666,13667,7,11,
+        0,0,13667,13668,7,7,0,0,13668,13669,7,7,0,0,13669,13670,7,13,0,0,
+        13670,13671,7,11,0,0,13671,1734,1,0,0,0,13672,13673,7,11,0,0,13673,
+        13674,7,2,0,0,13674,13675,7,0,0,0,13675,13676,7,9,0,0,13676,1736,
+        1,0,0,0,13677,13678,7,11,0,0,13678,13679,7,2,0,0,13679,13680,7,1,
+        0,0,13680,1738,1,0,0,0,13681,13682,7,11,0,0,13682,13683,7,2,0,0,
+        13683,13684,7,1,0,0,13684,13685,7,16,0,0,13685,13686,7,10,0,0,13686,
+        13687,7,11,0,0,13687,13688,7,6,0,0,13688,1740,1,0,0,0,13689,13690,
+        7,11,0,0,13690,13691,7,2,0,0,13691,13692,7,1,0,0,13692,13693,7,7,
+        0,0,13693,13694,7,13,0,0,13694,13695,7,11,0,0,13695,1742,1,0,0,0,
+        13696,13697,7,11,0,0,13697,13698,7,2,0,0,13698,13699,7,1,0,0,13699,
+        13700,7,5,0,0,13700,1744,1,0,0,0,13701,13702,7,11,0,0,13702,13703,
+        7,2,0,0,13703,13704,7,8,0,0,13704,13705,7,0,0,0,13705,13706,7,11,
+        0,0,13706,13707,5,95,0,0,13707,13708,7,10,0,0,13708,13709,7,7,0,
+        0,13709,13710,7,9,0,0,13710,13711,7,6,0,0,13711,13712,7,25,0,0,13712,
+        13713,7,6,0,0,13713,13714,7,5,0,0,13714,1746,1,0,0,0,13715,13716,
+        7,11,0,0,13716,13717,7,2,0,0,13717,13718,7,8,0,0,13718,13719,7,0,
+        0,0,13719,13720,7,11,0,0,13720,1748,1,0,0,0,13721,13722,7,11,0,0,
+        13722,13723,7,2,0,0,13723,13724,7,8,0,0,13724,13725,7,0,0,0,13725,
+        13726,7,11,0,0,13726,13727,7,4,0,0,13727,13728,7,10,0,0,13728,13729,
+        7,14,0,0,13729,13730,7,6,0,0,13730,1750,1,0,0,0,13731,13732,7,11,
+        0,0,13732,13733,7,2,0,0,13733,13734,7,8,0,0,13734,13735,7,0,0,0,
+        13735,13736,7,11,0,0,13736,13737,7,4,0,0,13737,13738,7,10,0,0,13738,
+        13739,7,14,0,0,13739,13740,7,6,0,0,13740,13741,7,5,0,0,13741,13742,
+        7,4,0,0,13742,13743,7,0,0,0,13743,13744,7,14,0,0,13744,13745,7,15,
+        0,0,13745,1752,1,0,0,0,13746,13747,7,11,0,0,13747,13748,7,2,0,0,
+        13748,13749,7,8,0,0,13749,13750,7,0,0,0,13750,13751,7,4,0,0,13751,
+        13752,7,10,0,0,13752,13753,7,2,0,0,13753,13754,7,7,0,0,13754,1754,
+        1,0,0,0,13755,13756,7,11,0,0,13756,13757,7,2,0,0,13757,13758,7,8,
+        0,0,13758,13759,7,0,0,0,13759,13760,7,4,0,0,13760,13761,7,2,0,0,
+        13761,13762,7,3,0,0,13762,1756,1,0,0,0,13763,13764,7,11,0,0,13764,
+        13765,7,2,0,0,13765,13766,7,8,0,0,13766,13767,7,21,0,0,13767,13768,
+        7,9,0,0,13768,13769,7,2,0,0,13769,13770,7,22,0,0,13770,13771,7,7,
+        0,0,13771,1758,1,0,0,0,13772,13773,7,11,0,0,13773,13774,7,2,0,0,
+        13774,13775,7,8,0,0,13775,13776,7,21,0,0,13776,13777,7,6,0,0,13777,
+        13778,7,9,0,0,13778,1760,1,0,0,0,13779,13780,7,11,0,0,13780,13781,
+        7,2,0,0,13781,13782,7,8,0,0,13782,13783,7,21,0,0,13783,13784,7,10,
+        0,0,13784,13785,7,7,0,0,13785,13786,7,17,0,0,13786,1762,1,0,0,0,
+        13787,13788,7,11,0,0,13788,13789,7,2,0,0,13789,13790,7,8,0,0,13790,
+        13791,7,21,0,0,13791,1764,1,0,0,0,13792,13793,7,11,0,0,13793,13794,
+        7,2,0,0,13794,13795,7,17,0,0,13795,13796,7,16,0,0,13796,13797,7,
+        10,0,0,13797,13798,7,11,0,0,13798,13799,7,6,0,0,13799,1766,1,0,0,
+        0,13800,13801,7,11,0,0,13801,13802,7,2,0,0,13802,13803,7,17,0,0,
+        13803,13804,7,16,0,0,13804,13805,7,10,0,0,13805,13806,7,11,0,0,13806,
+        13807,7,6,0,0,13807,13808,7,5,0,0,13808,1768,1,0,0,0,13809,13810,
+        7,11,0,0,13810,13811,7,2,0,0,13811,13812,7,17,0,0,13812,13813,7,
+        17,0,0,13813,13814,7,10,0,0,13814,13815,7,7,0,0,13815,13816,7,17,
+        0,0,13816,1770,1,0,0,0,13817,13818,7,11,0,0,13818,13819,7,2,0,0,
+        13819,13820,7,17,0,0,13820,13821,7,10,0,0,13821,13822,7,8,0,0,13822,
+        13823,7,0,0,0,13823,13824,7,11,0,0,13824,1772,1,0,0,0,13825,13826,
+        7,11,0,0,13826,13827,7,2,0,0,13827,13828,7,17,0,0,13828,13829,7,
+        10,0,0,13829,13830,7,8,0,0,13830,13831,7,0,0,0,13831,13832,7,11,
+        0,0,13832,13833,5,95,0,0,13833,13834,7,3,0,0,13834,13835,7,6,0,0,
+        13835,13836,7,0,0,0,13836,13837,7,9,0,0,13837,13838,7,5,0,0,13838,
+        13839,5,95,0,0,13839,13840,7,15,0,0,13840,13841,7,6,0,0,13841,13842,
+        7,3,0,0,13842,13843,5,95,0,0,13843,13844,7,8,0,0,13844,13845,7,0,
+        0,0,13845,13846,7,11,0,0,13846,13847,7,11,0,0,13847,1774,1,0,0,0,
+        13848,13849,7,11,0,0,13849,13850,7,2,0,0,13850,13851,7,17,0,0,13851,
+        13852,7,10,0,0,13852,13853,7,8,0,0,13853,13854,7,0,0,0,13854,13855,
+        7,11,0,0,13855,13856,5,95,0,0,13856,13857,7,3,0,0,13857,13858,7,
+        6,0,0,13858,13859,7,0,0,0,13859,13860,7,9,0,0,13860,13861,7,5,0,
+        0,13861,13862,5,95,0,0,13862,13863,7,15,0,0,13863,13864,7,6,0,0,
+        13864,13865,7,3,0,0,13865,13866,5,95,0,0,13866,13867,7,5,0,0,13867,
+        13868,7,6,0,0,13868,13869,7,5,0,0,13869,13870,7,5,0,0,13870,13871,
+        7,10,0,0,13871,13872,7,2,0,0,13872,13873,7,7,0,0,13873,1776,1,0,
+        0,0,13874,13875,7,11,0,0,13875,13876,7,2,0,0,13876,13877,7,17,0,
+        0,13877,1778,1,0,0,0,13878,13879,7,11,0,0,13879,13880,7,2,0,0,13880,
+        13881,7,17,0,0,13881,13882,7,14,0,0,13882,13883,7,10,0,0,13883,13884,
+        7,7,0,0,13884,13885,7,10,0,0,13885,13886,7,7,0,0,13886,13887,7,17,
+        0,0,13887,1780,1,0,0,0,13888,13889,7,11,0,0,13889,13890,7,2,0,0,
+        13890,13891,7,17,0,0,13891,13892,7,2,0,0,13892,13893,7,16,0,0,13893,
+        13894,7,16,0,0,13894,1782,1,0,0,0,13895,13896,7,11,0,0,13896,13897,
+        7,2,0,0,13897,13898,7,17,0,0,13898,13899,7,2,0,0,13899,13900,7,7,
+        0,0,13900,1784,1,0,0,0,13901,13902,7,11,0,0,13902,13903,7,2,0,0,
+        13903,13904,7,17,0,0,13904,13905,5,95,0,0,13905,13906,7,3,0,0,13906,
+        13907,7,6,0,0,13907,13908,7,0,0,0,13908,13909,7,9,0,0,13909,13910,
+        5,95,0,0,13910,13911,7,2,0,0,13911,13912,7,7,0,0,13912,13913,7,11,
+        0,0,13913,13914,7,18,0,0,13914,13915,5,95,0,0,13915,13916,7,13,0,
+        0,13916,13917,7,10,0,0,13917,13918,7,2,0,0,13918,13919,7,11,0,0,
+        13919,13920,7,0,0,0,13920,13921,7,4,0,0,13921,13922,7,10,0,0,13922,
+        13923,7,2,0,0,13923,13924,7,7,0,0,13924,13925,7,5,0,0,13925,1786,
+        1,0,0,0,13926,13927,7,11,0,0,13927,13928,7,2,0,0,13928,13929,7,7,
+        0,0,13929,13930,7,17,0,0,13930,1788,1,0,0,0,13931,13932,7,11,0,0,
+        13932,13933,7,2,0,0,13933,13934,7,2,0,0,13934,13935,7,15,0,0,13935,
+        1790,1,0,0,0,13936,13937,7,11,0,0,13937,13938,7,2,0,0,13938,13939,
+        7,5,0,0,13939,13940,7,4,0,0,13940,1792,1,0,0,0,13941,13942,7,11,
+        0,0,13942,13943,7,2,0,0,13943,13944,7,22,0,0,13944,13945,7,6,0,0,
+        13945,13946,7,3,0,0,13946,1794,1,0,0,0,13947,13948,7,11,0,0,13948,
+        13949,7,2,0,0,13949,13950,7,22,0,0,13950,1796,1,0,0,0,13951,13952,
+        7,11,0,0,13952,13953,7,15,0,0,13953,13954,7,0,0,0,13954,13955,7,
+        9,0,0,13955,1798,1,0,0,0,13956,13957,7,11,0,0,13957,13958,7,3,0,
+        0,13958,13959,7,4,0,0,13959,13960,7,3,0,0,13960,13961,7,10,0,0,13961,
+        13962,7,14,0,0,13962,1800,1,0,0,0,13963,13964,7,11,0,0,13964,13965,
+        7,4,0,0,13965,13966,7,3,0,0,13966,13967,7,10,0,0,13967,13968,7,14,
+        0,0,13968,1802,1,0,0,0,13969,13970,7,14,0,0,13970,1804,1,0,0,0,13971,
+        13972,7,14,0,0,13972,13973,7,0,0,0,13973,13974,7,10,0,0,13974,13975,
+        7,7,0,0,13975,1806,1,0,0,0,13976,13977,7,14,0,0,13977,13978,7,0,
+        0,0,13978,13979,7,21,0,0,13979,13980,7,6,0,0,13980,13981,5,95,0,
+        0,13981,13982,7,3,0,0,13982,13983,7,6,0,0,13983,13984,7,16,0,0,13984,
+        1808,1,0,0,0,13985,13986,7,14,0,0,13986,13987,7,0,0,0,13987,13988,
+        7,7,0,0,13988,13989,7,0,0,0,13989,13990,7,17,0,0,13990,13991,7,6,
+        0,0,13991,13992,7,9,0,0,13992,1810,1,0,0,0,13993,13994,7,14,0,0,
+        13994,13995,7,0,0,0,13995,13996,7,7,0,0,13996,13997,7,0,0,0,13997,
+        13998,7,17,0,0,13998,13999,7,6,0,0,13999,1812,1,0,0,0,14000,14001,
+        7,14,0,0,14001,14002,7,0,0,0,14002,14003,7,7,0,0,14003,14004,7,0,
+        0,0,14004,14005,7,17,0,0,14005,14006,7,6,0,0,14006,14007,7,14,0,
+        0,14007,14008,7,6,0,0,14008,14009,7,7,0,0,14009,14010,7,4,0,0,14010,
+        1814,1,0,0,0,14011,14012,7,14,0,0,14012,14013,7,0,0,0,14013,14014,
+        7,7,0,0,14014,14015,7,0,0,0,14015,14016,7,17,0,0,14016,14017,7,6,
+        0,0,14017,14018,7,3,0,0,14018,1816,1,0,0,0,14019,14020,7,14,0,0,
+        14020,14021,7,0,0,0,14021,14022,7,7,0,0,14022,14023,7,9,0,0,14023,
+        14024,7,0,0,0,14024,14025,7,4,0,0,14025,14026,7,2,0,0,14026,14027,
+        7,3,0,0,14027,14028,7,18,0,0,14028,1818,1,0,0,0,14029,14030,7,14,
+        0,0,14030,14031,7,0,0,0,14031,14032,7,7,0,0,14032,14033,7,12,0,0,
+        14033,14034,7,0,0,0,14034,14035,7,11,0,0,14035,1820,1,0,0,0,14036,
+        14037,7,14,0,0,14037,14038,7,0,0,0,14038,14039,7,15,0,0,14039,1822,
+        1,0,0,0,14040,14041,7,14,0,0,14041,14042,7,0,0,0,14042,14043,7,15,
+        0,0,14043,14044,7,15,0,0,14044,14045,7,10,0,0,14045,14046,7,7,0,
+        0,14046,14047,7,17,0,0,14047,1824,1,0,0,0,14048,14049,7,14,0,0,14049,
+        14050,7,0,0,0,14050,14051,7,5,0,0,14051,14052,7,21,0,0,14052,1826,
+        1,0,0,0,14053,14054,7,14,0,0,14054,14055,7,0,0,0,14055,14056,7,5,
+        0,0,14056,14057,7,4,0,0,14057,14058,7,6,0,0,14058,14059,7,3,0,0,
+        14059,1828,1,0,0,0,14060,14061,7,14,0,0,14061,14062,7,0,0,0,14062,
+        14063,7,4,0,0,14063,14064,7,8,0,0,14064,14065,7,19,0,0,14065,14066,
+        7,6,0,0,14066,14067,7,9,0,0,14067,1830,1,0,0,0,14068,14069,7,14,
+        0,0,14069,14070,7,0,0,0,14070,14071,7,4,0,0,14071,14072,7,8,0,0,
+        14072,14073,7,19,0,0,14073,14074,7,6,0,0,14074,14075,7,5,0,0,14075,
+        1832,1,0,0,0,14076,14077,7,14,0,0,14077,14078,7,0,0,0,14078,14079,
+        7,4,0,0,14079,14080,7,8,0,0,14080,14081,7,19,0,0,14081,1834,1,0,
+        0,0,14082,14083,7,14,0,0,14083,14084,7,0,0,0,14084,14085,7,4,0,0,
+        14085,14086,7,8,0,0,14086,14087,7,19,0,0,14087,14088,5,95,0,0,14088,
+        14089,7,7,0,0,14089,14090,7,12,0,0,14090,14091,7,14,0,0,14091,14092,
+        7,1,0,0,14092,14093,7,6,0,0,14093,14094,7,3,0,0,14094,1836,1,0,0,
+        0,14095,14096,7,14,0,0,14096,14097,7,0,0,0,14097,14098,7,4,0,0,14098,
+        14099,7,8,0,0,14099,14100,7,19,0,0,14100,14101,5,95,0,0,14101,14102,
+        7,3,0,0,14102,14103,7,6,0,0,14103,14104,7,8,0,0,14104,14105,7,2,
+        0,0,14105,14106,7,17,0,0,14106,14107,7,7,0,0,14107,14108,7,10,0,
+        0,14108,14109,7,23,0,0,14109,14110,7,6,0,0,14110,1838,1,0,0,0,14111,
+        14112,7,14,0,0,14112,14113,7,0,0,0,14113,14114,7,4,0,0,14114,14115,
+        7,6,0,0,14115,14116,7,3,0,0,14116,14117,7,10,0,0,14117,14118,7,0,
+        0,0,14118,14119,7,11,0,0,14119,14120,7,10,0,0,14120,14121,7,23,0,
+        0,14121,14122,7,6,0,0,14122,14123,7,9,0,0,14123,1840,1,0,0,0,14124,
+        14125,7,14,0,0,14125,14126,7,0,0,0,14126,14127,7,4,0,0,14127,14128,
+        7,6,0,0,14128,14129,7,3,0,0,14129,14130,7,10,0,0,14130,14131,7,0,
+        0,0,14131,14132,7,11,0,0,14132,14133,7,10,0,0,14133,14134,7,23,0,
+        0,14134,14135,7,6,0,0,14135,1842,1,0,0,0,14136,14137,7,14,0,0,14137,
+        14138,7,0,0,0,14138,14139,7,25,0,0,14139,14140,7,0,0,0,14140,14141,
+        7,3,0,0,14141,14142,7,8,0,0,14142,14143,7,19,0,0,14143,14144,7,11,
+        0,0,14144,14145,7,2,0,0,14145,14146,7,17,0,0,14146,14147,7,5,0,0,
+        14147,1844,1,0,0,0,14148,14149,7,14,0,0,14149,14150,7,0,0,0,14150,
+        14151,7,25,0,0,14151,14152,7,9,0,0,14152,14153,7,0,0,0,14153,14154,
+        7,4,0,0,14154,14155,7,0,0,0,14155,14156,7,16,0,0,14156,14157,7,10,
+        0,0,14157,14158,7,11,0,0,14158,14159,7,6,0,0,14159,14160,7,5,0,0,
+        14160,1846,1,0,0,0,14161,14162,7,14,0,0,14162,14163,7,0,0,0,14163,
+        14164,7,25,0,0,14164,14165,7,6,0,0,14165,14166,7,25,0,0,14166,14167,
+        7,4,0,0,14167,14168,7,6,0,0,14168,14169,7,7,0,0,14169,14170,7,4,
+        0,0,14170,14171,7,5,0,0,14171,1848,1,0,0,0,14172,14173,7,14,0,0,
+        14173,14174,7,0,0,0,14174,14175,7,25,0,0,14175,14176,7,10,0,0,14176,
+        14177,7,14,0,0,14177,14178,7,10,0,0,14178,14179,7,23,0,0,14179,14180,
+        7,6,0,0,14180,1850,1,0,0,0,14181,14182,7,14,0,0,14182,14183,7,0,
+        0,0,14183,14184,7,25,0,0,14184,14185,7,10,0,0,14185,14186,7,7,0,
+        0,14186,14187,7,5,0,0,14187,14188,7,4,0,0,14188,14189,7,0,0,0,14189,
+        14190,7,7,0,0,14190,14191,7,8,0,0,14191,14192,7,6,0,0,14192,14193,
+        7,5,0,0,14193,1852,1,0,0,0,14194,14195,7,14,0,0,14195,14196,7,0,
+        0,0,14196,14197,7,25,0,0,14197,14198,7,11,0,0,14198,14199,7,2,0,
+        0,14199,14200,7,17,0,0,14200,14201,7,16,0,0,14201,14202,7,10,0,0,
+        14202,14203,7,11,0,0,14203,14204,7,6,0,0,14204,14205,7,5,0,0,14205,
+        1854,1,0,0,0,14206,14207,7,14,0,0,14207,14208,7,0,0,0,14208,14209,
+        7,25,0,0,14209,14210,7,11,0,0,14210,14211,7,2,0,0,14211,14212,7,
+        17,0,0,14212,14213,7,19,0,0,14213,14214,7,10,0,0,14214,14215,7,5,
+        0,0,14215,14216,7,4,0,0,14216,14217,7,2,0,0,14217,14218,7,3,0,0,
+        14218,14219,7,18,0,0,14219,1856,1,0,0,0,14220,14221,7,14,0,0,14221,
+        14222,7,0,0,0,14222,14223,7,25,0,0,14223,14224,7,11,0,0,14224,14225,
+        7,2,0,0,14225,14226,7,17,0,0,14226,14227,7,14,0,0,14227,14228,7,
+        6,0,0,14228,14229,7,14,0,0,14229,14230,7,1,0,0,14230,14231,7,6,0,
+        0,14231,14232,7,3,0,0,14232,14233,7,5,0,0,14233,1858,1,0,0,0,14234,
+        14235,7,14,0,0,14235,14236,7,0,0,0,14236,14237,7,25,0,0,14237,14238,
+        5,95,0,0,14238,14239,7,5,0,0,14239,14240,7,19,0,0,14240,14241,7,
+        0,0,0,14241,14242,7,3,0,0,14242,14243,7,6,0,0,14243,14244,7,9,0,
+        0,14244,14245,5,95,0,0,14245,14246,7,4,0,0,14246,14247,7,6,0,0,14247,
+        14248,7,14,0,0,14248,14249,7,15,0,0,14249,14250,5,95,0,0,14250,14251,
+        7,5,0,0,14251,14252,7,10,0,0,14252,14253,7,23,0,0,14253,14254,7,
+        6,0,0,14254,1860,1,0,0,0,14255,14256,7,14,0,0,14256,14257,7,0,0,
+        0,14257,14258,7,25,0,0,14258,14259,7,5,0,0,14259,14260,7,10,0,0,
+        14260,14261,7,23,0,0,14261,14262,7,6,0,0,14262,1862,1,0,0,0,14263,
+        14264,7,14,0,0,14264,14265,7,0,0,0,14265,14266,7,25,0,0,14266,14267,
+        7,4,0,0,14267,14268,7,3,0,0,14268,14269,7,0,0,0,14269,14270,7,7,
+        0,0,14270,14271,7,5,0,0,14271,1864,1,0,0,0,14272,14273,7,14,0,0,
+        14273,14274,7,0,0,0,14274,14275,7,25,0,0,14275,14276,7,13,0,0,14276,
+        14277,7,0,0,0,14277,14278,7,11,0,0,14278,14279,7,12,0,0,14279,14280,
+        7,6,0,0,14280,1866,1,0,0,0,14281,14282,7,14,0,0,14282,14283,7,6,
+        0,0,14283,14284,7,0,0,0,14284,14285,7,5,0,0,14285,14286,7,12,0,0,
+        14286,14287,7,3,0,0,14287,14288,7,6,0,0,14288,1868,1,0,0,0,14289,
+        14290,7,14,0,0,14290,14291,7,6,0,0,14291,14292,7,0,0,0,14292,14293,
+        7,5,0,0,14293,14294,7,12,0,0,14294,14295,7,3,0,0,14295,14296,7,6,
+        0,0,14296,14297,7,5,0,0,14297,1870,1,0,0,0,14298,14299,7,14,0,0,
+        14299,14300,7,6,0,0,14300,14301,7,9,0,0,14301,14302,7,10,0,0,14302,
+        14303,7,12,0,0,14303,14304,7,14,0,0,14304,1872,1,0,0,0,14305,14306,
+        7,14,0,0,14306,14307,7,6,0,0,14307,14308,7,14,0,0,14308,14309,7,
+        1,0,0,14309,14310,7,6,0,0,14310,14311,7,3,0,0,14311,1874,1,0,0,0,
+        14312,14313,7,14,0,0,14313,14314,7,6,0,0,14314,14315,7,14,0,0,14315,
+        14316,7,1,0,0,14316,14317,7,6,0,0,14317,14318,7,3,0,0,14318,14319,
+        5,95,0,0,14319,14320,7,8,0,0,14320,14321,7,0,0,0,14321,14322,7,15,
+        0,0,14322,14323,7,4,0,0,14323,14324,7,10,0,0,14324,14325,7,2,0,0,
+        14325,14326,7,7,0,0,14326,1876,1,0,0,0,14327,14328,7,14,0,0,14328,
+        14329,7,6,0,0,14329,14330,7,14,0,0,14330,14331,7,1,0,0,14331,14332,
+        7,6,0,0,14332,14333,7,3,0,0,14333,14334,5,95,0,0,14334,14335,7,9,
+        0,0,14335,14336,7,6,0,0,14336,14337,7,5,0,0,14337,14338,7,8,0,0,
+        14338,14339,7,3,0,0,14339,14340,7,10,0,0,14340,14341,7,15,0,0,14341,
+        14342,7,4,0,0,14342,14343,7,10,0,0,14343,14344,7,2,0,0,14344,14345,
+        7,7,0,0,14345,1878,1,0,0,0,14346,14347,7,14,0,0,14347,14348,7,6,
+        0,0,14348,14349,7,14,0,0,14349,14350,7,1,0,0,14350,14351,7,6,0,0,
+        14351,14352,7,3,0,0,14352,14353,5,95,0,0,14353,14354,7,7,0,0,14354,
+        14355,7,0,0,0,14355,14356,7,14,0,0,14356,14357,7,6,0,0,14357,1880,
+        1,0,0,0,14358,14359,7,14,0,0,14359,14360,7,6,0,0,14360,14361,7,14,
+        0,0,14361,14362,7,1,0,0,14362,14363,7,6,0,0,14363,14364,7,3,0,0,
+        14364,14365,5,95,0,0,14365,14366,7,12,0,0,14366,14367,7,7,0,0,14367,
+        14368,7,10,0,0,14368,14369,7,24,0,0,14369,14370,7,12,0,0,14370,14371,
+        7,6,0,0,14371,14372,5,95,0,0,14372,14373,7,7,0,0,14373,14374,7,0,
+        0,0,14374,14375,7,14,0,0,14375,14376,7,6,0,0,14376,1882,1,0,0,0,
+        14377,14378,7,14,0,0,14378,14379,7,6,0,0,14379,14380,7,14,0,0,14380,
+        14381,7,8,0,0,14381,14382,7,2,0,0,14382,14383,7,14,0,0,14383,14384,
+        7,15,0,0,14384,14385,7,3,0,0,14385,14386,7,6,0,0,14386,14387,7,5,
+        0,0,14387,14388,7,5,0,0,14388,1884,1,0,0,0,14389,14390,7,14,0,0,
+        14390,14391,7,6,0,0,14391,14392,7,14,0,0,14392,14393,7,2,0,0,14393,
+        14394,7,3,0,0,14394,14395,7,18,0,0,14395,1886,1,0,0,0,14396,14397,
+        7,14,0,0,14397,14398,7,6,0,0,14398,14399,7,3,0,0,14399,14400,7,17,
+        0,0,14400,14401,7,6,0,0,14401,14402,5,36,0,0,14402,14403,7,0,0,0,
+        14403,14404,7,8,0,0,14404,14405,7,4,0,0,14405,14406,7,10,0,0,14406,
+        14407,7,2,0,0,14407,14408,7,7,0,0,14408,14409,7,5,0,0,14409,1888,
+        1,0,0,0,14410,14411,7,14,0,0,14411,14412,7,6,0,0,14412,14413,7,3,
+        0,0,14413,14414,7,17,0,0,14414,14415,7,6,0,0,14415,14416,5,95,0,
+        0,14416,14417,7,0,0,0,14417,14418,7,20,0,0,14418,1890,1,0,0,0,14419,
+        14420,7,14,0,0,14420,14421,7,6,0,0,14421,14422,7,3,0,0,14422,14423,
+        7,17,0,0,14423,14424,7,6,0,0,14424,14425,5,95,0,0,14425,14426,7,
+        8,0,0,14426,14427,7,2,0,0,14427,14428,7,7,0,0,14428,14429,7,5,0,
+        0,14429,14430,7,4,0,0,14430,14431,5,95,0,0,14431,14432,7,2,0,0,14432,
+        14433,7,7,0,0,14433,1892,1,0,0,0,14434,14435,7,14,0,0,14435,14436,
+        7,6,0,0,14436,14437,7,3,0,0,14437,14438,7,17,0,0,14438,14439,7,6,
+        0,0,14439,1894,1,0,0,0,14440,14441,7,14,0,0,14441,14442,7,6,0,0,
+        14442,14443,7,3,0,0,14443,14444,7,17,0,0,14444,14445,7,6,0,0,14445,
+        14446,5,95,0,0,14446,14447,7,5,0,0,14447,14448,7,20,0,0,14448,1896,
+        1,0,0,0,14449,14450,7,14,0,0,14450,14451,7,6,0,0,14451,14452,7,4,
+        0,0,14452,14453,7,0,0,0,14453,14454,7,9,0,0,14454,14455,7,0,0,0,
+        14455,14456,7,4,0,0,14456,14457,7,0,0,0,14457,1898,1,0,0,0,14458,
+        14459,7,14,0,0,14459,14460,7,6,0,0,14460,14461,7,4,0,0,14461,14462,
+        7,19,0,0,14462,14463,7,2,0,0,14463,14464,7,9,0,0,14464,1900,1,0,
+        0,0,14465,14466,7,14,0,0,14466,14467,7,10,0,0,14467,14468,7,17,0,
+        0,14468,14469,7,3,0,0,14469,14470,7,0,0,0,14470,14471,7,4,0,0,14471,
+        14472,7,6,0,0,14472,1902,1,0,0,0,14473,14474,7,14,0,0,14474,14475,
+        7,10,0,0,14475,14476,7,17,0,0,14476,14477,7,3,0,0,14477,14478,7,
+        0,0,0,14478,14479,7,4,0,0,14479,14480,7,10,0,0,14480,14481,7,2,0,
+        0,14481,14482,7,7,0,0,14482,1904,1,0,0,0,14483,14484,7,14,0,0,14484,
+        14485,7,10,0,0,14485,14486,7,7,0,0,14486,14487,7,6,0,0,14487,14488,
+        7,25,0,0,14488,14489,7,4,0,0,14489,14490,7,6,0,0,14490,14491,7,7,
+        0,0,14491,14492,7,4,0,0,14492,14493,7,5,0,0,14493,1906,1,0,0,0,14494,
+        14495,7,14,0,0,14495,14496,7,10,0,0,14496,14497,7,7,0,0,14497,14498,
+        7,10,0,0,14498,14499,7,14,0,0,14499,14500,7,10,0,0,14500,14501,7,
+        23,0,0,14501,14502,7,6,0,0,14502,1908,1,0,0,0,14503,14504,7,14,0,
+        0,14504,14505,7,10,0,0,14505,14506,7,7,0,0,14506,14507,7,10,0,0,
+        14507,14508,7,14,0,0,14508,14509,7,12,0,0,14509,14510,7,14,0,0,14510,
+        1910,1,0,0,0,14511,14512,7,14,0,0,14512,14513,7,10,0,0,14513,14514,
+        7,7,0,0,14514,14515,7,10,0,0,14515,14516,7,7,0,0,14516,14517,7,17,
+        0,0,14517,1912,1,0,0,0,14518,14519,7,14,0,0,14519,14520,7,10,0,0,
+        14520,14521,7,7,0,0,14521,14522,7,12,0,0,14522,14523,7,5,0,0,14523,
+        1914,1,0,0,0,14524,14525,7,14,0,0,14525,14526,7,10,0,0,14526,14527,
+        7,7,0,0,14527,14528,7,12,0,0,14528,14529,7,5,0,0,14529,14530,5,95,
+        0,0,14530,14531,7,7,0,0,14531,14532,7,12,0,0,14532,14533,7,11,0,
+        0,14533,14534,7,11,0,0,14534,1916,1,0,0,0,14535,14536,7,14,0,0,14536,
+        14537,7,10,0,0,14537,14538,7,7,0,0,14538,14539,7,12,0,0,14539,14540,
+        7,4,0,0,14540,14541,7,6,0,0,14541,1918,1,0,0,0,14542,14543,7,14,
+        0,0,14543,14544,7,10,0,0,14544,14545,7,7,0,0,14545,14546,7,12,0,
+        0,14546,14547,7,4,0,0,14547,14548,7,6,0,0,14548,14549,7,5,0,0,14549,
+        1920,1,0,0,0,14550,14551,7,14,0,0,14551,14552,7,10,0,0,14552,14553,
+        7,7,0,0,14553,14554,7,13,0,0,14554,14555,7,0,0,0,14555,14556,7,11,
+        0,0,14556,14557,7,12,0,0,14557,14558,7,6,0,0,14558,1922,1,0,0,0,
+        14559,14560,7,14,0,0,14560,14561,7,10,0,0,14561,14562,7,3,0,0,14562,
+        14563,7,3,0,0,14563,14564,7,2,0,0,14564,14565,7,3,0,0,14565,14566,
+        7,8,0,0,14566,14567,7,2,0,0,14567,14568,7,11,0,0,14568,14569,7,9,
+        0,0,14569,1924,1,0,0,0,14570,14571,7,14,0,0,14571,14572,7,10,0,0,
+        14572,14573,7,3,0,0,14573,14574,7,3,0,0,14574,14575,7,2,0,0,14575,
+        14576,7,3,0,0,14576,14577,7,19,0,0,14577,14578,7,2,0,0,14578,14579,
+        7,4,0,0,14579,1926,1,0,0,0,14580,14581,7,14,0,0,14581,14582,7,10,
+        0,0,14582,14583,7,3,0,0,14583,14584,7,3,0,0,14584,14585,7,2,0,0,
+        14585,14586,7,3,0,0,14586,1928,1,0,0,0,14587,14588,7,14,0,0,14588,
+        14589,7,10,0,0,14589,14590,7,5,0,0,14590,14591,7,5,0,0,14591,14592,
+        7,10,0,0,14592,14593,7,7,0,0,14593,14594,7,17,0,0,14594,1930,1,0,
+        0,0,14595,14596,7,14,0,0,14596,14597,7,10,0,0,14597,14598,7,5,0,
+        0,14598,14599,7,14,0,0,14599,14600,7,0,0,0,14600,14601,7,4,0,0,14601,
+        14602,7,8,0,0,14602,14603,7,19,0,0,14603,1932,1,0,0,0,14604,14605,
+        7,14,0,0,14605,14606,7,11,0,0,14606,14607,7,5,0,0,14607,14608,7,
+        11,0,0,14608,14609,7,0,0,0,14609,14610,7,1,0,0,14610,14611,7,6,0,
+        0,14611,14612,7,11,0,0,14612,1934,1,0,0,0,14613,14614,7,14,0,0,14614,
+        14615,7,2,0,0,14615,14616,7,9,0,0,14616,14617,7,6,0,0,14617,14618,
+        7,11,0,0,14618,14619,5,95,0,0,14619,14620,7,8,0,0,14620,14621,7,
+        2,0,0,14621,14622,7,14,0,0,14622,14623,7,15,0,0,14623,14624,7,10,
+        0,0,14624,14625,7,11,0,0,14625,14626,7,6,0,0,14626,14627,5,95,0,
+        0,14627,14628,7,5,0,0,14628,14629,7,12,0,0,14629,14630,7,1,0,0,14630,
+        14631,7,24,0,0,14631,14632,7,12,0,0,14632,14633,7,6,0,0,14633,14634,
+        7,3,0,0,14634,14635,7,18,0,0,14635,1936,1,0,0,0,14636,14637,7,14,
+        0,0,14637,14638,7,2,0,0,14638,14639,7,9,0,0,14639,14640,7,6,0,0,
+        14640,14641,7,11,0,0,14641,14642,5,95,0,0,14642,14643,7,9,0,0,14643,
+        14644,7,2,0,0,14644,14645,7,7,0,0,14645,14646,7,4,0,0,14646,14647,
+        7,13,0,0,14647,14648,7,6,0,0,14648,14649,7,3,0,0,14649,14650,7,10,
+        0,0,14650,14651,7,16,0,0,14651,14652,7,18,0,0,14652,14653,5,95,0,
+        0,14653,14654,7,12,0,0,14654,14655,7,7,0,0,14655,14656,7,10,0,0,
+        14656,14657,7,24,0,0,14657,14658,7,12,0,0,14658,14659,7,6,0,0,14659,
+        14660,7,7,0,0,14660,14661,7,6,0,0,14661,14662,7,5,0,0,14662,14663,
+        7,5,0,0,14663,1938,1,0,0,0,14664,14665,7,14,0,0,14665,14666,7,2,
+        0,0,14666,14667,7,9,0,0,14667,14668,7,6,0,0,14668,14669,7,11,0,0,
+        14669,14670,5,95,0,0,14670,14671,7,9,0,0,14671,14672,7,18,0,0,14672,
+        14673,7,7,0,0,14673,14674,7,0,0,0,14674,14675,7,14,0,0,14675,14676,
+        7,10,0,0,14676,14677,7,8,0,0,14677,14678,5,95,0,0,14678,14679,7,
+        5,0,0,14679,14680,7,12,0,0,14680,14681,7,1,0,0,14681,14682,7,24,
+        0,0,14682,14683,7,12,0,0,14683,14684,7,6,0,0,14684,14685,7,3,0,0,
+        14685,14686,7,18,0,0,14686,1940,1,0,0,0,14687,14688,7,14,0,0,14688,
+        14689,7,2,0,0,14689,14690,7,9,0,0,14690,14691,7,6,0,0,14691,14692,
+        7,11,0,0,14692,14693,5,95,0,0,14693,14694,7,14,0,0,14694,14695,7,
+        10,0,0,14695,14696,7,7,0,0,14696,14697,5,95,0,0,14697,14698,7,0,
+        0,0,14698,14699,7,7,0,0,14699,14700,7,0,0,0,14700,14701,7,11,0,0,
+        14701,14702,7,18,0,0,14702,14703,7,5,0,0,14703,14704,7,10,0,0,14704,
+        14705,7,5,0,0,14705,1942,1,0,0,0,14706,14707,7,14,0,0,14707,14708,
+        7,2,0,0,14708,14709,7,9,0,0,14709,14710,7,6,0,0,14710,14711,7,11,
+        0,0,14711,1944,1,0,0,0,14712,14713,7,14,0,0,14713,14714,7,2,0,0,
+        14714,14715,7,9,0,0,14715,14716,7,6,0,0,14716,14717,7,11,0,0,14717,
+        14718,5,95,0,0,14718,14719,7,7,0,0,14719,14720,7,1,0,0,14720,1946,
+        1,0,0,0,14721,14722,7,14,0,0,14722,14723,7,2,0,0,14723,14724,7,9,
+        0,0,14724,14725,7,6,0,0,14725,14726,7,11,0,0,14726,14727,5,95,0,
+        0,14727,14728,7,7,0,0,14728,14729,7,2,0,0,14729,14730,5,95,0,0,14730,
+        14731,7,0,0,0,14731,14732,7,7,0,0,14732,14733,7,0,0,0,14733,14734,
+        7,11,0,0,14734,14735,7,18,0,0,14735,14736,7,5,0,0,14736,14737,7,
+        10,0,0,14737,14738,7,5,0,0,14738,1948,1,0,0,0,14739,14740,7,14,0,
+        0,14740,14741,7,2,0,0,14741,14742,7,9,0,0,14742,14743,7,6,0,0,14743,
+        14744,7,11,0,0,14744,14745,5,95,0,0,14745,14746,7,15,0,0,14746,14747,
+        7,1,0,0,14747,14748,7,18,0,0,14748,1950,1,0,0,0,14749,14750,7,14,
+        0,0,14750,14751,7,2,0,0,14751,14752,7,9,0,0,14752,14753,7,6,0,0,
+        14753,14754,7,11,0,0,14754,14755,5,95,0,0,14755,14756,7,15,0,0,14756,
+        14757,7,12,0,0,14757,14758,7,5,0,0,14758,14759,7,19,0,0,14759,14760,
+        5,95,0,0,14760,14761,7,3,0,0,14761,14762,7,6,0,0,14762,14763,7,16,
+        0,0,14763,1952,1,0,0,0,14764,14765,7,14,0,0,14765,14766,7,2,0,0,
+        14766,14767,7,9,0,0,14767,14768,7,6,0,0,14768,14769,7,11,0,0,14769,
+        14770,5,95,0,0,14770,14771,7,5,0,0,14771,14772,7,13,0,0,14772,1954,
+        1,0,0,0,14773,14774,7,14,0,0,14774,14775,7,2,0,0,14775,14776,7,9,
+        0,0,14776,14777,7,6,0,0,14777,1956,1,0,0,0,14778,14779,7,14,0,0,
+        14779,14780,7,2,0,0,14780,14781,7,9,0,0,14781,14782,7,10,0,0,14782,
+        14783,7,16,0,0,14783,14784,7,10,0,0,14784,14785,7,8,0,0,14785,14786,
+        7,0,0,0,14786,14787,7,4,0,0,14787,14788,7,10,0,0,14788,14789,7,2,
+        0,0,14789,14790,7,7,0,0,14790,1958,1,0,0,0,14791,14792,7,14,0,0,
+        14792,14793,7,2,0,0,14793,14794,7,9,0,0,14794,14795,7,10,0,0,14795,
+        14796,7,16,0,0,14796,14797,7,18,0,0,14797,14798,5,95,0,0,14798,14799,
+        7,8,0,0,14799,14800,7,2,0,0,14800,14801,7,11,0,0,14801,14802,7,12,
+        0,0,14802,14803,7,14,0,0,14803,14804,7,7,0,0,14804,14805,5,95,0,
+        0,14805,14806,7,4,0,0,14806,14807,7,18,0,0,14807,14808,7,15,0,0,
+        14808,14809,7,6,0,0,14809,1960,1,0,0,0,14810,14811,7,14,0,0,14811,
+        14812,7,2,0,0,14812,14813,7,9,0,0,14813,14814,7,10,0,0,14814,14815,
+        7,16,0,0,14815,14816,7,18,0,0,14816,1962,1,0,0,0,14817,14818,7,14,
+        0,0,14818,14819,7,2,0,0,14819,14820,7,9,0,0,14820,1964,1,0,0,0,14821,
+        14822,7,14,0,0,14822,14823,7,2,0,0,14823,14824,7,9,0,0,14824,14825,
+        7,12,0,0,14825,14826,7,11,0,0,14826,14827,7,6,0,0,14827,1966,1,0,
+        0,0,14828,14829,7,14,0,0,14829,14830,7,2,0,0,14830,14831,7,7,0,0,
+        14831,14832,7,10,0,0,14832,14833,7,4,0,0,14833,14834,7,2,0,0,14834,
+        14835,7,3,0,0,14835,14836,7,10,0,0,14836,14837,7,7,0,0,14837,14838,
+        7,17,0,0,14838,1968,1,0,0,0,14839,14840,7,14,0,0,14840,14841,7,2,
+        0,0,14841,14842,7,7,0,0,14842,14843,7,10,0,0,14843,14844,7,4,0,0,
+        14844,14845,7,2,0,0,14845,14846,7,3,0,0,14846,1970,1,0,0,0,14847,
+        14848,7,14,0,0,14848,14849,7,2,0,0,14849,14850,7,7,0,0,14850,14851,
+        7,4,0,0,14851,14852,7,19,0,0,14852,1972,1,0,0,0,14853,14854,7,14,
+        0,0,14854,14855,7,2,0,0,14855,14856,7,7,0,0,14856,14857,7,4,0,0,
+        14857,14858,7,19,0,0,14858,14859,7,5,0,0,14859,14860,5,95,0,0,14860,
+        14861,7,1,0,0,14861,14862,7,6,0,0,14862,14863,7,4,0,0,14863,14864,
+        7,22,0,0,14864,14865,7,6,0,0,14865,14866,7,6,0,0,14866,14867,7,7,
+        0,0,14867,1974,1,0,0,0,14868,14869,7,14,0,0,14869,14870,7,2,0,0,
+        14870,14871,7,7,0,0,14871,14872,7,4,0,0,14872,14873,7,19,0,0,14873,
+        14874,7,5,0,0,14874,1976,1,0,0,0,14875,14876,7,14,0,0,14876,14877,
+        7,2,0,0,14877,14878,7,12,0,0,14878,14879,7,7,0,0,14879,14880,7,4,
+        0,0,14880,1978,1,0,0,0,14881,14882,7,14,0,0,14882,14883,7,2,0,0,
+        14883,14884,7,12,0,0,14884,14885,7,7,0,0,14885,14886,7,4,0,0,14886,
+        14887,7,15,0,0,14887,14888,7,0,0,0,14888,14889,7,4,0,0,14889,14890,
+        7,19,0,0,14890,1980,1,0,0,0,14891,14892,7,14,0,0,14892,14893,7,2,
+        0,0,14893,14894,7,12,0,0,14894,14895,7,7,0,0,14895,14896,7,4,0,0,
+        14896,14897,7,15,0,0,14897,14898,7,2,0,0,14898,14899,7,10,0,0,14899,
+        14900,7,7,0,0,14900,14901,7,4,0,0,14901,1982,1,0,0,0,14902,14903,
+        7,14,0,0,14903,14904,7,2,0,0,14904,14905,7,13,0,0,14905,14906,7,
+        6,0,0,14906,14907,7,14,0,0,14907,14908,7,6,0,0,14908,14909,7,7,0,
+        0,14909,14910,7,4,0,0,14910,1984,1,0,0,0,14911,14912,7,14,0,0,14912,
+        14913,7,2,0,0,14913,14914,7,13,0,0,14914,14915,7,6,0,0,14915,1986,
+        1,0,0,0,14916,14917,7,14,0,0,14917,14918,7,12,0,0,14918,14919,7,
+        11,0,0,14919,14920,7,4,0,0,14920,14921,7,10,0,0,14921,14922,7,9,
+        0,0,14922,14923,7,10,0,0,14923,14924,7,14,0,0,14924,14925,7,6,0,
+        0,14925,14926,7,7,0,0,14926,14927,7,5,0,0,14927,14928,7,10,0,0,14928,
+        14929,7,2,0,0,14929,14930,7,7,0,0,14930,14931,7,0,0,0,14931,14932,
+        7,11,0,0,14932,1988,1,0,0,0,14933,14934,7,14,0,0,14934,14935,7,12,
+        0,0,14935,14936,7,11,0,0,14936,14937,7,4,0,0,14937,14938,7,10,0,
+        0,14938,14939,7,5,0,0,14939,14940,7,6,0,0,14940,14941,7,4,0,0,14941,
+        1990,1,0,0,0,14942,14943,7,14,0,0,14943,14944,7,13,0,0,14944,14945,
+        5,95,0,0,14945,14946,7,14,0,0,14946,14947,7,6,0,0,14947,14948,7,
+        3,0,0,14948,14949,7,17,0,0,14949,14950,7,6,0,0,14950,1992,1,0,0,
+        0,14951,14952,7,7,0,0,14952,14953,7,0,0,0,14953,14954,7,14,0,0,14954,
+        14955,7,6,0,0,14955,14956,7,9,0,0,14956,1994,1,0,0,0,14957,14958,
+        7,7,0,0,14958,14959,7,0,0,0,14959,14960,7,14,0,0,14960,14961,7,6,
+        0,0,14961,1996,1,0,0,0,14962,14963,7,7,0,0,14963,14964,7,0,0,0,14964,
+        14965,7,14,0,0,14965,14966,7,6,0,0,14966,14967,7,5,0,0,14967,14968,
+        7,15,0,0,14968,14969,7,0,0,0,14969,14970,7,8,0,0,14970,14971,7,6,
+        0,0,14971,1998,1,0,0,0,14972,14973,7,7,0,0,14973,14974,7,0,0,0,14974,
+        14975,7,7,0,0,14975,2000,1,0,0,0,14976,14977,7,7,0,0,14977,14978,
+        7,0,0,0,14978,14979,7,7,0,0,14979,14980,7,13,0,0,14980,14981,7,11,
+        0,0,14981,2002,1,0,0,0,14982,14983,7,7,0,0,14983,14984,7,0,0,0,14984,
+        14985,7,4,0,0,14985,14986,7,10,0,0,14986,14987,7,2,0,0,14987,14988,
+        7,7,0,0,14988,14989,7,0,0,0,14989,14990,7,11,0,0,14990,2004,1,0,
+        0,0,14991,14992,7,7,0,0,14992,14993,7,0,0,0,14993,14994,7,4,0,0,
+        14994,14995,7,10,0,0,14995,14996,7,13,0,0,14996,14997,7,6,0,0,14997,
+        14998,5,95,0,0,14998,14999,7,16,0,0,14999,15000,7,12,0,0,15000,15001,
+        7,11,0,0,15001,15002,7,11,0,0,15002,15003,5,95,0,0,15003,15004,7,
+        2,0,0,15004,15005,7,12,0,0,15005,15006,7,4,0,0,15006,15007,7,6,0,
+        0,15007,15008,7,3,0,0,15008,15009,5,95,0,0,15009,15010,7,20,0,0,
+        15010,15011,7,2,0,0,15011,15012,7,10,0,0,15012,15013,7,7,0,0,15013,
+        2006,1,0,0,0,15014,15015,7,7,0,0,15015,15016,7,0,0,0,15016,15017,
+        7,4,0,0,15017,15018,7,10,0,0,15018,15019,7,13,0,0,15019,15020,7,
+        6,0,0,15020,2008,1,0,0,0,15021,15022,7,7,0,0,15022,15023,7,0,0,0,
+        15023,15024,7,4,0,0,15024,15025,7,12,0,0,15025,15026,7,3,0,0,15026,
+        15027,7,0,0,0,15027,15028,7,11,0,0,15028,2010,1,0,0,0,15029,15030,
+        7,7,0,0,15030,15031,7,0,0,0,15031,15032,7,4,0,0,15032,15033,7,12,
+        0,0,15033,15034,7,3,0,0,15034,15035,7,0,0,0,15035,15036,7,11,0,0,
+        15036,15037,7,7,0,0,15037,2012,1,0,0,0,15038,15039,7,7,0,0,15039,
+        15040,7,0,0,0,15040,15041,7,13,0,0,15041,2014,1,0,0,0,15042,15043,
+        7,7,0,0,15043,15044,7,8,0,0,15044,15045,7,19,0,0,15045,15046,7,0,
+        0,0,15046,15047,7,3,0,0,15047,15048,5,95,0,0,15048,15049,7,8,0,0,
+        15049,15050,7,5,0,0,15050,2016,1,0,0,0,15051,15052,7,7,0,0,15052,
+        15053,7,8,0,0,15053,15054,7,19,0,0,15054,15055,7,0,0,0,15055,15056,
+        7,3,0,0,15056,2018,1,0,0,0,15057,15058,7,7,0,0,15058,15059,7,8,0,
+        0,15059,15060,7,19,0,0,15060,15061,7,3,0,0,15061,2020,1,0,0,0,15062,
+        15063,7,7,0,0,15063,15064,7,8,0,0,15064,15065,7,11,0,0,15065,15066,
+        7,2,0,0,15066,15067,7,1,0,0,15067,2022,1,0,0,0,15068,15069,7,7,0,
+        0,15069,15070,7,6,0,0,15070,15071,7,6,0,0,15071,15072,7,9,0,0,15072,
+        15073,7,6,0,0,15073,15074,7,9,0,0,15074,2024,1,0,0,0,15075,15076,
+        7,7,0,0,15076,15077,7,6,0,0,15077,15078,7,17,0,0,15078,2026,1,0,
+        0,0,15079,15080,7,7,0,0,15080,15081,7,6,0,0,15081,15082,7,5,0,0,
+        15082,15083,7,4,0,0,15083,15084,7,6,0,0,15084,15085,7,9,0,0,15085,
+        2028,1,0,0,0,15086,15087,7,7,0,0,15087,15088,7,6,0,0,15088,15089,
+        7,5,0,0,15089,15090,7,4,0,0,15090,15091,7,6,0,0,15091,15092,7,9,
+        0,0,15092,15093,5,95,0,0,15093,15094,7,4,0,0,15094,15095,7,0,0,0,
+        15095,15096,7,1,0,0,15096,15097,7,11,0,0,15097,15098,7,6,0,0,15098,
+        15099,5,95,0,0,15099,15100,7,16,0,0,15100,15101,7,0,0,0,15101,15102,
+        7,5,0,0,15102,15103,7,4,0,0,15103,15104,5,95,0,0,15104,15105,7,10,
+        0,0,15105,15106,7,7,0,0,15106,15107,7,5,0,0,15107,15108,7,6,0,0,
+        15108,15109,7,3,0,0,15109,15110,7,4,0,0,15110,2030,1,0,0,0,15111,
+        15112,7,7,0,0,15112,15113,7,6,0,0,15113,15114,7,5,0,0,15114,15115,
+        7,4,0,0,15115,15116,7,6,0,0,15116,15117,7,9,0,0,15117,15118,5,95,
+        0,0,15118,15119,7,4,0,0,15119,15120,7,0,0,0,15120,15121,7,1,0,0,
+        15121,15122,7,11,0,0,15122,15123,7,6,0,0,15123,15124,5,95,0,0,15124,
+        15125,7,17,0,0,15125,15126,7,6,0,0,15126,15127,7,4,0,0,15127,15128,
+        5,95,0,0,15128,15129,7,3,0,0,15129,15130,7,6,0,0,15130,15131,7,16,
+        0,0,15131,15132,7,5,0,0,15132,2032,1,0,0,0,15133,15134,7,7,0,0,15134,
+        15135,7,6,0,0,15135,15136,7,5,0,0,15136,15137,7,4,0,0,15137,15138,
+        7,6,0,0,15138,15139,7,9,0,0,15139,15140,5,95,0,0,15140,15141,7,4,
+        0,0,15141,15142,7,0,0,0,15142,15143,7,1,0,0,15143,15144,7,11,0,0,
+        15144,15145,7,6,0,0,15145,15146,5,95,0,0,15146,15147,7,10,0,0,15147,
+        15148,7,9,0,0,15148,2034,1,0,0,0,15149,15150,7,7,0,0,15150,15151,
+        7,6,0,0,15151,15152,7,5,0,0,15152,15153,7,4,0,0,15153,15154,7,6,
+        0,0,15154,15155,7,9,0,0,15155,15156,5,95,0,0,15156,15157,7,4,0,0,
+        15157,15158,7,0,0,0,15158,15159,7,1,0,0,15159,15160,7,11,0,0,15160,
+        15161,7,6,0,0,15161,15162,5,95,0,0,15162,15163,7,5,0,0,15163,15164,
+        7,6,0,0,15164,15165,7,4,0,0,15165,15166,5,95,0,0,15166,15167,7,3,
+        0,0,15167,15168,7,6,0,0,15168,15169,7,16,0,0,15169,15170,7,5,0,0,
+        15170,2036,1,0,0,0,15171,15172,7,7,0,0,15172,15173,7,6,0,0,15173,
+        15174,7,5,0,0,15174,15175,7,4,0,0,15175,15176,7,6,0,0,15176,15177,
+        7,9,0,0,15177,15178,5,95,0,0,15178,15179,7,4,0,0,15179,15180,7,0,
+        0,0,15180,15181,7,1,0,0,15181,15182,7,11,0,0,15182,15183,7,6,0,0,
+        15183,15184,5,95,0,0,15184,15185,7,5,0,0,15185,15186,7,6,0,0,15186,
+        15187,7,4,0,0,15187,15188,5,95,0,0,15188,15189,7,5,0,0,15189,15190,
+        7,6,0,0,15190,15191,7,4,0,0,15191,15192,7,10,0,0,15192,15193,7,9,
+        0,0,15193,2038,1,0,0,0,15194,15195,7,7,0,0,15195,15196,7,6,0,0,15196,
+        15197,7,4,0,0,15197,15198,7,22,0,0,15198,15199,7,2,0,0,15199,15200,
+        7,3,0,0,15200,15201,7,21,0,0,15201,2040,1,0,0,0,15202,15203,7,7,
+        0,0,15203,15204,7,6,0,0,15204,15205,7,13,0,0,15205,15206,7,6,0,0,
+        15206,15207,7,3,0,0,15207,2042,1,0,0,0,15208,15209,7,7,0,0,15209,
+        15210,7,6,0,0,15210,15211,7,22,0,0,15211,2044,1,0,0,0,15212,15213,
+        7,7,0,0,15213,15214,7,6,0,0,15214,15215,7,22,0,0,15215,15216,7,11,
+        0,0,15216,15217,7,10,0,0,15217,15218,7,7,0,0,15218,15219,7,6,0,0,
+        15219,2046,1,0,0,0,15220,15221,7,7,0,0,15221,15222,7,6,0,0,15222,
+        15223,7,22,0,0,15223,15224,5,95,0,0,15224,15225,7,4,0,0,15225,15226,
+        7,10,0,0,15226,15227,7,14,0,0,15227,15228,7,6,0,0,15228,2048,1,0,
+        0,0,15229,15230,7,7,0,0,15230,15231,7,6,0,0,15231,15232,7,25,0,0,
+        15232,15233,7,4,0,0,15233,15234,5,95,0,0,15234,15235,7,9,0,0,15235,
+        15236,7,0,0,0,15236,15237,7,18,0,0,15237,2050,1,0,0,0,15238,15239,
+        7,7,0,0,15239,15240,7,6,0,0,15240,15241,7,25,0,0,15241,15242,7,4,
+        0,0,15242,2052,1,0,0,0,15243,15244,7,7,0,0,15244,15245,7,11,0,0,
+        15245,15246,5,95,0,0,15246,15247,7,0,0,0,15247,15248,7,20,0,0,15248,
+        2054,1,0,0,0,15249,15250,7,7,0,0,15250,15251,7,11,0,0,15251,15252,
+        7,20,0,0,15252,15253,5,95,0,0,15253,15254,7,1,0,0,15254,15255,7,
+        0,0,0,15255,15256,7,4,0,0,15256,15257,7,8,0,0,15257,15258,7,19,0,
+        0,15258,15259,7,10,0,0,15259,15260,7,7,0,0,15260,15261,7,17,0,0,
+        15261,2056,1,0,0,0,15262,15263,7,7,0,0,15263,15264,7,11,0,0,15264,
+        15265,7,20,0,0,15265,15266,5,95,0,0,15266,15267,7,10,0,0,15267,15268,
+        7,7,0,0,15268,15269,7,9,0,0,15269,15270,7,6,0,0,15270,15271,7,25,
+        0,0,15271,15272,5,95,0,0,15272,15273,7,16,0,0,15273,15274,7,10,0,
+        0,15274,15275,7,11,0,0,15275,15276,7,4,0,0,15276,15277,7,6,0,0,15277,
+        15278,7,3,0,0,15278,2058,1,0,0,0,15279,15280,7,7,0,0,15280,15281,
+        7,11,0,0,15281,15282,7,20,0,0,15282,15283,5,95,0,0,15283,15284,7,
+        10,0,0,15284,15285,7,7,0,0,15285,15286,7,9,0,0,15286,15287,7,6,0,
+        0,15287,15288,7,25,0,0,15288,15289,5,95,0,0,15289,15290,7,5,0,0,
+        15290,15291,7,8,0,0,15291,15292,7,0,0,0,15292,15293,7,7,0,0,15293,
+        2060,1,0,0,0,15294,15295,7,7,0,0,15295,15296,7,11,0,0,15296,15297,
+        7,20,0,0,15297,15298,5,95,0,0,15298,15299,7,15,0,0,15299,15300,7,
+        3,0,0,15300,15301,7,6,0,0,15301,15302,7,16,0,0,15302,15303,7,6,0,
+        0,15303,15304,7,4,0,0,15304,15305,7,8,0,0,15305,15306,7,19,0,0,15306,
+        2062,1,0,0,0,15307,15308,7,7,0,0,15308,15309,7,11,0,0,15309,15310,
+        7,5,0,0,15310,15311,5,95,0,0,15311,15312,7,8,0,0,15312,15313,7,0,
+        0,0,15313,15314,7,11,0,0,15314,15315,7,6,0,0,15315,15316,7,7,0,0,
+        15316,15317,7,9,0,0,15317,15318,7,0,0,0,15318,15319,7,3,0,0,15319,
+        2064,1,0,0,0,15320,15321,7,7,0,0,15321,15322,7,11,0,0,15322,15323,
+        7,5,0,0,15323,15324,5,95,0,0,15324,15325,7,8,0,0,15325,15326,7,19,
+        0,0,15326,15327,7,0,0,0,15327,15328,7,3,0,0,15328,15329,7,0,0,0,
+        15329,15330,7,8,0,0,15330,15331,7,4,0,0,15331,15332,7,6,0,0,15332,
+        15333,7,3,0,0,15333,15334,7,5,0,0,15334,15335,7,6,0,0,15335,15336,
+        7,4,0,0,15336,2066,1,0,0,0,15337,15338,7,7,0,0,15338,15339,7,11,
+        0,0,15339,15340,7,5,0,0,15340,15341,5,95,0,0,15341,15342,7,8,0,0,
+        15342,15343,7,19,0,0,15343,15344,7,0,0,0,15344,15345,7,3,0,0,15345,
+        15346,7,5,0,0,15346,15347,7,6,0,0,15347,15348,7,4,0,0,15348,15349,
+        5,95,0,0,15349,15350,7,9,0,0,15350,15351,7,6,0,0,15351,15352,7,8,
+        0,0,15352,15353,7,11,0,0,15353,15354,5,95,0,0,15354,15355,7,11,0,
+        0,15355,15356,7,6,0,0,15356,15357,7,7,0,0,15357,2068,1,0,0,0,15358,
+        15359,7,7,0,0,15359,15360,7,11,0,0,15360,15361,7,5,0,0,15361,15362,
+        5,95,0,0,15362,15363,7,8,0,0,15363,15364,7,19,0,0,15364,15365,7,
+        0,0,0,15365,15366,7,3,0,0,15366,15367,7,5,0,0,15367,15368,7,6,0,
+        0,15368,15369,7,4,0,0,15369,15370,5,95,0,0,15370,15371,7,10,0,0,
+        15371,15372,7,9,0,0,15372,2070,1,0,0,0,15373,15374,7,7,0,0,15374,
+        15375,7,11,0,0,15375,15376,7,5,0,0,15376,15377,5,95,0,0,15377,15378,
+        7,8,0,0,15378,15379,7,19,0,0,15379,15380,7,0,0,0,15380,15381,7,3,
+        0,0,15381,15382,7,5,0,0,15382,15383,7,6,0,0,15383,15384,7,4,0,0,
+        15384,15385,5,95,0,0,15385,15386,7,7,0,0,15386,15387,7,0,0,0,15387,
+        15388,7,14,0,0,15388,15389,7,6,0,0,15389,2072,1,0,0,0,15390,15391,
+        7,7,0,0,15391,15392,7,11,0,0,15392,15393,7,5,0,0,15393,15394,5,95,
+        0,0,15394,15395,7,8,0,0,15395,15396,7,2,0,0,15396,15397,7,14,0,0,
+        15397,15398,7,15,0,0,15398,2074,1,0,0,0,15399,15400,7,7,0,0,15400,
+        15401,7,11,0,0,15401,15402,7,5,0,0,15402,15403,5,95,0,0,15403,15404,
+        7,8,0,0,15404,15405,7,12,0,0,15405,15406,7,3,0,0,15406,15407,7,3,
+        0,0,15407,15408,7,6,0,0,15408,15409,7,7,0,0,15409,15410,7,8,0,0,
+        15410,15411,7,18,0,0,15411,2076,1,0,0,0,15412,15413,7,7,0,0,15413,
+        15414,7,11,0,0,15414,15415,7,5,0,0,15415,15416,5,95,0,0,15416,15417,
+        7,9,0,0,15417,15418,7,0,0,0,15418,15419,7,4,0,0,15419,15420,7,6,
+        0,0,15420,15421,5,95,0,0,15421,15422,7,16,0,0,15422,15423,7,2,0,
+        0,15423,15424,7,3,0,0,15424,15425,7,14,0,0,15425,15426,7,0,0,0,15426,
+        15427,7,4,0,0,15427,2078,1,0,0,0,15428,15429,7,7,0,0,15429,15430,
+        7,11,0,0,15430,15431,7,5,0,0,15431,15432,5,95,0,0,15432,15433,7,
+        9,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,11,0,0,15438,15439,7,0,0,0,
+        15439,15440,7,7,0,0,15440,15441,7,17,0,0,15441,15442,7,12,0,0,15442,
+        15443,7,0,0,0,15443,15444,7,17,0,0,15444,15445,7,6,0,0,15445,2080,
+        1,0,0,0,15446,15447,7,7,0,0,15447,15448,7,11,0,0,15448,15449,7,5,
+        0,0,15449,15450,5,95,0,0,15450,15451,7,10,0,0,15451,15452,7,7,0,
+        0,15452,15453,7,10,0,0,15453,15454,7,4,0,0,15454,15455,7,8,0,0,15455,
+        15456,7,0,0,0,15456,15457,7,15,0,0,15457,2082,1,0,0,0,15458,15459,
+        7,7,0,0,15459,15460,7,11,0,0,15460,15461,7,5,0,0,15461,15462,5,95,
+        0,0,15462,15463,7,10,0,0,15463,15464,7,5,0,0,15464,15465,7,2,0,0,
+        15465,15466,5,95,0,0,15466,15467,7,8,0,0,15467,15468,7,12,0,0,15468,
+        15469,7,3,0,0,15469,15470,7,3,0,0,15470,15471,7,6,0,0,15471,15472,
+        7,7,0,0,15472,15473,7,8,0,0,15473,15474,7,18,0,0,15474,2084,1,0,
+        0,0,15475,15476,7,7,0,0,15476,15477,7,11,0,0,15477,15478,5,95,0,
+        0,15478,15479,7,5,0,0,15479,15480,7,20,0,0,15480,2086,1,0,0,0,15481,
+        15482,7,7,0,0,15482,15483,7,11,0,0,15483,15484,7,5,0,0,15484,15485,
+        5,95,0,0,15485,15486,7,11,0,0,15486,15487,7,0,0,0,15487,15488,7,
+        7,0,0,15488,15489,7,17,0,0,15489,2088,1,0,0,0,15490,15491,7,7,0,
+        0,15491,15492,7,11,0,0,15492,15493,7,5,0,0,15493,15494,5,95,0,0,
+        15494,15495,7,11,0,0,15495,15496,7,0,0,0,15496,15497,7,7,0,0,15497,
+        15498,7,17,0,0,15498,15499,7,12,0,0,15499,15500,7,0,0,0,15500,15501,
+        7,17,0,0,15501,15502,7,6,0,0,15502,2090,1,0,0,0,15503,15504,7,7,
+        0,0,15504,15505,7,11,0,0,15505,15506,7,5,0,0,15506,15507,5,95,0,
+        0,15507,15508,7,11,0,0,15508,15509,7,6,0,0,15509,15510,7,7,0,0,15510,
+        15511,7,17,0,0,15511,15512,7,4,0,0,15512,15513,7,19,0,0,15513,15514,
+        5,95,0,0,15514,15515,7,5,0,0,15515,15516,7,6,0,0,15516,15517,7,14,
+        0,0,15517,15518,7,0,0,0,15518,15519,7,7,0,0,15519,15520,7,4,0,0,
+        15520,15521,7,10,0,0,15521,15522,7,8,0,0,15522,15523,7,5,0,0,15523,
+        2092,1,0,0,0,15524,15525,7,7,0,0,15525,15526,7,11,0,0,15526,15527,
+        7,5,0,0,15527,15528,5,95,0,0,15528,15529,7,11,0,0,15529,15530,7,
+        2,0,0,15530,15531,7,22,0,0,15531,15532,7,6,0,0,15532,15533,7,3,0,
+        0,15533,2094,1,0,0,0,15534,15535,7,7,0,0,15535,15536,7,11,0,0,15536,
+        15537,7,5,0,0,15537,15538,5,95,0,0,15538,15539,7,7,0,0,15539,15540,
+        7,8,0,0,15540,15541,7,19,0,0,15541,15542,7,0,0,0,15542,15543,7,3,
+        0,0,15543,15544,5,95,0,0,15544,15545,7,8,0,0,15545,15546,7,2,0,0,
+        15546,15547,7,7,0,0,15547,15548,7,13,0,0,15548,15549,5,95,0,0,15549,
+        15550,7,6,0,0,15550,15551,7,25,0,0,15551,15552,7,8,0,0,15552,15553,
+        7,15,0,0,15553,2096,1,0,0,0,15554,15555,7,7,0,0,15555,15556,7,11,
+        0,0,15556,15557,7,5,0,0,15557,15558,5,95,0,0,15558,15559,7,7,0,0,
+        15559,15560,7,12,0,0,15560,15561,7,14,0,0,15561,15562,7,6,0,0,15562,
+        15563,7,3,0,0,15563,15564,7,10,0,0,15564,15565,7,8,0,0,15565,15566,
+        5,95,0,0,15566,15567,7,8,0,0,15567,15568,7,19,0,0,15568,15569,7,
+        0,0,0,15569,15570,7,3,0,0,15570,15571,7,0,0,0,15571,15572,7,8,0,
+        0,15572,15573,7,4,0,0,15573,15574,7,6,0,0,15574,15575,7,3,0,0,15575,
+        15576,7,5,0,0,15576,2098,1,0,0,0,15577,15578,7,7,0,0,15578,15579,
+        7,11,0,0,15579,15580,7,5,0,0,15580,15581,5,95,0,0,15581,15582,7,
+        5,0,0,15582,15583,7,2,0,0,15583,15584,7,3,0,0,15584,15585,7,4,0,
+        0,15585,2100,1,0,0,0,15586,15587,7,7,0,0,15587,15588,7,11,0,0,15588,
+        15589,7,5,0,0,15589,15590,7,5,0,0,15590,15591,7,2,0,0,15591,15592,
+        7,3,0,0,15592,15593,7,4,0,0,15593,2102,1,0,0,0,15594,15595,7,7,0,
+        0,15595,15596,7,11,0,0,15596,15597,7,5,0,0,15597,15598,5,95,0,0,
+        15598,15599,7,5,0,0,15599,15600,7,15,0,0,15600,15601,7,6,0,0,15601,
+        15602,7,8,0,0,15602,15603,7,10,0,0,15603,15604,7,0,0,0,15604,15605,
+        7,11,0,0,15605,15606,5,95,0,0,15606,15607,7,8,0,0,15607,15608,7,
+        19,0,0,15608,15609,7,0,0,0,15609,15610,7,3,0,0,15610,15611,7,5,0,
+        0,15611,2104,1,0,0,0,15612,15613,7,7,0,0,15613,15614,7,11,0,0,15614,
+        15615,7,5,0,0,15615,15616,5,95,0,0,15616,15617,7,4,0,0,15617,15618,
+        7,6,0,0,15618,15619,7,3,0,0,15619,15620,7,3,0,0,15620,15621,7,10,
+        0,0,15621,15622,7,4,0,0,15622,15623,7,2,0,0,15623,15624,7,3,0,0,
+        15624,15625,7,18,0,0,15625,2106,1,0,0,0,15626,15627,7,7,0,0,15627,
+        15628,7,11,0,0,15628,15629,7,5,0,0,15629,15630,5,95,0,0,15630,15631,
+        7,12,0,0,15631,15632,7,15,0,0,15632,15633,7,15,0,0,15633,15634,7,
+        6,0,0,15634,15635,7,3,0,0,15635,2108,1,0,0,0,15636,15637,7,7,0,0,
+        15637,15638,7,2,0,0,15638,15639,5,95,0,0,15639,15640,7,0,0,0,15640,
+        15641,7,8,0,0,15641,15642,7,8,0,0,15642,15643,7,6,0,0,15643,15644,
+        7,5,0,0,15644,15645,7,5,0,0,15645,2110,1,0,0,0,15646,15647,7,7,0,
+        0,15647,15648,7,2,0,0,15648,15649,5,95,0,0,15649,15650,7,0,0,0,15650,
+        15651,7,9,0,0,15651,15652,7,0,0,0,15652,15653,7,15,0,0,15653,15654,
+        7,4,0,0,15654,15655,7,10,0,0,15655,15656,7,13,0,0,15656,15657,7,
+        6,0,0,15657,15658,5,95,0,0,15658,15659,7,15,0,0,15659,15660,7,11,
+        0,0,15660,15661,7,0,0,0,15661,15662,7,7,0,0,15662,2112,1,0,0,0,15663,
+        15664,7,7,0,0,15664,15665,7,2,0,0,15665,15666,5,95,0,0,15666,15667,
+        7,0,0,0,15667,15668,7,7,0,0,15668,15669,7,5,0,0,15669,15670,7,10,
+        0,0,15670,15671,5,95,0,0,15671,15672,7,3,0,0,15672,15673,7,6,0,0,
+        15673,15674,7,0,0,0,15674,15675,7,3,0,0,15675,15676,7,8,0,0,15676,
+        15677,7,19,0,0,15677,2114,1,0,0,0,15678,15679,7,7,0,0,15679,15680,
+        7,2,0,0,15680,15681,7,0,0,0,15681,15682,7,15,0,0,15682,15683,7,15,
+        0,0,15683,15684,7,6,0,0,15684,15685,7,7,0,0,15685,15686,7,9,0,0,
+        15686,2116,1,0,0,0,15687,15688,7,7,0,0,15688,15689,7,2,0,0,15689,
+        15690,7,0,0,0,15690,15691,7,3,0,0,15691,15692,7,8,0,0,15692,15693,
+        7,19,0,0,15693,15694,7,10,0,0,15694,15695,7,13,0,0,15695,15696,7,
+        6,0,0,15696,15697,7,11,0,0,15697,15698,7,2,0,0,15698,15699,7,17,
+        0,0,15699,2118,1,0,0,0,15700,15701,7,7,0,0,15701,15702,7,2,0,0,15702,
+        15703,7,0,0,0,15703,15704,7,12,0,0,15704,15705,7,9,0,0,15705,15706,
+        7,10,0,0,15706,15707,7,4,0,0,15707,2120,1,0,0,0,15708,15709,7,7,
+        0,0,15709,15710,7,2,0,0,15710,15711,7,1,0,0,15711,15712,7,0,0,0,
+        15712,15713,7,9,0,0,15713,15714,7,16,0,0,15714,15715,7,10,0,0,15715,
+        15716,7,11,0,0,15716,15717,7,6,0,0,15717,2122,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,0,
+        0,0,15722,15723,7,12,0,0,15723,15724,7,4,0,0,15724,15725,7,2,0,0,
+        15725,15726,5,95,0,0,15726,15727,7,3,0,0,15727,15728,7,6,0,0,15728,
+        15729,7,2,0,0,15729,15730,7,15,0,0,15730,15731,7,4,0,0,15731,15732,
+        7,10,0,0,15732,15733,7,14,0,0,15733,15734,7,10,0,0,15734,15735,7,
+        23,0,0,15735,15736,7,6,0,0,15736,2124,1,0,0,0,15737,15738,7,7,0,
+        0,15738,15739,7,2,0,0,15739,15740,5,95,0,0,15740,15741,7,1,0,0,15741,
+        15742,7,0,0,0,15742,15743,7,5,0,0,15743,15744,7,6,0,0,15744,15745,
+        7,4,0,0,15745,15746,7,0,0,0,15746,15747,7,1,0,0,15747,15748,7,11,
+        0,0,15748,15749,7,6,0,0,15749,15750,5,95,0,0,15750,15751,7,14,0,
+        0,15751,15752,7,12,0,0,15752,15753,7,11,0,0,15753,15754,7,4,0,0,
+        15754,15755,7,10,0,0,15755,15756,7,14,0,0,15756,15757,7,13,0,0,15757,
+        15758,5,95,0,0,15758,15759,7,3,0,0,15759,15760,7,6,0,0,15760,15761,
+        7,22,0,0,15761,15762,7,3,0,0,15762,15763,7,10,0,0,15763,15764,7,
+        4,0,0,15764,15765,7,6,0,0,15765,2126,1,0,0,0,15766,15767,7,7,0,0,
+        15767,15768,7,2,0,0,15768,15769,5,95,0,0,15769,15770,7,1,0,0,15770,
+        15771,7,0,0,0,15771,15772,7,4,0,0,15772,15773,7,8,0,0,15773,15774,
+        7,19,0,0,15774,15775,5,95,0,0,15775,15776,7,4,0,0,15776,15777,7,
+        0,0,0,15777,15778,7,1,0,0,15778,15779,7,11,0,0,15779,15780,7,6,0,
+        0,15780,15781,5,95,0,0,15781,15782,7,0,0,0,15782,15783,7,8,0,0,15783,
+        15784,7,8,0,0,15784,15785,7,6,0,0,15785,15786,7,5,0,0,15786,15787,
+        7,5,0,0,15787,15788,5,95,0,0,15788,15789,7,1,0,0,15789,15790,7,18,
+        0,0,15790,15791,5,95,0,0,15791,15792,7,3,0,0,15792,15793,7,2,0,0,
+        15793,15794,7,22,0,0,15794,15795,7,10,0,0,15795,15796,7,9,0,0,15796,
+        2128,1,0,0,0,15797,15798,7,7,0,0,15798,15799,7,2,0,0,15799,15800,
+        5,95,0,0,15800,15801,7,1,0,0,15801,15802,7,10,0,0,15802,15803,7,
+        7,0,0,15803,15804,7,9,0,0,15804,15805,5,95,0,0,15805,15806,7,0,0,
+        0,15806,15807,7,22,0,0,15807,15808,7,0,0,0,15808,15809,7,3,0,0,15809,
+        15810,7,6,0,0,15810,2130,1,0,0,0,15811,15812,7,7,0,0,15812,15813,
+        7,2,0,0,15813,15814,5,95,0,0,15814,15815,7,1,0,0,15815,15816,7,12,
+        0,0,15816,15817,7,16,0,0,15817,15818,7,16,0,0,15818,15819,7,6,0,
+        0,15819,15820,7,3,0,0,15820,2132,1,0,0,0,15821,15822,7,7,0,0,15822,
+        15823,7,2,0,0,15823,15824,7,8,0,0,15824,15825,7,0,0,0,15825,15826,
+        7,8,0,0,15826,15827,7,19,0,0,15827,15828,7,6,0,0,15828,2134,1,0,
+        0,0,15829,15830,7,7,0,0,15830,15831,7,2,0,0,15831,15832,7,8,0,0,
+        15832,15833,7,19,0,0,15833,15834,7,6,0,0,15834,15835,7,8,0,0,15835,
+        15836,7,21,0,0,15836,2136,1,0,0,0,15837,15838,7,7,0,0,15838,15839,
+        7,2,0,0,15839,15840,5,95,0,0,15840,15841,7,8,0,0,15841,15842,7,0,
+        0,0,15842,15843,7,3,0,0,15843,15844,7,4,0,0,15844,15845,7,6,0,0,
+        15845,15846,7,5,0,0,15846,15847,7,10,0,0,15847,15848,7,0,0,0,15848,
+        15849,7,7,0,0,15849,2138,1,0,0,0,15850,15851,7,7,0,0,15851,15852,
+        7,2,0,0,15852,15853,5,95,0,0,15853,15854,7,8,0,0,15854,15855,7,19,
+        0,0,15855,15856,7,6,0,0,15856,15857,7,8,0,0,15857,15858,7,21,0,0,
+        15858,15859,5,95,0,0,15859,15860,7,0,0,0,15860,15861,7,8,0,0,15861,
+        15862,7,11,0,0,15862,15863,5,95,0,0,15863,15864,7,3,0,0,15864,15865,
+        7,6,0,0,15865,15866,7,22,0,0,15866,15867,7,3,0,0,15867,15868,7,10,
+        0,0,15868,15869,7,4,0,0,15869,15870,7,6,0,0,15870,2140,1,0,0,0,15871,
+        15872,7,7,0,0,15872,15873,7,2,0,0,15873,15874,5,95,0,0,15874,15875,
+        7,8,0,0,15875,15876,7,11,0,0,15876,15877,7,12,0,0,15877,15878,7,
+        5,0,0,15878,15879,7,4,0,0,15879,15880,7,6,0,0,15880,15881,7,3,0,
+        0,15881,15882,5,95,0,0,15882,15883,7,1,0,0,15883,15884,7,18,0,0,
+        15884,15885,5,95,0,0,15885,15886,7,3,0,0,15886,15887,7,2,0,0,15887,
+        15888,7,22,0,0,15888,15889,7,10,0,0,15889,15890,7,9,0,0,15890,2142,
+        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,8,0,0,15895,15896,7,11,0,0,15896,15897,7,12,0,
+        0,15897,15898,7,5,0,0,15898,15899,7,4,0,0,15899,15900,7,6,0,0,15900,
+        15901,7,3,0,0,15901,15902,7,10,0,0,15902,15903,7,7,0,0,15903,15904,
+        7,17,0,0,15904,2144,1,0,0,0,15905,15906,7,7,0,0,15906,15907,7,2,
+        0,0,15907,15908,5,95,0,0,15908,15909,7,8,0,0,15909,15910,7,2,0,0,
+        15910,15911,7,0,0,0,15911,15912,7,11,0,0,15912,15913,7,6,0,0,15913,
+        15914,7,5,0,0,15914,15915,7,8,0,0,15915,15916,7,6,0,0,15916,15917,
+        5,95,0,0,15917,15918,7,5,0,0,15918,15919,7,24,0,0,15919,2146,1,0,
+        0,0,15920,15921,7,7,0,0,15921,15922,7,2,0,0,15922,15923,5,95,0,0,
+        15923,15924,7,8,0,0,15924,15925,7,2,0,0,15925,15926,7,14,0,0,15926,
+        15927,7,14,0,0,15927,15928,7,2,0,0,15928,15929,7,7,0,0,15929,15930,
+        5,95,0,0,15930,15931,7,9,0,0,15931,15932,7,0,0,0,15932,15933,7,4,
+        0,0,15933,15934,7,0,0,0,15934,2148,1,0,0,0,15935,15936,7,7,0,0,15936,
+        15937,7,2,0,0,15937,15938,7,8,0,0,15938,15939,7,2,0,0,15939,15940,
+        7,14,0,0,15940,15941,7,15,0,0,15941,15942,7,3,0,0,15942,15943,7,
+        6,0,0,15943,15944,7,5,0,0,15944,15945,7,5,0,0,15945,2150,1,0,0,0,
+        15946,15947,7,7,0,0,15947,15948,7,2,0,0,15948,15949,5,95,0,0,15949,
+        15950,7,8,0,0,15950,15951,7,2,0,0,15951,15952,7,7,0,0,15952,15953,
+        7,7,0,0,15953,15954,7,6,0,0,15954,15955,7,8,0,0,15955,15956,7,4,
+        0,0,15956,15957,5,95,0,0,15957,15958,7,1,0,0,15958,15959,7,18,0,
+        0,15959,15960,5,95,0,0,15960,15961,7,8,0,0,15961,15962,7,1,0,0,15962,
+        15963,5,95,0,0,15963,15964,7,22,0,0,15964,15965,7,19,0,0,15965,15966,
+        7,3,0,0,15966,15967,5,95,0,0,15967,15968,7,2,0,0,15968,15969,7,7,
+        0,0,15969,15970,7,11,0,0,15970,15971,7,18,0,0,15971,2152,1,0,0,0,
+        15972,15973,7,7,0,0,15973,15974,7,2,0,0,15974,15975,5,95,0,0,15975,
+        15976,7,8,0,0,15976,15977,7,2,0,0,15977,15978,7,7,0,0,15978,15979,
+        7,7,0,0,15979,15980,7,6,0,0,15980,15981,7,8,0,0,15981,15982,7,4,
+        0,0,15982,15983,5,95,0,0,15983,15984,7,1,0,0,15984,15985,7,18,0,
+        0,15985,15986,5,95,0,0,15986,15987,7,8,0,0,15987,15988,7,2,0,0,15988,
+        15989,7,14,0,0,15989,15990,7,1,0,0,15990,15991,7,10,0,0,15991,15992,
+        7,7,0,0,15992,15993,7,6,0,0,15993,15994,5,95,0,0,15994,15995,7,5,
+        0,0,15995,15996,7,22,0,0,15996,2154,1,0,0,0,15997,15998,7,7,0,0,
+        15998,15999,7,2,0,0,15999,16000,5,95,0,0,16000,16001,7,8,0,0,16001,
+        16002,7,2,0,0,16002,16003,7,7,0,0,16003,16004,7,7,0,0,16004,16005,
+        7,6,0,0,16005,16006,7,8,0,0,16006,16007,7,4,0,0,16007,16008,5,95,
+        0,0,16008,16009,7,1,0,0,16009,16010,7,18,0,0,16010,16011,5,95,0,
+        0,16011,16012,7,8,0,0,16012,16013,7,2,0,0,16013,16014,7,5,0,0,16014,
+        16015,7,4,0,0,16015,16016,5,95,0,0,16016,16017,7,1,0,0,16017,16018,
+        7,0,0,0,16018,16019,7,5,0,0,16019,16020,7,6,0,0,16020,16021,7,9,
+        0,0,16021,2156,1,0,0,0,16022,16023,7,7,0,0,16023,16024,7,2,0,0,16024,
+        16025,5,95,0,0,16025,16026,7,8,0,0,16026,16027,7,2,0,0,16027,16028,
+        7,7,0,0,16028,16029,7,7,0,0,16029,16030,7,6,0,0,16030,16031,7,8,
+        0,0,16031,16032,7,4,0,0,16032,16033,5,95,0,0,16033,16034,7,1,0,0,
+        16034,16035,7,18,0,0,16035,16036,5,95,0,0,16036,16037,7,6,0,0,16037,
+        16038,7,11,0,0,16038,16039,7,10,0,0,16039,16040,7,14,0,0,16040,16041,
+        5,95,0,0,16041,16042,7,9,0,0,16042,16043,7,12,0,0,16043,16044,7,
+        15,0,0,16044,16045,7,5,0,0,16045,2158,1,0,0,0,16046,16047,7,7,0,
+        0,16047,16048,7,2,0,0,16048,16049,5,95,0,0,16049,16050,7,8,0,0,16050,
+        16051,7,2,0,0,16051,16052,7,7,0,0,16052,16053,7,7,0,0,16053,16054,
+        7,6,0,0,16054,16055,7,8,0,0,16055,16056,7,4,0,0,16056,16057,5,95,
+        0,0,16057,16058,7,1,0,0,16058,16059,7,18,0,0,16059,16060,5,95,0,
+        0,16060,16061,7,16,0,0,16061,16062,7,10,0,0,16062,16063,7,11,0,0,
+        16063,16064,7,4,0,0,16064,16065,7,6,0,0,16065,16066,7,3,0,0,16066,
+        16067,7,10,0,0,16067,16068,7,7,0,0,16068,16069,7,17,0,0,16069,2160,
+        1,0,0,0,16070,16071,7,7,0,0,16071,16072,7,2,0,0,16072,16073,7,8,
+        0,0,16073,16074,7,2,0,0,16074,16075,7,15,0,0,16075,16076,7,18,0,
+        0,16076,2162,1,0,0,0,16077,16078,7,7,0,0,16078,16079,7,2,0,0,16079,
+        16080,5,95,0,0,16080,16081,7,8,0,0,16081,16082,7,2,0,0,16082,16083,
+        7,5,0,0,16083,16084,7,4,0,0,16084,16085,5,95,0,0,16085,16086,7,25,
+        0,0,16086,16087,7,14,0,0,16087,16088,7,11,0,0,16088,16089,5,95,0,
+        0,16089,16090,7,24,0,0,16090,16091,7,12,0,0,16091,16092,7,6,0,0,
+        16092,16093,7,3,0,0,16093,16094,7,18,0,0,16094,16095,5,95,0,0,16095,
+        16096,7,3,0,0,16096,16097,7,6,0,0,16097,16098,7,22,0,0,16098,16099,
+        7,3,0,0,16099,16100,7,10,0,0,16100,16101,7,4,0,0,16101,16102,7,6,
+        0,0,16102,2164,1,0,0,0,16103,16104,7,7,0,0,16104,16105,7,2,0,0,16105,
+        16106,5,95,0,0,16106,16107,7,8,0,0,16107,16108,7,15,0,0,16108,16109,
+        7,12,0,0,16109,16110,5,95,0,0,16110,16111,7,8,0,0,16111,16112,7,
+        2,0,0,16112,16113,7,5,0,0,16113,16114,7,4,0,0,16114,16115,7,10,0,
+        0,16115,16116,7,7,0,0,16116,16117,7,17,0,0,16117,2166,1,0,0,0,16118,
+        16119,7,7,0,0,16119,16120,7,2,0,0,16120,16121,7,8,0,0,16121,16122,
+        7,15,0,0,16122,16123,7,12,0,0,16123,16124,5,95,0,0,16124,16125,7,
+        8,0,0,16125,16126,7,2,0,0,16126,16127,7,5,0,0,16127,16128,7,4,0,
+        0,16128,16129,7,10,0,0,16129,16130,7,7,0,0,16130,16131,7,17,0,0,
+        16131,2168,1,0,0,0,16132,16133,7,7,0,0,16133,16134,7,2,0,0,16134,
+        16135,7,8,0,0,16135,16136,7,18,0,0,16136,16137,7,8,0,0,16137,16138,
+        7,11,0,0,16138,16139,7,6,0,0,16139,2170,1,0,0,0,16140,16141,7,7,
+        0,0,16141,16142,7,2,0,0,16142,16143,5,95,0,0,16143,16144,7,9,0,0,
+        16144,16145,7,0,0,0,16145,16146,7,4,0,0,16146,16147,7,0,0,0,16147,
+        16148,5,95,0,0,16148,16149,7,5,0,0,16149,16150,7,6,0,0,16150,16151,
+        7,8,0,0,16151,16152,7,12,0,0,16152,16153,7,3,0,0,16153,16154,7,10,
+        0,0,16154,16155,7,4,0,0,16155,16156,7,18,0,0,16156,16157,5,95,0,
+        0,16157,16158,7,3,0,0,16158,16159,7,6,0,0,16159,16160,7,22,0,0,16160,
+        16161,7,3,0,0,16161,16162,7,10,0,0,16162,16163,7,4,0,0,16163,16164,
+        7,6,0,0,16164,2172,1,0,0,0,16165,16166,7,7,0,0,16166,16167,7,2,0,
+        0,16167,16168,5,95,0,0,16168,16169,7,9,0,0,16169,16170,7,6,0,0,16170,
+        16171,7,8,0,0,16171,16172,7,2,0,0,16172,16173,7,3,0,0,16173,16174,
+        7,3,0,0,16174,16175,7,6,0,0,16175,16176,7,11,0,0,16176,16177,7,0,
+        0,0,16177,16178,7,4,0,0,16178,16179,7,6,0,0,16179,2174,1,0,0,0,16180,
+        16181,7,7,0,0,16181,16182,7,2,0,0,16182,16183,7,9,0,0,16183,16184,
+        7,6,0,0,16184,16185,7,11,0,0,16185,16186,7,0,0,0,16186,16187,7,18,
+        0,0,16187,2176,1,0,0,0,16188,16189,7,7,0,0,16189,16190,7,2,0,0,16190,
+        16191,7,9,0,0,16191,16192,7,10,0,0,16192,16193,7,3,0,0,16193,16194,
+        7,6,0,0,16194,16195,7,8,0,0,16195,16196,7,4,0,0,16196,16197,7,10,
+        0,0,16197,16198,7,2,0,0,16198,2178,1,0,0,0,16199,16200,7,7,0,0,16200,
+        16201,7,2,0,0,16201,16202,7,9,0,0,16202,16203,7,10,0,0,16203,16204,
+        7,5,0,0,16204,16205,7,8,0,0,16205,16206,7,0,0,0,16206,16207,7,3,
+        0,0,16207,16208,7,9,0,0,16208,16209,7,16,0,0,16209,16210,7,10,0,
+        0,16210,16211,7,11,0,0,16211,16212,7,6,0,0,16212,2180,1,0,0,0,16213,
+        16214,7,7,0,0,16214,16215,7,2,0,0,16215,16216,5,95,0,0,16216,16217,
+        7,9,0,0,16217,16218,7,2,0,0,16218,16219,7,14,0,0,16219,16220,7,0,
+        0,0,16220,16221,7,10,0,0,16221,16222,7,7,0,0,16222,16223,5,95,0,
+        0,16223,16224,7,10,0,0,16224,16225,7,7,0,0,16225,16226,7,9,0,0,16226,
+        16227,7,6,0,0,16227,16228,7,25,0,0,16228,16229,5,95,0,0,16229,16230,
+        7,16,0,0,16230,16231,7,10,0,0,16231,16232,7,11,0,0,16232,16233,7,
+        4,0,0,16233,16234,7,6,0,0,16234,16235,7,3,0,0,16235,2182,1,0,0,0,
+        16236,16237,7,7,0,0,16237,16238,7,2,0,0,16238,16239,5,95,0,0,16239,
+        16240,7,9,0,0,16240,16241,7,5,0,0,16241,16242,7,4,0,0,16242,16243,
+        5,95,0,0,16243,16244,7,12,0,0,16244,16245,7,15,0,0,16245,16246,7,
+        17,0,0,16246,16247,7,3,0,0,16247,16248,7,0,0,0,16248,16249,7,9,0,
+        0,16249,16250,7,6,0,0,16250,16251,5,95,0,0,16251,16252,7,10,0,0,
+        16252,16253,7,7,0,0,16253,16254,7,5,0,0,16254,16255,7,6,0,0,16255,
+        16256,7,3,0,0,16256,16257,7,4,0,0,16257,16258,5,95,0,0,16258,16259,
+        7,8,0,0,16259,16260,7,2,0,0,16260,16261,7,7,0,0,16261,16262,7,13,
+        0,0,16262,2184,1,0,0,0,16263,16264,7,7,0,0,16264,16265,7,2,0,0,16265,
+        16266,5,95,0,0,16266,16267,7,6,0,0,16267,16268,7,11,0,0,16268,16269,
+        7,10,0,0,16269,16270,7,14,0,0,16270,16271,5,95,0,0,16271,16272,7,
+        17,0,0,16272,16273,7,3,0,0,16273,16274,7,2,0,0,16274,16275,7,12,
+        0,0,16275,16276,7,15,0,0,16276,16277,7,1,0,0,16277,16278,7,18,0,
+        0,16278,2186,1,0,0,0,16279,16280,7,7,0,0,16280,16281,7,2,0,0,16281,
+        16282,5,95,0,0,16282,16283,7,6,0,0,16283,16284,7,11,0,0,16284,16285,
+        7,10,0,0,16285,16286,7,14,0,0,16286,16287,7,10,0,0,16287,16288,7,
+        7,0,0,16288,16289,7,0,0,0,16289,16290,7,4,0,0,16290,16291,7,6,0,
+        0,16291,16292,5,95,0,0,16292,16293,7,20,0,0,16293,16294,7,2,0,0,
+        16294,16295,7,10,0,0,16295,16296,7,7,0,0,16296,2188,1,0,0,0,16297,
+        16298,7,7,0,0,16298,16299,7,2,0,0,16299,16300,5,95,0,0,16300,16301,
+        7,6,0,0,16301,16302,7,11,0,0,16302,16303,7,10,0,0,16303,16304,7,
+        14,0,0,16304,16305,7,10,0,0,16305,16306,7,7,0,0,16306,16307,7,0,
+        0,0,16307,16308,7,4,0,0,16308,16309,7,6,0,0,16309,16310,5,95,0,0,
+        16310,16311,7,2,0,0,16311,16312,7,1,0,0,16312,16313,7,18,0,0,16313,
+        2190,1,0,0,0,16314,16315,7,7,0,0,16315,16316,7,2,0,0,16316,16317,
+        5,95,0,0,16317,16318,7,6,0,0,16318,16319,7,11,0,0,16319,16320,7,
+        10,0,0,16320,16321,7,14,0,0,16321,16322,7,10,0,0,16322,16323,7,7,
+        0,0,16323,16324,7,0,0,0,16324,16325,7,4,0,0,16325,16326,7,6,0,0,
+        16326,16327,5,95,0,0,16327,16328,7,2,0,0,16328,16329,7,12,0,0,16329,
+        16330,7,4,0,0,16330,16331,7,6,0,0,16331,16332,7,3,0,0,16332,16333,
+        5,95,0,0,16333,16334,7,20,0,0,16334,16335,7,2,0,0,16335,16336,7,
+        10,0,0,16336,16337,7,7,0,0,16337,2192,1,0,0,0,16338,16339,7,7,0,
+        0,16339,16340,7,2,0,0,16340,16341,7,6,0,0,16341,16342,7,7,0,0,16342,
+        16343,7,4,0,0,16343,16344,7,10,0,0,16344,16345,7,4,0,0,16345,16346,
+        7,18,0,0,16346,16347,7,6,0,0,16347,16348,7,5,0,0,16348,16349,7,8,
+        0,0,16349,16350,7,0,0,0,16350,16351,7,15,0,0,16351,16352,7,10,0,
+        0,16352,16353,7,7,0,0,16353,16354,7,17,0,0,16354,2194,1,0,0,0,16355,
+        16356,7,7,0,0,16356,16357,7,2,0,0,16357,16358,5,95,0,0,16358,16359,
+        7,6,0,0,16359,16360,7,25,0,0,16360,16361,7,15,0,0,16361,16362,7,
+        0,0,0,16362,16363,7,7,0,0,16363,16364,7,9,0,0,16364,16365,5,95,0,
+        0,16365,16366,7,17,0,0,16366,16367,7,5,0,0,16367,16368,7,6,0,0,16368,
+        16369,7,4,0,0,16369,16370,5,95,0,0,16370,16371,7,4,0,0,16371,16372,
+        7,2,0,0,16372,16373,5,95,0,0,16373,16374,7,12,0,0,16374,16375,7,
+        7,0,0,16375,16376,7,10,0,0,16376,16377,7,2,0,0,16377,16378,7,7,0,
+        0,16378,2196,1,0,0,0,16379,16380,7,7,0,0,16380,16381,7,2,0,0,16381,
+        16382,5,95,0,0,16382,16383,7,6,0,0,16383,16384,7,25,0,0,16384,16385,
+        7,15,0,0,16385,16386,7,0,0,0,16386,16387,7,7,0,0,16387,16388,7,9,
+        0,0,16388,2198,1,0,0,0,16389,16390,7,7,0,0,16390,16391,7,2,0,0,16391,
+        16392,5,95,0,0,16392,16393,7,6,0,0,16393,16394,7,25,0,0,16394,16395,
+        7,15,0,0,16395,16396,7,0,0,0,16396,16397,7,7,0,0,16397,16398,7,9,
+        0,0,16398,16399,5,95,0,0,16399,16400,7,4,0,0,16400,16401,7,0,0,0,
+        16401,16402,7,1,0,0,16402,16403,7,11,0,0,16403,16404,7,6,0,0,16404,
+        2200,1,0,0,0,16405,16406,7,7,0,0,16406,16407,7,2,0,0,16407,16408,
+        7,6,0,0,16408,16409,7,25,0,0,16409,16410,7,4,0,0,16410,16411,7,6,
+        0,0,16411,16412,7,7,0,0,16412,16413,7,9,0,0,16413,2202,1,0,0,0,16414,
+        16415,7,7,0,0,16415,16416,7,2,0,0,16416,16417,5,95,0,0,16417,16418,
+        7,16,0,0,16418,16419,7,0,0,0,16419,16420,7,8,0,0,16420,16421,7,4,
+        0,0,16421,2204,1,0,0,0,16422,16423,7,7,0,0,16423,16424,7,2,0,0,16424,
+        16425,5,95,0,0,16425,16426,7,16,0,0,16426,16427,7,0,0,0,16427,16428,
+        7,8,0,0,16428,16429,7,4,0,0,16429,16430,7,2,0,0,16430,16431,7,3,
+        0,0,16431,16432,7,10,0,0,16432,16433,7,23,0,0,16433,16434,7,6,0,
+        0,16434,16435,5,95,0,0,16435,16436,7,20,0,0,16436,16437,7,2,0,0,
+        16437,16438,7,10,0,0,16438,16439,7,7,0,0,16439,2206,1,0,0,0,16440,
+        16441,7,7,0,0,16441,16442,7,2,0,0,16442,16443,5,95,0,0,16443,16444,
+        7,16,0,0,16444,16445,7,10,0,0,16445,16446,7,11,0,0,16446,16447,7,
+        4,0,0,16447,16448,7,6,0,0,16448,16449,7,3,0,0,16449,16450,7,10,0,
+        0,16450,16451,7,7,0,0,16451,16452,7,17,0,0,16452,2208,1,0,0,0,16453,
+        16454,7,7,0,0,16454,16455,7,2,0,0,16455,16456,7,16,0,0,16456,16457,
+        7,2,0,0,16457,16458,7,3,0,0,16458,16459,7,8,0,0,16459,16460,7,6,
+        0,0,16460,2210,1,0,0,0,16461,16462,7,7,0,0,16462,16463,7,2,0,0,16463,
+        16464,5,95,0,0,16464,16465,7,16,0,0,16465,16466,7,12,0,0,16466,16467,
+        7,11,0,0,16467,16468,7,11,0,0,16468,16469,5,95,0,0,16469,16470,7,
+        2,0,0,16470,16471,7,12,0,0,16471,16472,7,4,0,0,16472,16473,7,6,0,
+        0,16473,16474,7,3,0,0,16474,16475,5,95,0,0,16475,16476,7,20,0,0,
+        16476,16477,7,2,0,0,16477,16478,7,10,0,0,16478,16479,7,7,0,0,16479,
+        16480,5,95,0,0,16480,16481,7,4,0,0,16481,16482,7,2,0,0,16482,16483,
+        5,95,0,0,16483,16484,7,2,0,0,16484,16485,7,12,0,0,16485,16486,7,
+        4,0,0,16486,16487,7,6,0,0,16487,16488,7,3,0,0,16488,2212,1,0,0,0,
+        16489,16490,7,7,0,0,16490,16491,7,2,0,0,16491,16492,5,95,0,0,16492,
+        16493,7,17,0,0,16493,16494,7,0,0,0,16494,16495,7,4,0,0,16495,16496,
+        7,19,0,0,16496,16497,7,6,0,0,16497,16498,7,3,0,0,16498,16499,5,95,
+        0,0,16499,16500,7,2,0,0,16500,16501,7,15,0,0,16501,16502,7,4,0,0,
+        16502,16503,7,10,0,0,16503,16504,7,14,0,0,16504,16505,7,10,0,0,16505,
+        16506,7,23,0,0,16506,16507,7,6,0,0,16507,16508,7,3,0,0,16508,16509,
+        5,95,0,0,16509,16510,7,5,0,0,16510,16511,7,4,0,0,16511,16512,7,0,
+        0,0,16512,16513,7,4,0,0,16513,16514,7,10,0,0,16514,16515,7,5,0,0,
+        16515,16516,7,4,0,0,16516,16517,7,10,0,0,16517,16518,7,8,0,0,16518,
+        16519,7,5,0,0,16519,2214,1,0,0,0,16520,16521,7,7,0,0,16521,16522,
+        7,2,0,0,16522,16523,5,95,0,0,16523,16524,7,17,0,0,16524,16525,7,
+        1,0,0,16525,16526,7,18,0,0,16526,16527,5,95,0,0,16527,16528,7,15,
+        0,0,16528,16529,7,12,0,0,16529,16530,7,5,0,0,16530,16531,7,19,0,
+        0,16531,16532,7,9,0,0,16532,16533,7,2,0,0,16533,16534,7,22,0,0,16534,
+        16535,7,7,0,0,16535,2216,1,0,0,0,16536,16537,7,7,0,0,16537,16538,
+        7,2,0,0,16538,16539,7,17,0,0,16539,16540,7,12,0,0,16540,16541,7,
+        0,0,0,16541,16542,7,3,0,0,16542,16543,7,0,0,0,16543,16544,7,7,0,
+        0,16544,16545,7,4,0,0,16545,16546,7,6,0,0,16546,16547,7,6,0,0,16547,
+        2218,1,0,0,0,16548,16549,7,7,0,0,16549,16550,7,2,0,0,16550,16551,
+        5,95,0,0,16551,16552,7,10,0,0,16552,16553,7,7,0,0,16553,16554,7,
+        9,0,0,16554,16555,7,6,0,0,16555,16556,7,25,0,0,16556,16557,5,95,
+        0,0,16557,16558,7,16,0,0,16558,16559,7,16,0,0,16559,16560,7,5,0,
+        0,16560,2220,1,0,0,0,16561,16562,7,7,0,0,16562,16563,7,2,0,0,16563,
+        16564,5,95,0,0,16564,16565,7,10,0,0,16565,16566,7,7,0,0,16566,16567,
+        7,9,0,0,16567,16568,7,6,0,0,16568,16569,7,25,0,0,16569,2222,1,0,
+        0,0,16570,16571,7,7,0,0,16571,16572,7,2,0,0,16572,16573,5,95,0,0,
+        16573,16574,7,10,0,0,16574,16575,7,7,0,0,16575,16576,7,9,0,0,16576,
+        16577,7,6,0,0,16577,16578,7,25,0,0,16578,16579,5,95,0,0,16579,16580,
+        7,5,0,0,16580,16581,7,5,0,0,16581,2224,1,0,0,0,16582,16583,7,7,0,
+        0,16583,16584,7,2,0,0,16584,16585,5,95,0,0,16585,16586,7,10,0,0,
+        16586,16587,7,7,0,0,16587,16588,7,14,0,0,16588,16589,7,6,0,0,16589,
+        16590,7,14,0,0,16590,16591,7,2,0,0,16591,16592,7,3,0,0,16592,16593,
+        7,18,0,0,16593,2226,1,0,0,0,16594,16595,7,7,0,0,16595,16596,7,2,
+        0,0,16596,16597,5,95,0,0,16597,16598,7,10,0,0,16598,16599,7,7,0,
+        0,16599,16600,7,14,0,0,16600,16601,7,6,0,0,16601,16602,7,14,0,0,
+        16602,16603,7,2,0,0,16603,16604,7,3,0,0,16604,16605,7,18,0,0,16605,
+        16606,5,95,0,0,16606,16607,7,15,0,0,16607,16608,7,3,0,0,16608,16609,
+        7,12,0,0,16609,16610,7,7,0,0,16610,16611,7,10,0,0,16611,16612,7,
+        7,0,0,16612,16613,7,17,0,0,16613,2228,1,0,0,0,16614,16615,7,7,0,
+        0,16615,16616,7,2,0,0,16616,16617,7,21,0,0,16617,16618,7,6,0,0,16618,
+        16619,7,6,0,0,16619,16620,7,15,0,0,16620,2230,1,0,0,0,16621,16622,
+        7,7,0,0,16622,16623,7,2,0,0,16623,16624,5,95,0,0,16624,16625,7,11,
+        0,0,16625,16626,7,2,0,0,16626,16627,7,0,0,0,16627,16628,7,9,0,0,
+        16628,2232,1,0,0,0,16629,16630,7,7,0,0,16630,16631,7,2,0,0,16631,
+        16632,7,11,0,0,16632,16633,7,2,0,0,16633,16634,7,8,0,0,16634,16635,
+        7,0,0,0,16635,16636,7,11,0,0,16636,2234,1,0,0,0,16637,16638,7,7,
+        0,0,16638,16639,7,2,0,0,16639,16640,7,11,0,0,16640,16641,7,2,0,0,
+        16641,16642,7,17,0,0,16642,2236,1,0,0,0,16643,16644,7,7,0,0,16644,
+        16645,7,2,0,0,16645,16646,7,11,0,0,16646,16647,7,2,0,0,16647,16648,
+        7,17,0,0,16648,16649,7,16,0,0,16649,16650,7,10,0,0,16650,16651,7,
+        11,0,0,16651,16652,7,6,0,0,16652,2238,1,0,0,0,16653,16654,7,7,0,
+        0,16654,16655,7,2,0,0,16655,16656,7,11,0,0,16656,16657,7,2,0,0,16657,
+        16658,7,17,0,0,16658,16659,7,17,0,0,16659,16660,7,10,0,0,16660,16661,
+        7,7,0,0,16661,16662,7,17,0,0,16662,2240,1,0,0,0,16663,16664,7,7,
+        0,0,16664,16665,7,2,0,0,16665,16666,7,14,0,0,16666,16667,7,0,0,0,
+        16667,16668,7,15,0,0,16668,16669,7,15,0,0,16669,16670,7,10,0,0,16670,
+        16671,7,7,0,0,16671,16672,7,17,0,0,16672,2242,1,0,0,0,16673,16674,
+        7,7,0,0,16674,16675,7,2,0,0,16675,16676,7,14,0,0,16676,16677,7,0,
+        0,0,16677,16678,7,25,0,0,16678,16679,7,13,0,0,16679,16680,7,0,0,
+        0,16680,16681,7,11,0,0,16681,16682,7,12,0,0,16682,16683,7,6,0,0,
+        16683,2244,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,14,0,0,16688,16689,7,6,0,0,16689,16690,
+        7,3,0,0,16690,16691,7,17,0,0,16691,16692,7,6,0,0,16692,2246,1,0,
+        0,0,16693,16694,7,7,0,0,16694,16695,7,2,0,0,16695,16696,7,14,0,0,
+        16696,16697,7,10,0,0,16697,16698,7,7,0,0,16698,16699,7,10,0,0,16699,
+        16700,7,14,0,0,16700,16701,7,10,0,0,16701,16702,7,23,0,0,16702,16703,
+        7,6,0,0,16703,2248,1,0,0,0,16704,16705,7,7,0,0,16705,16706,7,2,0,
+        0,16706,16707,7,14,0,0,16707,16708,7,10,0,0,16708,16709,7,7,0,0,
+        16709,16710,7,13,0,0,16710,16711,7,0,0,0,16711,16712,7,11,0,0,16712,
+        16713,7,12,0,0,16713,16714,7,6,0,0,16714,2250,1,0,0,0,16715,16716,
+        7,7,0,0,16716,16717,7,2,0,0,16717,16718,5,95,0,0,16718,16719,7,14,
+        0,0,16719,16720,7,2,0,0,16720,16721,7,9,0,0,16721,16722,7,6,0,0,
+        16722,16723,7,11,0,0,16723,16724,5,95,0,0,16724,16725,7,15,0,0,16725,
+        16726,7,12,0,0,16726,16727,7,5,0,0,16727,16728,7,19,0,0,16728,16729,
+        5,95,0,0,16729,16730,7,3,0,0,16730,16731,7,6,0,0,16731,16732,7,16,
+        0,0,16732,2252,1,0,0,0,16733,16734,7,7,0,0,16734,16735,7,2,0,0,16735,
+        16736,5,95,0,0,16736,16737,7,14,0,0,16737,16738,7,2,0,0,16738,16739,
+        7,7,0,0,16739,16740,7,10,0,0,16740,16741,7,4,0,0,16741,16742,7,2,
+        0,0,16742,16743,7,3,0,0,16743,16744,7,10,0,0,16744,16745,7,7,0,0,
+        16745,16746,7,17,0,0,16746,2254,1,0,0,0,16747,16748,7,7,0,0,16748,
+        16749,7,2,0,0,16749,16750,7,14,0,0,16750,16751,7,2,0,0,16751,16752,
+        7,7,0,0,16752,16753,7,10,0,0,16753,16754,7,4,0,0,16754,16755,7,2,
+        0,0,16755,16756,7,3,0,0,16756,16757,7,10,0,0,16757,16758,7,7,0,0,
+        16758,16759,7,17,0,0,16759,2256,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,14,0,0,16764,16765,
+        7,2,0,0,16765,16766,7,7,0,0,16766,16767,7,10,0,0,16767,16768,7,4,
+        0,0,16768,16769,7,2,0,0,16769,16770,7,3,0,0,16770,2258,1,0,0,0,16771,
+        16772,7,7,0,0,16772,16773,7,2,0,0,16773,16774,5,95,0,0,16774,16775,
+        7,14,0,0,16775,16776,7,12,0,0,16776,16777,7,11,0,0,16777,16778,7,
+        4,0,0,16778,16779,7,10,0,0,16779,16780,7,14,0,0,16780,16781,7,13,
+        0,0,16781,16782,5,95,0,0,16782,16783,7,3,0,0,16783,16784,7,6,0,0,
+        16784,16785,7,22,0,0,16785,16786,7,3,0,0,16786,16787,7,10,0,0,16787,
+        16788,7,4,0,0,16788,16789,7,6,0,0,16789,2260,1,0,0,0,16790,16791,
+        7,7,0,0,16791,16792,7,2,0,0,16792,16793,5,95,0,0,16793,16794,7,7,
+        0,0,16794,16795,7,0,0,0,16795,16796,7,4,0,0,16796,16797,7,10,0,0,
+        16797,16798,7,13,0,0,16798,16799,7,6,0,0,16799,16800,5,95,0,0,16800,
+        16801,7,16,0,0,16801,16802,7,12,0,0,16802,16803,7,11,0,0,16803,16804,
+        7,11,0,0,16804,16805,5,95,0,0,16805,16806,7,2,0,0,16806,16807,7,
+        12,0,0,16807,16808,7,4,0,0,16808,16809,7,6,0,0,16809,16810,7,3,0,
+        0,16810,16811,5,95,0,0,16811,16812,7,20,0,0,16812,16813,7,2,0,0,
+        16813,16814,7,10,0,0,16814,16815,7,7,0,0,16815,2262,1,0,0,0,16816,
+        16817,7,7,0,0,16817,16818,7,2,0,0,16818,16819,7,7,0,0,16819,16820,
+        7,1,0,0,16820,16821,7,11,0,0,16821,16822,7,2,0,0,16822,16823,7,8,
+        0,0,16823,16824,7,21,0,0,16824,16825,7,10,0,0,16825,16826,7,7,0,
+        0,16826,16827,7,17,0,0,16827,2264,1,0,0,0,16828,16829,7,7,0,0,16829,
+        16830,7,2,0,0,16830,16831,7,7,0,0,16831,16832,7,6,0,0,16832,16833,
+        7,9,0,0,16833,16834,7,10,0,0,16834,16835,7,4,0,0,16835,16836,7,10,
+        0,0,16836,16837,7,2,0,0,16837,16838,7,7,0,0,16838,16839,7,0,0,0,
+        16839,16840,7,1,0,0,16840,16841,7,11,0,0,16841,16842,7,6,0,0,16842,
+        2266,1,0,0,0,16843,16844,7,7,0,0,16844,16845,7,2,0,0,16845,16846,
+        7,7,0,0,16846,16847,7,6,0,0,16847,2268,1,0,0,0,16848,16849,7,7,0,
+        0,16849,16850,7,2,0,0,16850,16851,7,7,0,0,16851,16852,7,15,0,0,16852,
+        16853,7,0,0,0,16853,16854,7,3,0,0,16854,16855,7,4,0,0,16855,16856,
+        7,10,0,0,16856,16857,7,4,0,0,16857,16858,7,10,0,0,16858,16859,7,
+        2,0,0,16859,16860,7,7,0,0,16860,16861,7,6,0,0,16861,16862,7,9,0,
+        0,16862,2270,1,0,0,0,16863,16864,7,7,0,0,16864,16865,7,2,0,0,16865,
+        16866,7,7,0,0,16866,16867,7,12,0,0,16867,16868,7,11,0,0,16868,16869,
+        7,11,0,0,16869,16870,7,10,0,0,16870,16871,7,16,0,0,16871,2272,1,
+        0,0,0,16872,16873,7,7,0,0,16873,16874,7,2,0,0,16874,16875,5,95,0,
+        0,16875,16876,7,7,0,0,16876,16877,7,11,0,0,16877,16878,7,20,0,0,
+        16878,16879,5,95,0,0,16879,16880,7,1,0,0,16880,16881,7,0,0,0,16881,
+        16882,7,4,0,0,16882,16883,7,8,0,0,16883,16884,7,19,0,0,16884,16885,
+        7,10,0,0,16885,16886,7,7,0,0,16886,16887,7,17,0,0,16887,2274,1,0,
+        0,0,16888,16889,7,7,0,0,16889,16890,7,2,0,0,16890,16891,5,95,0,0,
+        16891,16892,7,7,0,0,16892,16893,7,11,0,0,16893,16894,7,20,0,0,16894,
+        16895,5,95,0,0,16895,16896,7,15,0,0,16896,16897,7,3,0,0,16897,16898,
+        7,6,0,0,16898,16899,7,16,0,0,16899,16900,7,6,0,0,16900,16901,7,4,
+        0,0,16901,16902,7,8,0,0,16902,16903,7,19,0,0,16903,2276,1,0,0,0,
+        16904,16905,7,7,0,0,16905,16906,7,2,0,0,16906,2278,1,0,0,0,16907,
+        16908,7,7,0,0,16908,16909,7,2,0,0,16909,16910,7,7,0,0,16910,16911,
+        7,5,0,0,16911,16912,7,8,0,0,16912,16913,7,19,0,0,16913,16914,7,6,
+        0,0,16914,16915,7,14,0,0,16915,16916,7,0,0,0,16916,2280,1,0,0,0,
+        16917,16918,7,7,0,0,16918,16919,7,2,0,0,16919,16920,5,95,0,0,16920,
+        16921,7,2,0,0,16921,16922,7,1,0,0,16922,16923,7,20,0,0,16923,16924,
+        7,6,0,0,16924,16925,7,8,0,0,16925,16926,7,4,0,0,16926,16927,5,95,
+        0,0,16927,16928,7,11,0,0,16928,16929,7,10,0,0,16929,16930,7,7,0,
+        0,16930,16931,7,21,0,0,16931,2282,1,0,0,0,16932,16933,7,7,0,0,16933,
+        16934,7,2,0,0,16934,16935,7,2,0,0,16935,16936,7,3,0,0,16936,16937,
+        7,9,0,0,16937,16938,7,6,0,0,16938,16939,7,3,0,0,16939,2284,1,0,0,
+        0,16940,16941,7,7,0,0,16941,16942,7,2,0,0,16942,16943,5,95,0,0,16943,
+        16944,7,2,0,0,16944,16945,7,3,0,0,16945,16946,7,9,0,0,16946,16947,
+        7,6,0,0,16947,16948,7,3,0,0,16948,16949,5,95,0,0,16949,16950,7,3,
+        0,0,16950,16951,7,2,0,0,16951,16952,7,11,0,0,16952,16953,7,11,0,
+        0,16953,16954,7,12,0,0,16954,16955,7,15,0,0,16955,16956,7,5,0,0,
+        16956,2286,1,0,0,0,16957,16958,7,7,0,0,16958,16959,7,2,0,0,16959,
+        16960,5,95,0,0,16960,16961,7,2,0,0,16961,16962,7,12,0,0,16962,16963,
+        7,4,0,0,16963,16964,7,6,0,0,16964,16965,7,3,0,0,16965,16966,5,95,
+        0,0,16966,16967,7,20,0,0,16967,16968,7,2,0,0,16968,16969,7,10,0,
+        0,16969,16970,7,7,0,0,16970,16971,5,95,0,0,16971,16972,7,4,0,0,16972,
+        16973,7,2,0,0,16973,16974,5,95,0,0,16974,16975,7,0,0,0,16975,16976,
+        7,7,0,0,16976,16977,7,4,0,0,16977,16978,7,10,0,0,16978,2288,1,0,
+        0,0,16979,16980,7,7,0,0,16980,16981,7,2,0,0,16981,16982,5,95,0,0,
+        16982,16983,7,2,0,0,16983,16984,7,12,0,0,16984,16985,7,4,0,0,16985,
+        16986,7,6,0,0,16986,16987,7,3,0,0,16987,16988,5,95,0,0,16988,16989,
+        7,20,0,0,16989,16990,7,2,0,0,16990,16991,7,10,0,0,16991,16992,7,
+        7,0,0,16992,16993,5,95,0,0,16993,16994,7,4,0,0,16994,16995,7,2,0,
+        0,16995,16996,5,95,0,0,16996,16997,7,10,0,0,16997,16998,7,7,0,0,
+        16998,16999,7,7,0,0,16999,17000,7,6,0,0,17000,17001,7,3,0,0,17001,
+        2290,1,0,0,0,17002,17003,7,7,0,0,17003,17004,7,2,0,0,17004,17005,
+        7,2,0,0,17005,17006,7,13,0,0,17006,17007,7,6,0,0,17007,17008,7,3,
+        0,0,17008,17009,7,3,0,0,17009,17010,7,10,0,0,17010,17011,7,9,0,0,
+        17011,17012,7,6,0,0,17012,2292,1,0,0,0,17013,17014,7,7,0,0,17014,
+        17015,7,2,0,0,17015,17016,5,95,0,0,17016,17017,7,15,0,0,17017,17018,
+        7,0,0,0,17018,17019,7,3,0,0,17019,17020,7,0,0,0,17020,17021,7,11,
+        0,0,17021,17022,7,11,0,0,17022,17023,7,6,0,0,17023,17024,7,11,0,
+        0,17024,17025,5,95,0,0,17025,17026,7,10,0,0,17026,17027,7,7,0,0,
+        17027,17028,7,9,0,0,17028,17029,7,6,0,0,17029,17030,7,25,0,0,17030,
+        2294,1,0,0,0,17031,17032,7,7,0,0,17032,17033,7,2,0,0,17033,17034,
+        7,15,0,0,17034,17035,7,0,0,0,17035,17036,7,3,0,0,17036,17037,7,0,
+        0,0,17037,17038,7,11,0,0,17038,17039,7,11,0,0,17039,17040,7,6,0,
+        0,17040,17041,7,11,0,0,17041,17042,5,95,0,0,17042,17043,7,10,0,0,
+        17043,17044,7,7,0,0,17044,17045,7,9,0,0,17045,17046,7,6,0,0,17046,
+        17047,7,25,0,0,17047,2296,1,0,0,0,17048,17049,7,7,0,0,17049,17050,
+        7,2,0,0,17050,17051,5,95,0,0,17051,17052,7,15,0,0,17052,17053,7,
+        0,0,0,17053,17054,7,3,0,0,17054,17055,7,0,0,0,17055,17056,7,11,0,
+        0,17056,17057,7,11,0,0,17057,17058,7,6,0,0,17058,17059,7,11,0,0,
+        17059,2298,1,0,0,0,17060,17061,7,7,0,0,17061,17062,7,2,0,0,17062,
+        17063,7,15,0,0,17063,17064,7,0,0,0,17064,17065,7,3,0,0,17065,17066,
+        7,0,0,0,17066,17067,7,11,0,0,17067,17068,7,11,0,0,17068,17069,7,
+        6,0,0,17069,17070,7,11,0,0,17070,2300,1,0,0,0,17071,17072,7,7,0,
+        0,17072,17073,7,2,0,0,17073,17074,5,95,0,0,17074,17075,7,15,0,0,
+        17075,17076,7,0,0,0,17076,17077,7,3,0,0,17077,17078,7,4,0,0,17078,
+        17079,7,10,0,0,17079,17080,7,0,0,0,17080,17081,7,11,0,0,17081,17082,
+        5,95,0,0,17082,17083,7,8,0,0,17083,17084,7,2,0,0,17084,17085,7,14,
+        0,0,17085,17086,7,14,0,0,17086,17087,7,10,0,0,17087,17088,7,4,0,
+        0,17088,2302,1,0,0,0,17089,17090,7,7,0,0,17090,17091,7,2,0,0,17091,
+        17092,5,95,0,0,17092,17093,7,15,0,0,17093,17094,7,0,0,0,17094,17095,
+        7,3,0,0,17095,17096,7,4,0,0,17096,17097,7,10,0,0,17097,17098,7,0,
+        0,0,17098,17099,7,11,0,0,17099,17100,5,95,0,0,17100,17101,7,20,0,
+        0,17101,17102,7,2,0,0,17102,17103,7,10,0,0,17103,17104,7,7,0,0,17104,
+        2304,1,0,0,0,17105,17106,7,7,0,0,17106,17107,7,2,0,0,17107,17108,
+        5,95,0,0,17108,17109,7,15,0,0,17109,17110,7,0,0,0,17110,17111,7,
+        3,0,0,17111,17112,7,4,0,0,17112,17113,7,10,0,0,17113,17114,7,0,0,
+        0,17114,17115,7,11,0,0,17115,17116,5,95,0,0,17116,17117,7,3,0,0,
+        17117,17118,7,2,0,0,17118,17119,7,11,0,0,17119,17120,7,11,0,0,17120,
+        17121,7,12,0,0,17121,17122,7,15,0,0,17122,17123,5,95,0,0,17123,17124,
+        7,15,0,0,17124,17125,7,12,0,0,17125,17126,7,5,0,0,17126,17127,7,
+        19,0,0,17127,17128,7,9,0,0,17128,17129,7,2,0,0,17129,17130,7,22,
+        0,0,17130,17131,7,7,0,0,17131,2306,1,0,0,0,17132,17133,7,7,0,0,17133,
+        17134,7,2,0,0,17134,17135,7,15,0,0,17135,17136,7,0,0,0,17136,17137,
+        7,3,0,0,17137,17138,7,4,0,0,17138,17139,7,10,0,0,17139,17140,7,4,
+        0,0,17140,17141,7,10,0,0,17141,17142,7,2,0,0,17142,17143,7,7,0,0,
+        17143,2308,1,0,0,0,17144,17145,7,7,0,0,17145,17146,7,2,0,0,17146,
+        17147,5,95,0,0,17147,17148,7,15,0,0,17148,17149,7,11,0,0,17149,17150,
+        7,0,0,0,17150,17151,7,8,0,0,17151,17152,7,6,0,0,17152,17153,5,95,
+        0,0,17153,17154,7,9,0,0,17154,17155,7,10,0,0,17155,17156,7,5,0,0,
+        17156,17157,7,4,0,0,17157,17158,7,10,0,0,17158,17159,7,7,0,0,17159,
+        17160,7,8,0,0,17160,17161,7,4,0,0,17161,2310,1,0,0,0,17162,17163,
+        7,7,0,0,17163,17164,7,2,0,0,17164,17165,5,95,0,0,17165,17166,7,15,
+        0,0,17166,17167,7,11,0,0,17167,17168,7,0,0,0,17168,17169,7,8,0,0,
+        17169,17170,7,6,0,0,17170,17171,5,95,0,0,17171,17172,7,17,0,0,17172,
+        17173,7,3,0,0,17173,17174,7,2,0,0,17174,17175,7,12,0,0,17175,17176,
+        7,15,0,0,17176,17177,5,95,0,0,17177,17178,7,1,0,0,17178,17179,7,
+        18,0,0,17179,2312,1,0,0,0,17180,17181,7,7,0,0,17181,17182,7,2,0,
+        0,17182,17183,5,95,0,0,17183,17184,7,15,0,0,17184,17185,7,24,0,0,
+        17185,17186,5,95,0,0,17186,17187,7,8,0,0,17187,17188,7,2,0,0,17188,
+        17189,7,7,0,0,17189,17190,7,8,0,0,17190,17191,7,12,0,0,17191,17192,
+        7,3,0,0,17192,17193,7,3,0,0,17193,17194,7,6,0,0,17194,17195,7,7,
+        0,0,17195,17196,7,4,0,0,17196,17197,5,95,0,0,17197,17198,7,12,0,
+        0,17198,17199,7,7,0,0,17199,17200,7,10,0,0,17200,17201,7,2,0,0,17201,
+        17202,7,7,0,0,17202,2314,1,0,0,0,17203,17204,7,7,0,0,17204,17205,
+        7,2,0,0,17205,17206,5,95,0,0,17206,17207,7,15,0,0,17207,17208,7,
+        24,0,0,17208,17209,5,95,0,0,17209,17210,7,14,0,0,17210,17211,7,0,
+        0,0,17211,17212,7,15,0,0,17212,2316,1,0,0,0,17213,17214,7,7,0,0,
+        17214,17215,7,2,0,0,17215,17216,7,15,0,0,17216,17217,7,3,0,0,17217,
+        17218,7,2,0,0,17218,17219,7,14,0,0,17219,17220,7,15,0,0,17220,17221,
+        7,4,0,0,17221,2318,1,0,0,0,17222,17223,7,7,0,0,17223,17224,7,2,0,
+        0,17224,17225,5,95,0,0,17225,17226,7,15,0,0,17226,17227,7,24,0,0,
+        17227,17228,5,95,0,0,17228,17229,7,3,0,0,17229,17230,7,6,0,0,17230,
+        17231,7,15,0,0,17231,17232,7,11,0,0,17232,17233,7,10,0,0,17233,17234,
+        7,8,0,0,17234,17235,7,0,0,0,17235,17236,7,4,0,0,17236,17237,7,6,
+        0,0,17237,2320,1,0,0,0,17238,17239,7,7,0,0,17239,17240,7,2,0,0,17240,
+        17241,5,95,0,0,17241,17242,7,15,0,0,17242,17243,7,24,0,0,17243,17244,
+        5,95,0,0,17244,17245,7,5,0,0,17245,17246,7,21,0,0,17246,17247,7,
+        6,0,0,17247,17248,7,22,0,0,17248,2322,1,0,0,0,17249,17250,7,7,0,
+        0,17250,17251,7,2,0,0,17251,17252,5,95,0,0,17252,17253,7,15,0,0,
+        17253,17254,7,3,0,0,17254,17255,7,12,0,0,17255,17256,7,7,0,0,17256,
+        17257,7,6,0,0,17257,17258,5,95,0,0,17258,17259,7,17,0,0,17259,17260,
+        7,5,0,0,17260,17261,7,6,0,0,17261,17262,7,4,0,0,17262,17263,7,5,
+        0,0,17263,2324,1,0,0,0,17264,17265,7,7,0,0,17265,17266,7,2,0,0,17266,
+        17267,5,95,0,0,17267,17268,7,15,0,0,17268,17269,7,12,0,0,17269,17270,
+        7,11,0,0,17270,17271,7,11,0,0,17271,17272,5,95,0,0,17272,17273,7,
+        15,0,0,17273,17274,7,3,0,0,17274,17275,7,6,0,0,17275,17276,7,9,0,
+        0,17276,2326,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,15,0,0,17281,17282,7,12,0,0,17282,17283,
+        7,5,0,0,17283,17284,7,19,0,0,17284,17285,5,95,0,0,17285,17286,7,
+        15,0,0,17286,17287,7,3,0,0,17287,17288,7,6,0,0,17288,17289,7,9,0,
+        0,17289,2328,1,0,0,0,17290,17291,7,7,0,0,17291,17292,7,2,0,0,17292,
+        17293,5,95,0,0,17293,17294,7,15,0,0,17294,17295,7,12,0,0,17295,17296,
+        7,5,0,0,17296,17297,7,19,0,0,17297,17298,5,95,0,0,17298,17299,7,
+        5,0,0,17299,17300,7,12,0,0,17300,17301,7,1,0,0,17301,17302,7,24,
+        0,0,17302,2330,1,0,0,0,17303,17304,7,7,0,0,17304,17305,7,2,0,0,17305,
+        17306,5,95,0,0,17306,17307,7,15,0,0,17307,17308,7,25,0,0,17308,17309,
+        5,95,0,0,17309,17310,7,16,0,0,17310,17311,7,0,0,0,17311,17312,7,
+        12,0,0,17312,17313,7,11,0,0,17313,17314,7,4,0,0,17314,17315,5,95,
+        0,0,17315,17316,7,4,0,0,17316,17317,7,2,0,0,17317,17318,7,11,0,0,
+        17318,17319,7,6,0,0,17319,17320,7,3,0,0,17320,17321,7,0,0,0,17321,
+        17322,7,7,0,0,17322,17323,7,8,0,0,17323,17324,7,6,0,0,17324,2332,
+        1,0,0,0,17325,17326,7,7,0,0,17326,17327,7,2,0,0,17327,17328,5,95,
+        0,0,17328,17329,7,15,0,0,17329,17330,7,25,0,0,17330,17331,5,95,0,
+        0,17331,17332,7,20,0,0,17332,17333,7,2,0,0,17333,17334,7,10,0,0,
+        17334,17335,7,7,0,0,17335,17336,5,95,0,0,17336,17337,7,16,0,0,17337,
+        17338,7,10,0,0,17338,17339,7,11,0,0,17339,17340,7,4,0,0,17340,17341,
+        7,6,0,0,17341,17342,7,3,0,0,17342,2334,1,0,0,0,17343,17344,7,7,0,
+        0,17344,17345,7,2,0,0,17345,17346,5,95,0,0,17346,17347,7,24,0,0,
+        17347,17348,7,21,0,0,17348,17349,7,7,0,0,17349,17350,5,95,0,0,17350,
+        17351,7,1,0,0,17351,17352,7,12,0,0,17352,17353,7,16,0,0,17353,17354,
+        7,16,0,0,17354,2336,1,0,0,0,17355,17356,7,7,0,0,17356,17357,7,2,
+        0,0,17357,17358,5,95,0,0,17358,17359,7,24,0,0,17359,17360,7,12,0,
+        0,17360,17361,7,6,0,0,17361,17362,7,3,0,0,17362,17363,7,18,0,0,17363,
+        17364,5,95,0,0,17364,17365,7,4,0,0,17365,17366,7,3,0,0,17366,17367,
+        7,0,0,0,17367,17368,7,7,0,0,17368,17369,7,5,0,0,17369,17370,7,16,
+        0,0,17370,17371,7,2,0,0,17371,17372,7,3,0,0,17372,17373,7,14,0,0,
+        17373,17374,7,0,0,0,17374,17375,7,4,0,0,17375,17376,7,10,0,0,17376,
+        17377,7,2,0,0,17377,17378,7,7,0,0,17378,2338,1,0,0,0,17379,17380,
+        7,7,0,0,17380,17381,7,2,0,0,17381,17382,5,95,0,0,17382,17383,7,3,
+        0,0,17383,17384,7,6,0,0,17384,17385,7,16,0,0,17385,17386,5,95,0,
+        0,17386,17387,7,8,0,0,17387,17388,7,0,0,0,17388,17389,7,5,0,0,17389,
+        17390,7,8,0,0,17390,17391,7,0,0,0,17391,17392,7,9,0,0,17392,17393,
+        7,6,0,0,17393,2340,1,0,0,0,17394,17395,7,7,0,0,17395,17396,7,2,0,
+        0,17396,17397,7,3,0,0,17397,17398,7,6,0,0,17398,17399,7,11,0,0,17399,
+        17400,7,2,0,0,17400,17401,7,8,0,0,17401,17402,7,0,0,0,17402,17403,
+        7,4,0,0,17403,17404,7,6,0,0,17404,2342,1,0,0,0,17405,17406,7,7,0,
+        0,17406,17407,7,2,0,0,17407,17408,7,3,0,0,17408,17409,7,6,0,0,17409,
+        17410,7,11,0,0,17410,17411,7,18,0,0,17411,2344,1,0,0,0,17412,17413,
+        7,7,0,0,17413,17414,7,2,0,0,17414,17415,7,3,0,0,17415,17416,7,6,
+        0,0,17416,17417,7,15,0,0,17417,17418,7,0,0,0,17418,17419,7,10,0,
+        0,17419,17420,7,3,0,0,17420,2346,1,0,0,0,17421,17422,7,7,0,0,17422,
+        17423,7,2,0,0,17423,17424,7,3,0,0,17424,17425,7,6,0,0,17425,17426,
+        7,15,0,0,17426,17427,7,11,0,0,17427,17428,7,0,0,0,17428,17429,7,
+        18,0,0,17429,2348,1,0,0,0,17430,17431,7,7,0,0,17431,17432,7,2,0,
+        0,17432,17433,7,3,0,0,17433,17434,7,6,0,0,17434,17435,7,5,0,0,17435,
+        17436,7,6,0,0,17436,17437,7,4,0,0,17437,17438,7,11,0,0,17438,17439,
+        7,2,0,0,17439,17440,7,17,0,0,17440,17441,7,5,0,0,17441,2350,1,0,
+        0,0,17442,17443,7,7,0,0,17443,17444,7,2,0,0,17444,17445,5,95,0,0,
+        17445,17446,7,3,0,0,17446,17447,7,6,0,0,17447,17448,7,5,0,0,17448,
+        17449,7,12,0,0,17449,17450,7,11,0,0,17450,17451,7,4,0,0,17451,17452,
+        5,95,0,0,17452,17453,7,8,0,0,17453,17454,7,0,0,0,17454,17455,7,8,
+        0,0,17455,17456,7,19,0,0,17456,17457,7,6,0,0,17457,2352,1,0,0,0,
+        17458,17459,7,7,0,0,17459,17460,7,2,0,0,17460,17461,7,3,0,0,17461,
+        17462,7,6,0,0,17462,17463,7,13,0,0,17463,17464,7,6,0,0,17464,17465,
+        7,3,0,0,17465,17466,7,5,0,0,17466,17467,7,6,0,0,17467,2354,1,0,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,22,0,0,17474,17475,
+        7,3,0,0,17475,17476,7,10,0,0,17476,17477,7,4,0,0,17477,17478,7,6,
+        0,0,17478,2356,1,0,0,0,17479,17480,7,7,0,0,17480,17481,7,2,0,0,17481,
+        17482,7,3,0,0,17482,17483,7,6,0,0,17483,17484,7,22,0,0,17484,17485,
+        7,3,0,0,17485,17486,7,10,0,0,17486,17487,7,4,0,0,17487,17488,7,6,
+        0,0,17488,2358,1,0,0,0,17489,17490,7,7,0,0,17490,17491,7,2,0,0,17491,
+        17492,7,3,0,0,17492,17493,7,14,0,0,17493,17494,7,0,0,0,17494,17495,
+        7,11,0,0,17495,2360,1,0,0,0,17496,17497,7,7,0,0,17497,17498,7,2,
+        0,0,17498,17499,5,95,0,0,17499,17500,7,3,0,0,17500,17501,7,2,0,0,
+        17501,17502,7,2,0,0,17502,17503,7,4,0,0,17503,17504,5,95,0,0,17504,
+        17505,7,5,0,0,17505,17506,7,22,0,0,17506,17507,5,95,0,0,17507,17508,
+        7,16,0,0,17508,17509,7,2,0,0,17509,17510,7,3,0,0,17510,17511,5,95,
+        0,0,17511,17512,7,11,0,0,17512,17513,7,2,0,0,17513,17514,7,8,0,0,
+        17514,17515,7,0,0,0,17515,17516,7,11,0,0,17516,2362,1,0,0,0,17517,
+        17518,7,7,0,0,17518,17519,7,2,0,0,17519,17520,7,3,0,0,17520,17521,
+        7,2,0,0,17521,17522,7,22,0,0,17522,17523,7,9,0,0,17523,17524,7,6,
+        0,0,17524,17525,7,15,0,0,17525,17526,7,6,0,0,17526,17527,7,7,0,0,
+        17527,17528,7,9,0,0,17528,17529,7,6,0,0,17529,17530,7,7,0,0,17530,
+        17531,7,8,0,0,17531,17532,7,10,0,0,17532,17533,7,6,0,0,17533,17534,
+        7,5,0,0,17534,2364,1,0,0,0,17535,17536,7,7,0,0,17536,17537,7,2,0,
+        0,17537,17538,7,5,0,0,17538,17539,7,8,0,0,17539,17540,7,0,0,0,17540,
+        17541,7,11,0,0,17541,17542,7,6,0,0,17542,2366,1,0,0,0,17543,17544,
+        7,7,0,0,17544,17545,7,2,0,0,17545,17546,7,5,0,0,17546,17547,7,8,
+        0,0,17547,17548,7,19,0,0,17548,17549,7,6,0,0,17549,17550,7,14,0,
+        0,17550,17551,7,0,0,0,17551,17552,7,8,0,0,17552,17553,7,19,0,0,17553,
+        17554,7,6,0,0,17554,17555,7,8,0,0,17555,17556,7,21,0,0,17556,2368,
+        1,0,0,0,17557,17558,7,7,0,0,17558,17559,7,2,0,0,17559,17560,7,5,
+        0,0,17560,17561,7,6,0,0,17561,17562,7,17,0,0,17562,17563,7,14,0,
+        0,17563,17564,7,6,0,0,17564,17565,7,7,0,0,17565,17566,7,4,0,0,17566,
+        2370,1,0,0,0,17567,17568,7,7,0,0,17568,17569,7,2,0,0,17569,17570,
+        5,95,0,0,17570,17571,7,5,0,0,17571,17572,7,6,0,0,17572,17573,7,14,
+        0,0,17573,17574,7,10,0,0,17574,17575,7,20,0,0,17575,17576,7,2,0,
+        0,17576,17577,7,10,0,0,17577,17578,7,7,0,0,17578,2372,1,0,0,0,17579,
+        17580,7,7,0,0,17580,17581,7,2,0,0,17581,17582,5,95,0,0,17582,17583,
+        7,5,0,0,17583,17584,7,6,0,0,17584,17585,7,14,0,0,17585,17586,7,10,
+        0,0,17586,17587,5,95,0,0,17587,17588,7,4,0,0,17588,17589,7,2,0,0,
+        17589,17590,5,95,0,0,17590,17591,7,10,0,0,17591,17592,7,7,0,0,17592,
+        17593,7,7,0,0,17593,17594,7,6,0,0,17594,17595,7,3,0,0,17595,2374,
+        1,0,0,0,17596,17597,7,7,0,0,17597,17598,7,2,0,0,17598,17599,5,95,
+        0,0,17599,17600,7,5,0,0,17600,17601,7,6,0,0,17601,17602,7,4,0,0,
+        17602,17603,5,95,0,0,17603,17604,7,4,0,0,17604,17605,7,2,0,0,17605,
+        17606,5,95,0,0,17606,17607,7,20,0,0,17607,17608,7,2,0,0,17608,17609,
+        7,10,0,0,17609,17610,7,7,0,0,17610,2376,1,0,0,0,17611,17612,7,7,
+        0,0,17612,17613,7,2,0,0,17613,17614,7,5,0,0,17614,17615,7,19,0,0,
+        17615,17616,7,0,0,0,17616,17617,7,3,0,0,17617,17618,7,9,0,0,17618,
+        2378,1,0,0,0,17619,17620,7,7,0,0,17620,17621,7,2,0,0,17621,17622,
+        7,5,0,0,17622,17623,7,2,0,0,17623,17624,7,3,0,0,17624,17625,7,4,
+        0,0,17625,2380,1,0,0,0,17626,17627,7,7,0,0,17627,17628,7,2,0,0,17628,
+        17629,5,95,0,0,17629,17630,7,5,0,0,17630,17631,7,24,0,0,17631,17632,
+        7,11,0,0,17632,17633,5,95,0,0,17633,17634,7,4,0,0,17634,17635,7,
+        3,0,0,17635,17636,7,0,0,0,17636,17637,7,7,0,0,17637,17638,7,5,0,
+        0,17638,17639,7,11,0,0,17639,17640,7,0,0,0,17640,17641,7,4,0,0,17641,
+        17642,7,10,0,0,17642,17643,7,2,0,0,17643,17644,7,7,0,0,17644,2382,
+        1,0,0,0,17645,17646,7,7,0,0,17646,17647,7,2,0,0,17647,17648,5,95,
+        0,0,17648,17649,7,5,0,0,17649,17650,7,24,0,0,17650,17651,7,11,0,
+        0,17651,17652,5,95,0,0,17652,17653,7,4,0,0,17653,17654,7,12,0,0,
+        17654,17655,7,7,0,0,17655,17656,7,6,0,0,17656,2384,1,0,0,0,17657,
+        17658,7,7,0,0,17658,17659,7,2,0,0,17659,17660,5,95,0,0,17660,17661,
+        7,5,0,0,17661,17662,7,4,0,0,17662,17663,7,0,0,0,17663,17664,7,3,
+        0,0,17664,17665,5,95,0,0,17665,17666,7,4,0,0,17666,17667,7,3,0,0,
+        17667,17668,7,0,0,0,17668,17669,7,7,0,0,17669,17670,7,5,0,0,17670,
+        17671,7,16,0,0,17671,17672,7,2,0,0,17672,17673,7,3,0,0,17673,17674,
+        7,14,0,0,17674,17675,7,0,0,0,17675,17676,7,4,0,0,17676,17677,7,10,
+        0,0,17677,17678,7,2,0,0,17678,17679,7,7,0,0,17679,2386,1,0,0,0,17680,
+        17681,7,7,0,0,17681,17682,7,2,0,0,17682,17683,5,95,0,0,17683,17684,
+        7,5,0,0,17684,17685,7,4,0,0,17685,17686,7,0,0,0,17686,17687,7,4,
+        0,0,17687,17688,7,6,0,0,17688,17689,7,14,0,0,17689,17690,7,6,0,0,
+        17690,17691,7,7,0,0,17691,17692,7,4,0,0,17692,17693,5,95,0,0,17693,
+        17694,7,24,0,0,17694,17695,7,12,0,0,17695,17696,7,6,0,0,17696,17697,
+        7,12,0,0,17697,17698,7,10,0,0,17698,17699,7,7,0,0,17699,17700,7,
+        17,0,0,17700,2388,1,0,0,0,17701,17702,7,7,0,0,17702,17703,7,2,0,
+        0,17703,17704,5,95,0,0,17704,17705,7,5,0,0,17705,17706,7,4,0,0,17706,
+        17707,7,0,0,0,17707,17708,7,4,0,0,17708,17709,7,5,0,0,17709,17710,
+        5,95,0,0,17710,17711,7,17,0,0,17711,17712,7,5,0,0,17712,17713,7,
+        6,0,0,17713,17714,7,4,0,0,17714,17715,7,5,0,0,17715,2390,1,0,0,0,
+        17716,17717,7,7,0,0,17717,17718,7,2,0,0,17718,17719,7,5,0,0,17719,
+        17720,7,4,0,0,17720,17721,7,3,0,0,17721,17722,7,10,0,0,17722,17723,
+        7,8,0,0,17723,17724,7,4,0,0,17724,2392,1,0,0,0,17725,17726,7,7,0,
+        0,17726,17727,7,2,0,0,17727,17728,5,95,0,0,17728,17729,7,5,0,0,17729,
+        17730,7,12,0,0,17730,17731,7,1,0,0,17731,17732,7,24,0,0,17732,17733,
+        7,12,0,0,17733,17734,7,6,0,0,17734,17735,7,3,0,0,17735,17736,7,18,
+        0,0,17736,17737,5,95,0,0,17737,17738,7,15,0,0,17738,17739,7,3,0,
+        0,17739,17740,7,12,0,0,17740,17741,7,7,0,0,17741,17742,7,10,0,0,
+        17742,17743,7,7,0,0,17743,17744,7,17,0,0,17744,2394,1,0,0,0,17745,
+        17746,7,7,0,0,17746,17747,7,2,0,0,17747,17748,5,95,0,0,17748,17749,
+        7,5,0,0,17749,17750,7,12,0,0,17750,17751,7,1,0,0,17751,17752,7,5,
+        0,0,17752,17753,7,4,0,0,17753,17754,7,3,0,0,17754,17755,7,1,0,0,
+        17755,17756,5,95,0,0,17756,17757,7,15,0,0,17757,17758,7,0,0,0,17758,
+        17759,7,9,0,0,17759,2396,1,0,0,0,17760,17761,7,7,0,0,17761,17762,
+        7,2,0,0,17762,17763,5,95,0,0,17763,17764,7,5,0,0,17764,17765,7,22,
+        0,0,17765,17766,7,0,0,0,17766,17767,7,15,0,0,17767,17768,5,95,0,
+        0,17768,17769,7,20,0,0,17769,17770,7,2,0,0,17770,17771,7,10,0,0,
+        17771,17772,7,7,0,0,17772,17773,5,95,0,0,17773,17774,7,10,0,0,17774,
+        17775,7,7,0,0,17775,17776,7,15,0,0,17776,17777,7,12,0,0,17777,17778,
+        7,4,0,0,17778,17779,7,5,0,0,17779,2398,1,0,0,0,17780,17781,7,7,0,
+        0,17781,17782,7,2,0,0,17782,17783,7,5,0,0,17783,17784,7,22,0,0,17784,
+        17785,7,10,0,0,17785,17786,7,4,0,0,17786,17787,7,8,0,0,17787,17788,
+        7,19,0,0,17788,2400,1,0,0,0,17789,17790,7,7,0,0,17790,17791,7,2,
+        0,0,17791,17792,5,95,0,0,17792,17793,7,4,0,0,17793,17794,7,0,0,0,
+        17794,17795,7,1,0,0,17795,17796,7,11,0,0,17796,17797,7,6,0,0,17797,
+        17798,5,95,0,0,17798,17799,7,11,0,0,17799,17800,7,2,0,0,17800,17801,
+        7,2,0,0,17801,17802,7,21,0,0,17802,17803,7,12,0,0,17803,17804,7,
+        15,0,0,17804,17805,5,95,0,0,17805,17806,7,1,0,0,17806,17807,7,18,
+        0,0,17807,17808,5,95,0,0,17808,17809,7,7,0,0,17809,17810,7,11,0,
+        0,17810,2402,1,0,0,0,17811,17812,7,7,0,0,17812,17813,7,2,0,0,17813,
+        17814,5,95,0,0,17814,17815,7,4,0,0,17815,17816,7,6,0,0,17816,17817,
+        7,14,0,0,17817,17818,7,15,0,0,17818,17819,5,95,0,0,17819,17820,7,
+        4,0,0,17820,17821,7,0,0,0,17821,17822,7,1,0,0,17822,17823,7,11,0,
+        0,17823,17824,7,6,0,0,17824,2404,1,0,0,0,17825,17826,7,7,0,0,17826,
+        17827,7,2,0,0,17827,17828,7,4,0,0,17828,17829,7,19,0,0,17829,17830,
+        7,10,0,0,17830,17831,7,7,0,0,17831,17832,7,17,0,0,17832,2406,1,0,
+        0,0,17833,17834,7,7,0,0,17834,17835,7,2,0,0,17835,17836,7,4,0,0,
+        17836,17837,7,10,0,0,17837,17838,7,16,0,0,17838,17839,7,10,0,0,17839,
+        17840,7,8,0,0,17840,17841,7,0,0,0,17841,17842,7,4,0,0,17842,17843,
+        7,10,0,0,17843,17844,7,2,0,0,17844,17845,7,7,0,0,17845,2408,1,0,
+        0,0,17846,17847,7,7,0,0,17847,17848,7,2,0,0,17848,17849,7,4,0,0,
+        17849,17850,7,3,0,0,17850,17851,7,10,0,0,17851,17852,7,14,0,0,17852,
+        2410,1,0,0,0,17853,17854,7,7,0,0,17854,17855,7,2,0,0,17855,17856,
+        7,4,0,0,17856,2412,1,0,0,0,17857,17858,7,7,0,0,17858,17859,7,2,0,
+        0,17859,17860,5,95,0,0,17860,17861,7,4,0,0,17861,17862,7,3,0,0,17862,
+        17863,7,0,0,0,17863,17864,7,7,0,0,17864,17865,7,5,0,0,17865,17866,
+        7,16,0,0,17866,17867,7,2,0,0,17867,17868,7,3,0,0,17868,17869,7,14,
+        0,0,17869,17870,5,95,0,0,17870,17871,7,9,0,0,17871,17872,7,10,0,
+        0,17872,17873,7,5,0,0,17873,17874,7,4,0,0,17874,17875,7,10,0,0,17875,
+        17876,7,7,0,0,17876,17877,7,8,0,0,17877,17878,7,4,0,0,17878,17879,
+        5,95,0,0,17879,17880,7,0,0,0,17880,17881,7,17,0,0,17881,17882,7,
+        17,0,0,17882,2414,1,0,0,0,17883,17884,7,7,0,0,17884,17885,7,2,0,
+        0,17885,17886,5,95,0,0,17886,17887,7,12,0,0,17887,17888,7,7,0,0,
+        17888,17889,7,7,0,0,17889,17890,7,6,0,0,17890,17891,7,5,0,0,17891,
+        17892,7,4,0,0,17892,2416,1,0,0,0,17893,17894,7,7,0,0,17894,17895,
+        7,2,0,0,17895,17896,5,95,0,0,17896,17897,7,12,0,0,17897,17898,7,
+        5,0,0,17898,17899,7,6,0,0,17899,17900,5,95,0,0,17900,17901,7,8,0,
+        0,17901,17902,7,12,0,0,17902,17903,7,1,0,0,17903,17904,7,6,0,0,17904,
+        2418,1,0,0,0,17905,17906,7,7,0,0,17906,17907,7,2,0,0,17907,17908,
+        5,95,0,0,17908,17909,7,12,0,0,17909,17910,7,5,0,0,17910,17911,7,
+        6,0,0,17911,17912,5,95,0,0,17912,17913,7,19,0,0,17913,17914,7,0,
+        0,0,17914,17915,7,5,0,0,17915,17916,7,19,0,0,17916,17917,5,95,0,
+        0,17917,17918,7,0,0,0,17918,17919,7,17,0,0,17919,17920,7,17,0,0,
+        17920,17921,7,3,0,0,17921,17922,7,6,0,0,17922,17923,7,17,0,0,17923,
+        17924,7,0,0,0,17924,17925,7,4,0,0,17925,17926,7,10,0,0,17926,17927,
+        7,2,0,0,17927,17928,7,7,0,0,17928,2420,1,0,0,0,17929,17930,7,7,0,
+        0,17930,17931,7,2,0,0,17931,17932,5,95,0,0,17932,17933,7,12,0,0,
+        17933,17934,7,5,0,0,17934,17935,7,6,0,0,17935,17936,5,95,0,0,17936,
+        17937,7,19,0,0,17937,17938,7,0,0,0,17938,17939,7,5,0,0,17939,17940,
+        7,19,0,0,17940,17941,5,95,0,0,17941,17942,7,17,0,0,17942,17943,7,
+        1,0,0,17943,17944,7,18,0,0,17944,17945,5,95,0,0,17945,17946,7,16,
+        0,0,17946,17947,7,2,0,0,17947,17948,7,3,0,0,17948,17949,5,95,0,0,
+        17949,17950,7,15,0,0,17950,17951,7,12,0,0,17951,17952,7,5,0,0,17952,
+        17953,7,19,0,0,17953,17954,7,9,0,0,17954,17955,7,2,0,0,17955,17956,
+        7,22,0,0,17956,17957,7,7,0,0,17957,2422,1,0,0,0,17958,17959,7,7,
+        0,0,17959,17960,7,2,0,0,17960,17961,5,95,0,0,17961,17962,7,12,0,
+        0,17962,17963,7,5,0,0,17963,17964,7,6,0,0,17964,17965,5,95,0,0,17965,
+        17966,7,19,0,0,17966,17967,7,0,0,0,17967,17968,7,5,0,0,17968,17969,
+        7,19,0,0,17969,2424,1,0,0,0,17970,17971,7,7,0,0,17971,17972,7,2,
+        0,0,17972,17973,5,95,0,0,17973,17974,7,12,0,0,17974,17975,7,5,0,
+        0,17975,17976,7,6,0,0,17976,17977,5,95,0,0,17977,17978,7,10,0,0,
+        17978,17979,7,7,0,0,17979,17980,7,13,0,0,17980,17981,7,10,0,0,17981,
+        17982,7,5,0,0,17982,17983,7,10,0,0,17983,17984,7,1,0,0,17984,17985,
+        7,11,0,0,17985,17986,7,6,0,0,17986,17987,5,95,0,0,17987,17988,7,
+        10,0,0,17988,17989,7,7,0,0,17989,17990,7,9,0,0,17990,17991,7,6,0,
+        0,17991,17992,7,25,0,0,17992,17993,7,6,0,0,17993,17994,7,5,0,0,17994,
+        2426,1,0,0,0,17995,17996,7,7,0,0,17996,17997,7,2,0,0,17997,17998,
+        5,95,0,0,17998,17999,7,12,0,0,17999,18000,7,5,0,0,18000,18001,7,
+        6,0,0,18001,18002,5,95,0,0,18002,18003,7,14,0,0,18003,18004,7,6,
+        0,0,18004,18005,7,3,0,0,18005,18006,7,17,0,0,18006,18007,7,6,0,0,
+        18007,2428,1,0,0,0,18008,18009,7,7,0,0,18009,18010,7,2,0,0,18010,
+        18011,5,95,0,0,18011,18012,7,12,0,0,18012,18013,7,5,0,0,18013,18014,
+        7,6,0,0,18014,18015,5,95,0,0,18015,18016,7,7,0,0,18016,18017,7,11,
+        0,0,18017,2430,1,0,0,0,18018,18019,7,7,0,0,18019,18020,7,2,0,0,18020,
+        18021,5,95,0,0,18021,18022,7,12,0,0,18022,18023,7,5,0,0,18023,18024,
+        7,6,0,0,18024,18025,5,95,0,0,18025,18026,7,13,0,0,18026,18027,7,
+        6,0,0,18027,18028,7,8,0,0,18028,18029,7,4,0,0,18029,18030,7,2,0,
+        0,18030,18031,7,3,0,0,18031,18032,5,95,0,0,18032,18033,7,0,0,0,18033,
+        18034,7,17,0,0,18034,18035,7,17,0,0,18035,18036,7,3,0,0,18036,18037,
+        7,6,0,0,18037,18038,7,17,0,0,18038,18039,7,0,0,0,18039,18040,7,4,
+        0,0,18040,18041,7,10,0,0,18041,18042,7,2,0,0,18042,18043,7,7,0,0,
+        18043,2432,1,0,0,0,18044,18045,7,7,0,0,18045,18046,7,2,0,0,18046,
+        18047,7,13,0,0,18047,18048,7,0,0,0,18048,18049,7,11,0,0,18049,18050,
+        7,10,0,0,18050,18051,7,9,0,0,18051,18052,7,0,0,0,18052,18053,7,4,
+        0,0,18053,18054,7,6,0,0,18054,2434,1,0,0,0,18055,18056,7,7,0,0,18056,
+        18057,7,2,0,0,18057,18058,5,95,0,0,18058,18059,7,13,0,0,18059,18060,
+        7,6,0,0,18060,18061,7,8,0,0,18061,18062,7,4,0,0,18062,18063,7,2,
+        0,0,18063,18064,7,3,0,0,18064,18065,5,95,0,0,18065,18066,7,4,0,0,
+        18066,18067,7,3,0,0,18067,18068,7,0,0,0,18068,18069,7,7,0,0,18069,
+        18070,7,5,0,0,18070,18071,7,16,0,0,18071,18072,7,2,0,0,18072,18073,
+        7,3,0,0,18073,18074,7,14,0,0,18074,18075,5,95,0,0,18075,18076,7,
+        9,0,0,18076,18077,7,10,0,0,18077,18078,7,14,0,0,18078,18079,7,5,
+        0,0,18079,2436,1,0,0,0,18080,18081,7,7,0,0,18081,18082,7,2,0,0,18082,
+        18083,5,95,0,0,18083,18084,7,13,0,0,18084,18085,7,6,0,0,18085,18086,
+        7,8,0,0,18086,18087,7,4,0,0,18087,18088,7,2,0,0,18088,18089,7,3,
+        0,0,18089,18090,5,95,0,0,18090,18091,7,4,0,0,18091,18092,7,3,0,0,
+        18092,18093,7,0,0,0,18093,18094,7,7,0,0,18094,18095,7,5,0,0,18095,
+        18096,7,16,0,0,18096,18097,7,2,0,0,18097,18098,7,3,0,0,18098,18099,
+        7,14,0,0,18099,18100,5,95,0,0,18100,18101,7,16,0,0,18101,18102,7,
+        0,0,0,18102,18103,7,8,0,0,18103,18104,7,4,0,0,18104,2438,1,0,0,0,
+        18105,18106,7,7,0,0,18106,18107,7,2,0,0,18107,18108,5,95,0,0,18108,
+        18109,7,13,0,0,18109,18110,7,6,0,0,18110,18111,7,8,0,0,18111,18112,
+        7,4,0,0,18112,18113,7,2,0,0,18113,18114,7,3,0,0,18114,18115,5,95,
+        0,0,18115,18116,7,4,0,0,18116,18117,7,3,0,0,18117,18118,7,0,0,0,
+        18118,18119,7,7,0,0,18119,18120,7,5,0,0,18120,18121,7,16,0,0,18121,
+        18122,7,2,0,0,18122,18123,7,3,0,0,18123,18124,7,14,0,0,18124,2440,
+        1,0,0,0,18125,18126,7,7,0,0,18126,18127,7,2,0,0,18127,18128,7,22,
+        0,0,18128,18129,7,0,0,0,18129,18130,7,10,0,0,18130,18131,7,4,0,0,
+        18131,2442,1,0,0,0,18132,18133,7,7,0,0,18133,18134,7,2,0,0,18134,
+        18135,5,95,0,0,18135,18136,7,25,0,0,18136,18137,7,9,0,0,18137,18138,
+        7,1,0,0,18138,18139,5,95,0,0,18139,18140,7,16,0,0,18140,18141,7,
+        0,0,0,18141,18142,7,5,0,0,18142,18143,7,4,0,0,18143,18144,7,15,0,
+        0,18144,18145,7,0,0,0,18145,18146,7,4,0,0,18146,18147,7,19,0,0,18147,
+        18148,5,95,0,0,18148,18149,7,10,0,0,18149,18150,7,7,0,0,18150,18151,
+        7,5,0,0,18151,18152,7,6,0,0,18152,18153,7,3,0,0,18153,18154,7,4,
+        0,0,18154,2444,1,0,0,0,18155,18156,7,7,0,0,18156,18157,7,2,0,0,18157,
+        18158,5,95,0,0,18158,18159,7,25,0,0,18159,18160,7,14,0,0,18160,18161,
+        7,11,0,0,18161,18162,5,95,0,0,18162,18163,7,9,0,0,18163,18164,7,
+        14,0,0,18164,18165,7,11,0,0,18165,18166,5,95,0,0,18166,18167,7,3,
+        0,0,18167,18168,7,6,0,0,18168,18169,7,22,0,0,18169,18170,7,3,0,0,
+        18170,18171,7,10,0,0,18171,18172,7,4,0,0,18172,18173,7,6,0,0,18173,
+        2446,1,0,0,0,18174,18175,7,7,0,0,18175,18176,7,2,0,0,18176,18177,
+        5,95,0,0,18177,18178,7,25,0,0,18178,18179,7,14,0,0,18179,18180,7,
+        11,0,0,18180,18181,7,10,0,0,18181,18182,7,7,0,0,18182,18183,7,9,
+        0,0,18183,18184,7,6,0,0,18184,18185,7,25,0,0,18185,18186,5,95,0,
+        0,18186,18187,7,3,0,0,18187,18188,7,6,0,0,18188,18189,7,22,0,0,18189,
+        18190,7,3,0,0,18190,18191,7,10,0,0,18191,18192,7,4,0,0,18192,18193,
+        7,6,0,0,18193,18194,5,95,0,0,18194,18195,7,10,0,0,18195,18196,7,
+        7,0,0,18196,18197,5,95,0,0,18197,18198,7,5,0,0,18198,18199,7,6,0,
+        0,18199,18200,7,11,0,0,18200,18201,7,6,0,0,18201,18202,7,8,0,0,18202,
+        18203,7,4,0,0,18203,2448,1,0,0,0,18204,18205,7,7,0,0,18205,18206,
+        7,2,0,0,18206,18207,5,95,0,0,18207,18208,7,25,0,0,18208,18209,7,
+        14,0,0,18209,18210,7,11,0,0,18210,18211,7,10,0,0,18211,18212,7,7,
+        0,0,18212,18213,7,9,0,0,18213,18214,7,6,0,0,18214,18215,7,25,0,0,
+        18215,18216,5,95,0,0,18216,18217,7,3,0,0,18217,18218,7,6,0,0,18218,
+        18219,7,22,0,0,18219,18220,7,3,0,0,18220,18221,7,10,0,0,18221,18222,
+        7,4,0,0,18222,18223,7,6,0,0,18223,2450,1,0,0,0,18224,18225,7,7,0,
+        0,18225,18226,7,2,0,0,18226,18227,5,95,0,0,18227,18228,7,25,0,0,
+        18228,18229,7,14,0,0,18229,18230,7,11,0,0,18230,18231,5,95,0,0,18231,
+        18232,7,24,0,0,18232,18233,7,12,0,0,18233,18234,7,6,0,0,18234,18235,
+        7,3,0,0,18235,18236,7,18,0,0,18236,18237,5,95,0,0,18237,18238,7,
+        3,0,0,18238,18239,7,6,0,0,18239,18240,7,22,0,0,18240,18241,7,3,0,
+        0,18241,18242,7,10,0,0,18242,18243,7,4,0,0,18243,18244,7,6,0,0,18244,
+        2452,1,0,0,0,18245,18246,7,7,0,0,18246,18247,7,2,0,0,18247,18248,
+        5,95,0,0,18248,18249,7,23,0,0,18249,18250,7,2,0,0,18250,18251,7,
+        7,0,0,18251,18252,7,6,0,0,18252,18253,7,14,0,0,18253,18254,7,0,0,
+        0,18254,18255,7,15,0,0,18255,2454,1,0,0,0,18256,18257,7,7,0,0,18257,
+        18258,7,4,0,0,18258,18259,7,19,0,0,18259,18260,5,95,0,0,18260,18261,
+        7,13,0,0,18261,18262,7,0,0,0,18262,18263,7,11,0,0,18263,18264,7,
+        12,0,0,18264,18265,7,6,0,0,18265,2456,1,0,0,0,18266,18267,7,7,0,
+        0,18267,18268,7,12,0,0,18268,18269,7,11,0,0,18269,18270,7,11,0,0,
+        18270,18271,7,10,0,0,18271,18272,7,16,0,0,18272,2458,1,0,0,0,18273,
+        18274,7,7,0,0,18274,18275,7,12,0,0,18275,18276,7,11,0,0,18276,18277,
+        7,11,0,0,18277,2460,1,0,0,0,18278,18279,7,7,0,0,18279,18280,7,12,
+        0,0,18280,18281,7,11,0,0,18281,18282,7,11,0,0,18282,18283,7,5,0,
+        0,18283,2462,1,0,0,0,18284,18285,7,7,0,0,18285,18286,7,12,0,0,18286,
+        18287,7,14,0,0,18287,18288,7,1,0,0,18288,18289,7,6,0,0,18289,18290,
+        7,3,0,0,18290,2464,1,0,0,0,18291,18292,7,7,0,0,18292,18293,7,12,
+        0,0,18293,18294,7,14,0,0,18294,18295,7,6,0,0,18295,18296,7,3,0,0,
+        18296,18297,7,10,0,0,18297,18298,7,8,0,0,18298,2466,1,0,0,0,18299,
+        18300,7,7,0,0,18300,18301,7,12,0,0,18301,18302,7,14,0,0,18302,18303,
+        5,95,0,0,18303,18304,7,10,0,0,18304,18305,7,7,0,0,18305,18306,7,
+        9,0,0,18306,18307,7,6,0,0,18307,18308,7,25,0,0,18308,18309,5,95,
+        0,0,18309,18310,7,21,0,0,18310,18311,7,6,0,0,18311,18312,7,18,0,
+        0,18312,18313,7,5,0,0,18313,2468,1,0,0,0,18314,18315,7,7,0,0,18315,
+        18316,7,12,0,0,18316,18317,7,14,0,0,18317,18318,7,4,0,0,18318,18319,
+        7,2,0,0,18319,18320,7,9,0,0,18320,18321,7,5,0,0,18321,18322,7,10,
+        0,0,18322,18323,7,7,0,0,18323,18324,7,4,0,0,18324,18325,7,6,0,0,
+        18325,18326,7,3,0,0,18326,18327,7,13,0,0,18327,18328,7,0,0,0,18328,
+        18329,7,11,0,0,18329,2470,1,0,0,0,18330,18331,7,7,0,0,18331,18332,
+        7,12,0,0,18332,18333,7,14,0,0,18333,18334,7,4,0,0,18334,18335,7,
+        2,0,0,18335,18336,7,18,0,0,18336,18337,7,14,0,0,18337,18338,7,10,
+        0,0,18338,18339,7,7,0,0,18339,18340,7,4,0,0,18340,18341,7,6,0,0,
+        18341,18342,7,3,0,0,18342,18343,7,13,0,0,18343,18344,7,0,0,0,18344,
+        18345,7,11,0,0,18345,2472,1,0,0,0,18346,18347,7,7,0,0,18347,18348,
+        7,13,0,0,18348,18349,7,0,0,0,18349,18350,7,3,0,0,18350,18351,7,8,
+        0,0,18351,18352,7,19,0,0,18352,18353,7,0,0,0,18353,18354,7,3,0,0,
+        18354,18355,5,50,0,0,18355,2474,1,0,0,0,18356,18357,7,7,0,0,18357,
+        18358,7,13,0,0,18358,18359,7,11,0,0,18359,18360,5,50,0,0,18360,2476,
+        1,0,0,0,18361,18362,7,2,0,0,18362,18363,7,1,0,0,18363,18364,7,20,
+        0,0,18364,18365,7,6,0,0,18365,18366,7,8,0,0,18366,18367,7,4,0,0,
+        18367,18368,5,50,0,0,18368,18369,7,25,0,0,18369,18370,7,14,0,0,18370,
+        18371,7,11,0,0,18371,2478,1,0,0,0,18372,18373,7,2,0,0,18373,18374,
+        7,1,0,0,18374,18375,7,20,0,0,18375,18376,7,6,0,0,18376,18377,7,8,
+        0,0,18377,18378,7,4,0,0,18378,2480,1,0,0,0,18379,18380,7,2,0,0,18380,
+        18381,7,1,0,0,18381,18382,7,20,0,0,18382,18383,5,95,0,0,18383,18384,
+        7,10,0,0,18384,18385,7,9,0,0,18385,2482,1,0,0,0,18386,18387,7,2,
+        0,0,18387,18388,7,1,0,0,18388,18389,7,20,0,0,18389,18390,7,7,0,0,
+        18390,18391,7,2,0,0,18391,2484,1,0,0,0,18392,18393,7,2,0,0,18393,
+        18394,7,1,0,0,18394,18395,7,20,0,0,18395,18396,7,7,0,0,18396,18397,
+        7,2,0,0,18397,18398,5,95,0,0,18398,18399,7,3,0,0,18399,18400,7,6,
+        0,0,18400,18401,7,12,0,0,18401,18402,7,5,0,0,18402,18403,7,6,0,0,
+        18403,2486,1,0,0,0,18404,18405,7,2,0,0,18405,18406,7,8,0,0,18406,
+        18407,7,8,0,0,18407,18408,7,12,0,0,18408,18409,7,3,0,0,18409,18410,
+        7,6,0,0,18410,18411,7,7,0,0,18411,18412,7,8,0,0,18412,18413,7,6,
+        0,0,18413,18414,7,5,0,0,18414,2488,1,0,0,0,18415,18416,7,2,0,0,18416,
+        18417,7,16,0,0,18417,18418,7,16,0,0,18418,18419,7,11,0,0,18419,18420,
+        7,10,0,0,18420,18421,7,7,0,0,18421,18422,7,6,0,0,18422,2490,1,0,
+        0,0,18423,18424,7,2,0,0,18424,18425,7,16,0,0,18425,18426,7,16,0,
+        0,18426,2492,1,0,0,0,18427,18428,7,2,0,0,18428,18429,7,16,0,0,18429,
+        18430,7,16,0,0,18430,18431,7,5,0,0,18431,18432,7,6,0,0,18432,18433,
+        7,4,0,0,18433,2494,1,0,0,0,18434,18435,7,2,0,0,18435,18436,7,16,
+        0,0,18436,2496,1,0,0,0,18437,18438,7,2,0,0,18438,18439,7,10,0,0,
+        18439,18440,7,9,0,0,18440,18441,7,10,0,0,18441,18442,7,7,0,0,18442,
+        18443,7,9,0,0,18443,18444,7,6,0,0,18444,18445,7,25,0,0,18445,2498,
+        1,0,0,0,18446,18447,7,2,0,0,18447,18448,7,10,0,0,18448,18449,7,9,
+        0,0,18449,2500,1,0,0,0,18450,18451,7,2,0,0,18451,18452,7,11,0,0,
+        18452,18453,7,0,0,0,18453,18454,7,15,0,0,18454,2502,1,0,0,0,18455,
+        18456,7,2,0,0,18456,18457,7,11,0,0,18457,18458,7,9,0,0,18458,2504,
+        1,0,0,0,18459,18460,7,2,0,0,18460,18461,7,11,0,0,18461,18462,7,9,
+        0,0,18462,18463,5,95,0,0,18463,18464,7,15,0,0,18464,18465,7,12,0,
+        0,18465,18466,7,5,0,0,18466,18467,7,19,0,0,18467,18468,5,95,0,0,
+        18468,18469,7,15,0,0,18469,18470,7,3,0,0,18470,18471,7,6,0,0,18471,
+        18472,7,9,0,0,18472,2506,1,0,0,0,18473,18474,7,2,0,0,18474,18475,
+        7,11,0,0,18475,18476,7,5,0,0,18476,2508,1,0,0,0,18477,18478,7,2,
+        0,0,18478,18479,7,11,0,0,18479,18480,7,4,0,0,18480,18481,7,15,0,
+        0,18481,2510,1,0,0,0,18482,18483,7,2,0,0,18483,18484,7,14,0,0,18484,
+        18485,7,10,0,0,18485,18486,7,4,0,0,18486,2512,1,0,0,0,18487,18488,
+        7,2,0,0,18488,18489,7,7,0,0,18489,18490,7,6,0,0,18490,2514,1,0,0,
+        0,18491,18492,7,2,0,0,18492,18493,7,7,0,0,18493,18494,7,11,0,0,18494,
+        18495,7,10,0,0,18495,18496,7,7,0,0,18496,18497,7,6,0,0,18497,2516,
+        1,0,0,0,18498,18499,7,2,0,0,18499,18500,7,7,0,0,18500,18501,7,11,
+        0,0,18501,18502,7,10,0,0,18502,18503,7,7,0,0,18503,18504,7,6,0,0,
+        18504,18505,7,11,0,0,18505,18506,7,2,0,0,18506,18507,7,17,0,0,18507,
+        2518,1,0,0,0,18508,18509,7,2,0,0,18509,18510,7,7,0,0,18510,18511,
+        7,11,0,0,18511,18512,7,18,0,0,18512,2520,1,0,0,0,18513,18514,7,2,
+        0,0,18514,18515,7,7,0,0,18515,2522,1,0,0,0,18516,18517,7,2,0,0,18517,
+        18518,7,15,0,0,18518,18519,7,0,0,0,18519,18520,7,24,0,0,18520,18521,
+        7,12,0,0,18521,18522,7,6,0,0,18522,2524,1,0,0,0,18523,18524,7,2,
+        0,0,18524,18525,7,15,0,0,18525,18526,7,0,0,0,18526,18527,7,24,0,
+        0,18527,18528,7,12,0,0,18528,18529,7,6,0,0,18529,18530,5,95,0,0,
+        18530,18531,7,4,0,0,18531,18532,7,3,0,0,18532,18533,7,0,0,0,18533,
+        18534,7,7,0,0,18534,18535,7,5,0,0,18535,18536,7,16,0,0,18536,18537,
+        7,2,0,0,18537,18538,7,3,0,0,18538,18539,7,14,0,0,18539,2526,1,0,
+        0,0,18540,18541,7,2,0,0,18541,18542,7,15,0,0,18542,18543,7,0,0,0,
+        18543,18544,7,24,0,0,18544,18545,7,12,0,0,18545,18546,7,6,0,0,18546,
+        18547,5,95,0,0,18547,18548,7,25,0,0,18548,18549,7,8,0,0,18549,18550,
+        7,0,0,0,18550,18551,7,7,0,0,18551,18552,7,2,0,0,18552,18553,7,7,
+        0,0,18553,18554,7,10,0,0,18554,18555,7,8,0,0,18555,18556,7,0,0,0,
+        18556,18557,7,11,0,0,18557,2528,1,0,0,0,18558,18559,7,2,0,0,18559,
+        18560,7,15,0,0,18560,18561,7,8,0,0,18561,18562,7,2,0,0,18562,18563,
+        7,9,0,0,18563,18564,7,6,0,0,18564,2530,1,0,0,0,18565,18566,7,2,0,
+        0,18566,18567,7,15,0,0,18567,18568,7,6,0,0,18568,18569,7,7,0,0,18569,
+        2532,1,0,0,0,18570,18571,7,2,0,0,18571,18572,7,15,0,0,18572,18573,
+        7,6,0,0,18573,18574,7,3,0,0,18574,18575,7,0,0,0,18575,18576,7,4,
+        0,0,18576,18577,7,10,0,0,18577,18578,7,2,0,0,18578,18579,7,7,0,0,
+        18579,18580,7,5,0,0,18580,2534,1,0,0,0,18581,18582,7,2,0,0,18582,
+        18583,7,15,0,0,18583,18584,7,6,0,0,18584,18585,7,3,0,0,18585,18586,
+        7,0,0,0,18586,18587,7,4,0,0,18587,18588,7,2,0,0,18588,18589,7,3,
+        0,0,18589,2536,1,0,0,0,18590,18591,7,2,0,0,18591,18592,7,15,0,0,
+        18592,18593,7,4,0,0,18593,18594,5,95,0,0,18594,18595,7,6,0,0,18595,
+        18596,7,5,0,0,18596,18597,7,4,0,0,18597,18598,7,10,0,0,18598,18599,
+        7,14,0,0,18599,18600,7,0,0,0,18600,18601,7,4,0,0,18601,18602,7,6,
+        0,0,18602,2538,1,0,0,0,18603,18604,7,2,0,0,18604,18605,7,15,0,0,
+        18605,18606,7,4,0,0,18606,18607,7,10,0,0,18607,18608,7,14,0,0,18608,
+        18609,7,0,0,0,18609,18610,7,11,0,0,18610,2540,1,0,0,0,18611,18612,
+        7,2,0,0,18612,18613,7,15,0,0,18613,18614,7,4,0,0,18614,18615,7,10,
+        0,0,18615,18616,7,14,0,0,18616,18617,7,10,0,0,18617,18618,7,23,0,
+        0,18618,18619,7,6,0,0,18619,2542,1,0,0,0,18620,18621,7,2,0,0,18621,
+        18622,7,15,0,0,18622,18623,7,4,0,0,18623,18624,7,10,0,0,18624,18625,
+        7,14,0,0,18625,18626,7,10,0,0,18626,18627,7,23,0,0,18627,18628,7,
+        6,0,0,18628,18629,7,3,0,0,18629,18630,5,95,0,0,18630,18631,7,16,
+        0,0,18631,18632,7,6,0,0,18632,18633,7,0,0,0,18633,18634,7,4,0,0,
+        18634,18635,7,12,0,0,18635,18636,7,3,0,0,18636,18637,7,6,0,0,18637,
+        18638,7,5,0,0,18638,18639,5,95,0,0,18639,18640,7,6,0,0,18640,18641,
+        7,7,0,0,18641,18642,7,0,0,0,18642,18643,7,1,0,0,18643,18644,7,11,
+        0,0,18644,18645,7,6,0,0,18645,2544,1,0,0,0,18646,18647,7,2,0,0,18647,
+        18648,7,15,0,0,18648,18649,7,4,0,0,18649,18650,7,10,0,0,18650,18651,
+        7,14,0,0,18651,18652,7,10,0,0,18652,18653,7,23,0,0,18653,18654,7,
+        6,0,0,18654,18655,7,3,0,0,18655,18656,5,95,0,0,18656,18657,7,17,
+        0,0,18657,18658,7,2,0,0,18658,18659,7,0,0,0,18659,18660,7,11,0,0,
+        18660,2546,1,0,0,0,18661,18662,7,2,0,0,18662,18663,7,15,0,0,18663,
+        18664,7,4,0,0,18664,18665,7,10,0,0,18665,18666,7,2,0,0,18666,18667,
+        7,7,0,0,18667,2548,1,0,0,0,18668,18669,7,2,0,0,18669,18670,7,15,
+        0,0,18670,18671,7,4,0,0,18671,18672,7,10,0,0,18672,18673,7,2,0,0,
+        18673,18674,7,7,0,0,18674,18675,7,0,0,0,18675,18676,7,11,0,0,18676,
+        18677,7,11,0,0,18677,18678,7,18,0,0,18678,2550,1,0,0,0,18679,18680,
+        7,2,0,0,18680,18681,7,15,0,0,18681,18682,7,4,0,0,18682,18683,5,95,
+        0,0,18683,18684,7,15,0,0,18684,18685,7,0,0,0,18685,18686,7,3,0,0,
+        18686,18687,7,0,0,0,18687,18688,7,14,0,0,18688,2552,1,0,0,0,18689,
+        18690,7,2,0,0,18690,18691,7,3,0,0,18691,18692,7,0,0,0,18692,18693,
+        5,95,0,0,18693,18694,7,1,0,0,18694,18695,7,3,0,0,18695,18696,7,0,
+        0,0,18696,18697,7,7,0,0,18697,18698,7,8,0,0,18698,18699,7,19,0,0,
+        18699,2554,1,0,0,0,18700,18701,7,2,0,0,18701,18702,7,3,0,0,18702,
+        18703,7,0,0,0,18703,18704,5,95,0,0,18704,18705,7,8,0,0,18705,18706,
+        7,19,0,0,18706,18707,7,6,0,0,18707,18708,7,8,0,0,18708,18709,7,21,
+        0,0,18709,18710,5,95,0,0,18710,18711,7,0,0,0,18711,18712,7,8,0,0,
+        18712,18713,7,11,0,0,18713,2556,1,0,0,0,18714,18715,7,2,0,0,18715,
+        18716,7,3,0,0,18716,18717,7,0,0,0,18717,18718,5,95,0,0,18718,18719,
+        7,8,0,0,18719,18720,7,19,0,0,18720,18721,7,6,0,0,18721,18722,7,8,
+        0,0,18722,18723,7,21,0,0,18723,18724,5,95,0,0,18724,18725,7,15,0,
+        0,18725,18726,7,3,0,0,18726,18727,7,10,0,0,18727,18728,7,13,0,0,
+        18728,18729,7,10,0,0,18729,18730,7,11,0,0,18730,18731,7,6,0,0,18731,
+        18732,7,17,0,0,18732,18733,7,6,0,0,18733,2558,1,0,0,0,18734,18735,
+        7,2,0,0,18735,18736,7,3,0,0,18736,18737,7,0,0,0,18737,18738,5,95,
+        0,0,18738,18739,7,8,0,0,18739,18740,7,11,0,0,18740,18741,7,12,0,
+        0,18741,18742,7,5,0,0,18742,18743,7,4,0,0,18743,18744,7,6,0,0,18744,
+        18745,7,3,0,0,18745,18746,7,10,0,0,18746,18747,7,7,0,0,18747,18748,
+        7,17,0,0,18748,2560,1,0,0,0,18749,18750,7,2,0,0,18750,18751,7,3,
+        0,0,18751,18752,7,0,0,0,18752,18753,7,9,0,0,18753,18754,7,0,0,0,
+        18754,18755,7,4,0,0,18755,18756,7,0,0,0,18756,2562,1,0,0,0,18757,
+        18758,7,2,0,0,18758,18759,7,3,0,0,18759,18760,7,8,0,0,18760,2564,
+        1,0,0,0,18761,18762,7,2,0,0,18762,18763,7,3,0,0,18763,18764,7,0,
+        0,0,18764,18765,7,8,0,0,18765,18766,7,11,0,0,18766,18767,7,6,0,0,
+        18767,18768,5,95,0,0,18768,18769,7,9,0,0,18769,18770,7,0,0,0,18770,
+        18771,7,4,0,0,18771,18772,7,6,0,0,18772,2566,1,0,0,0,18773,18774,
+        7,2,0,0,18774,18775,7,3,0,0,18775,18776,7,0,0,0,18776,18777,7,8,
+        0,0,18777,18778,7,11,0,0,18778,18779,7,6,0,0,18779,18780,5,95,0,
+        0,18780,18781,7,7,0,0,18781,18782,7,12,0,0,18782,18783,7,14,0,0,
+        18783,18784,7,1,0,0,18784,18785,7,6,0,0,18785,18786,7,3,0,0,18786,
+        2568,1,0,0,0,18787,18788,7,2,0,0,18788,18789,7,3,0,0,18789,18790,
+        7,0,0,0,18790,18791,7,9,0,0,18791,18792,7,6,0,0,18792,18793,7,1,
+        0,0,18793,18794,7,12,0,0,18794,18795,7,17,0,0,18795,2570,1,0,0,0,
+        18796,18797,7,2,0,0,18797,18798,7,3,0,0,18798,18799,7,0,0,0,18799,
+        18800,5,95,0,0,18800,18801,7,9,0,0,18801,18802,7,5,0,0,18802,18803,
+        7,4,0,0,18803,18804,5,95,0,0,18804,18805,7,0,0,0,18805,18806,7,16,
+        0,0,18806,18807,7,16,0,0,18807,18808,7,6,0,0,18808,18809,7,8,0,0,
+        18809,18810,7,4,0,0,18810,18811,7,6,0,0,18811,18812,7,9,0,0,18812,
+        2572,1,0,0,0,18813,18814,7,2,0,0,18814,18815,7,3,0,0,18815,18816,
+        7,0,0,0,18816,18817,5,95,0,0,18817,18818,7,9,0,0,18818,18819,7,5,
+        0,0,18819,18820,7,4,0,0,18820,18821,5,95,0,0,18821,18822,7,8,0,0,
+        18822,18823,7,2,0,0,18823,18824,7,7,0,0,18824,18825,7,13,0,0,18825,
+        18826,7,6,0,0,18826,18827,7,3,0,0,18827,18828,7,4,0,0,18828,2574,
+        1,0,0,0,18829,18830,7,2,0,0,18830,18831,7,3,0,0,18831,18832,7,0,
+        0,0,18832,18833,5,95,0,0,18833,18834,7,9,0,0,18834,18835,7,5,0,0,
+        18835,18836,7,4,0,0,18836,18837,5,95,0,0,18837,18838,7,6,0,0,18838,
+        18839,7,3,0,0,18839,18840,7,3,0,0,18840,18841,7,2,0,0,18841,18842,
+        7,3,0,0,18842,2576,1,0,0,0,18843,18844,7,2,0,0,18844,18845,7,3,0,
+        0,18845,18846,7,0,0,0,18846,18847,5,95,0,0,18847,18848,7,17,0,0,
+        18848,18849,7,6,0,0,18849,18850,7,4,0,0,18850,18851,5,95,0,0,18851,
+        18852,7,0,0,0,18852,18853,7,8,0,0,18853,18854,7,11,0,0,18854,18855,
+        7,10,0,0,18855,18856,7,9,0,0,18856,18857,7,5,0,0,18857,2578,1,0,
+        0,0,18858,18859,7,2,0,0,18859,18860,7,3,0,0,18860,18861,7,0,0,0,
+        18861,18862,5,95,0,0,18862,18863,7,17,0,0,18863,18864,7,6,0,0,18864,
+        18865,7,4,0,0,18865,18866,5,95,0,0,18866,18867,7,15,0,0,18867,18868,
+        7,3,0,0,18868,18869,7,10,0,0,18869,18870,7,13,0,0,18870,18871,7,
+        10,0,0,18871,18872,7,11,0,0,18872,18873,7,6,0,0,18873,18874,7,17,
+        0,0,18874,18875,7,6,0,0,18875,18876,7,5,0,0,18876,2580,1,0,0,0,18877,
+        18878,7,2,0,0,18878,18879,7,3,0,0,18879,18880,7,0,0,0,18880,18881,
+        5,95,0,0,18881,18882,7,19,0,0,18882,18883,7,0,0,0,18883,18884,7,
+        5,0,0,18884,18885,7,19,0,0,18885,2582,1,0,0,0,18886,18887,7,2,0,
+        0,18887,18888,7,3,0,0,18888,18889,7,0,0,0,18889,18890,5,95,0,0,18890,
+        18891,7,10,0,0,18891,18892,7,7,0,0,18892,18893,7,13,0,0,18893,18894,
+        7,2,0,0,18894,18895,7,21,0,0,18895,18896,7,10,0,0,18896,18897,7,
+        7,0,0,18897,18898,7,17,0,0,18898,18899,5,95,0,0,18899,18900,7,12,
+        0,0,18900,18901,7,5,0,0,18901,18902,7,6,0,0,18902,18903,7,3,0,0,
+        18903,18904,7,10,0,0,18904,18905,7,9,0,0,18905,2584,1,0,0,0,18906,
+        18907,7,2,0,0,18907,18908,7,3,0,0,18908,18909,7,0,0,0,18909,18910,
+        5,95,0,0,18910,18911,7,10,0,0,18911,18912,7,7,0,0,18912,18913,7,
+        13,0,0,18913,18914,7,2,0,0,18914,18915,7,21,0,0,18915,18916,7,10,
+        0,0,18916,18917,7,7,0,0,18917,18918,7,17,0,0,18918,18919,5,95,0,
+        0,18919,18920,7,12,0,0,18920,18921,7,5,0,0,18921,18922,7,6,0,0,18922,
+        18923,7,3,0,0,18923,2586,1,0,0,0,18924,18925,7,2,0,0,18925,18926,
+        7,3,0,0,18926,18927,7,0,0,0,18927,18928,5,95,0,0,18928,18929,7,10,
+        0,0,18929,18930,7,7,0,0,18930,18931,7,13,0,0,18931,18932,7,2,0,0,
+        18932,18933,7,21,0,0,18933,18934,7,10,0,0,18934,18935,7,7,0,0,18935,
+        18936,7,17,0,0,18936,18937,5,95,0,0,18937,18938,7,25,0,0,18938,18939,
+        7,5,0,0,18939,18940,5,95,0,0,18940,18941,7,12,0,0,18941,18942,7,
+        5,0,0,18942,18943,7,6,0,0,18943,18944,7,3,0,0,18944,18945,5,95,0,
+        0,18945,18946,7,17,0,0,18946,18947,7,12,0,0,18947,18948,7,10,0,0,
+        18948,18949,7,9,0,0,18949,2588,1,0,0,0,18950,18951,7,2,0,0,18951,
+        18952,7,3,0,0,18952,18953,7,0,0,0,18953,18954,5,95,0,0,18954,18955,
+        7,10,0,0,18955,18956,7,7,0,0,18956,18957,7,13,0,0,18957,18958,7,
+        2,0,0,18958,18959,7,21,0,0,18959,18960,7,10,0,0,18960,18961,7,7,
+        0,0,18961,18962,7,17,0,0,18962,18963,5,95,0,0,18963,18964,7,25,0,
+        0,18964,18965,7,5,0,0,18965,18966,5,95,0,0,18966,18967,7,12,0,0,
+        18967,18968,7,5,0,0,18968,18969,7,6,0,0,18969,18970,7,3,0,0,18970,
+        2590,1,0,0,0,18971,18972,7,2,0,0,18972,18973,7,3,0,0,18973,18974,
+        7,0,0,0,18974,18975,5,95,0,0,18975,18976,7,3,0,0,18976,18977,7,0,
+        0,0,18977,18978,7,22,0,0,18978,18979,7,8,0,0,18979,18980,7,2,0,0,
+        18980,18981,7,14,0,0,18981,18982,7,15,0,0,18982,18983,7,0,0,0,18983,
+        18984,7,3,0,0,18984,18985,7,6,0,0,18985,2592,1,0,0,0,18986,18987,
+        7,2,0,0,18987,18988,7,3,0,0,18988,18989,7,0,0,0,18989,18990,5,95,
+        0,0,18990,18991,7,3,0,0,18991,18992,7,0,0,0,18992,18993,7,22,0,0,
+        18993,18994,7,8,0,0,18994,18995,7,2,0,0,18995,18996,7,7,0,0,18996,
+        18997,7,8,0,0,18997,18998,7,0,0,0,18998,18999,7,4,0,0,18999,2594,
+        1,0,0,0,19000,19001,7,2,0,0,19001,19002,7,3,0,0,19002,19003,7,0,
+        0,0,19003,19004,5,95,0,0,19004,19005,7,3,0,0,19005,19006,7,2,0,0,
+        19006,19007,7,22,0,0,19007,19008,7,5,0,0,19008,19009,7,8,0,0,19009,
+        19010,7,7,0,0,19010,2596,1,0,0,0,19011,19012,7,2,0,0,19012,19013,
+        7,3,0,0,19013,19014,7,0,0,0,19014,19015,5,95,0,0,19015,19016,7,3,
+        0,0,19016,19017,7,2,0,0,19017,19018,7,22,0,0,19018,19019,7,5,0,0,
+        19019,19020,7,8,0,0,19020,19021,7,7,0,0,19021,19022,5,95,0,0,19022,
+        19023,7,3,0,0,19023,19024,7,0,0,0,19024,19025,7,22,0,0,19025,2598,
+        1,0,0,0,19026,19027,7,2,0,0,19027,19028,7,3,0,0,19028,19029,7,0,
+        0,0,19029,19030,5,95,0,0,19030,19031,7,3,0,0,19031,19032,7,2,0,0,
+        19032,19033,7,22,0,0,19033,19034,7,13,0,0,19034,19035,7,6,0,0,19035,
+        19036,7,3,0,0,19036,19037,7,5,0,0,19037,19038,7,10,0,0,19038,19039,
+        7,2,0,0,19039,19040,7,7,0,0,19040,2600,1,0,0,0,19041,19042,7,2,0,
+        0,19042,19043,7,3,0,0,19043,19044,7,0,0,0,19044,19045,5,95,0,0,19045,
+        19046,7,4,0,0,19046,19047,7,0,0,0,19047,19048,7,1,0,0,19048,19049,
+        7,13,0,0,19049,19050,7,6,0,0,19050,19051,7,3,0,0,19051,19052,7,5,
+        0,0,19052,19053,7,10,0,0,19053,19054,7,2,0,0,19054,19055,7,7,0,0,
+        19055,2602,1,0,0,0,19056,19057,7,2,0,0,19057,19058,7,3,0,0,19058,
+        19059,7,0,0,0,19059,19060,5,95,0,0,19060,19061,7,22,0,0,19061,19062,
+        7,3,0,0,19062,19063,7,10,0,0,19063,19064,7,4,0,0,19064,19065,7,6,
+        0,0,19065,19066,5,95,0,0,19066,19067,7,4,0,0,19067,19068,7,10,0,
+        0,19068,19069,7,14,0,0,19069,19070,7,6,0,0,19070,2604,1,0,0,0,19071,
+        19072,7,2,0,0,19072,19073,7,3,0,0,19073,19074,7,9,0,0,19074,19075,
+        7,6,0,0,19075,19076,7,3,0,0,19076,19077,7,6,0,0,19077,19078,7,9,
+        0,0,19078,2606,1,0,0,0,19079,19080,7,2,0,0,19080,19081,7,3,0,0,19081,
+        19082,7,9,0,0,19082,19083,7,6,0,0,19083,19084,7,3,0,0,19084,19085,
+        7,6,0,0,19085,19086,7,9,0,0,19086,19087,5,95,0,0,19087,19088,7,15,
+        0,0,19088,19089,7,3,0,0,19089,19090,7,6,0,0,19090,19091,7,9,0,0,
+        19091,19092,7,10,0,0,19092,19093,7,8,0,0,19093,19094,7,0,0,0,19094,
+        19095,7,4,0,0,19095,19096,7,6,0,0,19096,19097,7,5,0,0,19097,2608,
+        1,0,0,0,19098,19099,7,2,0,0,19099,19100,7,3,0,0,19100,19101,7,9,
+        0,0,19101,19102,7,6,0,0,19102,19103,7,3,0,0,19103,2610,1,0,0,0,19104,
+        19105,7,2,0,0,19105,19106,7,3,0,0,19106,19107,7,9,0,0,19107,19108,
+        7,10,0,0,19108,19109,7,7,0,0,19109,19110,7,0,0,0,19110,19111,7,11,
+        0,0,19111,19112,7,10,0,0,19112,19113,7,4,0,0,19113,19114,7,18,0,
+        0,19114,2612,1,0,0,0,19115,19116,7,2,0,0,19116,19117,7,3,0,0,19117,
+        19118,5,95,0,0,19118,19119,7,6,0,0,19119,19120,7,25,0,0,19120,19121,
+        7,15,0,0,19121,19122,7,0,0,0,19122,19123,7,7,0,0,19123,19124,7,9,
+        0,0,19124,2614,1,0,0,0,19125,19126,7,2,0,0,19126,19127,7,3,0,0,19127,
+        19128,7,17,0,0,19128,19129,7,0,0,0,19129,19130,7,7,0,0,19130,19131,
+        7,10,0,0,19131,19132,7,23,0,0,19132,19133,7,0,0,0,19133,19134,7,
+        4,0,0,19134,19135,7,10,0,0,19135,19136,7,2,0,0,19136,19137,7,7,0,
+        0,19137,2616,1,0,0,0,19138,19139,7,2,0,0,19139,19140,7,3,0,0,19140,
+        2618,1,0,0,0,19141,19142,7,2,0,0,19142,19143,7,3,0,0,19143,19144,
+        5,95,0,0,19144,19145,7,15,0,0,19145,19146,7,3,0,0,19146,19147,7,
+        6,0,0,19147,19148,7,9,0,0,19148,19149,7,10,0,0,19149,19150,7,8,0,
+        0,19150,19151,7,0,0,0,19151,19152,7,4,0,0,19152,19153,7,6,0,0,19153,
+        19154,7,5,0,0,19154,2620,1,0,0,0,19155,19156,7,2,0,0,19156,19157,
+        7,5,0,0,19157,19158,7,6,0,0,19158,19159,7,3,0,0,19159,19160,7,3,
+        0,0,19160,19161,7,2,0,0,19161,19162,7,3,0,0,19162,2622,1,0,0,0,19163,
+        19164,7,2,0,0,19164,19165,7,4,0,0,19165,19166,7,19,0,0,19166,19167,
+        7,6,0,0,19167,19168,7,3,0,0,19168,2624,1,0,0,0,19169,19170,7,2,0,
+        0,19170,19171,7,12,0,0,19171,19172,7,4,0,0,19172,19173,7,6,0,0,19173,
+        19174,7,3,0,0,19174,19175,5,95,0,0,19175,19176,7,20,0,0,19176,19177,
+        7,2,0,0,19177,19178,7,10,0,0,19178,19179,7,7,0,0,19179,19180,5,95,
+        0,0,19180,19181,7,4,0,0,19181,19182,7,2,0,0,19182,19183,5,95,0,0,
+        19183,19184,7,0,0,0,19184,19185,7,7,0,0,19185,19186,7,4,0,0,19186,
+        19187,7,10,0,0,19187,2626,1,0,0,0,19188,19189,7,2,0,0,19189,19190,
+        7,12,0,0,19190,19191,7,4,0,0,19191,19192,7,6,0,0,19192,19193,7,3,
+        0,0,19193,19194,5,95,0,0,19194,19195,7,20,0,0,19195,19196,7,2,0,
+        0,19196,19197,7,10,0,0,19197,19198,7,7,0,0,19198,19199,5,95,0,0,
+        19199,19200,7,4,0,0,19200,19201,7,2,0,0,19201,19202,5,95,0,0,19202,
+        19203,7,10,0,0,19203,19204,7,7,0,0,19204,19205,7,7,0,0,19205,19206,
+        7,6,0,0,19206,19207,7,3,0,0,19207,2628,1,0,0,0,19208,19209,7,2,0,
+        0,19209,19210,7,12,0,0,19210,19211,7,4,0,0,19211,19212,7,6,0,0,19212,
+        19213,7,3,0,0,19213,2630,1,0,0,0,19214,19215,7,2,0,0,19215,19216,
+        7,12,0,0,19216,19217,7,4,0,0,19217,19218,7,11,0,0,19218,19219,7,
+        10,0,0,19219,19220,7,7,0,0,19220,19221,7,6,0,0,19221,19222,5,95,
+        0,0,19222,19223,7,11,0,0,19223,19224,7,6,0,0,19224,19225,7,0,0,0,
+        19225,19226,7,16,0,0,19226,2632,1,0,0,0,19227,19228,7,2,0,0,19228,
+        19229,7,12,0,0,19229,19230,7,4,0,0,19230,19231,7,11,0,0,19231,19232,
+        7,10,0,0,19232,19233,7,7,0,0,19233,19234,7,6,0,0,19234,2634,1,0,
+        0,0,19235,19236,7,2,0,0,19236,19237,7,12,0,0,19237,19238,7,4,0,0,
+        19238,19239,7,15,0,0,19239,19240,7,12,0,0,19240,19241,7,4,0,0,19241,
+        19242,7,16,0,0,19242,19243,7,2,0,0,19243,19244,7,3,0,0,19244,19245,
+        7,14,0,0,19245,19246,7,0,0,0,19246,19247,7,4,0,0,19247,2636,1,0,
+        0,0,19248,19249,7,2,0,0,19249,19250,7,12,0,0,19250,19251,7,4,0,0,
+        19251,19252,5,95,0,0,19252,19253,7,2,0,0,19253,19254,7,16,0,0,19254,
+        19255,5,95,0,0,19255,19256,7,11,0,0,19256,19257,7,10,0,0,19257,19258,
+        7,7,0,0,19258,19259,7,6,0,0,19259,2638,1,0,0,0,19260,19261,7,2,0,
+        0,19261,19262,7,12,0,0,19262,19263,7,4,0,0,19263,2640,1,0,0,0,19264,
+        19265,7,2,0,0,19265,19266,7,13,0,0,19266,19267,7,6,0,0,19267,19268,
+        7,3,0,0,19268,19269,7,16,0,0,19269,19270,7,11,0,0,19270,19271,7,
+        2,0,0,19271,19272,7,22,0,0,19272,19273,5,95,0,0,19273,19274,7,7,
+        0,0,19274,19275,7,2,0,0,19275,19276,7,14,0,0,19276,19277,7,2,0,0,
+        19277,19278,7,13,0,0,19278,19279,7,6,0,0,19279,2642,1,0,0,0,19280,
+        19281,7,2,0,0,19281,19282,7,13,0,0,19282,19283,7,6,0,0,19283,19284,
+        7,3,0,0,19284,19285,7,16,0,0,19285,19286,7,11,0,0,19286,19287,7,
+        2,0,0,19287,19288,7,22,0,0,19288,2644,1,0,0,0,19289,19290,7,2,0,
+        0,19290,19291,7,13,0,0,19291,19292,7,6,0,0,19292,19293,7,3,0,0,19293,
+        19294,7,11,0,0,19294,19295,7,0,0,0,19295,19296,7,15,0,0,19296,19297,
+        7,5,0,0,19297,2646,1,0,0,0,19298,19299,7,2,0,0,19299,19300,7,13,
+        0,0,19300,19301,7,6,0,0,19301,19302,7,3,0,0,19302,2648,1,0,0,0,19303,
+        19304,7,2,0,0,19304,19305,7,13,0,0,19305,19306,7,6,0,0,19306,19307,
+        7,3,0,0,19307,19308,7,3,0,0,19308,19309,7,10,0,0,19309,19310,7,9,
+        0,0,19310,19311,7,6,0,0,19311,2650,1,0,0,0,19312,19313,7,2,0,0,19313,
+        19314,7,13,0,0,19314,19315,7,6,0,0,19315,19316,7,3,0,0,19316,19317,
+        7,3,0,0,19317,19318,7,10,0,0,19318,19319,7,9,0,0,19319,19320,7,10,
+        0,0,19320,19321,7,7,0,0,19321,19322,7,17,0,0,19322,2652,1,0,0,0,
+        19323,19324,7,2,0,0,19324,19325,7,22,0,0,19325,19326,7,7,0,0,19326,
+        19327,7,6,0,0,19327,19328,7,3,0,0,19328,2654,1,0,0,0,19329,19330,
+        7,2,0,0,19330,19331,7,22,0,0,19331,19332,7,7,0,0,19332,19333,7,6,
+        0,0,19333,19334,7,3,0,0,19334,19335,7,5,0,0,19335,19336,7,19,0,0,
+        19336,19337,7,10,0,0,19337,19338,7,15,0,0,19338,2656,1,0,0,0,19339,
+        19340,7,2,0,0,19340,19341,7,22,0,0,19341,19342,7,7,0,0,19342,2658,
+        1,0,0,0,19343,19344,7,15,0,0,19344,2660,1,0,0,0,19345,19346,7,15,
+        0,0,19346,19347,7,0,0,0,19347,19348,7,8,0,0,19348,19349,7,21,0,0,
+        19349,19350,7,0,0,0,19350,19351,7,17,0,0,19351,19352,7,6,0,0,19352,
+        2662,1,0,0,0,19353,19354,7,15,0,0,19354,19355,7,0,0,0,19355,19356,
+        7,8,0,0,19356,19357,7,21,0,0,19357,19358,7,0,0,0,19358,19359,7,17,
+        0,0,19359,19360,7,6,0,0,19360,19361,7,5,0,0,19361,2664,1,0,0,0,19362,
+        19363,7,15,0,0,19363,19364,7,0,0,0,19364,19365,7,3,0,0,19365,19366,
+        7,0,0,0,19366,19367,7,11,0,0,19367,19368,7,11,0,0,19368,19369,7,
+        6,0,0,19369,19370,7,11,0,0,19370,19371,5,95,0,0,19371,19372,7,6,
+        0,0,19372,19373,7,7,0,0,19373,19374,7,0,0,0,19374,19375,7,1,0,0,
+        19375,19376,7,11,0,0,19376,19377,7,6,0,0,19377,2666,1,0,0,0,19378,
+        19379,7,15,0,0,19379,19380,7,0,0,0,19380,19381,7,3,0,0,19381,19382,
+        7,0,0,0,19382,19383,7,11,0,0,19383,19384,7,11,0,0,19384,19385,7,
+        6,0,0,19385,19386,7,11,0,0,19386,19387,5,95,0,0,19387,19388,7,10,
+        0,0,19388,19389,7,7,0,0,19389,19390,7,9,0,0,19390,19391,7,6,0,0,
+        19391,19392,7,25,0,0,19392,2668,1,0,0,0,19393,19394,7,15,0,0,19394,
+        19395,7,0,0,0,19395,19396,7,3,0,0,19396,19397,7,0,0,0,19397,19398,
+        7,11,0,0,19398,19399,7,11,0,0,19399,19400,7,6,0,0,19400,19401,7,
+        11,0,0,19401,2670,1,0,0,0,19402,19403,7,15,0,0,19403,19404,7,0,0,
+        0,19404,19405,7,3,0,0,19405,19406,7,0,0,0,19406,19407,7,14,0,0,19407,
+        19408,7,6,0,0,19408,19409,7,4,0,0,19409,19410,7,6,0,0,19410,19411,
+        7,3,0,0,19411,19412,7,16,0,0,19412,19413,7,10,0,0,19413,19414,7,
+        11,0,0,19414,19415,7,6,0,0,19415,2672,1,0,0,0,19416,19417,7,15,0,
+        0,19417,19418,7,0,0,0,19418,19419,7,3,0,0,19419,19420,7,0,0,0,19420,
+        19421,7,14,0,0,19421,19422,7,6,0,0,19422,19423,7,4,0,0,19423,19424,
+        7,6,0,0,19424,19425,7,3,0,0,19425,19426,7,5,0,0,19426,2674,1,0,0,
+        0,19427,19428,7,15,0,0,19428,19429,7,0,0,0,19429,19430,7,3,0,0,19430,
+        19431,7,0,0,0,19431,19432,7,14,0,0,19432,2676,1,0,0,0,19433,19434,
+        7,15,0,0,19434,19435,7,0,0,0,19435,19436,7,3,0,0,19436,19437,7,6,
+        0,0,19437,19438,7,7,0,0,19438,19439,7,4,0,0,19439,2678,1,0,0,0,19440,
+        19441,7,15,0,0,19441,19442,7,0,0,0,19442,19443,7,3,0,0,19443,19444,
+        7,6,0,0,19444,19445,7,7,0,0,19445,19446,7,4,0,0,19446,19447,5,95,
+        0,0,19447,19448,7,11,0,0,19448,19449,7,6,0,0,19449,19450,7,13,0,
+        0,19450,19451,7,6,0,0,19451,19452,7,11,0,0,19452,19453,5,95,0,0,
+        19453,19454,7,7,0,0,19454,19455,7,0,0,0,19455,19456,7,14,0,0,19456,
+        19457,7,6,0,0,19457,2680,1,0,0,0,19458,19459,7,15,0,0,19459,19460,
+        7,0,0,0,19460,19461,7,3,0,0,19461,19462,7,6,0,0,19462,19463,7,7,
+        0,0,19463,19464,7,4,0,0,19464,19465,5,95,0,0,19465,19466,7,12,0,
+        0,19466,19467,7,7,0,0,19467,19468,7,10,0,0,19468,19469,7,24,0,0,
+        19469,19470,7,12,0,0,19470,19471,7,6,0,0,19471,19472,5,95,0,0,19472,
+        19473,7,7,0,0,19473,19474,7,0,0,0,19474,19475,7,14,0,0,19475,19476,
+        7,6,0,0,19476,2682,1,0,0,0,19477,19478,7,15,0,0,19478,19479,7,0,
+        0,0,19479,19480,7,3,0,0,19480,19481,7,10,0,0,19481,19482,7,4,0,0,
+        19482,19483,7,18,0,0,19483,2684,1,0,0,0,19484,19485,7,15,0,0,19485,
+        19486,7,0,0,0,19486,19487,7,3,0,0,19487,19488,7,24,0,0,19488,19489,
+        7,12,0,0,19489,19490,7,6,0,0,19490,19491,7,4,0,0,19491,2686,1,0,
+        0,0,19492,19493,7,15,0,0,19493,19494,7,0,0,0,19494,19495,7,3,0,0,
+        19495,19496,7,4,0,0,19496,19497,7,10,0,0,19497,19498,7,0,0,0,19498,
+        19499,7,11,0,0,19499,19500,5,95,0,0,19500,19501,7,20,0,0,19501,19502,
+        7,2,0,0,19502,19503,7,10,0,0,19503,19504,7,7,0,0,19504,2688,1,0,
+        0,0,19505,19506,7,15,0,0,19506,19507,7,0,0,0,19507,19508,7,3,0,0,
+        19508,19509,7,4,0,0,19509,19510,7,10,0,0,19510,19511,7,0,0,0,19511,
+        19512,7,11,0,0,19512,19513,7,11,0,0,19513,19514,7,18,0,0,19514,2690,
+        1,0,0,0,19515,19516,7,15,0,0,19516,19517,7,0,0,0,19517,19518,7,3,
+        0,0,19518,19519,7,4,0,0,19519,19520,7,10,0,0,19520,19521,7,0,0,0,
+        19521,19522,7,11,0,0,19522,2692,1,0,0,0,19523,19524,7,15,0,0,19524,
+        19525,7,0,0,0,19525,19526,7,3,0,0,19526,19527,7,4,0,0,19527,19528,
+        7,10,0,0,19528,19529,7,0,0,0,19529,19530,7,11,0,0,19530,19531,5,
+        95,0,0,19531,19532,7,3,0,0,19532,19533,7,2,0,0,19533,19534,7,11,
+        0,0,19534,19535,7,11,0,0,19535,19536,7,12,0,0,19536,19537,7,15,0,
+        0,19537,19538,5,95,0,0,19538,19539,7,15,0,0,19539,19540,7,12,0,0,
+        19540,19541,7,5,0,0,19541,19542,7,19,0,0,19542,19543,7,9,0,0,19543,
+        19544,7,2,0,0,19544,19545,7,22,0,0,19545,19546,7,7,0,0,19546,2694,
+        1,0,0,0,19547,19548,7,15,0,0,19548,19549,7,0,0,0,19549,19550,7,3,
+        0,0,19550,19551,7,4,0,0,19551,19552,7,10,0,0,19552,19553,7,4,0,0,
+        19553,19554,7,10,0,0,19554,19555,7,2,0,0,19555,19556,7,7,0,0,19556,
+        19557,5,95,0,0,19557,19558,7,19,0,0,19558,19559,7,0,0,0,19559,19560,
+        7,5,0,0,19560,19561,7,19,0,0,19561,2696,1,0,0,0,19562,19563,7,15,
+        0,0,19563,19564,7,0,0,0,19564,19565,7,3,0,0,19565,19566,7,4,0,0,
+        19566,19567,7,10,0,0,19567,19568,7,4,0,0,19568,19569,7,10,0,0,19569,
+        19570,7,2,0,0,19570,19571,7,7,0,0,19571,19572,5,95,0,0,19572,19573,
+        7,11,0,0,19573,19574,7,10,0,0,19574,19575,7,5,0,0,19575,19576,7,
+        4,0,0,19576,2698,1,0,0,0,19577,19578,7,15,0,0,19578,19579,7,0,0,
+        0,19579,19580,7,3,0,0,19580,19581,7,4,0,0,19581,19582,7,10,0,0,19582,
+        19583,7,4,0,0,19583,19584,7,10,0,0,19584,19585,7,2,0,0,19585,19586,
+        7,7,0,0,19586,2700,1,0,0,0,19587,19588,7,15,0,0,19588,19589,7,0,
+        0,0,19589,19590,7,3,0,0,19590,19591,7,4,0,0,19591,19592,7,10,0,0,
+        19592,19593,7,4,0,0,19593,19594,7,10,0,0,19594,19595,7,2,0,0,19595,
+        19596,7,7,0,0,19596,19597,5,95,0,0,19597,19598,7,3,0,0,19598,19599,
+        7,0,0,0,19599,19600,7,7,0,0,19600,19601,7,17,0,0,19601,19602,7,6,
+        0,0,19602,2702,1,0,0,0,19603,19604,7,15,0,0,19604,19605,7,0,0,0,
+        19605,19606,7,3,0,0,19606,19607,7,4,0,0,19607,19608,7,10,0,0,19608,
+        19609,7,4,0,0,19609,19610,7,10,0,0,19610,19611,7,2,0,0,19611,19612,
+        7,7,0,0,19612,19613,7,5,0,0,19613,2704,1,0,0,0,19614,19615,7,15,
+        0,0,19615,19616,7,0,0,0,19616,19617,7,3,0,0,19617,19618,7,4,0,0,
+        19618,19619,5,36,0,0,19619,19620,7,7,0,0,19620,19621,7,12,0,0,19621,
+        19622,7,14,0,0,19622,19623,5,36,0,0,19623,19624,7,10,0,0,19624,19625,
+        7,7,0,0,19625,19626,7,5,0,0,19626,19627,7,4,0,0,19627,2706,1,0,0,
+        0,19628,19629,7,15,0,0,19629,19630,7,0,0,0,19630,19631,7,5,0,0,19631,
+        19632,7,5,0,0,19632,19633,7,10,0,0,19633,19634,7,7,0,0,19634,19635,
+        7,17,0,0,19635,2708,1,0,0,0,19636,19637,7,15,0,0,19637,19638,7,0,
+        0,0,19638,19639,7,5,0,0,19639,19640,7,5,0,0,19640,19641,7,22,0,0,
+        19641,19642,7,2,0,0,19642,19643,7,3,0,0,19643,19644,7,9,0,0,19644,
+        19645,5,95,0,0,19645,19646,7,17,0,0,19646,19647,7,3,0,0,19647,19648,
+        7,0,0,0,19648,19649,7,8,0,0,19649,19650,7,6,0,0,19650,19651,5,95,
+        0,0,19651,19652,7,4,0,0,19652,19653,7,10,0,0,19653,19654,7,14,0,
+        0,19654,19655,7,6,0,0,19655,2710,1,0,0,0,19656,19657,7,15,0,0,19657,
+        19658,7,0,0,0,19658,19659,7,5,0,0,19659,19660,7,5,0,0,19660,19661,
+        7,22,0,0,19661,19662,7,2,0,0,19662,19663,7,3,0,0,19663,19664,7,9,
+        0,0,19664,19665,5,95,0,0,19665,19666,7,11,0,0,19666,19667,7,10,0,
+        0,19667,19668,7,16,0,0,19668,19669,7,6,0,0,19669,19670,5,95,0,0,
+        19670,19671,7,4,0,0,19671,19672,7,10,0,0,19672,19673,7,14,0,0,19673,
+        19674,7,6,0,0,19674,2712,1,0,0,0,19675,19676,7,15,0,0,19676,19677,
+        7,0,0,0,19677,19678,7,5,0,0,19678,19679,7,5,0,0,19679,19680,7,22,
+        0,0,19680,19681,7,2,0,0,19681,19682,7,3,0,0,19682,19683,7,9,0,0,
+        19683,19684,5,95,0,0,19684,19685,7,11,0,0,19685,19686,7,2,0,0,19686,
+        19687,7,8,0,0,19687,19688,7,21,0,0,19688,19689,5,95,0,0,19689,19690,
+        7,4,0,0,19690,19691,7,10,0,0,19691,19692,7,14,0,0,19692,19693,7,
+        6,0,0,19693,2714,1,0,0,0,19694,19695,7,15,0,0,19695,19696,7,0,0,
+        0,19696,19697,7,5,0,0,19697,19698,7,5,0,0,19698,19699,7,22,0,0,19699,
+        19700,7,2,0,0,19700,19701,7,3,0,0,19701,19702,7,9,0,0,19702,2716,
+        1,0,0,0,19703,19704,7,15,0,0,19704,19705,7,0,0,0,19705,19706,7,5,
+        0,0,19706,19707,7,5,0,0,19707,19708,7,22,0,0,19708,19709,7,2,0,0,
+        19709,19710,7,3,0,0,19710,19711,7,9,0,0,19711,19712,5,95,0,0,19712,
+        19713,7,3,0,0,19713,19714,7,6,0,0,19714,19715,7,12,0,0,19715,19716,
+        7,5,0,0,19716,19717,7,6,0,0,19717,19718,5,95,0,0,19718,19719,7,14,
+        0,0,19719,19720,7,0,0,0,19720,19721,7,25,0,0,19721,2718,1,0,0,0,
+        19722,19723,7,15,0,0,19723,19724,7,0,0,0,19724,19725,7,5,0,0,19725,
+        19726,7,5,0,0,19726,19727,7,22,0,0,19727,19728,7,2,0,0,19728,19729,
+        7,3,0,0,19729,19730,7,9,0,0,19730,19731,5,95,0,0,19731,19732,7,3,
+        0,0,19732,19733,7,6,0,0,19733,19734,7,12,0,0,19734,19735,7,5,0,0,
+        19735,19736,7,6,0,0,19736,19737,5,95,0,0,19737,19738,7,4,0,0,19738,
+        19739,7,10,0,0,19739,19740,7,14,0,0,19740,19741,7,6,0,0,19741,2720,
+        1,0,0,0,19742,19743,7,15,0,0,19743,19744,7,0,0,0,19744,19745,7,5,
+        0,0,19745,19746,7,5,0,0,19746,19747,7,22,0,0,19747,19748,7,2,0,0,
+        19748,19749,7,3,0,0,19749,19750,7,9,0,0,19750,19751,5,95,0,0,19751,
+        19752,7,3,0,0,19752,19753,7,2,0,0,19753,19754,7,11,0,0,19754,19755,
+        7,11,0,0,19755,19756,7,2,0,0,19756,19757,7,13,0,0,19757,19758,7,
+        6,0,0,19758,19759,7,3,0,0,19759,19760,5,95,0,0,19760,19761,7,4,0,
+        0,19761,19762,7,10,0,0,19762,19763,7,14,0,0,19763,19764,7,6,0,0,
+        19764,2722,1,0,0,0,19765,19766,7,15,0,0,19766,19767,7,0,0,0,19767,
+        19768,7,5,0,0,19768,19769,7,5,0,0,19769,19770,7,22,0,0,19770,19771,
+        7,2,0,0,19771,19772,7,3,0,0,19772,19773,7,9,0,0,19773,19774,5,95,
+        0,0,19774,19775,7,13,0,0,19775,19776,7,6,0,0,19776,19777,7,3,0,0,
+        19777,19778,7,10,0,0,19778,19779,7,16,0,0,19779,19780,7,18,0,0,19780,
+        19781,5,95,0,0,19781,19782,7,16,0,0,19782,19783,7,12,0,0,19783,19784,
+        7,7,0,0,19784,19785,7,8,0,0,19785,19786,7,4,0,0,19786,19787,7,10,
+        0,0,19787,19788,7,2,0,0,19788,19789,7,7,0,0,19789,2724,1,0,0,0,19790,
+        19791,7,15,0,0,19791,19792,7,0,0,0,19792,19793,7,5,0,0,19793,19794,
+        7,4,0,0,19794,2726,1,0,0,0,19795,19796,7,15,0,0,19796,19797,7,0,
+        0,0,19797,19798,7,4,0,0,19798,19799,7,8,0,0,19799,19800,7,19,0,0,
+        19800,2728,1,0,0,0,19801,19802,7,15,0,0,19802,19803,7,0,0,0,19803,
+        19804,7,4,0,0,19804,19805,7,19,0,0,19805,2730,1,0,0,0,19806,19807,
+        7,15,0,0,19807,19808,7,0,0,0,19808,19809,7,4,0,0,19809,19810,7,19,
+        0,0,19810,19811,5,95,0,0,19811,19812,7,15,0,0,19812,19813,7,3,0,
+        0,19813,19814,7,6,0,0,19814,19815,7,16,0,0,19815,19816,7,10,0,0,
+        19816,19817,7,25,0,0,19817,2732,1,0,0,0,19818,19819,7,15,0,0,19819,
+        19820,7,0,0,0,19820,19821,7,4,0,0,19821,19822,7,19,0,0,19822,19823,
+        7,5,0,0,19823,2734,1,0,0,0,19824,19825,7,15,0,0,19825,19826,7,0,
+        0,0,19826,19827,7,4,0,0,19827,19828,7,4,0,0,19828,19829,7,6,0,0,
+        19829,19830,7,3,0,0,19830,19831,7,7,0,0,19831,2736,1,0,0,0,19832,
+        19833,7,15,0,0,19833,19834,7,1,0,0,19834,19835,7,11,0,0,19835,19836,
+        5,95,0,0,19836,19837,7,19,0,0,19837,19838,7,5,0,0,19838,19839,5,
+        95,0,0,19839,19840,7,1,0,0,19840,19841,7,6,0,0,19841,19842,7,17,
+        0,0,19842,19843,7,10,0,0,19843,19844,7,7,0,0,19844,2738,1,0,0,0,
+        19845,19846,7,15,0,0,19846,19847,7,1,0,0,19847,19848,7,11,0,0,19848,
+        19849,5,95,0,0,19849,19850,7,19,0,0,19850,19851,7,5,0,0,19851,19852,
+        5,95,0,0,19852,19853,7,6,0,0,19853,19854,7,7,0,0,19854,19855,7,9,
+        0,0,19855,2740,1,0,0,0,19856,19857,7,15,0,0,19857,19858,7,8,0,0,
+        19858,19859,7,4,0,0,19859,19860,7,16,0,0,19860,19861,7,3,0,0,19861,
+        19862,7,6,0,0,19862,19863,7,6,0,0,19863,2742,1,0,0,0,19864,19865,
+        7,15,0,0,19865,19866,7,8,0,0,19866,19867,7,4,0,0,19867,19868,7,10,
+        0,0,19868,19869,7,7,0,0,19869,19870,7,8,0,0,19870,19871,7,3,0,0,
+        19871,19872,7,6,0,0,19872,19873,7,0,0,0,19873,19874,7,5,0,0,19874,
+        19875,7,6,0,0,19875,2744,1,0,0,0,19876,19877,7,15,0,0,19877,19878,
+        7,8,0,0,19878,19879,7,4,0,0,19879,19880,7,4,0,0,19880,19881,7,19,
+        0,0,19881,19882,7,3,0,0,19882,19883,7,6,0,0,19883,19884,7,5,0,0,
+        19884,19885,7,19,0,0,19885,19886,7,2,0,0,19886,19887,7,11,0,0,19887,
+        19888,7,9,0,0,19888,2746,1,0,0,0,19889,19890,7,15,0,0,19890,19891,
+        7,8,0,0,19891,19892,7,4,0,0,19892,19893,7,12,0,0,19893,19894,7,5,
+        0,0,19894,19895,7,6,0,0,19895,19896,7,9,0,0,19896,2748,1,0,0,0,19897,
+        19898,7,15,0,0,19898,19899,7,8,0,0,19899,19900,7,4,0,0,19900,19901,
+        7,13,0,0,19901,19902,7,6,0,0,19902,19903,7,3,0,0,19903,19904,7,5,
+        0,0,19904,19905,7,10,0,0,19905,19906,7,2,0,0,19906,19907,7,7,0,0,
+        19907,2750,1,0,0,0,19908,19909,7,15,0,0,19909,19910,7,6,0,0,19910,
+        19911,7,7,0,0,19911,19912,7,9,0,0,19912,19913,7,10,0,0,19913,19914,
+        7,7,0,0,19914,19915,7,17,0,0,19915,2752,1,0,0,0,19916,19920,5,37,
+        0,0,19917,19919,3,4981,2490,0,19918,19917,1,0,0,0,19919,19922,1,
+        0,0,0,19920,19918,1,0,0,0,19920,19921,1,0,0,0,19921,19923,1,0,0,
+        0,19922,19920,1,0,0,0,19923,19924,7,16,0,0,19924,19925,7,2,0,0,19925,
+        19926,7,12,0,0,19926,19927,7,7,0,0,19927,19928,7,9,0,0,19928,2754,
+        1,0,0,0,19929,19933,5,37,0,0,19930,19932,3,4981,2490,0,19931,19930,
+        1,0,0,0,19932,19935,1,0,0,0,19933,19931,1,0,0,0,19933,19934,1,0,
+        0,0,19934,19936,1,0,0,0,19935,19933,1,0,0,0,19936,19937,7,10,0,0,
+        19937,19938,7,5,0,0,19938,19939,7,2,0,0,19939,19940,7,15,0,0,19940,
+        19941,7,6,0,0,19941,19942,7,7,0,0,19942,2756,1,0,0,0,19943,19947,
+        5,37,0,0,19944,19946,3,4981,2490,0,19945,19944,1,0,0,0,19946,19949,
+        1,0,0,0,19947,19945,1,0,0,0,19947,19948,1,0,0,0,19948,19950,1,0,
+        0,0,19949,19947,1,0,0,0,19950,19951,7,7,0,0,19951,19952,7,2,0,0,
+        19952,19953,7,4,0,0,19953,19954,7,16,0,0,19954,19955,7,2,0,0,19955,
+        19956,7,12,0,0,19956,19957,7,7,0,0,19957,19958,7,9,0,0,19958,2758,
+        1,0,0,0,19959,19960,7,15,0,0,19960,19961,7,6,0,0,19961,19962,7,3,
+        0,0,19962,19963,7,8,0,0,19963,19964,7,6,0,0,19964,19965,7,7,0,0,
+        19965,19966,7,4,0,0,19966,2760,1,0,0,0,19967,19968,7,15,0,0,19968,
+        19969,7,6,0,0,19969,19970,7,3,0,0,19970,19971,7,8,0,0,19971,19972,
+        7,6,0,0,19972,19973,7,7,0,0,19973,19974,7,4,0,0,19974,19975,5,95,
+        0,0,19975,19976,7,3,0,0,19976,19977,7,0,0,0,19977,19978,7,7,0,0,
+        19978,19979,7,21,0,0,19979,19980,7,14,0,0,19980,2762,1,0,0,0,19981,
+        19985,5,37,0,0,19982,19984,3,4981,2490,0,19983,19982,1,0,0,0,19984,
+        19987,1,0,0,0,19985,19983,1,0,0,0,19985,19986,1,0,0,0,19986,19988,
+        1,0,0,0,19987,19985,1,0,0,0,19988,19989,7,3,0,0,19989,19990,7,2,
+        0,0,19990,19991,7,22,0,0,19991,19992,7,8,0,0,19992,19993,7,2,0,0,
+        19993,19994,7,12,0,0,19994,19995,7,7,0,0,19995,19996,7,4,0,0,19996,
+        2764,1,0,0,0,19997,20001,5,37,0,0,19998,20000,3,4981,2490,0,19999,
+        19998,1,0,0,0,20000,20003,1,0,0,0,20001,19999,1,0,0,0,20001,20002,
+        1,0,0,0,20002,20004,1,0,0,0,20003,20001,1,0,0,0,20004,20005,7,3,
+        0,0,20005,20006,7,2,0,0,20006,20007,7,22,0,0,20007,20008,7,4,0,0,
+        20008,20009,7,18,0,0,20009,20010,7,15,0,0,20010,20011,7,6,0,0,20011,
+        2766,1,0,0,0,20012,20016,5,37,0,0,20013,20015,3,4981,2490,0,20014,
+        20013,1,0,0,0,20015,20018,1,0,0,0,20016,20014,1,0,0,0,20016,20017,
+        1,0,0,0,20017,20019,1,0,0,0,20018,20016,1,0,0,0,20019,20020,7,4,
+        0,0,20020,20021,7,18,0,0,20021,20022,7,15,0,0,20022,20023,7,6,0,
+        0,20023,2768,1,0,0,0,20024,20028,5,37,0,0,20025,20027,3,4981,2490,
+        0,20026,20025,1,0,0,0,20027,20030,1,0,0,0,20028,20026,1,0,0,0,20028,
+        20029,1,0,0,0,20029,20031,1,0,0,0,20030,20028,1,0,0,0,20031,20032,
+        7,1,0,0,20032,20033,7,12,0,0,20033,20034,7,11,0,0,20034,20035,7,
+        21,0,0,20035,20036,5,95,0,0,20036,20037,7,6,0,0,20037,20038,7,25,
+        0,0,20038,20039,7,8,0,0,20039,20040,7,6,0,0,20040,20041,7,15,0,0,
+        20041,20042,7,4,0,0,20042,20043,7,10,0,0,20043,20044,7,2,0,0,20044,
+        20045,7,7,0,0,20045,20046,7,5,0,0,20046,2770,1,0,0,0,20047,20051,
+        5,37,0,0,20048,20050,3,4981,2490,0,20049,20048,1,0,0,0,20050,20053,
+        1,0,0,0,20051,20049,1,0,0,0,20051,20052,1,0,0,0,20052,20054,1,0,
+        0,0,20053,20051,1,0,0,0,20054,20055,7,1,0,0,20055,20056,7,12,0,0,
+        20056,20057,7,11,0,0,20057,20058,7,21,0,0,20058,20059,5,95,0,0,20059,
+        20060,7,3,0,0,20060,20061,7,2,0,0,20061,20062,7,22,0,0,20062,20063,
+        7,8,0,0,20063,20064,7,2,0,0,20064,20065,7,12,0,0,20065,20066,7,7,
+        0,0,20066,20067,7,4,0,0,20067,2772,1,0,0,0,20068,20069,7,15,0,0,
+        20069,20070,7,6,0,0,20070,20071,7,3,0,0,20071,20072,7,16,0,0,20072,
+        20073,7,2,0,0,20073,20074,7,3,0,0,20074,20075,7,14,0,0,20075,20076,
+        7,0,0,0,20076,20077,7,7,0,0,20077,20078,7,8,0,0,20078,20079,7,6,
+        0,0,20079,2774,1,0,0,0,20080,20081,7,15,0,0,20081,20082,7,6,0,0,
+        20082,20083,7,3,0,0,20083,20084,7,10,0,0,20084,20085,7,2,0,0,20085,
+        20086,7,9,0,0,20086,2776,1,0,0,0,20087,20088,7,15,0,0,20088,20089,
+        7,6,0,0,20089,20090,7,3,0,0,20090,20091,7,14,0,0,20091,20092,7,0,
+        0,0,20092,20093,7,7,0,0,20093,20094,7,6,0,0,20094,20095,7,7,0,0,
+        20095,20096,7,4,0,0,20096,2778,1,0,0,0,20097,20098,7,15,0,0,20098,
+        20099,7,6,0,0,20099,20100,7,3,0,0,20100,20101,7,14,0,0,20101,20102,
+        7,10,0,0,20102,20103,7,5,0,0,20103,20104,7,5,0,0,20104,20105,7,10,
+        0,0,20105,20106,7,2,0,0,20106,20107,7,7,0,0,20107,2780,1,0,0,0,20108,
+        20109,7,15,0,0,20109,20110,7,6,0,0,20110,20111,7,3,0,0,20111,20112,
+        7,14,0,0,20112,20113,7,12,0,0,20113,20114,7,4,0,0,20114,20115,7,
+        6,0,0,20115,2782,1,0,0,0,20116,20117,7,15,0,0,20117,20118,7,6,0,
+        0,20118,20119,7,3,0,0,20119,2784,1,0,0,0,20120,20121,7,15,0,0,20121,
+        20122,7,16,0,0,20122,20123,7,10,0,0,20123,20124,7,11,0,0,20124,20125,
+        7,6,0,0,20125,2786,1,0,0,0,20126,20127,7,15,0,0,20127,20128,7,19,
+        0,0,20128,20129,7,18,0,0,20129,20130,7,5,0,0,20130,20131,7,10,0,
+        0,20131,20132,7,8,0,0,20132,20133,7,0,0,0,20133,20134,7,11,0,0,20134,
+        2788,1,0,0,0,20135,20136,7,15,0,0,20136,20137,7,10,0,0,20137,20138,
+        7,21,0,0,20138,20139,7,6,0,0,20139,20140,7,18,0,0,20140,2790,1,0,
+        0,0,20141,20142,7,15,0,0,20142,20143,7,10,0,0,20143,20144,7,15,0,
+        0,20144,20145,7,6,0,0,20145,20146,7,11,0,0,20146,20147,7,10,0,0,
+        20147,20148,7,7,0,0,20148,20149,7,6,0,0,20149,20150,7,9,0,0,20150,
+        2792,1,0,0,0,20151,20152,7,15,0,0,20152,20153,7,10,0,0,20153,20154,
+        7,15,0,0,20154,20155,7,6,0,0,20155,2794,1,0,0,0,20156,20157,7,15,
+        0,0,20157,20158,7,10,0,0,20158,20159,7,13,0,0,20159,20160,5,95,0,
+        0,20160,20161,7,17,0,0,20161,20162,7,1,0,0,20162,2796,1,0,0,0,20163,
+        20164,7,15,0,0,20164,20165,7,10,0,0,20165,20166,7,13,0,0,20166,20167,
+        7,2,0,0,20167,20168,7,4,0,0,20168,2798,1,0,0,0,20169,20170,7,15,
+        0,0,20170,20171,7,10,0,0,20171,20172,7,13,0,0,20172,20173,5,95,0,
+        0,20173,20174,7,5,0,0,20174,20175,7,5,0,0,20175,20176,7,16,0,0,20176,
+        2800,1,0,0,0,20177,20178,7,15,0,0,20178,20179,7,11,0,0,20179,20180,
+        7,0,0,0,20180,20181,7,8,0,0,20181,20182,7,6,0,0,20182,20183,5,95,
+        0,0,20183,20184,7,9,0,0,20184,20185,7,10,0,0,20185,20186,7,5,0,0,
+        20186,20187,7,4,0,0,20187,20188,7,10,0,0,20188,20189,7,7,0,0,20189,
+        20190,7,8,0,0,20190,20191,7,4,0,0,20191,2802,1,0,0,0,20192,20193,
+        7,15,0,0,20193,20194,7,11,0,0,20194,20195,7,0,0,0,20195,20196,7,
+        8,0,0,20196,20197,7,6,0,0,20197,20198,5,95,0,0,20198,20199,7,17,
+        0,0,20199,20200,7,3,0,0,20200,20201,7,2,0,0,20201,20202,7,12,0,0,
+        20202,20203,7,15,0,0,20203,20204,5,95,0,0,20204,20205,7,1,0,0,20205,
+        20206,7,18,0,0,20206,2804,1,0,0,0,20207,20208,7,15,0,0,20208,20209,
+        7,11,0,0,20209,20210,7,0,0,0,20210,20211,7,7,0,0,20211,2806,1,0,
+        0,0,20212,20213,7,15,0,0,20213,20214,7,11,0,0,20214,20215,7,5,0,
+        0,20215,20216,7,8,0,0,20216,20217,7,2,0,0,20217,20218,7,15,0,0,20218,
+        20219,7,6,0,0,20219,20220,5,95,0,0,20220,20221,7,5,0,0,20221,20222,
+        7,6,0,0,20222,20223,7,4,0,0,20223,20224,7,4,0,0,20224,20225,7,10,
+        0,0,20225,20226,7,7,0,0,20226,20227,7,17,0,0,20227,20228,7,5,0,0,
+        20228,2808,1,0,0,0,20229,20230,7,15,0,0,20230,20231,7,11,0,0,20231,
+        20232,7,5,0,0,20232,20233,5,95,0,0,20233,20234,7,10,0,0,20234,20235,
+        7,7,0,0,20235,20236,7,4,0,0,20236,20237,7,6,0,0,20237,20238,7,17,
+        0,0,20238,20239,7,6,0,0,20239,20240,7,3,0,0,20240,2810,1,0,0,0,20241,
+        20242,7,15,0,0,20242,20243,7,11,0,0,20243,20244,7,5,0,0,20244,20245,
+        7,24,0,0,20245,20246,7,11,0,0,20246,20247,5,95,0,0,20247,20248,7,
+        8,0,0,20248,20249,7,8,0,0,20249,20250,7,16,0,0,20250,20251,7,11,
+        0,0,20251,20252,7,0,0,0,20252,20253,7,17,0,0,20253,20254,7,5,0,0,
+        20254,2812,1,0,0,0,20255,20256,7,15,0,0,20256,20257,7,11,0,0,20257,
+        20258,7,5,0,0,20258,20259,7,24,0,0,20259,20260,7,11,0,0,20260,20261,
+        5,95,0,0,20261,20262,7,8,0,0,20262,20263,7,2,0,0,20263,20264,7,9,
+        0,0,20264,20265,7,6,0,0,20265,20266,5,95,0,0,20266,20267,7,4,0,0,
+        20267,20268,7,18,0,0,20268,20269,7,15,0,0,20269,20270,7,6,0,0,20270,
+        2814,1,0,0,0,20271,20272,7,15,0,0,20272,20273,7,11,0,0,20273,20274,
+        7,5,0,0,20274,20275,7,24,0,0,20275,20276,7,11,0,0,20276,20277,5,
+        95,0,0,20277,20278,7,9,0,0,20278,20279,7,6,0,0,20279,20280,7,1,0,
+        0,20280,20281,7,12,0,0,20281,20282,7,17,0,0,20282,2816,1,0,0,0,20283,
+        20284,7,15,0,0,20284,20285,7,11,0,0,20285,20286,7,5,0,0,20286,20287,
+        7,24,0,0,20287,20288,7,11,0,0,20288,20289,5,95,0,0,20289,20290,7,
+        2,0,0,20290,20291,7,15,0,0,20291,20292,7,4,0,0,20292,20293,7,10,
+        0,0,20293,20294,7,14,0,0,20294,20295,7,10,0,0,20295,20296,7,23,0,
+        0,20296,20297,7,6,0,0,20297,20298,5,95,0,0,20298,20299,7,11,0,0,
+        20299,20300,7,6,0,0,20300,20301,7,13,0,0,20301,20302,7,6,0,0,20302,
+        20303,7,11,0,0,20303,2818,1,0,0,0,20304,20305,7,15,0,0,20305,20306,
+        7,11,0,0,20306,20307,7,5,0,0,20307,20308,7,24,0,0,20308,20309,7,
+        11,0,0,20309,20310,5,95,0,0,20310,20311,7,22,0,0,20311,20312,7,0,
+        0,0,20312,20313,7,3,0,0,20313,20314,7,7,0,0,20314,20315,7,10,0,0,
+        20315,20316,7,7,0,0,20316,20317,7,17,0,0,20317,20318,7,5,0,0,20318,
+        2820,1,0,0,0,20319,20320,7,15,0,0,20320,20321,7,11,0,0,20321,20322,
+        7,12,0,0,20322,20323,7,17,0,0,20323,20324,7,17,0,0,20324,20325,7,
+        0,0,0,20325,20326,7,1,0,0,20326,20327,7,11,0,0,20327,20328,7,6,0,
+        0,20328,2822,1,0,0,0,20329,20330,7,15,0,0,20330,20331,7,14,0,0,20331,
+        20332,7,6,0,0,20332,20333,7,14,0,0,20333,2824,1,0,0,0,20334,20335,
+        7,15,0,0,20335,20336,7,2,0,0,20336,20337,7,10,0,0,20337,20338,7,
+        7,0,0,20338,20339,7,4,0,0,20339,2826,1,0,0,0,20340,20341,7,15,0,
+        0,20341,20342,7,2,0,0,20342,20343,7,11,0,0,20343,20344,7,10,0,0,
+        20344,20345,7,8,0,0,20345,20346,7,18,0,0,20346,2828,1,0,0,0,20347,
+        20348,7,15,0,0,20348,20349,7,2,0,0,20349,20350,7,2,0,0,20350,20351,
+        7,11,0,0,20351,20352,5,95,0,0,20352,20353,5,49,0,0,20353,20354,5,
+        54,0,0,20354,20355,7,21,0,0,20355,2830,1,0,0,0,20356,20357,7,15,
+        0,0,20357,20358,7,2,0,0,20358,20359,7,2,0,0,20359,20360,7,11,0,0,
+        20360,20361,5,95,0,0,20361,20362,5,50,0,0,20362,20363,7,21,0,0,20363,
+        2832,1,0,0,0,20364,20365,7,15,0,0,20365,20366,7,2,0,0,20366,20367,
+        7,2,0,0,20367,20368,7,11,0,0,20368,20369,5,95,0,0,20369,20370,5,
+        51,0,0,20370,20371,5,50,0,0,20371,20372,7,21,0,0,20372,2834,1,0,
+        0,0,20373,20374,7,15,0,0,20374,20375,7,2,0,0,20375,20376,7,2,0,0,
+        20376,20377,7,11,0,0,20377,20378,5,95,0,0,20378,20379,5,52,0,0,20379,
+        20380,7,21,0,0,20380,2836,1,0,0,0,20381,20382,7,15,0,0,20382,20383,
+        7,2,0,0,20383,20384,7,2,0,0,20384,20385,7,11,0,0,20385,20386,5,95,
+        0,0,20386,20387,5,56,0,0,20387,20388,7,21,0,0,20388,2838,1,0,0,0,
+        20389,20390,7,15,0,0,20390,20391,7,2,0,0,20391,20392,7,5,0,0,20392,
+        20393,7,10,0,0,20393,20394,7,4,0,0,20394,20395,7,10,0,0,20395,20396,
+        7,2,0,0,20396,20397,7,7,0,0,20397,2840,1,0,0,0,20398,20399,7,15,
+        0,0,20399,20400,7,2,0,0,20400,20401,7,5,0,0,20401,20402,7,10,0,0,
+        20402,20403,7,4,0,0,20403,20404,7,10,0,0,20404,20405,7,13,0,0,20405,
+        20406,7,6,0,0,20406,20407,7,7,0,0,20407,2842,1,0,0,0,20408,20409,
+        7,15,0,0,20409,20410,7,2,0,0,20410,20411,7,5,0,0,20411,20412,7,10,
+        0,0,20412,20413,7,4,0,0,20413,20414,7,10,0,0,20414,20415,7,13,0,
+        0,20415,20416,7,6,0,0,20416,2844,1,0,0,0,20417,20418,7,15,0,0,20418,
+        20419,7,2,0,0,20419,20420,7,5,0,0,20420,20421,7,4,0,0,20421,20422,
+        5,95,0,0,20422,20423,7,4,0,0,20423,20424,7,3,0,0,20424,20425,7,0,
+        0,0,20425,20426,7,7,0,0,20426,20427,7,5,0,0,20427,20428,7,0,0,0,
+        20428,20429,7,8,0,0,20429,20430,7,4,0,0,20430,20431,7,10,0,0,20431,
+        20432,7,2,0,0,20432,20433,7,7,0,0,20433,2846,1,0,0,0,20434,20435,
+        7,15,0,0,20435,20436,7,2,0,0,20436,20437,7,22,0,0,20437,20438,7,
+        6,0,0,20438,20439,7,3,0,0,20439,20440,7,14,0,0,20440,20441,7,12,
+        0,0,20441,20442,7,11,0,0,20442,20443,7,4,0,0,20443,20444,7,10,0,
+        0,20444,20445,7,5,0,0,20445,20446,7,6,0,0,20446,20447,7,4,0,0,20447,
+        20448,5,95,0,0,20448,20449,7,1,0,0,20449,20450,7,18,0,0,20450,20451,
+        5,95,0,0,20451,20452,7,8,0,0,20452,20453,7,0,0,0,20453,20454,7,3,
+        0,0,20454,20455,7,9,0,0,20455,20456,7,10,0,0,20456,20457,7,7,0,0,
+        20457,20458,7,0,0,0,20458,20459,7,11,0,0,20459,20460,7,10,0,0,20460,
+        20461,7,4,0,0,20461,20462,7,18,0,0,20462,2848,1,0,0,0,20463,20464,
+        7,15,0,0,20464,20465,7,2,0,0,20465,20466,7,22,0,0,20466,20467,7,
+        6,0,0,20467,20468,7,3,0,0,20468,20469,7,14,0,0,20469,20470,7,12,
+        0,0,20470,20471,7,11,0,0,20471,20472,7,4,0,0,20472,20473,7,10,0,
+        0,20473,20474,7,5,0,0,20474,20475,7,6,0,0,20475,20476,7,4,0,0,20476,
+        2850,1,0,0,0,20477,20478,7,15,0,0,20478,20479,7,2,0,0,20479,20480,
+        7,22,0,0,20480,20481,7,6,0,0,20481,20482,7,3,0,0,20482,2852,1,0,
+        0,0,20483,20484,7,15,0,0,20484,20485,7,24,0,0,20485,20486,5,95,0,
+        0,20486,20487,7,8,0,0,20487,20488,7,2,0,0,20488,20489,7,7,0,0,20489,
+        20490,7,8,0,0,20490,20491,7,12,0,0,20491,20492,7,3,0,0,20492,20493,
+        7,3,0,0,20493,20494,7,6,0,0,20494,20495,7,7,0,0,20495,20496,7,4,
+        0,0,20496,20497,5,95,0,0,20497,20498,7,12,0,0,20498,20499,7,7,0,
+        0,20499,20500,7,10,0,0,20500,20501,7,2,0,0,20501,20502,7,7,0,0,20502,
+        2854,1,0,0,0,20503,20504,7,15,0,0,20504,20505,7,24,0,0,20505,20506,
+        5,95,0,0,20506,20507,7,9,0,0,20507,20508,7,10,0,0,20508,20509,7,
+        5,0,0,20509,20510,7,4,0,0,20510,20511,7,3,0,0,20511,20512,7,10,0,
+        0,20512,20513,7,1,0,0,20513,20514,7,12,0,0,20514,20515,7,4,0,0,20515,
+        20516,7,6,0,0,20516,2856,1,0,0,0,20517,20518,7,15,0,0,20518,20519,
+        7,24,0,0,20519,20520,5,95,0,0,20520,20521,7,9,0,0,20521,20522,7,
+        10,0,0,20522,20523,7,5,0,0,20523,20524,7,4,0,0,20524,20525,7,3,0,
+        0,20525,20526,7,10,0,0,20526,20527,7,1,0,0,20527,20528,7,12,0,0,
+        20528,20529,7,4,0,0,20529,20530,7,6,0,0,20530,20531,5,95,0,0,20531,
+        20532,7,22,0,0,20532,20533,7,10,0,0,20533,20534,7,7,0,0,20534,20535,
+        7,9,0,0,20535,20536,7,2,0,0,20536,20537,7,22,0,0,20537,2858,1,0,
+        0,0,20538,20539,7,15,0,0,20539,20540,7,24,0,0,20540,20541,5,95,0,
+        0,20541,20542,7,16,0,0,20542,20543,7,10,0,0,20543,20544,7,11,0,0,
+        20544,20545,7,4,0,0,20545,20546,7,6,0,0,20546,20547,7,3,0,0,20547,
+        2860,1,0,0,0,20548,20549,7,15,0,0,20549,20550,7,24,0,0,20550,20551,
+        5,95,0,0,20551,20552,7,14,0,0,20552,20553,7,0,0,0,20553,20554,7,
+        15,0,0,20554,2862,1,0,0,0,20555,20556,7,15,0,0,20556,20557,7,24,
+        0,0,20557,20558,5,95,0,0,20558,20559,7,7,0,0,20559,20560,7,2,0,0,
+        20560,20561,7,14,0,0,20561,20562,7,0,0,0,20562,20563,7,15,0,0,20563,
+        2864,1,0,0,0,20564,20565,7,15,0,0,20565,20566,7,24,0,0,20566,20567,
+        5,95,0,0,20567,20568,7,3,0,0,20568,20569,7,6,0,0,20569,20570,7,15,
+        0,0,20570,20571,7,11,0,0,20571,20572,7,10,0,0,20572,20573,7,8,0,
+        0,20573,20574,7,0,0,0,20574,20575,7,4,0,0,20575,20576,7,6,0,0,20576,
+        2866,1,0,0,0,20577,20578,7,15,0,0,20578,20579,7,24,0,0,20579,20580,
+        5,95,0,0,20580,20581,7,5,0,0,20581,20582,7,21,0,0,20582,20583,7,
+        6,0,0,20583,20584,7,22,0,0,20584,2868,1,0,0,0,20585,20586,7,15,0,
+        0,20586,20587,7,3,0,0,20587,20588,7,0,0,0,20588,20589,7,17,0,0,20589,
+        20590,7,14,0,0,20590,20591,7,0,0,0,20591,2870,1,0,0,0,20592,20593,
+        7,15,0,0,20593,20594,7,3,0,0,20594,20595,7,6,0,0,20595,20596,7,1,
+        0,0,20596,20597,7,12,0,0,20597,20598,7,10,0,0,20598,20599,7,11,0,
+        0,20599,20600,7,4,0,0,20600,2872,1,0,0,0,20601,20602,7,15,0,0,20602,
+        20603,7,3,0,0,20603,20604,7,6,0,0,20604,20605,7,8,0,0,20605,20606,
+        7,6,0,0,20606,20607,7,9,0,0,20607,20608,7,6,0,0,20608,20609,7,5,
+        0,0,20609,2874,1,0,0,0,20610,20611,7,15,0,0,20611,20612,7,3,0,0,
+        20612,20613,7,6,0,0,20613,20614,7,8,0,0,20614,20615,7,6,0,0,20615,
+        20616,7,9,0,0,20616,20617,7,10,0,0,20617,20618,7,7,0,0,20618,20619,
+        7,17,0,0,20619,2876,1,0,0,0,20620,20621,7,15,0,0,20621,20622,7,3,
+        0,0,20622,20623,7,6,0,0,20623,20624,7,8,0,0,20624,20625,7,10,0,0,
+        20625,20626,7,5,0,0,20626,20627,7,10,0,0,20627,20628,7,2,0,0,20628,
+        20629,7,7,0,0,20629,2878,1,0,0,0,20630,20631,7,15,0,0,20631,20632,
+        7,3,0,0,20632,20633,7,6,0,0,20633,20634,7,8,0,0,20634,20635,7,2,
+        0,0,20635,20636,7,14,0,0,20636,20637,7,15,0,0,20637,20638,7,12,0,
+        0,20638,20639,7,4,0,0,20639,20640,7,6,0,0,20640,20641,5,95,0,0,20641,
+        20642,7,5,0,0,20642,20643,7,12,0,0,20643,20644,7,1,0,0,20644,20645,
+        7,24,0,0,20645,20646,7,12,0,0,20646,20647,7,6,0,0,20647,20648,7,
+        3,0,0,20648,20649,7,18,0,0,20649,2880,1,0,0,0,20650,20651,7,15,0,
+        0,20651,20652,7,3,0,0,20652,20653,7,6,0,0,20653,20654,7,9,0,0,20654,
+        20655,7,10,0,0,20655,20656,7,8,0,0,20656,20657,7,0,0,0,20657,20658,
+        7,4,0,0,20658,20659,7,6,0,0,20659,20660,5,95,0,0,20660,20661,7,3,
+        0,0,20661,20662,7,6,0,0,20662,20663,7,2,0,0,20663,20664,7,3,0,0,
+        20664,20665,7,9,0,0,20665,20666,7,6,0,0,20666,20667,7,3,0,0,20667,
+        20668,7,5,0,0,20668,2882,1,0,0,0,20669,20670,7,15,0,0,20670,20671,
+        7,3,0,0,20671,20672,7,6,0,0,20672,20673,7,11,0,0,20673,20674,7,2,
+        0,0,20674,20675,7,0,0,0,20675,20676,7,9,0,0,20676,2884,1,0,0,0,20677,
+        20678,7,15,0,0,20678,20679,7,3,0,0,20679,20680,7,6,0,0,20680,20681,
+        7,15,0,0,20681,20682,7,0,0,0,20682,20683,7,3,0,0,20683,20684,7,6,
+        0,0,20684,2886,1,0,0,0,20685,20686,7,15,0,0,20686,20687,7,3,0,0,
+        20687,20688,7,6,0,0,20688,20689,7,15,0,0,20689,20690,7,3,0,0,20690,
+        20691,7,2,0,0,20691,20692,7,8,0,0,20692,20693,7,6,0,0,20693,20694,
+        7,5,0,0,20694,20695,7,5,0,0,20695,20696,7,2,0,0,20696,20697,7,3,
+        0,0,20697,2888,1,0,0,0,20698,20699,7,15,0,0,20699,20700,7,3,0,0,
+        20700,20701,7,6,0,0,20701,20702,7,5,0,0,20702,20703,7,6,0,0,20703,
+        20704,7,7,0,0,20704,20705,7,4,0,0,20705,20706,7,7,0,0,20706,20707,
+        7,7,0,0,20707,20708,7,13,0,0,20708,2890,1,0,0,0,20709,20710,7,15,
+        0,0,20710,20711,7,3,0,0,20711,20712,7,6,0,0,20712,20713,7,5,0,0,
+        20713,20714,7,6,0,0,20714,20715,7,7,0,0,20715,20716,7,4,0,0,20716,
+        2892,1,0,0,0,20717,20718,7,15,0,0,20718,20719,7,3,0,0,20719,20720,
+        7,6,0,0,20720,20721,7,5,0,0,20721,20722,7,6,0,0,20722,20723,7,7,
+        0,0,20723,20724,7,4,0,0,20724,20725,7,13,0,0,20725,2894,1,0,0,0,
+        20726,20727,7,15,0,0,20727,20728,7,3,0,0,20728,20729,7,6,0,0,20729,
+        20730,7,5,0,0,20730,20731,7,6,0,0,20731,20732,7,3,0,0,20732,20733,
+        7,13,0,0,20733,20734,7,6,0,0,20734,20735,5,95,0,0,20735,20736,7,
+        2,0,0,20736,20737,7,10,0,0,20737,20738,7,9,0,0,20738,2896,1,0,0,
+        0,20739,20740,7,15,0,0,20740,20741,7,3,0,0,20741,20742,7,6,0,0,20742,
+        20743,7,5,0,0,20743,20744,7,6,0,0,20744,20745,7,3,0,0,20745,20746,
+        7,13,0,0,20746,20747,7,6,0,0,20747,2898,1,0,0,0,20748,20749,7,15,
+        0,0,20749,20750,7,3,0,0,20750,20751,7,6,0,0,20751,20752,7,4,0,0,
+        20752,20753,7,4,0,0,20753,20754,7,18,0,0,20754,2900,1,0,0,0,20755,
+        20756,7,15,0,0,20756,20757,7,3,0,0,20757,20758,7,6,0,0,20758,20759,
+        7,13,0,0,20759,20760,7,10,0,0,20760,20761,7,2,0,0,20761,20762,7,
+        12,0,0,20762,20763,7,5,0,0,20763,2902,1,0,0,0,20764,20765,7,15,0,
+        0,20765,20766,7,3,0,0,20766,20767,7,6,0,0,20767,20768,7,13,0,0,20768,
+        2904,1,0,0,0,20769,20770,7,15,0,0,20770,20771,7,3,0,0,20771,20772,
+        7,10,0,0,20772,20773,7,14,0,0,20773,20774,7,0,0,0,20774,20775,7,
+        3,0,0,20775,20776,7,18,0,0,20776,2906,1,0,0,0,20777,20778,7,15,0,
+        0,20778,20779,7,3,0,0,20779,20780,7,10,0,0,20780,20781,7,7,0,0,20781,
+        20782,7,4,0,0,20782,20783,7,1,0,0,20783,20784,7,11,0,0,20784,20785,
+        7,2,0,0,20785,20786,7,1,0,0,20786,20787,7,4,0,0,20787,20788,7,2,
+        0,0,20788,20789,7,8,0,0,20789,20790,7,11,0,0,20790,20791,7,2,0,0,
+        20791,20792,7,1,0,0,20792,2908,1,0,0,0,20793,20794,7,15,0,0,20794,
+        20795,7,3,0,0,20795,20796,7,10,0,0,20796,20797,7,2,0,0,20797,20798,
+        7,3,0,0,20798,20799,7,10,0,0,20799,20800,7,4,0,0,20800,20801,7,18,
+        0,0,20801,2910,1,0,0,0,20802,20803,7,15,0,0,20803,20804,7,3,0,0,
+        20804,20805,7,10,0,0,20805,20806,7,2,0,0,20806,20807,7,3,0,0,20807,
+        2912,1,0,0,0,20808,20809,7,15,0,0,20809,20810,7,3,0,0,20810,20811,
+        7,10,0,0,20811,20812,7,13,0,0,20812,20813,7,0,0,0,20813,20814,7,
+        4,0,0,20814,20815,7,6,0,0,20815,2914,1,0,0,0,20816,20817,7,15,0,
+        0,20817,20818,7,3,0,0,20818,20819,7,10,0,0,20819,20820,7,13,0,0,
+        20820,20821,7,0,0,0,20821,20822,7,4,0,0,20822,20823,7,6,0,0,20823,
+        20824,5,95,0,0,20824,20825,7,5,0,0,20825,20826,7,17,0,0,20826,20827,
+        7,0,0,0,20827,2916,1,0,0,0,20828,20829,7,15,0,0,20829,20830,7,3,
+        0,0,20830,20831,7,10,0,0,20831,20832,7,13,0,0,20832,20833,7,10,0,
+        0,20833,20834,7,11,0,0,20834,20835,7,6,0,0,20835,20836,7,17,0,0,
+        20836,20837,7,6,0,0,20837,20838,7,9,0,0,20838,2918,1,0,0,0,20839,
+        20840,7,15,0,0,20840,20841,7,3,0,0,20841,20842,7,10,0,0,20842,20843,
+        7,13,0,0,20843,20844,7,10,0,0,20844,20845,7,11,0,0,20845,20846,7,
+        6,0,0,20846,20847,7,17,0,0,20847,20848,7,6,0,0,20848,2920,1,0,0,
+        0,20849,20850,7,15,0,0,20850,20851,7,3,0,0,20851,20852,7,10,0,0,
+        20852,20853,7,13,0,0,20853,20854,7,10,0,0,20854,20855,7,11,0,0,20855,
+        20856,7,6,0,0,20856,20857,7,17,0,0,20857,20858,7,6,0,0,20858,20859,
+        7,5,0,0,20859,2922,1,0,0,0,20860,20861,7,15,0,0,20861,20862,7,3,
+        0,0,20862,20863,7,2,0,0,20863,20864,7,8,0,0,20864,20865,7,6,0,0,
+        20865,20866,7,9,0,0,20866,20867,7,12,0,0,20867,20868,7,3,0,0,20868,
+        20869,7,0,0,0,20869,20870,7,11,0,0,20870,2924,1,0,0,0,20871,20872,
+        7,15,0,0,20872,20873,7,3,0,0,20873,20874,7,2,0,0,20874,20875,7,8,
+        0,0,20875,20876,7,6,0,0,20876,20877,7,9,0,0,20877,20878,7,12,0,0,
+        20878,20879,7,3,0,0,20879,20880,7,6,0,0,20880,2926,1,0,0,0,20881,
+        20882,7,15,0,0,20882,20883,7,3,0,0,20883,20884,7,2,0,0,20884,20885,
+        7,8,0,0,20885,20886,7,6,0,0,20886,20887,7,5,0,0,20887,20888,7,5,
+        0,0,20888,2928,1,0,0,0,20889,20890,7,15,0,0,20890,20891,7,3,0,0,
+        20891,20892,7,2,0,0,20892,20893,7,16,0,0,20893,20894,7,10,0,0,20894,
+        20895,7,11,0,0,20895,20896,7,6,0,0,20896,2930,1,0,0,0,20897,20898,
+        7,15,0,0,20898,20899,7,3,0,0,20899,20900,7,2,0,0,20900,20901,7,17,
+        0,0,20901,20902,7,3,0,0,20902,20903,7,0,0,0,20903,20904,7,14,0,0,
+        20904,2932,1,0,0,0,20905,20906,7,15,0,0,20906,20907,7,3,0,0,20907,
+        20908,7,2,0,0,20908,20909,7,20,0,0,20909,20910,7,6,0,0,20910,20911,
+        7,8,0,0,20911,20912,7,4,0,0,20912,2934,1,0,0,0,20913,20914,7,15,
+        0,0,20914,20915,7,3,0,0,20915,20916,7,2,0,0,20916,20917,7,15,0,0,
+        20917,20918,7,0,0,0,20918,20919,7,17,0,0,20919,20920,7,0,0,0,20920,
+        20921,7,4,0,0,20921,20922,7,6,0,0,20922,2936,1,0,0,0,20923,20924,
+        7,15,0,0,20924,20925,7,3,0,0,20925,20926,7,2,0,0,20926,20927,7,15,
+        0,0,20927,20928,7,6,0,0,20928,20929,7,3,0,0,20929,20930,7,4,0,0,
+        20930,20931,7,18,0,0,20931,2938,1,0,0,0,20932,20933,7,15,0,0,20933,
+        20934,7,3,0,0,20934,20935,7,2,0,0,20935,20936,7,4,0,0,20936,20937,
+        7,6,0,0,20937,20938,7,8,0,0,20938,20939,7,4,0,0,20939,20940,7,6,
+        0,0,20940,20941,7,9,0,0,20941,2940,1,0,0,0,20942,20943,7,15,0,0,
+        20943,20944,7,3,0,0,20944,20945,7,2,0,0,20945,20946,7,4,0,0,20946,
+        20947,7,6,0,0,20947,20948,7,8,0,0,20948,20949,7,4,0,0,20949,20950,
+        7,10,0,0,20950,20951,7,2,0,0,20951,20952,7,7,0,0,20952,2942,1,0,
+        0,0,20953,20954,7,15,0,0,20954,20955,7,3,0,0,20955,20956,7,2,0,0,
+        20956,20957,7,4,0,0,20957,20958,7,2,0,0,20958,20959,7,8,0,0,20959,
+        20960,7,2,0,0,20960,20961,7,11,0,0,20961,2944,1,0,0,0,20962,20963,
+        7,15,0,0,20963,20964,7,3,0,0,20964,20965,7,2,0,0,20965,20966,7,25,
+        0,0,20966,20967,7,18,0,0,20967,2946,1,0,0,0,20968,20969,7,15,0,0,
+        20969,20970,7,3,0,0,20970,20971,7,12,0,0,20971,20972,7,7,0,0,20972,
+        20973,7,10,0,0,20973,20974,7,7,0,0,20974,20975,7,17,0,0,20975,2948,
+        1,0,0,0,20976,20977,7,15,0,0,20977,20978,7,12,0,0,20978,20979,7,
+        1,0,0,20979,20980,7,11,0,0,20980,20981,7,10,0,0,20981,20982,7,8,
+        0,0,20982,2950,1,0,0,0,20983,20984,7,15,0,0,20984,20985,7,12,0,0,
+        20985,20986,7,11,0,0,20986,20987,7,11,0,0,20987,20988,5,95,0,0,20988,
+        20989,7,15,0,0,20989,20990,7,3,0,0,20990,20991,7,6,0,0,20991,20992,
+        7,9,0,0,20992,2952,1,0,0,0,20993,20994,7,15,0,0,20994,20995,7,12,
+        0,0,20995,20996,7,3,0,0,20996,20997,7,17,0,0,20997,20998,7,6,0,0,
+        20998,2954,1,0,0,0,20999,21000,7,15,0,0,21000,21001,7,12,0,0,21001,
+        21002,7,5,0,0,21002,21003,7,19,0,0,21003,21004,5,95,0,0,21004,21005,
+        7,15,0,0,21005,21006,7,3,0,0,21006,21007,7,6,0,0,21007,21008,7,9,
+        0,0,21008,2956,1,0,0,0,21009,21010,7,15,0,0,21010,21011,7,12,0,0,
+        21011,21012,7,5,0,0,21012,21013,7,19,0,0,21013,21014,5,95,0,0,21014,
+        21015,7,5,0,0,21015,21016,7,12,0,0,21016,21017,7,1,0,0,21017,21018,
+        7,24,0,0,21018,2958,1,0,0,0,21019,21020,7,15,0,0,21020,21021,7,25,
+        0,0,21021,21022,5,95,0,0,21022,21023,7,16,0,0,21023,21024,7,0,0,
+        0,21024,21025,7,12,0,0,21025,21026,7,11,0,0,21026,21027,7,4,0,0,
+        21027,21028,5,95,0,0,21028,21029,7,4,0,0,21029,21030,7,2,0,0,21030,
+        21031,7,11,0,0,21031,21032,7,6,0,0,21032,21033,7,3,0,0,21033,21034,
+        7,0,0,0,21034,21035,7,7,0,0,21035,21036,7,8,0,0,21036,21037,7,6,
+        0,0,21037,2960,1,0,0,0,21038,21039,7,15,0,0,21039,21040,7,25,0,0,
+        21040,21041,5,95,0,0,21041,21042,7,17,0,0,21042,21043,7,3,0,0,21043,
+        21044,7,0,0,0,21044,21045,7,7,0,0,21045,21046,7,12,0,0,21046,21047,
+        7,11,0,0,21047,21048,7,6,0,0,21048,2962,1,0,0,0,21049,21050,7,15,
+        0,0,21050,21051,7,25,0,0,21051,21052,5,95,0,0,21052,21053,7,20,0,
+        0,21053,21054,7,2,0,0,21054,21055,7,10,0,0,21055,21056,7,7,0,0,21056,
+        21057,5,95,0,0,21057,21058,7,16,0,0,21058,21059,7,10,0,0,21059,21060,
+        7,11,0,0,21060,21061,7,4,0,0,21061,21062,7,6,0,0,21062,21063,7,3,
+        0,0,21063,2964,1,0,0,0,21064,21065,7,24,0,0,21065,21066,7,1,0,0,
+        21066,21067,5,95,0,0,21067,21068,7,7,0,0,21068,21069,7,0,0,0,21069,
+        21070,7,14,0,0,21070,21071,7,6,0,0,21071,2966,1,0,0,0,21072,21073,
+        7,24,0,0,21073,21074,7,12,0,0,21074,21075,7,0,0,0,21075,21076,7,
+        3,0,0,21076,21077,7,4,0,0,21077,21078,7,6,0,0,21078,21079,7,3,0,
+        0,21079,21080,7,5,0,0,21080,2968,1,0,0,0,21081,21082,7,24,0,0,21082,
+        21083,7,12,0,0,21083,21084,7,6,0,0,21084,21085,7,3,0,0,21085,21086,
+        7,18,0,0,21086,21087,5,95,0,0,21087,21088,7,1,0,0,21088,21089,7,
+        11,0,0,21089,21090,7,2,0,0,21090,21091,7,8,0,0,21091,21092,7,21,
+        0,0,21092,2970,1,0,0,0,21093,21094,7,24,0,0,21094,21095,7,12,0,0,
+        21095,21096,7,6,0,0,21096,21097,7,3,0,0,21097,21098,7,18,0,0,21098,
+        2972,1,0,0,0,21099,21100,7,24,0,0,21100,21101,7,12,0,0,21101,21102,
+        7,6,0,0,21102,21103,7,12,0,0,21103,21104,7,6,0,0,21104,21105,5,95,
+        0,0,21105,21106,7,8,0,0,21106,21107,7,12,0,0,21107,21108,7,3,0,0,
+        21108,21109,7,3,0,0,21109,2974,1,0,0,0,21110,21111,7,24,0,0,21111,
+        21112,7,12,0,0,21112,21113,7,6,0,0,21113,21114,7,12,0,0,21114,21115,
+        7,6,0,0,21115,2976,1,0,0,0,21116,21117,7,24,0,0,21117,21118,7,12,
+        0,0,21118,21119,7,6,0,0,21119,21120,7,12,0,0,21120,21121,7,6,0,0,
+        21121,21122,5,95,0,0,21122,21123,7,3,0,0,21123,21124,7,2,0,0,21124,
+        21125,7,22,0,0,21125,21126,7,15,0,0,21126,2978,1,0,0,0,21127,21128,
+        7,24,0,0,21128,21129,7,12,0,0,21129,21130,7,10,0,0,21130,21131,7,
+        6,0,0,21131,21132,7,5,0,0,21132,21133,7,8,0,0,21133,21134,7,6,0,
+        0,21134,2980,1,0,0,0,21135,21136,7,24,0,0,21136,21137,7,12,0,0,21137,
+        21138,7,2,0,0,21138,21139,7,3,0,0,21139,21140,7,12,0,0,21140,21141,
+        7,14,0,0,21141,2982,1,0,0,0,21142,21143,7,24,0,0,21143,21144,7,12,
+        0,0,21144,21145,7,2,0,0,21145,21146,7,4,0,0,21146,21147,7,0,0,0,
+        21147,2984,1,0,0,0,21148,21149,7,24,0,0,21149,21150,7,12,0,0,21150,
+        21151,7,2,0,0,21151,21152,7,4,0,0,21152,21153,7,0,0,0,21153,21154,
+        7,17,0,0,21154,21155,7,3,0,0,21155,21156,7,2,0,0,21156,21157,7,12,
+        0,0,21157,21158,7,15,0,0,21158,2986,1,0,0,0,21159,21160,7,3,0,0,
+        21160,21161,7,0,0,0,21161,21162,7,10,0,0,21162,21163,7,5,0,0,21163,
+        21164,7,6,0,0,21164,2988,1,0,0,0,21165,21166,7,3,0,0,21166,21167,
+        7,0,0,0,21167,21168,7,7,0,0,21168,21169,7,9,0,0,21169,21170,7,2,
+        0,0,21170,21171,7,14,0,0,21171,21172,5,95,0,0,21172,21173,7,11,0,
+        0,21173,21174,7,2,0,0,21174,21175,7,8,0,0,21175,21176,7,0,0,0,21176,
+        21177,7,11,0,0,21177,2990,1,0,0,0,21178,21179,7,3,0,0,21179,21180,
+        7,0,0,0,21180,21181,7,7,0,0,21181,21182,7,9,0,0,21182,21183,7,2,
+        0,0,21183,21184,7,14,0,0,21184,2992,1,0,0,0,21185,21186,7,3,0,0,
+        21186,21187,7,0,0,0,21187,21188,7,7,0,0,21188,21189,7,17,0,0,21189,
+        21190,7,6,0,0,21190,2994,1,0,0,0,21191,21192,7,3,0,0,21192,21193,
+        7,0,0,0,21193,21194,7,7,0,0,21194,21195,7,21,0,0,21195,21196,7,14,
+        0,0,21196,2996,1,0,0,0,21197,21198,7,3,0,0,21198,21199,7,0,0,0,21199,
+        21200,7,15,0,0,21200,21201,7,10,0,0,21201,21202,7,9,0,0,21202,21203,
+        7,11,0,0,21203,21204,7,18,0,0,21204,2998,1,0,0,0,21205,21206,7,3,
+        0,0,21206,21207,7,0,0,0,21207,21208,7,22,0,0,21208,3000,1,0,0,0,
+        21209,21210,7,3,0,0,21210,21211,7,0,0,0,21211,21212,7,22,0,0,21212,
+        21213,7,4,0,0,21213,21214,7,2,0,0,21214,21215,7,19,0,0,21215,21216,
+        7,6,0,0,21216,21217,7,25,0,0,21217,3002,1,0,0,0,21218,21219,7,3,
+        0,0,21219,21220,7,0,0,0,21220,21221,7,22,0,0,21221,21222,7,4,0,0,
+        21222,21223,7,2,0,0,21223,21224,7,7,0,0,21224,21225,7,19,0,0,21225,
+        21226,7,6,0,0,21226,21227,7,25,0,0,21227,3004,1,0,0,0,21228,21229,
+        7,3,0,0,21229,21230,7,1,0,0,21230,21231,7,0,0,0,21231,3006,1,0,0,
+        0,21232,21233,7,3,0,0,21233,21234,7,1,0,0,21234,21235,7,2,0,0,21235,
+        21236,5,95,0,0,21236,21237,7,2,0,0,21237,21238,7,12,0,0,21238,21239,
+        7,4,0,0,21239,21240,7,11,0,0,21240,21241,7,10,0,0,21241,21242,7,
+        7,0,0,21242,21243,7,6,0,0,21243,3008,1,0,0,0,21244,21245,7,3,0,0,
+        21245,21246,7,8,0,0,21246,21247,7,16,0,0,21247,21248,7,10,0,0,21248,
+        21249,7,11,0,0,21249,21250,7,6,0,0,21250,3010,1,0,0,0,21251,21252,
+        7,3,0,0,21252,21253,7,9,0,0,21253,21254,7,1,0,0,21254,21255,7,0,
+        0,0,21255,3012,1,0,0,0,21256,21257,7,3,0,0,21257,21258,7,6,0,0,21258,
+        21259,7,0,0,0,21259,21260,7,9,0,0,21260,3014,1,0,0,0,21261,21262,
+        7,3,0,0,21262,21263,7,6,0,0,21263,21264,7,0,0,0,21264,21265,7,9,
+        0,0,21265,21266,7,5,0,0,21266,3016,1,0,0,0,21267,21268,7,3,0,0,21268,
+        21269,7,6,0,0,21269,21270,7,0,0,0,21270,21271,7,9,0,0,21271,21272,
+        7,5,0,0,21272,21273,7,10,0,0,21273,21274,7,23,0,0,21274,21275,7,
+        6,0,0,21275,3018,1,0,0,0,21276,21277,7,3,0,0,21277,21278,7,6,0,0,
+        21278,21279,7,0,0,0,21279,21280,7,11,0,0,21280,21281,7,14,0,0,21281,
+        3020,1,0,0,0,21282,21283,7,3,0,0,21283,21284,7,6,0,0,21284,21285,
+        7,0,0,0,21285,21286,7,11,0,0,21286,3022,1,0,0,0,21287,21288,7,3,
+        0,0,21288,21289,7,6,0,0,21289,21290,7,1,0,0,21290,21291,7,0,0,0,
+        21291,21292,7,11,0,0,21292,21293,7,0,0,0,21293,21294,7,7,0,0,21294,
+        21295,7,8,0,0,21295,21296,7,6,0,0,21296,3024,1,0,0,0,21297,21298,
+        7,3,0,0,21298,21299,7,6,0,0,21299,21300,7,1,0,0,21300,21301,7,12,
+        0,0,21301,21302,7,10,0,0,21302,21303,7,11,0,0,21303,21304,7,9,0,
+        0,21304,3026,1,0,0,0,21305,21306,7,3,0,0,21306,21307,7,6,0,0,21307,
+        21308,7,8,0,0,21308,21309,7,2,0,0,21309,21310,7,3,0,0,21310,21311,
+        7,9,0,0,21311,3028,1,0,0,0,21312,21313,7,3,0,0,21313,21314,7,6,0,
+        0,21314,21315,7,8,0,0,21315,21316,7,2,0,0,21316,21317,7,3,0,0,21317,
+        21318,7,9,0,0,21318,21319,7,5,0,0,21319,3030,1,0,0,0,21320,21321,
+        7,3,0,0,21321,21322,7,6,0,0,21322,21323,7,8,0,0,21323,21324,7,2,
+        0,0,21324,21325,7,3,0,0,21325,21326,7,9,0,0,21326,21327,7,5,0,0,
+        21327,21328,5,95,0,0,21328,21329,7,15,0,0,21329,21330,7,6,0,0,21330,
+        21331,7,3,0,0,21331,21332,5,95,0,0,21332,21333,7,1,0,0,21333,21334,
+        7,11,0,0,21334,21335,7,2,0,0,21335,21336,7,8,0,0,21336,21337,7,21,
+        0,0,21337,3032,1,0,0,0,21338,21339,7,3,0,0,21339,21340,7,6,0,0,21340,
+        21341,7,8,0,0,21341,21342,7,2,0,0,21342,21343,7,13,0,0,21343,21344,
+        7,6,0,0,21344,21345,7,3,0,0,21345,21346,7,0,0,0,21346,21347,7,1,
+        0,0,21347,21348,7,11,0,0,21348,21349,7,6,0,0,21349,3034,1,0,0,0,
+        21350,21351,7,3,0,0,21351,21352,7,6,0,0,21352,21353,7,8,0,0,21353,
+        21354,7,2,0,0,21354,21355,7,13,0,0,21355,21356,7,6,0,0,21356,21357,
+        7,3,0,0,21357,3036,1,0,0,0,21358,21359,7,3,0,0,21359,21360,7,6,0,
+        0,21360,21361,7,8,0,0,21361,21362,7,2,0,0,21362,21363,7,13,0,0,21363,
+        21364,7,6,0,0,21364,21365,7,3,0,0,21365,21366,7,18,0,0,21366,3038,
+        1,0,0,0,21367,21368,7,3,0,0,21368,21369,7,6,0,0,21369,21370,7,8,
+        0,0,21370,21371,7,18,0,0,21371,21372,7,8,0,0,21372,21373,7,11,0,
+        0,21373,21374,7,6,0,0,21374,21375,7,1,0,0,21375,21376,7,10,0,0,21376,
+        21377,7,7,0,0,21377,3040,1,0,0,0,21378,21379,7,3,0,0,21379,21380,
+        7,6,0,0,21380,21381,7,8,0,0,21381,21382,7,18,0,0,21382,21383,7,8,
+        0,0,21383,21384,7,11,0,0,21384,21385,7,6,0,0,21385,3042,1,0,0,0,
+        21386,21387,7,3,0,0,21387,21388,7,6,0,0,21388,21389,7,9,0,0,21389,
+        21390,7,0,0,0,21390,21391,7,8,0,0,21391,21392,7,4,0,0,21392,21393,
+        7,10,0,0,21393,21394,7,2,0,0,21394,21395,7,7,0,0,21395,3044,1,0,
+        0,0,21396,21397,7,3,0,0,21397,21398,7,6,0,0,21398,21399,7,9,0,0,
+        21399,21400,7,6,0,0,21400,21401,7,16,0,0,21401,21402,7,10,0,0,21402,
+        21403,7,7,0,0,21403,21404,7,6,0,0,21404,3046,1,0,0,0,21405,21406,
+        7,3,0,0,21406,21407,7,6,0,0,21407,21408,7,9,0,0,21408,21409,7,2,
+        0,0,21409,3048,1,0,0,0,21410,21411,7,3,0,0,21411,21412,7,6,0,0,21412,
+        21413,7,9,0,0,21413,21414,7,12,0,0,21414,21415,7,8,0,0,21415,21416,
+        7,6,0,0,21416,21417,7,9,0,0,21417,3050,1,0,0,0,21418,21419,7,3,0,
+        0,21419,21420,7,6,0,0,21420,21421,7,9,0,0,21421,21422,7,12,0,0,21422,
+        21423,7,7,0,0,21423,21424,7,9,0,0,21424,21425,7,0,0,0,21425,21426,
+        7,7,0,0,21426,21427,7,8,0,0,21427,21428,7,18,0,0,21428,3052,1,0,
+        0,0,21429,21430,7,3,0,0,21430,21431,7,6,0,0,21431,21432,7,16,0,0,
+        21432,21433,5,95,0,0,21433,21434,7,8,0,0,21434,21435,7,0,0,0,21435,
+        21436,7,5,0,0,21436,21437,7,8,0,0,21437,21438,7,0,0,0,21438,21439,
+        7,9,0,0,21439,21440,7,6,0,0,21440,21441,5,95,0,0,21441,21442,7,8,
+        0,0,21442,21443,7,12,0,0,21443,21444,7,3,0,0,21444,21445,7,5,0,0,
+        21445,21446,7,2,0,0,21446,21447,7,3,0,0,21447,3054,1,0,0,0,21448,
+        21449,7,3,0,0,21449,21450,7,6,0,0,21450,21451,7,16,0,0,21451,21452,
+        7,6,0,0,21452,21453,7,3,0,0,21453,21454,7,6,0,0,21454,21455,7,7,
+        0,0,21455,21456,7,8,0,0,21456,21457,7,6,0,0,21457,21458,7,9,0,0,
+        21458,3056,1,0,0,0,21459,21460,7,3,0,0,21460,21461,7,6,0,0,21461,
+        21462,7,16,0,0,21462,21463,7,6,0,0,21463,21464,7,3,0,0,21464,21465,
+        7,6,0,0,21465,21466,7,7,0,0,21466,21467,7,8,0,0,21467,21468,7,6,
+        0,0,21468,3058,1,0,0,0,21469,21470,7,3,0,0,21470,21471,7,6,0,0,21471,
+        21472,7,16,0,0,21472,21473,7,6,0,0,21473,21474,7,3,0,0,21474,21475,
+        7,6,0,0,21475,21476,7,7,0,0,21476,21477,7,8,0,0,21477,21478,7,6,
+        0,0,21478,21479,7,5,0,0,21479,3060,1,0,0,0,21480,21481,7,3,0,0,21481,
+        21482,7,6,0,0,21482,21483,7,16,0,0,21483,21484,7,6,0,0,21484,21485,
+        7,3,0,0,21485,21486,7,6,0,0,21486,21487,7,7,0,0,21487,21488,7,8,
+        0,0,21488,21489,7,10,0,0,21489,21490,7,7,0,0,21490,21491,7,17,0,
+        0,21491,3062,1,0,0,0,21492,21493,7,3,0,0,21493,21494,7,6,0,0,21494,
+        21495,7,16,0,0,21495,3064,1,0,0,0,21496,21497,7,3,0,0,21497,21498,
+        7,6,0,0,21498,21499,7,16,0,0,21499,21500,7,3,0,0,21500,21501,7,6,
+        0,0,21501,21502,7,5,0,0,21502,21503,7,19,0,0,21503,3066,1,0,0,0,
+        21504,21505,7,3,0,0,21505,21506,7,6,0,0,21506,21507,7,16,0,0,21507,
+        21508,7,4,0,0,21508,21509,7,2,0,0,21509,21510,7,19,0,0,21510,21511,
+        7,6,0,0,21511,21512,7,25,0,0,21512,3068,1,0,0,0,21513,21514,7,3,
+        0,0,21514,21515,7,6,0,0,21515,21516,7,17,0,0,21516,21517,7,6,0,0,
+        21517,21518,7,25,0,0,21518,21519,7,15,0,0,21519,21520,5,95,0,0,21520,
+        21521,7,8,0,0,21521,21522,7,2,0,0,21522,21523,7,12,0,0,21523,21524,
+        7,7,0,0,21524,21525,7,4,0,0,21525,3070,1,0,0,0,21526,21527,7,3,0,
+        0,21527,21528,7,6,0,0,21528,21529,7,17,0,0,21529,21530,7,6,0,0,21530,
+        21531,7,25,0,0,21531,21532,7,15,0,0,21532,21533,5,95,0,0,21533,21534,
+        7,10,0,0,21534,21535,7,7,0,0,21535,21536,7,5,0,0,21536,21537,7,4,
+        0,0,21537,21538,7,3,0,0,21538,3072,1,0,0,0,21539,21540,7,3,0,0,21540,
+        21541,7,6,0,0,21541,21542,7,17,0,0,21542,21543,7,6,0,0,21543,21544,
+        7,25,0,0,21544,21545,7,15,0,0,21545,21546,5,95,0,0,21546,21547,7,
+        11,0,0,21547,21548,7,10,0,0,21548,21549,7,21,0,0,21549,21550,7,6,
+        0,0,21550,3074,1,0,0,0,21551,21552,7,3,0,0,21552,21553,7,6,0,0,21553,
+        21554,7,17,0,0,21554,21555,7,6,0,0,21555,21556,7,25,0,0,21556,21557,
+        7,15,0,0,21557,21558,5,95,0,0,21558,21559,7,3,0,0,21559,21560,7,
+        6,0,0,21560,21561,7,15,0,0,21561,21562,7,11,0,0,21562,21563,7,0,
+        0,0,21563,21564,7,8,0,0,21564,21565,7,6,0,0,21565,3076,1,0,0,0,21566,
+        21567,7,3,0,0,21567,21568,7,6,0,0,21568,21569,7,17,0,0,21569,21570,
+        7,6,0,0,21570,21571,7,25,0,0,21571,21572,7,15,0,0,21572,21573,5,
+        95,0,0,21573,21574,7,5,0,0,21574,21575,7,12,0,0,21575,21576,7,1,
+        0,0,21576,21577,7,5,0,0,21577,21578,7,4,0,0,21578,21579,7,3,0,0,
+        21579,3078,1,0,0,0,21580,21581,7,3,0,0,21581,21582,7,6,0,0,21582,
+        21583,7,17,0,0,21583,21584,7,10,0,0,21584,21585,7,5,0,0,21585,21586,
+        7,4,0,0,21586,21587,7,6,0,0,21587,21588,7,3,0,0,21588,3080,1,0,0,
+        0,21589,21590,7,3,0,0,21590,21591,7,6,0,0,21591,21592,7,17,0,0,21592,
+        21593,7,3,0,0,21593,21594,5,95,0,0,21594,21595,7,0,0,0,21595,21596,
+        7,13,0,0,21596,21597,7,17,0,0,21597,21598,7,25,0,0,21598,3082,1,
+        0,0,0,21599,21600,7,3,0,0,21600,21601,7,6,0,0,21601,21602,7,17,0,
+        0,21602,21603,7,3,0,0,21603,21604,5,95,0,0,21604,21605,7,0,0,0,21605,
+        21606,7,13,0,0,21606,21607,7,17,0,0,21607,21608,7,18,0,0,21608,3084,
+        1,0,0,0,21609,21610,7,3,0,0,21610,21611,7,6,0,0,21611,21612,7,17,
+        0,0,21612,21613,7,3,0,0,21613,21614,5,95,0,0,21614,21615,7,8,0,0,
+        21615,21616,7,2,0,0,21616,21617,7,12,0,0,21617,21618,7,7,0,0,21618,
+        21619,7,4,0,0,21619,3086,1,0,0,0,21620,21621,7,3,0,0,21621,21622,
+        7,6,0,0,21622,21623,7,17,0,0,21623,21624,7,3,0,0,21624,21625,5,95,
+        0,0,21625,21626,7,10,0,0,21626,21627,7,7,0,0,21627,21628,7,4,0,0,
+        21628,21629,7,6,0,0,21629,21630,7,3,0,0,21630,21631,7,8,0,0,21631,
+        21632,7,6,0,0,21632,21633,7,15,0,0,21633,21634,7,4,0,0,21634,3088,
+        1,0,0,0,21635,21636,7,3,0,0,21636,21637,7,6,0,0,21637,21638,7,17,
+        0,0,21638,21639,7,3,0,0,21639,21640,5,95,0,0,21640,21641,7,3,0,0,
+        21641,21642,5,50,0,0,21642,3090,1,0,0,0,21643,21644,7,3,0,0,21644,
+        21645,7,6,0,0,21645,21646,7,17,0,0,21646,21647,7,3,0,0,21647,21648,
+        5,95,0,0,21648,21649,7,5,0,0,21649,21650,7,11,0,0,21650,21651,7,
+        2,0,0,21651,21652,7,15,0,0,21652,21653,7,6,0,0,21653,3092,1,0,0,
+        0,21654,21655,7,3,0,0,21655,21656,7,6,0,0,21656,21657,7,17,0,0,21657,
+        21658,7,3,0,0,21658,21659,5,95,0,0,21659,21660,7,5,0,0,21660,21661,
+        7,25,0,0,21661,21662,7,25,0,0,21662,3094,1,0,0,0,21663,21664,7,3,
+        0,0,21664,21665,7,6,0,0,21665,21666,7,17,0,0,21666,21667,7,3,0,0,
+        21667,21668,5,95,0,0,21668,21669,7,5,0,0,21669,21670,7,25,0,0,21670,
+        21671,7,18,0,0,21671,3096,1,0,0,0,21672,21673,7,3,0,0,21673,21674,
+        7,6,0,0,21674,21675,7,17,0,0,21675,21676,7,3,0,0,21676,21677,5,95,
+        0,0,21677,21678,7,5,0,0,21678,21679,7,18,0,0,21679,21680,7,18,0,
+        0,21680,3098,1,0,0,0,21681,21682,7,3,0,0,21682,21683,7,6,0,0,21683,
+        21684,7,17,0,0,21684,21685,7,12,0,0,21685,21686,7,11,0,0,21686,21687,
+        7,0,0,0,21687,21688,7,3,0,0,21688,3100,1,0,0,0,21689,21690,7,3,0,
+        0,21690,21691,7,6,0,0,21691,21692,7,20,0,0,21692,21693,7,6,0,0,21693,
+        21694,7,8,0,0,21694,21695,7,4,0,0,21695,3102,1,0,0,0,21696,21697,
+        7,3,0,0,21697,21698,7,6,0,0,21698,21699,7,21,0,0,21699,21700,7,6,
+        0,0,21700,21701,7,18,0,0,21701,3104,1,0,0,0,21702,21703,7,3,0,0,
+        21703,21704,7,6,0,0,21704,21705,7,11,0,0,21705,21706,7,0,0,0,21706,
+        21707,7,4,0,0,21707,21708,7,10,0,0,21708,21709,7,2,0,0,21709,21710,
+        7,7,0,0,21710,21711,7,0,0,0,21711,21712,7,11,0,0,21712,3106,1,0,
+        0,0,21713,21714,7,3,0,0,21714,21715,7,6,0,0,21715,21716,7,11,0,0,
+        21716,21717,7,10,0,0,21717,21718,7,6,0,0,21718,21719,7,5,0,0,21719,
+        21720,5,95,0,0,21720,21721,7,2,0,0,21721,21722,7,7,0,0,21722,3108,
+        1,0,0,0,21723,21724,7,3,0,0,21724,21725,7,6,0,0,21725,21726,7,11,
+        0,0,21726,21727,7,2,0,0,21727,21728,7,8,0,0,21728,21729,7,0,0,0,
+        21729,21730,7,4,0,0,21730,21731,7,6,0,0,21731,3110,1,0,0,0,21732,
+        21733,7,3,0,0,21733,21734,7,6,0,0,21734,21735,7,11,0,0,21735,21736,
+        7,18,0,0,21736,3112,1,0,0,0,21737,21738,7,3,0,0,21738,21739,7,6,
+        0,0,21739,21740,7,14,0,0,21740,21741,7,0,0,0,21741,21742,7,10,0,
+        0,21742,21743,7,7,0,0,21743,21744,7,9,0,0,21744,21745,7,6,0,0,21745,
+        21746,7,3,0,0,21746,3114,1,0,0,0,21747,21748,7,3,0,0,21748,21749,
+        7,6,0,0,21749,21750,7,14,0,0,21750,21751,7,2,0,0,21751,21752,7,4,
+        0,0,21752,21753,7,6,0,0,21753,3116,1,0,0,0,21754,21755,7,3,0,0,21755,
+        21756,7,6,0,0,21756,21757,7,14,0,0,21757,21758,7,2,0,0,21758,21759,
+        7,4,0,0,21759,21760,7,6,0,0,21760,21761,5,95,0,0,21761,21762,7,14,
+        0,0,21762,21763,7,0,0,0,21763,21764,7,15,0,0,21764,21765,7,15,0,
+        0,21765,21766,7,6,0,0,21766,21767,7,9,0,0,21767,3118,1,0,0,0,21768,
+        21769,7,3,0,0,21769,21770,7,6,0,0,21770,21771,7,14,0,0,21771,21772,
+        7,2,0,0,21772,21773,7,13,0,0,21773,21774,7,6,0,0,21774,3120,1,0,
+        0,0,21775,21776,7,3,0,0,21776,21777,7,6,0,0,21777,21778,7,7,0,0,
+        21778,21779,7,0,0,0,21779,21780,7,14,0,0,21780,21781,7,6,0,0,21781,
+        3122,1,0,0,0,21782,21783,7,3,0,0,21783,21784,7,6,0,0,21784,21785,
+        7,15,0,0,21785,21786,7,0,0,0,21786,21787,7,10,0,0,21787,21788,7,
+        3,0,0,21788,3124,1,0,0,0,21789,21790,7,3,0,0,21790,21791,7,6,0,0,
+        21791,21792,7,15,0,0,21792,21793,7,6,0,0,21793,21794,7,0,0,0,21794,
+        21795,7,4,0,0,21795,3126,1,0,0,0,21796,21797,7,3,0,0,21797,21798,
+        7,6,0,0,21798,21799,7,15,0,0,21799,21800,7,11,0,0,21800,21801,7,
+        0,0,0,21801,21802,7,8,0,0,21802,21803,7,6,0,0,21803,3128,1,0,0,0,
+        21804,21805,7,3,0,0,21805,21806,7,6,0,0,21806,21807,7,15,0,0,21807,
+        21808,7,11,0,0,21808,21809,7,10,0,0,21809,21810,7,8,0,0,21810,21811,
+        7,0,0,0,21811,21812,7,4,0,0,21812,21813,7,10,0,0,21813,21814,7,2,
+        0,0,21814,21815,7,7,0,0,21815,3130,1,0,0,0,21816,21817,7,3,0,0,21817,
+        21818,7,6,0,0,21818,21819,7,24,0,0,21819,21820,7,12,0,0,21820,21821,
+        7,10,0,0,21821,21822,7,3,0,0,21822,21823,7,6,0,0,21823,21824,7,9,
+        0,0,21824,3132,1,0,0,0,21825,21826,7,3,0,0,21826,21827,7,6,0,0,21827,
+        21828,7,5,0,0,21828,21829,7,6,0,0,21829,21830,7,4,0,0,21830,21831,
+        7,11,0,0,21831,21832,7,2,0,0,21832,21833,7,17,0,0,21833,21834,7,
+        5,0,0,21834,3134,1,0,0,0,21835,21836,7,3,0,0,21836,21837,7,6,0,0,
+        21837,21838,7,5,0,0,21838,21839,7,6,0,0,21839,21840,7,4,0,0,21840,
+        3136,1,0,0,0,21841,21842,7,3,0,0,21842,21843,7,6,0,0,21843,21844,
+        7,5,0,0,21844,21845,7,10,0,0,21845,21846,7,23,0,0,21846,21847,7,
+        6,0,0,21847,3138,1,0,0,0,21848,21849,7,3,0,0,21849,21850,7,6,0,0,
+        21850,21851,7,5,0,0,21851,21852,7,2,0,0,21852,21853,7,11,0,0,21853,
+        21854,7,13,0,0,21854,21855,7,6,0,0,21855,3140,1,0,0,0,21856,21857,
+        7,3,0,0,21857,21858,7,6,0,0,21858,21859,7,5,0,0,21859,21860,7,2,
+        0,0,21860,21861,7,11,0,0,21861,21862,7,13,0,0,21862,21863,7,6,0,
+        0,21863,21864,7,3,0,0,21864,3142,1,0,0,0,21865,21866,7,3,0,0,21866,
+        21867,7,6,0,0,21867,21868,7,5,0,0,21868,21869,7,2,0,0,21869,21870,
+        7,12,0,0,21870,21871,7,3,0,0,21871,21872,7,8,0,0,21872,21873,7,6,
+        0,0,21873,3144,1,0,0,0,21874,21875,7,3,0,0,21875,21876,7,6,0,0,21876,
+        21877,7,5,0,0,21877,21878,7,15,0,0,21878,21879,7,6,0,0,21879,21880,
+        7,8,0,0,21880,21881,7,4,0,0,21881,3146,1,0,0,0,21882,21883,7,3,0,
+        0,21883,21884,7,6,0,0,21884,21885,7,5,0,0,21885,21886,7,4,0,0,21886,
+        21887,7,0,0,0,21887,21888,7,3,0,0,21888,21889,7,4,0,0,21889,3148,
+        1,0,0,0,21890,21891,7,3,0,0,21891,21892,7,6,0,0,21892,21893,7,5,
+        0,0,21893,21894,7,4,0,0,21894,21895,7,2,0,0,21895,21896,7,3,0,0,
+        21896,21897,7,6,0,0,21897,21898,5,95,0,0,21898,21899,7,0,0,0,21899,
+        21900,7,5,0,0,21900,21901,5,95,0,0,21901,21902,7,10,0,0,21902,21903,
+        7,7,0,0,21903,21904,7,4,0,0,21904,21905,7,6,0,0,21905,21906,7,3,
+        0,0,21906,21907,7,13,0,0,21907,21908,7,0,0,0,21908,21909,7,11,0,
+        0,21909,21910,7,5,0,0,21910,3150,1,0,0,0,21911,21912,7,3,0,0,21912,
+        21913,7,6,0,0,21913,21914,7,5,0,0,21914,21915,7,4,0,0,21915,21916,
+        7,2,0,0,21916,21917,7,3,0,0,21917,21918,7,6,0,0,21918,3152,1,0,0,
+        0,21919,21920,7,3,0,0,21920,21921,7,6,0,0,21921,21922,7,5,0,0,21922,
+        21923,7,4,0,0,21923,21924,7,3,0,0,21924,21925,7,10,0,0,21925,21926,
+        7,8,0,0,21926,21927,7,4,0,0,21927,21928,5,95,0,0,21928,21929,7,0,
+        0,0,21929,21930,7,11,0,0,21930,21931,7,11,0,0,21931,21932,5,95,0,
+        0,21932,21933,7,3,0,0,21933,21934,7,6,0,0,21934,21935,7,16,0,0,21935,
+        21936,5,95,0,0,21936,21937,7,8,0,0,21937,21938,7,2,0,0,21938,21939,
+        7,7,0,0,21939,21940,7,5,0,0,21940,3154,1,0,0,0,21941,21942,7,3,0,
+        0,21942,21943,7,6,0,0,21943,21944,7,5,0,0,21944,21945,7,4,0,0,21945,
+        21946,7,3,0,0,21946,21947,7,10,0,0,21947,21948,7,8,0,0,21948,21949,
+        7,4,0,0,21949,21950,7,6,0,0,21950,21951,7,9,0,0,21951,3156,1,0,0,
+        0,21952,21953,7,3,0,0,21953,21954,7,6,0,0,21954,21955,7,5,0,0,21955,
+        21956,7,4,0,0,21956,21957,7,3,0,0,21957,21958,7,10,0,0,21958,21959,
+        7,8,0,0,21959,21960,7,4,0,0,21960,21961,5,95,0,0,21961,21962,7,3,
+        0,0,21962,21963,7,6,0,0,21963,21964,7,16,0,0,21964,21965,7,6,0,0,
+        21965,21966,7,3,0,0,21966,21967,7,6,0,0,21967,21968,7,7,0,0,21968,
+        21969,7,8,0,0,21969,21970,7,6,0,0,21970,21971,7,5,0,0,21971,3158,
+        1,0,0,0,21972,21973,7,3,0,0,21973,21974,7,6,0,0,21974,21975,7,5,
+        0,0,21975,21976,7,4,0,0,21976,21977,7,3,0,0,21977,21978,7,10,0,0,
+        21978,21979,7,8,0,0,21979,21980,7,4,0,0,21980,3160,1,0,0,0,21981,
+        21982,7,3,0,0,21982,21983,7,6,0,0,21983,21984,7,5,0,0,21984,21985,
+        7,12,0,0,21985,21986,7,11,0,0,21986,21987,7,4,0,0,21987,21988,5,
+        95,0,0,21988,21989,7,8,0,0,21989,21990,7,0,0,0,21990,21991,7,8,0,
+        0,21991,21992,7,19,0,0,21992,21993,7,6,0,0,21993,3162,1,0,0,0,21994,
+        21995,7,3,0,0,21995,21996,7,6,0,0,21996,21997,7,5,0,0,21997,21998,
+        7,12,0,0,21998,21999,7,11,0,0,21999,22000,7,4,0,0,22000,3164,1,0,
+        0,0,22001,22002,7,3,0,0,22002,22003,7,6,0,0,22003,22004,7,5,0,0,
+        22004,22005,7,12,0,0,22005,22006,7,14,0,0,22006,22007,7,0,0,0,22007,
+        22008,7,1,0,0,22008,22009,7,11,0,0,22009,22010,7,6,0,0,22010,3166,
+        1,0,0,0,22011,22012,7,3,0,0,22012,22013,7,6,0,0,22013,22014,7,5,
+        0,0,22014,22015,7,12,0,0,22015,22016,7,14,0,0,22016,22017,7,6,0,
+        0,22017,3168,1,0,0,0,22018,22019,7,3,0,0,22019,22020,7,6,0,0,22020,
+        22021,7,4,0,0,22021,22022,7,6,0,0,22022,22023,7,7,0,0,22023,22024,
+        7,4,0,0,22024,22025,7,10,0,0,22025,22026,7,2,0,0,22026,22027,7,7,
+        0,0,22027,3170,1,0,0,0,22028,22029,7,3,0,0,22029,22030,7,6,0,0,22030,
+        22031,7,4,0,0,22031,22032,7,3,0,0,22032,22033,7,18,0,0,22033,22034,
+        5,95,0,0,22034,22035,7,2,0,0,22035,22036,7,7,0,0,22036,22037,5,95,
+        0,0,22037,22038,7,3,0,0,22038,22039,7,2,0,0,22039,22040,7,22,0,0,
+        22040,22041,5,95,0,0,22041,22042,7,8,0,0,22042,22043,7,19,0,0,22043,
+        22044,7,0,0,0,22044,22045,7,7,0,0,22045,22046,7,17,0,0,22046,22047,
+        7,6,0,0,22047,3172,1,0,0,0,22048,22049,7,3,0,0,22049,22050,7,6,0,
+        0,22050,22051,7,4,0,0,22051,22052,7,12,0,0,22052,22053,7,3,0,0,22053,
+        22054,7,7,0,0,22054,22055,7,10,0,0,22055,22056,7,7,0,0,22056,22057,
+        7,17,0,0,22057,3174,1,0,0,0,22058,22059,7,3,0,0,22059,22060,7,6,
+        0,0,22060,22061,7,4,0,0,22061,22062,7,12,0,0,22062,22063,7,3,0,0,
+        22063,22064,7,7,0,0,22064,3176,1,0,0,0,22065,22066,7,3,0,0,22066,
+        22067,7,6,0,0,22067,22068,7,12,0,0,22068,22069,7,5,0,0,22069,22070,
+        7,6,0,0,22070,3178,1,0,0,0,22071,22072,7,3,0,0,22072,22073,7,6,0,
+        0,22073,22074,7,13,0,0,22074,22075,7,6,0,0,22075,22076,7,3,0,0,22076,
+        22077,7,5,0,0,22077,22078,7,6,0,0,22078,3180,1,0,0,0,22079,22080,
+        7,3,0,0,22080,22081,7,6,0,0,22081,22082,7,13,0,0,22082,22083,7,2,
+        0,0,22083,22084,7,21,0,0,22084,22085,7,6,0,0,22085,3182,1,0,0,0,
+        22086,22087,7,3,0,0,22087,22088,7,6,0,0,22088,22089,7,22,0,0,22089,
+        22090,7,3,0,0,22090,22091,7,10,0,0,22091,22092,7,4,0,0,22092,22093,
+        7,6,0,0,22093,22094,5,95,0,0,22094,22095,7,2,0,0,22095,22096,7,3,
+        0,0,22096,22097,5,95,0,0,22097,22098,7,6,0,0,22098,22099,7,3,0,0,
+        22099,22100,7,3,0,0,22100,22101,7,2,0,0,22101,22102,7,3,0,0,22102,
+        3184,1,0,0,0,22103,22104,7,3,0,0,22104,22105,7,6,0,0,22105,22106,
+        7,22,0,0,22106,22107,7,3,0,0,22107,22108,7,10,0,0,22108,22109,7,
+        4,0,0,22109,22110,7,6,0,0,22110,3186,1,0,0,0,22111,22112,7,3,0,0,
+        22112,22113,7,10,0,0,22113,22114,7,17,0,0,22114,22115,7,19,0,0,22115,
+        22116,7,4,0,0,22116,3188,1,0,0,0,22117,22118,7,3,0,0,22118,22119,
+        7,2,0,0,22119,22120,7,11,0,0,22120,22121,7,6,0,0,22121,3190,1,0,
+        0,0,22122,22123,7,3,0,0,22123,22124,7,2,0,0,22124,22125,7,11,0,0,
+        22125,22126,7,6,0,0,22126,22127,7,5,0,0,22127,22128,7,6,0,0,22128,
+        22129,7,4,0,0,22129,3192,1,0,0,0,22130,22131,7,3,0,0,22131,22132,
+        7,2,0,0,22132,22133,7,11,0,0,22133,22134,7,6,0,0,22134,22135,7,5,
+        0,0,22135,3194,1,0,0,0,22136,22137,7,3,0,0,22137,22138,7,2,0,0,22138,
+        22139,7,11,0,0,22139,22140,7,11,0,0,22140,22141,7,1,0,0,22141,22142,
+        7,0,0,0,22142,22143,7,8,0,0,22143,22144,7,21,0,0,22144,3196,1,0,
+        0,0,22145,22146,7,3,0,0,22146,22147,7,2,0,0,22147,22148,7,11,0,0,
+        22148,22149,7,11,0,0,22149,22150,7,10,0,0,22150,22151,7,7,0,0,22151,
+        22152,7,17,0,0,22152,3198,1,0,0,0,22153,22154,7,3,0,0,22154,22155,
+        7,2,0,0,22155,22156,7,11,0,0,22156,22157,7,11,0,0,22157,22158,7,
+        12,0,0,22158,22159,7,15,0,0,22159,3200,1,0,0,0,22160,22161,7,3,0,
+        0,22161,22162,7,2,0,0,22162,22163,7,22,0,0,22163,22164,7,9,0,0,22164,
+        22165,7,6,0,0,22165,22166,7,15,0,0,22166,22167,7,6,0,0,22167,22168,
+        7,7,0,0,22168,22169,7,9,0,0,22169,22170,7,6,0,0,22170,22171,7,7,
+        0,0,22171,22172,7,8,0,0,22172,22173,7,10,0,0,22173,22174,7,6,0,0,
+        22174,22175,7,5,0,0,22175,3202,1,0,0,0,22176,22177,7,3,0,0,22177,
+        22178,7,2,0,0,22178,22179,7,22,0,0,22179,22180,7,10,0,0,22180,22181,
+        7,9,0,0,22181,22182,5,95,0,0,22182,22183,7,14,0,0,22183,22184,7,
+        0,0,0,22184,22185,7,15,0,0,22185,22186,7,15,0,0,22186,22187,7,10,
+        0,0,22187,22188,7,7,0,0,22188,22189,7,17,0,0,22189,22190,5,95,0,
+        0,22190,22191,7,4,0,0,22191,22192,7,0,0,0,22192,22193,7,1,0,0,22193,
+        22194,7,11,0,0,22194,22195,7,6,0,0,22195,3204,1,0,0,0,22196,22197,
+        7,3,0,0,22197,22198,7,2,0,0,22198,22199,7,22,0,0,22199,22200,7,10,
+        0,0,22200,22201,7,9,0,0,22201,3206,1,0,0,0,22202,22203,7,3,0,0,22203,
+        22204,7,2,0,0,22204,22205,7,22,0,0,22205,22206,7,10,0,0,22206,22207,
+        7,9,0,0,22207,22208,7,4,0,0,22208,22209,7,2,0,0,22209,22210,7,8,
+        0,0,22210,22211,7,19,0,0,22211,22212,7,0,0,0,22212,22213,7,3,0,0,
+        22213,3208,1,0,0,0,22214,22215,7,3,0,0,22215,22216,7,2,0,0,22216,
+        22217,7,22,0,0,22217,22218,7,10,0,0,22218,22219,7,9,0,0,22219,22220,
+        7,4,0,0,22220,22221,7,2,0,0,22221,22222,7,7,0,0,22222,22223,7,8,
+        0,0,22223,22224,7,19,0,0,22224,22225,7,0,0,0,22225,22226,7,3,0,0,
+        22226,3210,1,0,0,0,22227,22228,7,3,0,0,22228,22229,7,2,0,0,22229,
+        22230,7,22,0,0,22230,22231,5,95,0,0,22231,22232,7,11,0,0,22232,22233,
+        7,6,0,0,22233,22234,7,7,0,0,22234,22235,7,17,0,0,22235,22236,7,4,
+        0,0,22236,22237,7,19,0,0,22237,3212,1,0,0,0,22238,22239,7,3,0,0,
+        22239,22240,7,2,0,0,22240,22241,7,22,0,0,22241,22242,7,7,0,0,22242,
+        22243,7,12,0,0,22243,22244,7,14,0,0,22244,3214,1,0,0,0,22245,22246,
+        7,3,0,0,22246,22247,7,2,0,0,22247,22248,7,22,0,0,22248,3216,1,0,
+        0,0,22249,22250,7,3,0,0,22250,22251,7,2,0,0,22251,22252,7,22,0,0,
+        22252,22253,7,5,0,0,22253,3218,1,0,0,0,22254,22255,7,3,0,0,22255,
+        22256,7,15,0,0,22256,22257,7,0,0,0,22257,22258,7,9,0,0,22258,3220,
+        1,0,0,0,22259,22260,7,3,0,0,22260,22261,7,4,0,0,22261,22262,7,3,
+        0,0,22262,22263,7,10,0,0,22263,22264,7,14,0,0,22264,3222,1,0,0,0,
+        22265,22266,7,3,0,0,22266,22267,7,12,0,0,22267,22268,7,11,0,0,22268,
+        22269,7,6,0,0,22269,3224,1,0,0,0,22270,22271,7,3,0,0,22271,22272,
+        7,12,0,0,22272,22273,7,11,0,0,22273,22274,7,6,0,0,22274,22275,7,
+        5,0,0,22275,3226,1,0,0,0,22276,22277,7,3,0,0,22277,22278,7,12,0,
+        0,22278,22279,7,7,0,0,22279,22280,7,7,0,0,22280,22281,7,10,0,0,22281,
+        22282,7,7,0,0,22282,22283,7,17,0,0,22283,3228,1,0,0,0,22284,22285,
+        7,5,0,0,22285,22286,7,0,0,0,22286,22287,7,11,0,0,22287,22288,7,4,
+        0,0,22288,3230,1,0,0,0,22289,22290,7,5,0,0,22290,22291,7,0,0,0,22291,
+        22292,7,14,0,0,22292,22293,7,15,0,0,22293,22294,7,11,0,0,22294,22295,
+        7,6,0,0,22295,3232,1,0,0,0,22296,22297,7,5,0,0,22297,22298,7,0,0,
+        0,22298,22299,7,13,0,0,22299,22300,7,6,0,0,22300,22301,5,95,0,0,
+        22301,22302,7,0,0,0,22302,22303,7,5,0,0,22303,22304,5,95,0,0,22304,
+        22305,7,10,0,0,22305,22306,7,7,0,0,22306,22307,7,4,0,0,22307,22308,
+        7,6,0,0,22308,22309,7,3,0,0,22309,22310,7,13,0,0,22310,22311,7,0,
+        0,0,22311,22312,7,11,0,0,22312,22313,7,5,0,0,22313,3234,1,0,0,0,
+        22314,22315,7,5,0,0,22315,22316,7,0,0,0,22316,22317,7,13,0,0,22317,
+        22318,7,6,0,0,22318,22319,7,15,0,0,22319,22320,7,2,0,0,22320,22321,
+        7,10,0,0,22321,22322,7,7,0,0,22322,22323,7,4,0,0,22323,3236,1,0,
+        0,0,22324,22325,7,5,0,0,22325,22326,7,0,0,0,22326,22327,7,13,0,0,
+        22327,22328,7,6,0,0,22328,3238,1,0,0,0,22329,22330,7,5,0,0,22330,
+        22331,7,1,0,0,22331,22332,5,52,0,0,22332,3240,1,0,0,0,22333,22334,
+        7,5,0,0,22334,22335,7,8,0,0,22335,22336,7,0,0,0,22336,22337,7,11,
+        0,0,22337,22338,7,6,0,0,22338,22339,5,95,0,0,22339,22340,7,3,0,0,
+        22340,22341,7,2,0,0,22341,22342,7,22,0,0,22342,22343,7,5,0,0,22343,
+        3242,1,0,0,0,22344,22345,7,5,0,0,22345,22346,7,8,0,0,22346,22347,
+        7,0,0,0,22347,22348,7,11,0,0,22348,22349,7,6,0,0,22349,3244,1,0,
+        0,0,22350,22351,7,5,0,0,22351,22352,7,8,0,0,22352,22353,7,0,0,0,
+        22353,22354,7,7,0,0,22354,22355,5,95,0,0,22355,22356,7,10,0,0,22356,
+        22357,7,7,0,0,22357,22358,7,5,0,0,22358,22359,7,4,0,0,22359,22360,
+        7,0,0,0,22360,22361,7,7,0,0,22361,22362,7,8,0,0,22362,22363,7,6,
+        0,0,22363,22364,7,5,0,0,22364,3246,1,0,0,0,22365,22366,7,5,0,0,22366,
+        22367,7,8,0,0,22367,22368,7,0,0,0,22368,22369,7,7,0,0,22369,3248,
+        1,0,0,0,22370,22371,7,5,0,0,22371,22372,7,8,0,0,22372,22373,7,19,
+        0,0,22373,22374,7,6,0,0,22374,22375,7,9,0,0,22375,22376,7,12,0,0,
+        22376,22377,7,11,0,0,22377,22378,7,6,0,0,22378,22379,7,3,0,0,22379,
+        3250,1,0,0,0,22380,22381,7,5,0,0,22381,22382,7,8,0,0,22382,22383,
+        7,19,0,0,22383,22384,7,6,0,0,22384,22385,7,14,0,0,22385,22386,7,
+        0,0,0,22386,22387,7,8,0,0,22387,22388,7,19,0,0,22388,22389,7,6,0,
+        0,22389,22390,7,8,0,0,22390,22391,7,21,0,0,22391,3252,1,0,0,0,22392,
+        22393,7,5,0,0,22393,22394,7,8,0,0,22394,22395,7,19,0,0,22395,22396,
+        7,6,0,0,22396,22397,7,14,0,0,22397,22398,7,0,0,0,22398,3254,1,0,
+        0,0,22399,22400,7,5,0,0,22400,22401,7,8,0,0,22401,22402,7,7,0,0,
+        22402,22403,5,95,0,0,22403,22404,7,0,0,0,22404,22405,7,5,0,0,22405,
+        22406,7,8,0,0,22406,22407,7,6,0,0,22407,22408,7,7,0,0,22408,22409,
+        7,9,0,0,22409,22410,7,10,0,0,22410,22411,7,7,0,0,22411,22412,7,17,
+        0,0,22412,3256,1,0,0,0,22413,22414,7,5,0,0,22414,22415,7,8,0,0,22415,
+        22416,7,7,0,0,22416,3258,1,0,0,0,22417,22418,7,5,0,0,22418,22419,
+        7,8,0,0,22419,22420,7,2,0,0,22420,22421,7,15,0,0,22421,22422,7,6,
+        0,0,22422,3260,1,0,0,0,22423,22424,7,5,0,0,22424,22425,7,8,0,0,22425,
+        22426,7,3,0,0,22426,22427,7,12,0,0,22427,22428,7,1,0,0,22428,3262,
+        1,0,0,0,22429,22430,7,5,0,0,22430,22431,7,9,0,0,22431,22432,5,95,
+        0,0,22432,22433,7,0,0,0,22433,22434,7,11,0,0,22434,22435,7,11,0,
+        0,22435,3264,1,0,0,0,22436,22437,7,5,0,0,22437,22438,7,9,0,0,22438,
+        22439,5,95,0,0,22439,22440,7,10,0,0,22440,22441,7,7,0,0,22441,22442,
+        7,19,0,0,22442,22443,7,10,0,0,22443,22444,7,1,0,0,22444,22445,7,
+        10,0,0,22445,22446,7,4,0,0,22446,3266,1,0,0,0,22447,22448,7,5,0,
+        0,22448,22449,7,9,0,0,22449,22450,7,2,0,0,22450,22451,5,95,0,0,22451,
+        22452,7,17,0,0,22452,22453,7,6,0,0,22453,22454,7,2,0,0,22454,22455,
+        7,14,0,0,22455,22456,5,95,0,0,22456,22457,7,14,0,0,22457,22458,7,
+        1,0,0,22458,22459,7,3,0,0,22459,3268,1,0,0,0,22460,22461,7,5,0,0,
+        22461,22462,7,9,0,0,22462,22463,7,2,0,0,22463,22464,5,95,0,0,22464,
+        22465,7,17,0,0,22465,22466,7,6,0,0,22466,22467,7,2,0,0,22467,22468,
+        7,14,0,0,22468,22469,7,6,0,0,22469,22470,7,4,0,0,22470,22471,7,3,
+        0,0,22471,22472,7,18,0,0,22472,3270,1,0,0,0,22473,22474,7,5,0,0,
+        22474,22475,7,9,0,0,22475,22476,5,95,0,0,22476,22477,7,5,0,0,22477,
+        22478,7,19,0,0,22478,22479,7,2,0,0,22479,22480,7,22,0,0,22480,3272,
+        1,0,0,0,22481,22482,7,5,0,0,22482,22483,7,6,0,0,22483,22484,7,0,
+        0,0,22484,22485,7,3,0,0,22485,22486,7,8,0,0,22486,22487,7,19,0,0,
+        22487,3274,1,0,0,0,22488,22489,7,5,0,0,22489,22490,7,6,0,0,22490,
+        22491,7,8,0,0,22491,22492,7,2,0,0,22492,22493,7,7,0,0,22493,22494,
+        7,9,0,0,22494,3276,1,0,0,0,22495,22496,7,5,0,0,22496,22497,7,6,0,
+        0,22497,22498,7,8,0,0,22498,22499,7,2,0,0,22499,22500,7,7,0,0,22500,
+        22501,7,9,0,0,22501,22502,7,5,0,0,22502,3278,1,0,0,0,22503,22504,
+        7,5,0,0,22504,22505,7,6,0,0,22505,22506,7,8,0,0,22506,22507,7,3,
+        0,0,22507,22508,7,6,0,0,22508,22509,7,4,0,0,22509,3280,1,0,0,0,22510,
+        22511,7,5,0,0,22511,22512,7,6,0,0,22512,22513,7,8,0,0,22513,22514,
+        7,12,0,0,22514,22515,7,3,0,0,22515,22516,7,6,0,0,22516,22517,7,16,
+        0,0,22517,22518,7,10,0,0,22518,22519,7,11,0,0,22519,22520,7,6,0,
+        0,22520,22521,5,95,0,0,22521,22522,7,9,0,0,22522,22523,7,1,0,0,22523,
+        22524,7,0,0,0,22524,3282,1,0,0,0,22525,22526,7,5,0,0,22526,22527,
+        7,6,0,0,22527,22528,7,8,0,0,22528,22529,7,12,0,0,22529,22530,7,3,
+        0,0,22530,22531,7,6,0,0,22531,22532,7,16,0,0,22532,22533,7,10,0,
+        0,22533,22534,7,11,0,0,22534,22535,7,6,0,0,22535,3284,1,0,0,0,22536,
+        22537,7,5,0,0,22537,22538,7,6,0,0,22538,22539,7,8,0,0,22539,22540,
+        7,12,0,0,22540,22541,7,3,0,0,22541,22542,7,10,0,0,22542,22543,7,
+        4,0,0,22543,22544,7,18,0,0,22544,3286,1,0,0,0,22545,22546,7,5,0,
+        0,22546,22547,7,6,0,0,22547,22548,7,6,0,0,22548,22549,7,9,0,0,22549,
+        3288,1,0,0,0,22550,22551,7,5,0,0,22551,22552,7,6,0,0,22552,22553,
+        7,17,0,0,22553,22554,5,95,0,0,22554,22555,7,1,0,0,22555,22556,7,
+        11,0,0,22556,22557,7,2,0,0,22557,22558,7,8,0,0,22558,22559,7,21,
+        0,0,22559,3290,1,0,0,0,22560,22561,7,5,0,0,22561,22562,7,6,0,0,22562,
+        22563,7,17,0,0,22563,22564,5,95,0,0,22564,22565,7,16,0,0,22565,22566,
+        7,10,0,0,22566,22567,7,11,0,0,22567,22568,7,6,0,0,22568,3292,1,0,
+        0,0,22569,22570,7,5,0,0,22570,22571,7,6,0,0,22571,22572,7,17,0,0,
+        22572,22573,7,14,0,0,22573,22574,7,6,0,0,22574,22575,7,7,0,0,22575,
+        22576,7,4,0,0,22576,3294,1,0,0,0,22577,22578,7,5,0,0,22578,22579,
+        7,6,0,0,22579,22580,7,11,0,0,22580,22581,7,6,0,0,22581,22582,7,8,
+        0,0,22582,22583,7,4,0,0,22583,22584,7,10,0,0,22584,22585,7,13,0,
+        0,22585,22586,7,10,0,0,22586,22587,7,4,0,0,22587,22588,7,18,0,0,
+        22588,3296,1,0,0,0,22589,22590,7,5,0,0,22590,22591,7,6,0,0,22591,
+        22592,7,11,0,0,22592,22593,7,6,0,0,22593,22594,7,8,0,0,22594,22595,
+        7,4,0,0,22595,3298,1,0,0,0,22596,22597,7,5,0,0,22597,22598,7,6,0,
+        0,22598,22599,7,11,0,0,22599,22600,7,16,0,0,22600,3300,1,0,0,0,22601,
+        22602,7,5,0,0,22602,22603,7,6,0,0,22603,22604,7,14,0,0,22604,22605,
+        7,10,0,0,22605,22606,7,20,0,0,22606,22607,7,2,0,0,22607,22608,7,
+        10,0,0,22608,22609,7,7,0,0,22609,22610,5,95,0,0,22610,22611,7,9,
+        0,0,22611,22612,7,3,0,0,22612,22613,7,10,0,0,22613,22614,7,13,0,
+        0,22614,22615,7,6,0,0,22615,22616,7,3,0,0,22616,3302,1,0,0,0,22617,
+        22618,7,5,0,0,22618,22619,7,6,0,0,22619,22620,7,14,0,0,22620,22621,
+        7,10,0,0,22621,22622,7,20,0,0,22622,22623,7,2,0,0,22623,22624,7,
+        10,0,0,22624,22625,7,7,0,0,22625,3304,1,0,0,0,22626,22627,7,5,0,
+        0,22627,22628,7,6,0,0,22628,22629,7,14,0,0,22629,22630,7,10,0,0,
+        22630,22631,5,95,0,0,22631,22632,7,4,0,0,22632,22633,7,2,0,0,22633,
+        22634,5,95,0,0,22634,22635,7,10,0,0,22635,22636,7,7,0,0,22636,22637,
+        7,7,0,0,22637,22638,7,6,0,0,22638,22639,7,3,0,0,22639,3306,1,0,0,
+        0,22640,22641,7,5,0,0,22641,22642,7,6,0,0,22642,22643,7,24,0,0,22643,
+        22644,7,12,0,0,22644,22645,7,6,0,0,22645,22646,7,7,0,0,22646,22647,
+        7,8,0,0,22647,22648,7,6,0,0,22648,22649,7,9,0,0,22649,3308,1,0,0,
+        0,22650,22651,7,5,0,0,22651,22652,7,6,0,0,22652,22653,7,24,0,0,22653,
+        22654,7,12,0,0,22654,22655,7,6,0,0,22655,22656,7,7,0,0,22656,22657,
+        7,8,0,0,22657,22658,7,6,0,0,22658,3310,1,0,0,0,22659,22660,7,5,0,
+        0,22660,22661,7,6,0,0,22661,22662,7,24,0,0,22662,22663,7,12,0,0,
+        22663,22664,7,6,0,0,22664,22665,7,7,0,0,22665,22666,7,8,0,0,22666,
+        22667,7,6,0,0,22667,22668,7,16,0,0,22668,22669,7,10,0,0,22669,22670,
+        7,11,0,0,22670,22671,7,6,0,0,22671,3312,1,0,0,0,22672,22673,7,5,
+        0,0,22673,22674,7,6,0,0,22674,22675,7,24,0,0,22675,22676,7,12,0,
+        0,22676,22677,7,6,0,0,22677,22678,7,7,0,0,22678,22679,7,4,0,0,22679,
+        22680,7,10,0,0,22680,22681,7,0,0,0,22681,22682,7,11,0,0,22682,3314,
+        1,0,0,0,22683,22684,7,5,0,0,22684,22685,7,6,0,0,22685,22686,7,24,
+        0,0,22686,3316,1,0,0,0,22687,22688,7,5,0,0,22688,22689,7,6,0,0,22689,
+        22690,7,3,0,0,22690,22691,7,9,0,0,22691,22692,7,6,0,0,22692,3318,
+        1,0,0,0,22693,22694,7,5,0,0,22694,22695,7,6,0,0,22695,22696,7,3,
+        0,0,22696,22697,7,9,0,0,22697,22698,7,6,0,0,22698,22699,7,15,0,0,
+        22699,22700,7,3,0,0,22700,22701,7,2,0,0,22701,22702,7,15,0,0,22702,
+        22703,7,6,0,0,22703,22704,7,3,0,0,22704,22705,7,4,0,0,22705,22706,
+        7,10,0,0,22706,22707,7,6,0,0,22707,22708,7,5,0,0,22708,3320,1,0,
+        0,0,22709,22710,7,5,0,0,22710,22711,7,6,0,0,22711,22712,7,3,0,0,
+        22712,22713,7,10,0,0,22713,22714,7,0,0,0,22714,22715,7,11,0,0,22715,
+        22716,7,10,0,0,22716,22717,7,23,0,0,22717,22718,7,0,0,0,22718,22719,
+        7,1,0,0,22719,22720,7,11,0,0,22720,22721,7,6,0,0,22721,3322,1,0,
+        0,0,22722,22723,7,5,0,0,22723,22724,7,6,0,0,22724,22725,7,3,0,0,
+        22725,22726,7,10,0,0,22726,22727,7,0,0,0,22727,22728,7,11,0,0,22728,
+        22729,7,11,0,0,22729,22730,7,18,0,0,22730,22731,5,95,0,0,22731,22732,
+        7,3,0,0,22732,22733,7,6,0,0,22733,22734,7,12,0,0,22734,22735,7,5,
+        0,0,22735,22736,7,0,0,0,22736,22737,7,1,0,0,22737,22738,7,11,0,0,
+        22738,22739,7,6,0,0,22739,3324,1,0,0,0,22740,22741,7,5,0,0,22741,
+        22742,7,6,0,0,22742,22743,7,3,0,0,22743,22744,7,10,0,0,22744,22745,
+        7,0,0,0,22745,22746,7,11,0,0,22746,3326,1,0,0,0,22747,22748,7,5,
+        0,0,22748,22749,7,6,0,0,22749,22750,7,3,0,0,22750,22751,7,13,0,0,
+        22751,22752,7,6,0,0,22752,22753,7,3,0,0,22753,22754,7,6,0,0,22754,
+        22755,7,3,0,0,22755,22756,7,3,0,0,22756,22757,7,2,0,0,22757,22758,
+        7,3,0,0,22758,3328,1,0,0,0,22759,22760,7,5,0,0,22760,22761,7,6,0,
+        0,22761,22762,7,3,0,0,22762,22763,7,13,0,0,22763,22764,7,10,0,0,
+        22764,22765,7,8,0,0,22765,22766,7,6,0,0,22766,22767,5,95,0,0,22767,
+        22768,7,7,0,0,22768,22769,7,0,0,0,22769,22770,7,14,0,0,22770,22771,
+        7,6,0,0,22771,22772,5,95,0,0,22772,22773,7,8,0,0,22773,22774,7,2,
+        0,0,22774,22775,7,7,0,0,22775,22776,7,13,0,0,22776,22777,7,6,0,0,
+        22777,22778,7,3,0,0,22778,22779,7,4,0,0,22779,3330,1,0,0,0,22780,
+        22781,7,5,0,0,22781,22782,7,6,0,0,22782,22783,7,3,0,0,22783,22784,
+        7,13,0,0,22784,22785,7,10,0,0,22785,22786,7,8,0,0,22786,22787,7,
+        6,0,0,22787,3332,1,0,0,0,22788,22789,7,5,0,0,22789,22790,7,6,0,0,
+        22790,22791,7,3,0,0,22791,22792,7,13,0,0,22792,22793,7,10,0,0,22793,
+        22794,7,8,0,0,22794,22795,7,6,0,0,22795,22796,7,5,0,0,22796,3334,
+        1,0,0,0,22797,22798,7,5,0,0,22798,22799,7,6,0,0,22799,22800,7,5,
+        0,0,22800,22801,7,5,0,0,22801,22802,7,10,0,0,22802,22803,7,2,0,0,
+        22803,22804,7,7,0,0,22804,22805,5,95,0,0,22805,22806,7,8,0,0,22806,
+        22807,7,0,0,0,22807,22808,7,8,0,0,22808,22809,7,19,0,0,22809,22810,
+        7,6,0,0,22810,22811,7,9,0,0,22811,22812,5,95,0,0,22812,22813,7,8,
+        0,0,22813,22814,7,12,0,0,22814,22815,7,3,0,0,22815,22816,7,5,0,0,
+        22816,22817,7,2,0,0,22817,22818,7,3,0,0,22818,22819,7,5,0,0,22819,
+        3336,1,0,0,0,22820,22821,7,5,0,0,22821,22822,7,6,0,0,22822,22823,
+        7,5,0,0,22823,22824,7,5,0,0,22824,22825,7,10,0,0,22825,22826,7,2,
+        0,0,22826,22827,7,7,0,0,22827,3338,1,0,0,0,22828,22829,7,5,0,0,22829,
+        22830,7,6,0,0,22830,22831,7,5,0,0,22831,22832,7,5,0,0,22832,22833,
+        7,10,0,0,22833,22834,7,2,0,0,22834,22835,7,7,0,0,22835,22836,7,5,
+        0,0,22836,22837,5,95,0,0,22837,22838,7,15,0,0,22838,22839,7,6,0,
+        0,22839,22840,7,3,0,0,22840,22841,5,95,0,0,22841,22842,7,12,0,0,
+        22842,22843,7,5,0,0,22843,22844,7,6,0,0,22844,22845,7,3,0,0,22845,
+        3340,1,0,0,0,22846,22847,7,5,0,0,22847,22848,7,6,0,0,22848,22849,
+        7,5,0,0,22849,22850,7,5,0,0,22850,22851,7,10,0,0,22851,22852,7,2,
+        0,0,22852,22853,7,7,0,0,22853,22854,7,4,0,0,22854,22855,7,10,0,0,
+        22855,22856,7,14,0,0,22856,22857,7,6,0,0,22857,22858,7,23,0,0,22858,
+        22859,7,2,0,0,22859,22860,7,7,0,0,22860,22861,7,6,0,0,22861,3342,
+        1,0,0,0,22862,22863,7,5,0,0,22863,22864,7,6,0,0,22864,22865,7,5,
+        0,0,22865,22866,7,5,0,0,22866,22867,7,10,0,0,22867,22868,7,2,0,0,
+        22868,22869,7,7,0,0,22869,22870,7,4,0,0,22870,22871,7,23,0,0,22871,
+        22872,7,7,0,0,22872,22873,7,0,0,0,22873,22874,7,14,0,0,22874,22875,
+        7,6,0,0,22875,3344,1,0,0,0,22876,22877,7,5,0,0,22877,22878,7,6,0,
+        0,22878,22879,7,4,0,0,22879,3346,1,0,0,0,22880,22881,7,5,0,0,22881,
+        22882,7,6,0,0,22882,22883,7,4,0,0,22883,22884,7,5,0,0,22884,3348,
+        1,0,0,0,22885,22886,7,5,0,0,22886,22887,7,6,0,0,22887,22888,7,4,
+        0,0,22888,22889,7,4,0,0,22889,22890,7,10,0,0,22890,22891,7,7,0,0,
+        22891,22892,7,17,0,0,22892,22893,7,5,0,0,22893,3350,1,0,0,0,22894,
+        22895,7,5,0,0,22895,22896,7,6,0,0,22896,22897,7,4,0,0,22897,22898,
+        5,95,0,0,22898,22899,7,4,0,0,22899,22900,7,2,0,0,22900,22901,5,95,
+        0,0,22901,22902,7,20,0,0,22902,22903,7,2,0,0,22903,22904,7,10,0,
+        0,22904,22905,7,7,0,0,22905,3352,1,0,0,0,22906,22907,7,5,0,0,22907,
+        22908,7,6,0,0,22908,22909,7,13,0,0,22909,22910,7,6,0,0,22910,22911,
+        7,3,0,0,22911,22912,7,6,0,0,22912,3354,1,0,0,0,22913,22914,7,5,0,
+        0,22914,22915,7,19,0,0,22915,22916,7,0,0,0,22916,22917,7,3,0,0,22917,
+        22918,7,9,0,0,22918,3356,1,0,0,0,22919,22920,7,5,0,0,22920,22921,
+        7,19,0,0,22921,22922,7,0,0,0,22922,22923,7,3,0,0,22923,22924,7,9,
+        0,0,22924,22925,7,5,0,0,22925,22926,7,15,0,0,22926,22927,7,0,0,0,
+        22927,22928,7,8,0,0,22928,22929,7,6,0,0,22929,3358,1,0,0,0,22930,
+        22931,7,5,0,0,22931,22932,7,19,0,0,22932,22933,7,0,0,0,22933,22934,
+        7,3,0,0,22934,22935,7,6,0,0,22935,22936,7,9,0,0,22936,22937,5,95,
+        0,0,22937,22938,7,15,0,0,22938,22939,7,2,0,0,22939,22940,7,2,0,0,
+        22940,22941,7,11,0,0,22941,3360,1,0,0,0,22942,22943,7,5,0,0,22943,
+        22944,7,19,0,0,22944,22945,7,0,0,0,22945,22946,7,3,0,0,22946,22947,
+        7,6,0,0,22947,22948,7,9,0,0,22948,3362,1,0,0,0,22949,22950,7,5,0,
+        0,22950,22951,7,19,0,0,22951,22952,7,0,0,0,22952,22953,7,3,0,0,22953,
+        22954,7,6,0,0,22954,3364,1,0,0,0,22955,22956,7,5,0,0,22956,22957,
+        7,19,0,0,22957,22958,7,0,0,0,22958,22959,7,3,0,0,22959,22960,7,10,
+        0,0,22960,22961,7,7,0,0,22961,22962,7,17,0,0,22962,3366,1,0,0,0,
+        22963,22964,7,5,0,0,22964,22965,7,19,0,0,22965,22966,7,6,0,0,22966,
+        22967,7,11,0,0,22967,22968,7,16,0,0,22968,22969,7,11,0,0,22969,22970,
+        7,10,0,0,22970,22971,7,16,0,0,22971,22972,7,6,0,0,22972,3368,1,0,
+        0,0,22973,22974,7,5,0,0,22974,22975,7,19,0,0,22975,22976,7,2,0,0,
+        22976,22977,7,22,0,0,22977,3370,1,0,0,0,22978,22979,7,5,0,0,22979,
+        22980,7,19,0,0,22980,22981,7,3,0,0,22981,22982,7,10,0,0,22982,22983,
+        7,7,0,0,22983,22984,7,21,0,0,22984,3372,1,0,0,0,22985,22986,7,5,
+        0,0,22986,22987,7,19,0,0,22987,22988,7,12,0,0,22988,22989,7,4,0,
+        0,22989,22990,7,9,0,0,22990,22991,7,2,0,0,22991,22992,7,22,0,0,22992,
+        22993,7,7,0,0,22993,3374,1,0,0,0,22994,22995,7,5,0,0,22995,22996,
+        7,10,0,0,22996,22997,7,1,0,0,22997,22998,7,11,0,0,22998,22999,7,
+        10,0,0,22999,23000,7,7,0,0,23000,23001,7,17,0,0,23001,23002,7,5,
+        0,0,23002,3376,1,0,0,0,23003,23004,7,5,0,0,23004,23005,7,10,0,0,
+        23005,23006,7,9,0,0,23006,3378,1,0,0,0,23007,23008,7,5,0,0,23008,
+        23009,7,10,0,0,23009,23010,7,4,0,0,23010,23011,7,6,0,0,23011,3380,
+        1,0,0,0,23012,23013,7,5,0,0,23013,23014,7,10,0,0,23014,23015,7,17,
+        0,0,23015,23016,7,7,0,0,23016,23017,7,0,0,0,23017,23018,7,11,0,0,
+        23018,23019,5,95,0,0,23019,23020,7,8,0,0,23020,23021,7,2,0,0,23021,
+        23022,7,14,0,0,23022,23023,7,15,0,0,23023,23024,7,2,0,0,23024,23025,
+        7,7,0,0,23025,23026,7,6,0,0,23026,23027,7,7,0,0,23027,23028,7,4,
+        0,0,23028,3382,1,0,0,0,23029,23030,7,5,0,0,23030,23031,7,10,0,0,
+        23031,23032,7,17,0,0,23032,23033,7,7,0,0,23033,23034,7,0,0,0,23034,
+        23035,7,11,0,0,23035,23036,5,95,0,0,23036,23037,7,16,0,0,23037,23038,
+        7,12,0,0,23038,23039,7,7,0,0,23039,23040,7,8,0,0,23040,23041,7,4,
+        0,0,23041,23042,7,10,0,0,23042,23043,7,2,0,0,23043,23044,7,7,0,0,
+        23044,3384,1,0,0,0,23045,23046,7,5,0,0,23046,23047,7,10,0,0,23047,
+        23048,7,17,0,0,23048,23049,7,7,0,0,23049,3386,1,0,0,0,23050,23051,
+        7,5,0,0,23051,23052,7,10,0,0,23052,23053,7,17,0,0,23053,23054,7,
+        7,0,0,23054,23055,7,4,0,0,23055,23056,7,18,0,0,23056,23057,7,15,
+        0,0,23057,23058,7,6,0,0,23058,3388,1,0,0,0,23059,23060,7,5,0,0,23060,
+        23061,7,10,0,0,23061,23062,7,14,0,0,23062,23063,7,15,0,0,23063,23064,
+        7,11,0,0,23064,23065,7,6,0,0,23065,23066,5,95,0,0,23066,23067,7,
+        10,0,0,23067,23068,7,7,0,0,23068,23069,7,4,0,0,23069,23070,7,6,0,
+        0,23070,23071,7,17,0,0,23071,23072,7,6,0,0,23072,23073,7,3,0,0,23073,
+        3390,1,0,0,0,23074,23075,7,5,0,0,23075,23076,7,10,0,0,23076,23077,
+        7,14,0,0,23077,23078,7,15,0,0,23078,23079,7,11,0,0,23079,23080,7,
+        6,0,0,23080,3392,1,0,0,0,23081,23082,7,5,0,0,23082,23083,7,10,0,
+        0,23083,23084,7,7,0,0,23084,23085,7,17,0,0,23085,23086,7,11,0,0,
+        23086,23087,7,6,0,0,23087,3394,1,0,0,0,23088,23089,7,5,0,0,23089,
+        23090,7,10,0,0,23090,23091,7,7,0,0,23091,23092,7,17,0,0,23092,23093,
+        7,11,0,0,23093,23094,7,6,0,0,23094,23095,7,4,0,0,23095,23096,7,0,
+        0,0,23096,23097,7,5,0,0,23097,23098,7,21,0,0,23098,3396,1,0,0,0,
+        23099,23100,7,5,0,0,23100,23101,7,10,0,0,23101,23102,7,7,0,0,23102,
+        23103,7,19,0,0,23103,3398,1,0,0,0,23104,23105,7,5,0,0,23105,23106,
+        7,10,0,0,23106,23107,7,7,0,0,23107,3400,1,0,0,0,23108,23109,7,5,
+        0,0,23109,23110,7,10,0,0,23110,23111,7,23,0,0,23111,23112,7,6,0,
+        0,23112,3402,1,0,0,0,23113,23114,7,5,0,0,23114,23115,7,10,0,0,23115,
+        23116,7,23,0,0,23116,23117,7,6,0,0,23117,23118,7,5,0,0,23118,3404,
+        1,0,0,0,23119,23120,7,5,0,0,23120,23121,7,21,0,0,23121,23122,7,10,
+        0,0,23122,23123,7,15,0,0,23123,23124,5,95,0,0,23124,23125,7,6,0,
+        0,23125,23126,7,25,0,0,23126,23127,7,4,0,0,23127,23128,5,95,0,0,
+        23128,23129,7,2,0,0,23129,23130,7,15,0,0,23130,23131,7,4,0,0,23131,
+        23132,7,10,0,0,23132,23133,7,14,0,0,23133,23134,7,10,0,0,23134,23135,
+        7,23,0,0,23135,23136,7,6,0,0,23136,23137,7,3,0,0,23137,3406,1,0,
+        0,0,23138,23139,7,5,0,0,23139,23140,7,21,0,0,23140,23141,7,10,0,
+        0,23141,23142,7,15,0,0,23142,3408,1,0,0,0,23143,23144,7,5,0,0,23144,
+        23145,7,21,0,0,23145,23146,7,10,0,0,23146,23147,7,15,0,0,23147,23148,
+        5,95,0,0,23148,23149,7,12,0,0,23149,23150,7,7,0,0,23150,23151,7,
+        24,0,0,23151,23152,5,95,0,0,23152,23153,7,12,0,0,23153,23154,7,7,
+        0,0,23154,23155,7,12,0,0,23155,23156,7,5,0,0,23156,23157,7,0,0,0,
+        23157,23158,7,1,0,0,23158,23159,7,11,0,0,23159,23160,7,6,0,0,23160,
+        23161,5,95,0,0,23161,23162,7,10,0,0,23162,23163,7,9,0,0,23163,23164,
+        7,25,0,0,23164,3410,1,0,0,0,23165,23166,7,5,0,0,23166,23167,7,21,
+        0,0,23167,23168,7,10,0,0,23168,23169,7,15,0,0,23169,23170,5,95,0,
+        0,23170,23171,7,12,0,0,23171,23172,7,7,0,0,23172,23173,7,12,0,0,
+        23173,23174,7,5,0,0,23174,23175,7,0,0,0,23175,23176,7,1,0,0,23176,
+        23177,7,11,0,0,23177,23178,7,6,0,0,23178,23179,5,95,0,0,23179,23180,
+        7,10,0,0,23180,23181,7,7,0,0,23181,23182,7,9,0,0,23182,23183,7,6,
+        0,0,23183,23184,7,25,0,0,23184,23185,7,6,0,0,23185,23186,7,5,0,0,
+        23186,3412,1,0,0,0,23187,23188,7,5,0,0,23188,23189,7,14,0,0,23189,
+        23190,7,0,0,0,23190,23191,7,11,0,0,23191,23192,7,11,0,0,23192,23193,
+        7,16,0,0,23193,23194,7,10,0,0,23194,23195,7,11,0,0,23195,23196,7,
+        6,0,0,23196,3414,1,0,0,0,23197,23198,7,5,0,0,23198,23199,7,14,0,
+        0,23199,23200,7,0,0,0,23200,23201,7,11,0,0,23201,23202,7,11,0,0,
+        23202,23203,7,10,0,0,23203,23204,7,7,0,0,23204,23205,7,4,0,0,23205,
+        3416,1,0,0,0,23206,23207,7,5,0,0,23207,23208,7,7,0,0,23208,23209,
+        7,0,0,0,23209,23210,7,15,0,0,23210,23211,7,5,0,0,23211,23212,7,19,
+        0,0,23212,23213,7,2,0,0,23213,23214,7,4,0,0,23214,3418,1,0,0,0,23215,
+        23216,7,5,0,0,23216,23217,7,2,0,0,23217,23218,7,14,0,0,23218,23219,
+        7,6,0,0,23219,3420,1,0,0,0,23220,23221,7,5,0,0,23221,23222,7,2,0,
+        0,23222,23223,7,3,0,0,23223,23224,7,4,0,0,23224,3422,1,0,0,0,23225,
+        23226,7,5,0,0,23226,23227,7,2,0,0,23227,23228,7,12,0,0,23228,23229,
+        7,7,0,0,23229,23230,7,9,0,0,23230,23231,7,6,0,0,23231,23232,7,25,
+        0,0,23232,3424,1,0,0,0,23233,23234,7,5,0,0,23234,23235,7,2,0,0,23235,
+        23236,7,12,0,0,23236,23237,7,3,0,0,23237,23238,7,8,0,0,23238,23239,
+        7,6,0,0,23239,23240,5,95,0,0,23240,23241,7,16,0,0,23241,23242,7,
+        10,0,0,23242,23243,7,11,0,0,23243,23244,7,6,0,0,23244,23245,5,95,
+        0,0,23245,23246,7,9,0,0,23246,23247,7,10,0,0,23247,23248,7,3,0,0,
+        23248,23249,7,6,0,0,23249,23250,7,8,0,0,23250,23251,7,4,0,0,23251,
+        23252,7,2,0,0,23252,23253,7,3,0,0,23253,23254,7,18,0,0,23254,3426,
+        1,0,0,0,23255,23256,7,5,0,0,23256,23257,7,2,0,0,23257,23258,7,12,
+        0,0,23258,23259,7,3,0,0,23259,23260,7,8,0,0,23260,23261,7,6,0,0,
+        23261,23262,5,95,0,0,23262,23263,7,16,0,0,23263,23264,7,10,0,0,23264,
+        23265,7,11,0,0,23265,23266,7,6,0,0,23266,23267,5,95,0,0,23267,23268,
+        7,7,0,0,23268,23269,7,0,0,0,23269,23270,7,14,0,0,23270,23271,7,6,
+        0,0,23271,23272,5,95,0,0,23272,23273,7,8,0,0,23273,23274,7,2,0,0,
+        23274,23275,7,7,0,0,23275,23276,7,13,0,0,23276,23277,7,6,0,0,23277,
+        23278,7,3,0,0,23278,23279,7,4,0,0,23279,3428,1,0,0,0,23280,23281,
+        7,5,0,0,23281,23282,7,2,0,0,23282,23283,7,12,0,0,23283,23284,7,3,
+        0,0,23284,23285,7,8,0,0,23285,23286,7,6,0,0,23286,3430,1,0,0,0,23287,
+        23288,7,5,0,0,23288,23289,7,15,0,0,23289,23290,7,0,0,0,23290,23291,
+        7,8,0,0,23291,23292,7,6,0,0,23292,3432,1,0,0,0,23293,23294,7,5,0,
+        0,23294,23295,7,15,0,0,23295,23296,7,6,0,0,23296,23297,7,8,0,0,23297,
+        23298,7,10,0,0,23298,23299,7,16,0,0,23299,23300,7,10,0,0,23300,23301,
+        7,8,0,0,23301,23302,7,0,0,0,23302,23303,7,4,0,0,23303,23304,7,10,
+        0,0,23304,23305,7,2,0,0,23305,23306,7,7,0,0,23306,3434,1,0,0,0,23307,
+        23308,7,5,0,0,23308,23309,7,15,0,0,23309,23310,7,16,0,0,23310,23311,
+        7,10,0,0,23311,23312,7,11,0,0,23312,23313,7,6,0,0,23313,3436,1,0,
+        0,0,23314,23315,7,5,0,0,23315,23316,7,15,0,0,23316,23317,7,11,0,
+        0,23317,23318,7,10,0,0,23318,23319,7,4,0,0,23319,3438,1,0,0,0,23320,
+        23321,7,5,0,0,23321,23322,7,15,0,0,23322,23323,7,3,0,0,23323,23324,
+        7,6,0,0,23324,23325,7,0,0,0,23325,23326,7,9,0,0,23326,23327,7,5,
+        0,0,23327,23328,7,19,0,0,23328,23329,7,6,0,0,23329,23330,7,6,0,0,
+        23330,23331,7,4,0,0,23331,3440,1,0,0,0,23332,23333,7,5,0,0,23333,
+        23334,7,24,0,0,23334,23335,7,11,0,0,23335,23336,7,9,0,0,23336,23337,
+        7,0,0,0,23337,23338,7,4,0,0,23338,23339,7,0,0,0,23339,3442,1,0,0,
+        0,23340,23341,7,5,0,0,23341,23342,7,24,0,0,23342,23343,7,11,0,0,
+        23343,23344,7,6,0,0,23344,23345,7,3,0,0,23345,23346,7,3,0,0,23346,
+        23347,7,2,0,0,23347,23348,7,3,0,0,23348,3444,1,0,0,0,23349,23350,
+        7,5,0,0,23350,23351,7,24,0,0,23351,23352,7,11,0,0,23352,23353,7,
+        11,0,0,23353,23354,7,9,0,0,23354,23355,7,3,0,0,23355,3446,1,0,0,
+        0,23356,23357,7,5,0,0,23357,23358,7,24,0,0,23358,23359,7,11,0,0,
+        23359,3448,1,0,0,0,23360,23361,7,16,0,0,23361,23362,7,7,0,0,23362,
+        23378,7,8,0,0,23363,23364,7,15,0,0,23364,23365,7,21,0,0,23365,23378,
+        7,1,0,0,23366,23367,7,15,0,0,23367,23368,7,21,0,0,23368,23378,7,
+        5,0,0,23369,23370,7,15,0,0,23370,23371,7,3,0,0,23371,23378,7,8,0,
+        0,23372,23373,7,4,0,0,23373,23374,7,3,0,0,23374,23378,7,17,0,0,23375,
+        23376,7,13,0,0,23376,23378,7,22,0,0,23377,23360,1,0,0,0,23377,23363,
+        1,0,0,0,23377,23366,1,0,0,0,23377,23369,1,0,0,0,23377,23372,1,0,
+        0,0,23377,23375,1,0,0,0,23378,3450,1,0,0,0,23379,23380,7,5,0,0,23380,
+        23381,7,24,0,0,23381,23382,7,11,0,0,23382,23383,5,95,0,0,23383,23384,
+        7,14,0,0,23384,23385,7,0,0,0,23385,23386,7,8,0,0,23386,23387,7,3,
+        0,0,23387,23388,7,2,0,0,23388,3452,1,0,0,0,23389,23390,7,5,0,0,23390,
+        23391,7,24,0,0,23391,23392,7,11,0,0,23392,23393,5,95,0,0,23393,23394,
+        7,4,0,0,23394,23395,7,3,0,0,23395,23396,7,0,0,0,23396,23397,7,8,
+        0,0,23397,23398,7,6,0,0,23398,3454,1,0,0,0,23399,23400,7,5,0,0,23400,
+        23401,7,24,0,0,23401,23402,7,11,0,0,23402,23403,5,95,0,0,23403,23404,
+        7,4,0,0,23404,23405,7,3,0,0,23405,23406,7,0,0,0,23406,23407,7,7,
+        0,0,23407,23408,7,5,0,0,23408,23409,7,11,0,0,23409,23410,7,0,0,0,
+        23410,23411,7,4,0,0,23411,23412,7,10,0,0,23412,23413,7,2,0,0,23413,
+        23414,7,7,0,0,23414,23415,5,95,0,0,23415,23416,7,15,0,0,23416,23417,
+        7,3,0,0,23417,23418,7,2,0,0,23418,23419,7,16,0,0,23419,23420,7,10,
+        0,0,23420,23421,7,11,0,0,23421,23422,7,6,0,0,23422,3456,1,0,0,0,
+        23423,23424,7,5,0,0,23424,23425,7,24,0,0,23425,23426,7,3,0,0,23426,
+        23427,7,4,0,0,23427,3458,1,0,0,0,23428,23429,7,5,0,0,23429,23430,
+        7,4,0,0,23430,23431,7,0,0,0,23431,23432,7,11,0,0,23432,23433,7,6,
+        0,0,23433,3460,1,0,0,0,23434,23435,7,5,0,0,23435,23436,7,4,0,0,23436,
+        23437,7,0,0,0,23437,23438,7,7,0,0,23438,23439,7,9,0,0,23439,23440,
+        7,0,0,0,23440,23441,7,11,0,0,23441,23442,7,2,0,0,23442,23443,7,7,
+        0,0,23443,23444,7,6,0,0,23444,3462,1,0,0,0,23445,23446,7,5,0,0,23446,
+        23447,7,4,0,0,23447,23448,7,0,0,0,23448,23449,7,7,0,0,23449,23450,
+        7,9,0,0,23450,23451,7,0,0,0,23451,23452,7,3,0,0,23452,23453,7,9,
+        0,0,23453,3464,1,0,0,0,23454,23455,7,5,0,0,23455,23456,7,4,0,0,23456,
+        23457,7,0,0,0,23457,23458,7,7,0,0,23458,23459,7,9,0,0,23459,23460,
+        7,0,0,0,23460,23461,7,3,0,0,23461,23462,7,9,0,0,23462,23463,5,95,
+        0,0,23463,23464,7,19,0,0,23464,23465,7,0,0,0,23465,23466,7,5,0,0,
+        23466,23467,7,19,0,0,23467,3466,1,0,0,0,23468,23469,7,5,0,0,23469,
+        23470,7,4,0,0,23470,23471,7,0,0,0,23471,23472,7,7,0,0,23472,23473,
+        7,9,0,0,23473,23474,7,1,0,0,23474,23475,7,18,0,0,23475,23476,5,95,
+        0,0,23476,23477,7,14,0,0,23477,23478,7,0,0,0,23478,23479,7,25,0,
+        0,23479,23480,5,95,0,0,23480,23481,7,9,0,0,23481,23482,7,0,0,0,23482,
+        23483,7,4,0,0,23483,23484,7,0,0,0,23484,23485,5,95,0,0,23485,23486,
+        7,9,0,0,23486,23487,7,6,0,0,23487,23488,7,11,0,0,23488,23489,7,0,
+        0,0,23489,23490,7,18,0,0,23490,3468,1,0,0,0,23491,23492,7,5,0,0,
+        23492,23493,7,4,0,0,23493,23494,7,0,0,0,23494,23495,7,7,0,0,23495,
+        23496,7,9,0,0,23496,23497,7,1,0,0,23497,23498,7,18,0,0,23498,23499,
+        7,5,0,0,23499,3470,1,0,0,0,23500,23501,7,5,0,0,23501,23502,7,4,0,
+        0,23502,23503,7,0,0,0,23503,23504,7,7,0,0,23504,23505,7,9,0,0,23505,
+        23506,7,1,0,0,23506,23507,7,18,0,0,23507,3472,1,0,0,0,23508,23509,
+        7,5,0,0,23509,23510,7,4,0,0,23510,23511,7,0,0,0,23511,23512,7,3,
+        0,0,23512,3474,1,0,0,0,23513,23514,7,5,0,0,23514,23515,7,4,0,0,23515,
+        23516,7,0,0,0,23516,23517,7,3,0,0,23517,23518,5,95,0,0,23518,23519,
+        7,4,0,0,23519,23520,7,3,0,0,23520,23521,7,0,0,0,23521,23522,7,7,
+        0,0,23522,23523,7,5,0,0,23523,23524,7,16,0,0,23524,23525,7,2,0,0,
+        23525,23526,7,3,0,0,23526,23527,7,14,0,0,23527,23528,7,0,0,0,23528,
+        23529,7,4,0,0,23529,23530,7,10,0,0,23530,23531,7,2,0,0,23531,23532,
+        7,7,0,0,23532,3476,1,0,0,0,23533,23534,7,5,0,0,23534,23535,7,4,0,
+        0,23535,23536,7,0,0,0,23536,23537,7,3,0,0,23537,23538,7,4,0,0,23538,
+        3478,1,0,0,0,23539,23540,7,5,0,0,23540,23541,7,4,0,0,23541,23542,
+        7,0,0,0,23542,23543,7,3,0,0,23543,23544,7,4,0,0,23544,23545,7,2,
+        0,0,23545,23546,7,16,0,0,23546,3480,1,0,0,0,23547,23548,7,5,0,0,
+        23548,23549,7,4,0,0,23549,23550,7,0,0,0,23550,23551,7,3,0,0,23551,
+        23552,7,4,0,0,23552,23553,7,12,0,0,23553,23554,7,15,0,0,23554,3482,
+        1,0,0,0,23555,23556,7,5,0,0,23556,23557,7,4,0,0,23557,23558,7,0,
+        0,0,23558,23559,7,4,0,0,23559,23560,7,6,0,0,23560,23561,7,14,0,0,
+        23561,23562,7,6,0,0,23562,23563,7,7,0,0,23563,23564,7,4,0,0,23564,
+        23565,5,95,0,0,23565,23566,7,10,0,0,23566,23567,7,9,0,0,23567,3484,
+        1,0,0,0,23568,23569,7,5,0,0,23569,23570,7,4,0,0,23570,23571,7,0,
+        0,0,23571,23572,7,4,0,0,23572,23573,7,6,0,0,23573,23574,7,14,0,0,
+        23574,23575,7,6,0,0,23575,23576,7,7,0,0,23576,23577,7,4,0,0,23577,
+        23578,5,95,0,0,23578,23579,7,24,0,0,23579,23580,7,12,0,0,23580,23581,
+        7,6,0,0,23581,23582,7,12,0,0,23582,23583,7,10,0,0,23583,23584,7,
+        7,0,0,23584,23585,7,17,0,0,23585,3486,1,0,0,0,23586,23587,7,5,0,
+        0,23587,23588,7,4,0,0,23588,23589,7,0,0,0,23589,23590,7,4,0,0,23590,
+        23591,7,6,0,0,23591,23592,7,14,0,0,23592,23593,7,6,0,0,23593,23594,
+        7,7,0,0,23594,23595,7,4,0,0,23595,23596,7,5,0,0,23596,3488,1,0,0,
+        0,23597,23598,7,5,0,0,23598,23599,7,4,0,0,23599,23600,7,0,0,0,23600,
+        23601,7,4,0,0,23601,23602,7,6,0,0,23602,23603,7,14,0,0,23603,23604,
+        7,6,0,0,23604,23605,7,7,0,0,23605,23606,7,4,0,0,23606,3490,1,0,0,
+        0,23607,23608,7,5,0,0,23608,23609,7,4,0,0,23609,23610,7,0,0,0,23610,
+        23611,7,4,0,0,23611,23612,7,6,0,0,23612,3492,1,0,0,0,23613,23614,
+        7,5,0,0,23614,23615,7,4,0,0,23615,23616,7,0,0,0,23616,23617,7,4,
+        0,0,23617,23618,7,10,0,0,23618,23619,7,8,0,0,23619,3494,1,0,0,0,
+        23620,23621,7,5,0,0,23621,23622,7,4,0,0,23622,23623,7,0,0,0,23623,
+        23624,7,4,0,0,23624,23625,7,10,0,0,23625,23626,7,5,0,0,23626,23627,
+        7,4,0,0,23627,23628,7,10,0,0,23628,23629,7,8,0,0,23629,23630,7,5,
+        0,0,23630,3496,1,0,0,0,23631,23632,7,5,0,0,23632,23633,7,4,0,0,23633,
+        23634,7,0,0,0,23634,23635,7,4,0,0,23635,23636,7,5,0,0,23636,23637,
+        5,95,0,0,23637,23638,7,1,0,0,23638,23639,7,10,0,0,23639,23640,7,
+        7,0,0,23640,23641,7,2,0,0,23641,23642,7,14,0,0,23642,23643,7,10,
+        0,0,23643,23644,7,0,0,0,23644,23645,7,11,0,0,23645,23646,5,95,0,
+        0,23646,23647,7,4,0,0,23647,23648,7,6,0,0,23648,23649,7,5,0,0,23649,
+        23650,7,4,0,0,23650,3498,1,0,0,0,23651,23652,7,5,0,0,23652,23653,
+        7,4,0,0,23653,23654,7,0,0,0,23654,23655,7,4,0,0,23655,23656,7,5,
+        0,0,23656,23657,5,95,0,0,23657,23658,7,8,0,0,23658,23659,7,3,0,0,
+        23659,23660,7,2,0,0,23660,23661,7,5,0,0,23661,23662,7,5,0,0,23662,
+        23663,7,4,0,0,23663,23664,7,0,0,0,23664,23665,7,1,0,0,23665,3500,
+        1,0,0,0,23666,23667,7,5,0,0,23667,23668,7,4,0,0,23668,23669,7,0,
+        0,0,23669,23670,7,4,0,0,23670,23671,7,5,0,0,23671,23672,5,95,0,0,
+        23672,23673,7,16,0,0,23673,23674,5,95,0,0,23674,23675,7,4,0,0,23675,
+        23676,7,6,0,0,23676,23677,7,5,0,0,23677,23678,7,4,0,0,23678,3502,
+        1,0,0,0,23679,23680,7,5,0,0,23680,23681,7,4,0,0,23681,23682,7,0,
+        0,0,23682,23683,7,4,0,0,23683,23684,7,5,0,0,23684,23685,5,95,0,0,
+        23685,23686,7,21,0,0,23686,23687,7,5,0,0,23687,23688,5,95,0,0,23688,
+        23689,7,4,0,0,23689,23690,7,6,0,0,23690,23691,7,5,0,0,23691,23692,
+        7,4,0,0,23692,3504,1,0,0,0,23693,23694,7,5,0,0,23694,23695,7,4,0,
+        0,23695,23696,7,0,0,0,23696,23697,7,4,0,0,23697,23698,7,5,0,0,23698,
+        23699,5,95,0,0,23699,23700,7,14,0,0,23700,23701,7,2,0,0,23701,23702,
+        7,9,0,0,23702,23703,7,6,0,0,23703,3506,1,0,0,0,23704,23705,7,5,0,
+        0,23705,23706,7,4,0,0,23706,23707,7,0,0,0,23707,23708,7,4,0,0,23708,
+        23709,7,5,0,0,23709,23710,5,95,0,0,23710,23711,7,14,0,0,23711,23712,
+        7,22,0,0,23712,23713,5,95,0,0,23713,23714,7,4,0,0,23714,23715,7,
+        6,0,0,23715,23716,7,5,0,0,23716,23717,7,4,0,0,23717,3508,1,0,0,0,
+        23718,23719,7,5,0,0,23719,23720,7,4,0,0,23720,23721,7,0,0,0,23721,
+        23722,7,4,0,0,23722,23723,7,5,0,0,23723,23724,5,95,0,0,23724,23725,
+        7,2,0,0,23725,23726,7,7,0,0,23726,23727,7,6,0,0,23727,23728,5,95,
+        0,0,23728,23729,7,22,0,0,23729,23730,7,0,0,0,23730,23731,7,18,0,
+        0,23731,23732,5,95,0,0,23732,23733,7,0,0,0,23733,23734,7,7,0,0,23734,
+        23735,7,2,0,0,23735,23736,7,13,0,0,23736,23737,7,0,0,0,23737,3510,
+        1,0,0,0,23738,23739,7,5,0,0,23739,23740,7,4,0,0,23740,23741,7,0,
+        0,0,23741,23742,7,4,0,0,23742,23743,7,5,0,0,23743,23744,5,95,0,0,
+        23744,23745,7,4,0,0,23745,23746,5,95,0,0,23746,23747,7,4,0,0,23747,
+        23748,7,6,0,0,23748,23749,7,5,0,0,23749,23750,7,4,0,0,23750,23751,
+        5,95,0,0,23751,23752,7,10,0,0,23752,23753,7,7,0,0,23753,23754,7,
+        9,0,0,23754,23755,7,6,0,0,23755,23756,7,15,0,0,23756,3512,1,0,0,
+        0,23757,23758,7,5,0,0,23758,23759,7,4,0,0,23759,23760,7,0,0,0,23760,
+        23761,7,4,0,0,23761,23762,7,5,0,0,23762,23763,5,95,0,0,23763,23764,
+        7,4,0,0,23764,23765,5,95,0,0,23765,23766,7,4,0,0,23766,23767,7,6,
+        0,0,23767,23768,7,5,0,0,23768,23769,7,4,0,0,23769,23770,5,95,0,0,
+        23770,23771,7,10,0,0,23771,23772,7,7,0,0,23772,23773,7,9,0,0,23773,
+        23774,7,6,0,0,23774,23775,7,15,0,0,23775,23776,7,12,0,0,23776,3514,
+        1,0,0,0,23777,23778,7,5,0,0,23778,23779,7,4,0,0,23779,23780,7,0,
+        0,0,23780,23781,7,4,0,0,23781,23782,7,5,0,0,23782,23783,5,95,0,0,
+        23783,23784,7,4,0,0,23784,23785,5,95,0,0,23785,23786,7,4,0,0,23786,
+        23787,7,6,0,0,23787,23788,7,5,0,0,23788,23789,7,4,0,0,23789,23790,
+        5,95,0,0,23790,23791,7,2,0,0,23791,23792,7,7,0,0,23792,23793,7,6,
+        0,0,23793,3516,1,0,0,0,23794,23795,7,5,0,0,23795,23796,7,4,0,0,23796,
+        23797,7,0,0,0,23797,23798,7,4,0,0,23798,23799,7,5,0,0,23799,23800,
+        5,95,0,0,23800,23801,7,4,0,0,23801,23802,5,95,0,0,23802,23803,7,
+        4,0,0,23803,23804,7,6,0,0,23804,23805,7,5,0,0,23805,23806,7,4,0,
+        0,23806,23807,5,95,0,0,23807,23808,7,15,0,0,23808,23809,7,0,0,0,
+        23809,23810,7,10,0,0,23810,23811,7,3,0,0,23811,23812,7,6,0,0,23812,
+        23813,7,9,0,0,23813,3518,1,0,0,0,23814,23815,7,5,0,0,23815,23816,
+        7,4,0,0,23816,23817,7,0,0,0,23817,23818,7,4,0,0,23818,23819,7,5,
+        0,0,23819,23820,5,95,0,0,23820,23821,7,22,0,0,23821,23822,7,5,0,
+        0,23822,23823,7,3,0,0,23823,23824,5,95,0,0,23824,23825,7,4,0,0,23825,
+        23826,7,6,0,0,23826,23827,7,5,0,0,23827,23828,7,4,0,0,23828,3520,
+        1,0,0,0,23829,23830,7,5,0,0,23830,23831,7,4,0,0,23831,23832,7,9,
+        0,0,23832,23833,7,9,0,0,23833,23834,7,6,0,0,23834,23835,7,13,0,0,
+        23835,23836,5,95,0,0,23836,23837,7,15,0,0,23837,23838,7,2,0,0,23838,
+        23839,7,15,0,0,23839,3522,1,0,0,0,23840,23841,7,5,0,0,23841,23842,
+        7,4,0,0,23842,23843,7,9,0,0,23843,23844,7,9,0,0,23844,23845,7,6,
+        0,0,23845,23846,7,13,0,0,23846,23847,5,95,0,0,23847,23848,7,5,0,
+        0,23848,23849,7,0,0,0,23849,23850,7,14,0,0,23850,23851,7,15,0,0,
+        23851,3524,1,0,0,0,23852,23853,7,5,0,0,23853,23854,7,4,0,0,23854,
+        23855,7,2,0,0,23855,23856,7,15,0,0,23856,3526,1,0,0,0,23857,23858,
+        7,5,0,0,23858,23859,7,4,0,0,23859,23860,7,2,0,0,23860,23861,7,3,
+        0,0,23861,23862,7,0,0,0,23862,23863,7,17,0,0,23863,23864,7,6,0,0,
+        23864,3528,1,0,0,0,23865,23866,7,5,0,0,23866,23867,7,4,0,0,23867,
+        23868,7,2,0,0,23868,23869,7,3,0,0,23869,23870,7,6,0,0,23870,3530,
+        1,0,0,0,23871,23872,7,5,0,0,23872,23873,7,4,0,0,23873,23874,7,3,
+        0,0,23874,23875,7,6,0,0,23875,23876,7,0,0,0,23876,23877,7,14,0,0,
+        23877,23878,7,5,0,0,23878,3532,1,0,0,0,23879,23880,7,5,0,0,23880,
+        23881,7,4,0,0,23881,23882,7,3,0,0,23882,23883,7,6,0,0,23883,23884,
+        7,0,0,0,23884,23885,7,14,0,0,23885,3534,1,0,0,0,23886,23887,7,5,
+        0,0,23887,23888,7,4,0,0,23888,23889,7,3,0,0,23889,23890,7,10,0,0,
+        23890,23891,7,8,0,0,23891,23892,7,4,0,0,23892,3536,1,0,0,0,23893,
+        23894,7,5,0,0,23894,23895,7,4,0,0,23895,23896,7,3,0,0,23896,23897,
+        7,10,0,0,23897,23898,7,7,0,0,23898,23899,7,17,0,0,23899,3538,1,0,
+        0,0,23900,23901,7,5,0,0,23901,23902,7,4,0,0,23902,23903,7,3,0,0,
+        23903,23904,7,10,0,0,23904,23905,7,15,0,0,23905,23906,7,6,0,0,23906,
+        23907,5,95,0,0,23907,23908,7,8,0,0,23908,23909,7,2,0,0,23909,23910,
+        7,11,0,0,23910,23911,7,12,0,0,23911,23912,7,14,0,0,23912,23913,7,
+        7,0,0,23913,23914,7,5,0,0,23914,3540,1,0,0,0,23915,23916,7,5,0,0,
+        23916,23917,7,4,0,0,23917,23918,7,3,0,0,23918,23919,7,10,0,0,23919,
+        23920,7,15,0,0,23920,23921,7,6,0,0,23921,23922,5,95,0,0,23922,23923,
+        7,22,0,0,23923,23924,7,10,0,0,23924,23925,7,9,0,0,23925,23926,7,
+        4,0,0,23926,23927,7,19,0,0,23927,3542,1,0,0,0,23928,23929,7,5,0,
+        0,23929,23930,7,4,0,0,23930,23931,7,3,0,0,23931,23932,7,10,0,0,23932,
+        23933,7,15,0,0,23933,3544,1,0,0,0,23934,23935,7,5,0,0,23935,23936,
+        7,4,0,0,23936,23937,7,3,0,0,23937,23938,7,12,0,0,23938,23939,7,8,
+        0,0,23939,23940,7,4,0,0,23940,23941,7,12,0,0,23941,23942,7,3,0,0,
+        23942,23943,7,6,0,0,23943,3546,1,0,0,0,23944,23945,7,5,0,0,23945,
+        23946,7,12,0,0,23946,23947,7,1,0,0,23947,23948,7,14,0,0,23948,23949,
+        7,12,0,0,23949,23950,7,11,0,0,23950,23951,7,4,0,0,23951,23952,7,
+        10,0,0,23952,23953,7,5,0,0,23953,23954,7,6,0,0,23954,23955,7,4,0,
+        0,23955,3548,1,0,0,0,23956,23957,7,5,0,0,23957,23958,7,12,0,0,23958,
+        23959,7,1,0,0,23959,23960,7,15,0,0,23960,23961,7,0,0,0,23961,23962,
+        7,3,0,0,23962,23963,7,4,0,0,23963,23964,7,10,0,0,23964,23965,7,4,
+        0,0,23965,23966,7,10,0,0,23966,23967,7,2,0,0,23967,23968,7,7,0,0,
+        23968,23969,5,95,0,0,23969,23970,7,3,0,0,23970,23971,7,6,0,0,23971,
+        23972,7,11,0,0,23972,3550,1,0,0,0,23973,23974,7,5,0,0,23974,23975,
+        7,12,0,0,23975,23976,7,1,0,0,23976,23977,7,15,0,0,23977,23978,7,
+        0,0,0,23978,23979,7,3,0,0,23979,23980,7,4,0,0,23980,23981,7,10,0,
+        0,23981,23982,7,4,0,0,23982,23983,7,10,0,0,23983,23984,7,2,0,0,23984,
+        23985,7,7,0,0,23985,23986,7,5,0,0,23986,3552,1,0,0,0,23987,23988,
+        7,5,0,0,23988,23989,7,12,0,0,23989,23990,7,1,0,0,23990,23991,7,15,
+        0,0,23991,23992,7,0,0,0,23992,23993,7,3,0,0,23993,23994,7,4,0,0,
+        23994,23995,7,10,0,0,23995,23996,7,4,0,0,23996,23997,7,10,0,0,23997,
+        23998,7,2,0,0,23998,23999,7,7,0,0,23999,3554,1,0,0,0,24000,24001,
+        7,5,0,0,24001,24002,7,12,0,0,24002,24003,7,1,0,0,24003,24004,7,24,
+        0,0,24004,24005,7,12,0,0,24005,24006,7,6,0,0,24006,24007,7,3,0,0,
+        24007,24008,7,10,0,0,24008,24009,7,6,0,0,24009,24010,7,5,0,0,24010,
+        3556,1,0,0,0,24011,24012,7,5,0,0,24012,24013,7,12,0,0,24013,24014,
+        7,1,0,0,24014,24015,7,24,0,0,24015,24016,7,12,0,0,24016,24017,7,
+        6,0,0,24017,24018,7,3,0,0,24018,24019,7,18,0,0,24019,24020,5,95,
+        0,0,24020,24021,7,15,0,0,24021,24022,7,3,0,0,24022,24023,7,12,0,
+        0,24023,24024,7,7,0,0,24024,24025,7,10,0,0,24025,24026,7,7,0,0,24026,
+        24027,7,17,0,0,24027,3558,1,0,0,0,24028,24029,7,5,0,0,24029,24030,
+        7,12,0,0,24030,24031,7,1,0,0,24031,24032,7,5,0,0,24032,24033,7,8,
+        0,0,24033,24034,7,3,0,0,24034,24035,7,10,0,0,24035,24036,7,1,0,0,
+        24036,24037,7,6,0,0,24037,3560,1,0,0,0,24038,24039,7,5,0,0,24039,
+        24040,7,12,0,0,24040,24041,7,1,0,0,24041,24042,7,5,0,0,24042,24043,
+        7,6,0,0,24043,24044,7,4,0,0,24044,3562,1,0,0,0,24045,24046,7,5,0,
+        0,24046,24047,7,12,0,0,24047,24048,7,1,0,0,24048,24049,7,5,0,0,24049,
+        24050,7,4,0,0,24050,24051,7,10,0,0,24051,24052,7,4,0,0,24052,24053,
+        7,12,0,0,24053,24054,7,4,0,0,24054,24055,7,0,0,0,24055,24056,7,1,
+        0,0,24056,24057,7,11,0,0,24057,24058,7,6,0,0,24058,3564,1,0,0,0,
+        24059,24060,7,5,0,0,24060,24061,7,12,0,0,24061,24062,7,1,0,0,24062,
+        24063,7,5,0,0,24063,24064,7,4,0,0,24064,24065,7,3,0,0,24065,24066,
+        5,50,0,0,24066,3566,1,0,0,0,24067,24068,7,5,0,0,24068,24069,7,12,
+        0,0,24069,24070,7,1,0,0,24070,24071,7,5,0,0,24071,24072,7,4,0,0,
+        24072,24073,7,3,0,0,24073,24074,5,52,0,0,24074,3568,1,0,0,0,24075,
+        24076,7,5,0,0,24076,24077,7,12,0,0,24077,24078,7,1,0,0,24078,24079,
+        7,5,0,0,24079,24080,7,4,0,0,24080,24081,7,3,0,0,24081,24082,7,1,
+        0,0,24082,3570,1,0,0,0,24083,24084,7,5,0,0,24084,24085,7,12,0,0,
+        24085,24086,7,1,0,0,24086,24087,7,5,0,0,24087,24088,7,4,0,0,24088,
+        24089,7,3,0,0,24089,24090,7,8,0,0,24090,3572,1,0,0,0,24091,24092,
+        7,5,0,0,24092,24093,7,12,0,0,24093,24094,7,1,0,0,24094,24095,7,4,
+        0,0,24095,24096,7,18,0,0,24096,24097,7,15,0,0,24097,24098,7,6,0,
+        0,24098,3574,1,0,0,0,24099,24100,7,5,0,0,24100,24101,7,12,0,0,24101,
+        24102,7,8,0,0,24102,24103,7,8,0,0,24103,24104,7,6,0,0,24104,24105,
+        7,5,0,0,24105,24106,7,5,0,0,24106,24107,7,16,0,0,24107,24108,7,12,
+        0,0,24108,24109,7,11,0,0,24109,3576,1,0,0,0,24110,24111,7,5,0,0,
+        24111,24112,7,12,0,0,24112,24113,7,8,0,0,24113,24114,7,8,0,0,24114,
+        24115,7,6,0,0,24115,24116,7,5,0,0,24116,24117,7,5,0,0,24117,3578,
+        1,0,0,0,24118,24119,7,5,0,0,24119,24120,7,12,0,0,24120,24121,7,14,
+        0,0,24121,24122,7,14,0,0,24122,24123,7,0,0,0,24123,24124,7,3,0,0,
+        24124,24125,7,18,0,0,24125,3580,1,0,0,0,24126,24127,7,5,0,0,24127,
+        24128,7,12,0,0,24128,24129,7,15,0,0,24129,24130,7,15,0,0,24130,24131,
+        7,11,0,0,24131,24132,7,6,0,0,24132,24133,7,14,0,0,24133,24134,7,
+        6,0,0,24134,24135,7,7,0,0,24135,24136,7,4,0,0,24136,24137,7,0,0,
+        0,24137,24138,7,11,0,0,24138,3582,1,0,0,0,24139,24140,7,5,0,0,24140,
+        24141,7,12,0,0,24141,24142,7,5,0,0,24142,24143,7,15,0,0,24143,24144,
+        7,6,0,0,24144,24145,7,7,0,0,24145,24146,7,9,0,0,24146,3584,1,0,0,
+        0,24147,24148,7,5,0,0,24148,24149,7,22,0,0,24149,24150,7,0,0,0,24150,
+        24151,7,15,0,0,24151,24152,5,95,0,0,24152,24153,7,20,0,0,24153,24154,
+        7,2,0,0,24154,24155,7,10,0,0,24155,24156,7,7,0,0,24156,24157,5,95,
+        0,0,24157,24158,7,10,0,0,24158,24159,7,7,0,0,24159,24160,7,15,0,
+        0,24160,24161,7,12,0,0,24161,24162,7,4,0,0,24162,24163,7,5,0,0,24163,
+        3586,1,0,0,0,24164,24165,7,5,0,0,24165,24166,7,22,0,0,24166,24167,
+        7,10,0,0,24167,24168,7,4,0,0,24168,24169,7,8,0,0,24169,24170,7,19,
+        0,0,24170,24171,7,2,0,0,24171,24172,7,13,0,0,24172,24173,7,6,0,0,
+        24173,24174,7,3,0,0,24174,3588,1,0,0,0,24175,24176,7,5,0,0,24176,
+        24177,7,22,0,0,24177,24178,7,10,0,0,24178,24179,7,4,0,0,24179,24180,
+        7,8,0,0,24180,24181,7,19,0,0,24181,3590,1,0,0,0,24182,24183,7,5,
+        0,0,24183,24184,7,18,0,0,24184,24185,7,7,0,0,24185,24186,7,8,0,0,
+        24186,24187,7,19,0,0,24187,24188,7,3,0,0,24188,24189,7,2,0,0,24189,
+        24190,7,7,0,0,24190,24191,7,2,0,0,24191,24192,7,12,0,0,24192,24193,
+        7,5,0,0,24193,3592,1,0,0,0,24194,24195,7,5,0,0,24195,24196,7,18,
+        0,0,24196,24197,7,7,0,0,24197,24198,7,8,0,0,24198,3594,1,0,0,0,24199,
+        24200,7,5,0,0,24200,24201,7,18,0,0,24201,24202,7,7,0,0,24202,24203,
+        7,2,0,0,24203,24204,7,7,0,0,24204,24205,7,18,0,0,24205,24206,7,14,
+        0,0,24206,3596,1,0,0,0,24207,24208,7,5,0,0,24208,24209,7,18,0,0,
+        24209,24210,7,5,0,0,24210,3598,1,0,0,0,24211,24212,7,5,0,0,24212,
+        24213,7,18,0,0,24213,24214,7,5,0,0,24214,24215,7,0,0,0,24215,24216,
+        7,5,0,0,24216,24217,7,14,0,0,24217,3600,1,0,0,0,24218,24219,7,5,
+        0,0,24219,24220,7,18,0,0,24220,24221,7,5,0,0,24221,24222,5,95,0,
+        0,24222,24223,7,0,0,0,24223,24224,7,12,0,0,24224,24225,7,9,0,0,24225,
+        24226,7,10,0,0,24226,24227,7,4,0,0,24227,3602,1,0,0,0,24228,24229,
+        7,5,0,0,24229,24230,7,18,0,0,24230,24231,7,5,0,0,24231,24232,7,0,
+        0,0,24232,24233,7,12,0,0,24233,24234,7,25,0,0,24234,3604,1,0,0,0,
+        24235,24236,7,5,0,0,24236,24237,7,18,0,0,24237,24238,7,5,0,0,24238,
+        24239,7,1,0,0,24239,24240,7,0,0,0,24240,24241,7,8,0,0,24241,24242,
+        7,21,0,0,24242,24243,7,12,0,0,24243,24244,7,15,0,0,24244,3606,1,
+        0,0,0,24245,24246,7,5,0,0,24246,24247,7,18,0,0,24247,24248,7,5,0,
+        0,24248,24249,5,95,0,0,24249,24250,7,8,0,0,24250,24251,7,19,0,0,
+        24251,24252,7,6,0,0,24252,24253,7,8,0,0,24253,24254,7,21,0,0,24254,
+        24255,7,0,0,0,24255,24256,7,8,0,0,24256,24257,7,11,0,0,24257,3608,
+        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,8,0,0,24263,24264,7,19,0,
+        0,24264,24265,7,6,0,0,24265,24266,7,8,0,0,24266,24267,7,21,0,0,24267,
+        24268,5,95,0,0,24268,24269,7,15,0,0,24269,24270,7,3,0,0,24270,24271,
+        7,10,0,0,24271,24272,7,13,0,0,24272,24273,7,10,0,0,24273,24274,7,
+        11,0,0,24274,24275,7,6,0,0,24275,24276,7,17,0,0,24276,24277,7,6,
+        0,0,24277,3610,1,0,0,0,24278,24279,7,5,0,0,24279,24280,7,18,0,0,
+        24280,24281,7,5,0,0,24281,24282,5,95,0,0,24282,24283,7,8,0,0,24283,
+        24284,7,2,0,0,24284,24285,7,7,0,0,24285,24286,7,7,0,0,24286,24287,
+        7,6,0,0,24287,24288,7,8,0,0,24288,24289,7,4,0,0,24289,24290,5,95,
+        0,0,24290,24291,7,1,0,0,24291,24292,7,18,0,0,24292,24293,5,95,0,
+        0,24293,24294,7,15,0,0,24294,24295,7,0,0,0,24295,24296,7,4,0,0,24296,
+        24297,7,19,0,0,24297,3612,1,0,0,0,24298,24299,7,5,0,0,24299,24300,
+        7,18,0,0,24300,24301,7,5,0,0,24301,24302,5,95,0,0,24302,24303,7,
+        8,0,0,24303,24304,7,2,0,0,24304,24305,7,7,0,0,24305,24306,7,4,0,
+        0,24306,24307,7,6,0,0,24307,24308,7,25,0,0,24308,24309,7,4,0,0,24309,
+        3614,1,0,0,0,24310,24311,7,5,0,0,24311,24312,7,18,0,0,24312,24313,
+        7,5,0,0,24313,24314,7,9,0,0,24314,24315,7,0,0,0,24315,24316,7,4,
+        0,0,24316,24317,7,6,0,0,24317,3616,1,0,0,0,24318,24319,7,5,0,0,24319,
+        24320,7,18,0,0,24320,24321,7,5,0,0,24321,24322,7,9,0,0,24322,24323,
+        7,1,0,0,24323,24324,7,0,0,0,24324,3618,1,0,0,0,24325,24326,7,5,0,
+        0,24326,24327,7,18,0,0,24327,24328,7,5,0,0,24328,24329,5,95,0,0,
+        24329,24330,7,9,0,0,24330,24331,7,1,0,0,24331,24332,7,12,0,0,24332,
+        24333,7,3,0,0,24333,24334,7,10,0,0,24334,24335,7,17,0,0,24335,24336,
+        7,6,0,0,24336,24337,7,7,0,0,24337,3620,1,0,0,0,24338,24339,7,5,0,
+        0,24339,24340,7,18,0,0,24340,24341,7,5,0,0,24341,24342,7,9,0,0,24342,
+        24343,7,17,0,0,24343,3622,1,0,0,0,24344,24345,7,5,0,0,24345,24346,
+        7,18,0,0,24346,24347,7,5,0,0,24347,24348,5,95,0,0,24348,24349,7,
+        9,0,0,24349,24350,7,11,0,0,24350,24351,5,95,0,0,24351,24352,7,8,
+        0,0,24352,24353,7,12,0,0,24353,24354,7,3,0,0,24354,24355,7,5,0,0,
+        24355,24356,7,2,0,0,24356,24357,7,3,0,0,24357,3624,1,0,0,0,24358,
+        24359,7,5,0,0,24359,24360,7,18,0,0,24360,24361,7,5,0,0,24361,24362,
+        5,95,0,0,24362,24363,7,9,0,0,24363,24364,7,14,0,0,24364,24365,5,
+        95,0,0,24365,24366,7,3,0,0,24366,24367,7,25,0,0,24367,24368,7,16,
+        0,0,24368,24369,7,2,0,0,24369,24370,7,3,0,0,24370,24371,7,14,0,0,
+        24371,24372,5,95,0,0,24372,24373,7,8,0,0,24373,24374,7,19,0,0,24374,
+        24375,7,3,0,0,24375,3626,1,0,0,0,24376,24377,7,5,0,0,24377,24378,
+        7,18,0,0,24378,24379,7,5,0,0,24379,24380,5,95,0,0,24380,24381,7,
+        9,0,0,24381,24382,7,14,0,0,24382,24383,5,95,0,0,24383,24384,7,3,
+        0,0,24384,24385,7,25,0,0,24385,24386,7,16,0,0,24386,24387,7,2,0,
+        0,24387,24388,7,3,0,0,24388,24389,7,14,0,0,24389,24390,5,95,0,0,
+        24390,24391,7,7,0,0,24391,24392,7,12,0,0,24392,24393,7,14,0,0,24393,
+        3628,1,0,0,0,24394,24395,7,5,0,0,24395,24396,7,18,0,0,24396,24397,
+        7,5,0,0,24397,24398,5,95,0,0,24398,24399,7,9,0,0,24399,24400,7,2,
+        0,0,24400,24401,7,14,0,0,24401,24402,5,95,0,0,24402,24403,7,8,0,
+        0,24403,24404,7,2,0,0,24404,24405,7,14,0,0,24405,24406,7,15,0,0,
+        24406,24407,7,0,0,0,24407,24408,7,3,0,0,24408,24409,7,6,0,0,24409,
+        3630,1,0,0,0,24410,24411,7,5,0,0,24411,24412,7,18,0,0,24412,24413,
+        7,5,0,0,24413,24414,5,95,0,0,24414,24415,7,9,0,0,24415,24416,7,5,
+        0,0,24416,24417,7,4,0,0,24417,24418,5,95,0,0,24418,24419,7,15,0,
+        0,24419,24420,7,3,0,0,24420,24421,7,10,0,0,24421,24422,7,14,0,0,
+        24422,24423,5,50,0,0,24423,24424,7,5,0,0,24424,24425,7,6,0,0,24425,
+        24426,7,8,0,0,24426,3632,1,0,0,0,24427,24428,7,5,0,0,24428,24429,
+        7,18,0,0,24429,24430,7,5,0,0,24430,24431,5,95,0,0,24431,24432,7,
+        9,0,0,24432,24433,7,5,0,0,24433,24434,7,4,0,0,24434,24435,5,95,0,
+        0,24435,24436,7,5,0,0,24436,24437,7,6,0,0,24437,24438,7,8,0,0,24438,
+        24439,5,50,0,0,24439,24440,7,15,0,0,24440,24441,7,3,0,0,24441,24442,
+        7,10,0,0,24442,24443,7,14,0,0,24443,3634,1,0,0,0,24444,24445,7,5,
+        0,0,24445,24446,7,18,0,0,24446,24447,7,5,0,0,24447,24448,5,95,0,
+        0,24448,24449,7,6,0,0,24449,24450,7,4,0,0,24450,24451,5,95,0,0,24451,
+        24452,7,1,0,0,24452,24453,7,16,0,0,24453,24454,7,10,0,0,24454,24455,
+        7,11,0,0,24455,24456,7,6,0,0,24456,24457,5,95,0,0,24457,24458,7,
+        4,0,0,24458,24459,7,2,0,0,24459,24460,5,95,0,0,24460,24461,7,3,0,
+        0,24461,24462,7,0,0,0,24462,24463,7,22,0,0,24463,3636,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,6,0,0,24469,24470,7,4,0,0,24470,24471,5,95,
+        0,0,24471,24472,7,1,0,0,24472,24473,7,11,0,0,24473,24474,7,2,0,0,
+        24474,24475,7,1,0,0,24475,24476,5,95,0,0,24476,24477,7,4,0,0,24477,
+        24478,7,2,0,0,24478,24479,5,95,0,0,24479,24480,7,10,0,0,24480,24481,
+        7,14,0,0,24481,24482,7,0,0,0,24482,24483,7,17,0,0,24483,24484,7,
+        6,0,0,24484,3638,1,0,0,0,24485,24486,7,5,0,0,24486,24487,7,18,0,
+        0,24487,24488,7,5,0,0,24488,24489,5,95,0,0,24489,24490,7,6,0,0,24490,
+        24491,7,4,0,0,24491,24492,5,95,0,0,24492,24493,7,10,0,0,24493,24494,
+        7,14,0,0,24494,24495,7,0,0,0,24495,24496,7,17,0,0,24496,24497,7,
+        6,0,0,24497,24498,5,95,0,0,24498,24499,7,4,0,0,24499,24500,7,2,0,
+        0,24500,24501,5,95,0,0,24501,24502,7,1,0,0,24502,24503,7,11,0,0,
+        24503,24504,7,2,0,0,24504,24505,7,1,0,0,24505,3640,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,6,0,0,24511,24512,7,4,0,0,24512,24513,5,95,
+        0,0,24513,24514,7,3,0,0,24514,24515,7,0,0,0,24515,24516,7,22,0,0,
+        24516,24517,5,95,0,0,24517,24518,7,4,0,0,24518,24519,7,2,0,0,24519,
+        24520,5,95,0,0,24520,24521,7,1,0,0,24521,24522,7,16,0,0,24522,24523,
+        7,10,0,0,24523,24524,7,11,0,0,24524,24525,7,6,0,0,24525,3642,1,0,
+        0,0,24526,24527,7,5,0,0,24527,24528,7,18,0,0,24528,24529,7,5,0,0,
+        24529,24530,5,95,0,0,24530,24531,7,6,0,0,24531,24532,7,25,0,0,24532,
+        24533,7,4,0,0,24533,24534,7,15,0,0,24534,24535,7,9,0,0,24535,24536,
+        7,4,0,0,24536,24537,7,25,0,0,24537,24538,7,4,0,0,24538,3644,1,0,
+        0,0,24539,24540,7,5,0,0,24540,24541,7,18,0,0,24541,24542,7,5,0,0,
+        24542,24543,5,95,0,0,24543,24544,7,6,0,0,24544,24545,7,25,0,0,24545,
+        24546,7,4,0,0,24546,24547,7,3,0,0,24547,24548,7,0,0,0,24548,24549,
+        7,8,0,0,24549,24550,7,4,0,0,24550,24551,5,95,0,0,24551,24552,7,12,
+        0,0,24552,24553,7,4,0,0,24553,24554,7,8,0,0,24554,3646,1,0,0,0,24555,
+        24556,7,5,0,0,24556,24557,7,18,0,0,24557,24558,7,5,0,0,24558,24559,
+        5,95,0,0,24559,24560,7,16,0,0,24560,24561,7,1,0,0,24561,24562,7,
+        4,0,0,24562,24563,5,95,0,0,24563,24564,7,10,0,0,24564,24565,7,7,
+        0,0,24565,24566,7,5,0,0,24566,24567,7,9,0,0,24567,24568,7,6,0,0,
+        24568,24569,7,11,0,0,24569,3648,1,0,0,0,24570,24571,7,5,0,0,24571,
+        24572,7,18,0,0,24572,24573,7,5,0,0,24573,24574,5,95,0,0,24574,24575,
+        7,16,0,0,24575,24576,7,10,0,0,24576,24577,7,11,0,0,24577,24578,7,
+        4,0,0,24578,24579,7,6,0,0,24579,24580,7,3,0,0,24580,24581,5,95,0,
+        0,24581,24582,7,0,0,0,24582,24583,7,8,0,0,24583,24584,7,11,0,0,24584,
+        24585,7,5,0,0,24585,3650,1,0,0,0,24586,24587,7,5,0,0,24587,24588,
+        7,18,0,0,24588,24589,7,5,0,0,24589,24590,5,95,0,0,24590,24591,7,
+        16,0,0,24591,24592,7,7,0,0,24592,24593,7,14,0,0,24593,24594,7,0,
+        0,0,24594,24595,7,4,0,0,24595,24596,7,8,0,0,24596,24597,7,19,0,0,
+        24597,24598,7,6,0,0,24598,24599,7,5,0,0,24599,3652,1,0,0,0,24600,
+        24601,7,5,0,0,24601,24602,7,18,0,0,24602,24603,7,5,0,0,24603,24604,
+        5,95,0,0,24604,24605,7,16,0,0,24605,24606,7,7,0,0,24606,24607,7,
+        3,0,0,24607,24608,7,6,0,0,24608,24609,7,15,0,0,24609,24610,7,11,
+        0,0,24610,24611,7,0,0,0,24611,24612,7,8,0,0,24612,24613,7,6,0,0,
+        24613,3654,1,0,0,0,24614,24615,7,5,0,0,24615,24616,7,18,0,0,24616,
+        24617,7,5,0,0,24617,24618,5,95,0,0,24618,24619,7,17,0,0,24619,24620,
+        7,6,0,0,24620,24621,7,4,0,0,24621,24622,5,95,0,0,24622,24623,7,0,
+        0,0,24623,24624,7,8,0,0,24624,24625,7,11,0,0,24625,24626,7,10,0,
+        0,24626,24627,7,9,0,0,24627,24628,7,5,0,0,24628,3656,1,0,0,0,24629,
+        24630,7,5,0,0,24630,24631,7,18,0,0,24631,24632,7,5,0,0,24632,24633,
+        5,95,0,0,24633,24634,7,17,0,0,24634,24635,7,6,0,0,24635,24636,7,
+        4,0,0,24636,24637,5,95,0,0,24637,24638,7,8,0,0,24638,24639,7,2,0,
+        0,24639,24640,7,11,0,0,24640,24641,5,95,0,0,24641,24642,7,0,0,0,
+        24642,24643,7,8,0,0,24643,24644,7,11,0,0,24644,24645,7,10,0,0,24645,
+        24646,7,9,0,0,24646,24647,7,5,0,0,24647,3658,1,0,0,0,24648,24649,
+        7,5,0,0,24649,24650,7,18,0,0,24650,24651,7,5,0,0,24651,24652,5,95,
+        0,0,24652,24653,7,17,0,0,24653,24654,7,6,0,0,24654,24655,7,4,0,0,
+        24655,24656,5,95,0,0,24656,24657,7,15,0,0,24657,24658,7,3,0,0,24658,
+        24659,7,10,0,0,24659,24660,7,13,0,0,24660,24661,7,10,0,0,24661,24662,
+        7,11,0,0,24662,24663,7,6,0,0,24663,24664,7,17,0,0,24664,24665,7,
+        6,0,0,24665,24666,7,5,0,0,24666,3660,1,0,0,0,24667,24668,7,5,0,0,
+        24668,24669,7,18,0,0,24669,24670,7,5,0,0,24670,24671,5,95,0,0,24671,
+        24672,7,17,0,0,24672,24673,7,6,0,0,24673,24674,7,4,0,0,24674,24675,
+        7,4,0,0,24675,24676,7,2,0,0,24676,24677,7,21,0,0,24677,24678,7,6,
+        0,0,24678,24679,7,7,0,0,24679,24680,7,10,0,0,24680,24681,7,9,0,0,
+        24681,3662,1,0,0,0,24682,24683,7,5,0,0,24683,24684,7,18,0,0,24684,
+        24685,7,5,0,0,24685,24686,5,95,0,0,24686,24687,7,17,0,0,24687,24688,
+        7,6,0,0,24688,24689,7,4,0,0,24689,24690,7,25,0,0,24690,24691,7,4,
+        0,0,24691,24692,7,10,0,0,24692,24693,7,13,0,0,24693,24694,7,0,0,
+        0,24694,24695,7,11,0,0,24695,3664,1,0,0,0,24696,24697,7,5,0,0,24697,
+        24698,7,18,0,0,24698,24699,7,5,0,0,24699,24700,5,95,0,0,24700,24701,
+        7,17,0,0,24701,24702,7,12,0,0,24702,24703,7,10,0,0,24703,24704,7,
+        9,0,0,24704,3666,1,0,0,0,24705,24706,7,5,0,0,24706,24707,7,18,0,
+        0,24707,24708,7,5,0,0,24708,24709,7,17,0,0,24709,24710,7,12,0,0,
+        24710,24711,7,10,0,0,24711,24712,7,9,0,0,24712,3668,1,0,0,0,24713,
+        24714,7,5,0,0,24714,24715,7,18,0,0,24715,24716,7,5,0,0,24716,24717,
+        7,21,0,0,24717,24718,7,14,0,0,24718,3670,1,0,0,0,24719,24720,7,5,
+        0,0,24720,24721,7,18,0,0,24721,24722,7,5,0,0,24722,24723,5,95,0,
+        0,24723,24724,7,14,0,0,24724,24725,7,0,0,0,24725,24726,7,21,0,0,
+        24726,24727,7,6,0,0,24727,24728,5,95,0,0,24728,24729,7,25,0,0,24729,
+        24730,7,14,0,0,24730,24731,7,11,0,0,24731,24732,7,7,0,0,24732,24733,
+        7,2,0,0,24733,24734,7,9,0,0,24734,24735,7,6,0,0,24735,24736,7,10,
+        0,0,24736,24737,7,9,0,0,24737,3672,1,0,0,0,24738,24739,7,5,0,0,24739,
+        24740,7,18,0,0,24740,24741,7,5,0,0,24741,24742,5,95,0,0,24742,24743,
+        7,14,0,0,24743,24744,7,0,0,0,24744,24745,7,21,0,0,24745,24746,7,
+        6,0,0,24746,24747,7,25,0,0,24747,24748,7,14,0,0,24748,24749,7,11,
+        0,0,24749,3674,1,0,0,0,24750,24751,7,5,0,0,24751,24752,7,18,0,0,
+        24752,24753,7,5,0,0,24753,24754,5,95,0,0,24754,24755,7,14,0,0,24755,
+        24756,7,21,0,0,24756,24757,7,25,0,0,24757,24758,7,14,0,0,24758,24759,
+        7,11,0,0,24759,24760,7,0,0,0,24760,24761,7,4,0,0,24761,24762,7,4,
+        0,0,24762,24763,7,3,0,0,24763,3676,1,0,0,0,24764,24765,7,5,0,0,24765,
+        24766,7,18,0,0,24766,24767,7,5,0,0,24767,24768,5,95,0,0,24768,24769,
+        7,14,0,0,24769,24770,7,21,0,0,24770,24771,7,25,0,0,24771,24772,7,
+        4,0,0,24772,24773,7,10,0,0,24773,3678,1,0,0,0,24774,24775,7,5,0,
+        0,24775,24776,7,18,0,0,24776,24777,7,5,0,0,24777,24778,7,2,0,0,24778,
+        24779,7,1,0,0,24779,24780,7,20,0,0,24780,3680,1,0,0,0,24781,24782,
+        7,5,0,0,24782,24783,7,18,0,0,24783,24784,7,5,0,0,24784,24785,5,95,
+        0,0,24785,24786,7,2,0,0,24786,24787,7,15,0,0,24787,24788,5,95,0,
+        0,24788,24789,7,0,0,0,24789,24790,7,9,0,0,24790,24791,7,4,0,0,24791,
+        24792,5,50,0,0,24792,24793,7,1,0,0,24793,24794,7,10,0,0,24794,24795,
+        7,7,0,0,24795,3682,1,0,0,0,24796,24797,7,5,0,0,24797,24798,7,18,
+        0,0,24798,24799,7,5,0,0,24799,24800,5,95,0,0,24800,24801,7,2,0,0,
+        24801,24802,7,15,0,0,24802,24803,5,95,0,0,24803,24804,7,0,0,0,24804,
+        24805,7,9,0,0,24805,24806,7,4,0,0,24806,24807,7,8,0,0,24807,24808,
+        7,2,0,0,24808,24809,7,7,0,0,24809,24810,7,5,0,0,24810,3684,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,0,0,0,24819,24820,7,11,0,0,24820,24821,7,
+        5,0,0,24821,24822,7,8,0,0,24822,24823,7,3,0,0,24823,24824,7,13,0,
+        0,24824,24825,7,0,0,0,24825,24826,7,11,0,0,24826,3686,1,0,0,0,24827,
+        24828,7,5,0,0,24828,24829,7,18,0,0,24829,24830,7,5,0,0,24830,24831,
+        5,95,0,0,24831,24832,7,2,0,0,24832,24833,7,15,0,0,24833,24834,5,
+        95,0,0,24834,24835,7,0,0,0,24835,24836,7,4,0,0,24836,24837,7,17,
+        0,0,24837,3688,1,0,0,0,24838,24839,7,5,0,0,24839,24840,7,18,0,0,
+        24840,24841,7,5,0,0,24841,24842,5,95,0,0,24842,24843,7,2,0,0,24843,
+        24844,7,15,0,0,24844,24845,5,95,0,0,24845,24846,7,1,0,0,24846,24847,
+        7,10,0,0,24847,24848,7,7,0,0,24848,24849,5,50,0,0,24849,24850,7,
+        0,0,0,24850,24851,7,9,0,0,24851,24852,7,4,0,0,24852,3690,1,0,0,0,
+        24853,24854,7,5,0,0,24854,24855,7,18,0,0,24855,24856,7,5,0,0,24856,
+        24857,5,95,0,0,24857,24858,7,2,0,0,24858,24859,7,15,0,0,24859,24860,
+        5,95,0,0,24860,24861,7,1,0,0,24861,24862,7,10,0,0,24862,24863,7,
+        4,0,0,24863,24864,7,13,0,0,24864,24865,7,6,0,0,24865,24866,7,8,0,
+        0,24866,3692,1,0,0,0,24867,24868,7,5,0,0,24868,24869,7,18,0,0,24869,
+        24870,7,5,0,0,24870,24871,5,95,0,0,24871,24872,7,2,0,0,24872,24873,
+        7,15,0,0,24873,24874,5,95,0,0,24874,24875,7,1,0,0,24875,24876,7,
+        11,0,0,24876,24877,5,50,0,0,24877,24878,7,3,0,0,24878,3694,1,0,0,
+        0,24879,24880,7,5,0,0,24880,24881,7,18,0,0,24881,24882,7,5,0,0,24882,
+        24883,5,95,0,0,24883,24884,7,2,0,0,24884,24885,7,15,0,0,24885,24886,
+        5,95,0,0,24886,24887,7,1,0,0,24887,24888,7,11,0,0,24888,24889,7,
+        2,0,0,24889,24890,7,2,0,0,24890,24891,7,14,0,0,24891,24892,5,95,
+        0,0,24892,24893,7,16,0,0,24893,24894,7,10,0,0,24894,24895,7,11,0,
+        0,24895,24896,7,4,0,0,24896,24897,7,6,0,0,24897,24898,7,3,0,0,24898,
+        24899,5,95,0,0,24899,24900,7,11,0,0,24900,24901,7,10,0,0,24901,24902,
+        7,5,0,0,24902,24903,7,4,0,0,24903,3696,1,0,0,0,24904,24905,7,5,0,
+        0,24905,24906,7,18,0,0,24906,24907,7,5,0,0,24907,24908,5,95,0,0,
+        24908,24909,7,2,0,0,24909,24910,7,15,0,0,24910,24911,5,95,0,0,24911,
+        24912,7,1,0,0,24912,24913,7,11,0,0,24913,24914,7,2,0,0,24914,24915,
+        7,2,0,0,24915,24916,7,14,0,0,24916,24917,5,95,0,0,24917,24918,7,
+        16,0,0,24918,24919,7,10,0,0,24919,24920,7,11,0,0,24920,24921,7,4,
+        0,0,24921,24922,7,6,0,0,24922,24923,7,3,0,0,24923,3698,1,0,0,0,24924,
+        24925,7,5,0,0,24925,24926,7,18,0,0,24926,24927,7,5,0,0,24927,24928,
+        5,95,0,0,24928,24929,7,2,0,0,24929,24930,7,15,0,0,24930,24931,5,
+        95,0,0,24931,24932,7,8,0,0,24932,24933,5,50,0,0,24933,24934,7,8,
+        0,0,24934,3700,1,0,0,0,24935,24936,7,5,0,0,24936,24937,7,18,0,0,
+        24937,24938,7,5,0,0,24938,24939,5,95,0,0,24939,24940,7,2,0,0,24940,
+        24941,7,15,0,0,24941,24942,5,95,0,0,24942,24943,7,8,0,0,24943,24944,
+        7,0,0,0,24944,24945,7,5,0,0,24945,24946,7,4,0,0,24946,3702,1,0,0,
+        0,24947,24948,7,5,0,0,24948,24949,7,18,0,0,24949,24950,7,5,0,0,24950,
+        24951,5,95,0,0,24951,24952,7,2,0,0,24952,24953,7,15,0,0,24953,24954,
+        5,95,0,0,24954,24955,7,8,0,0,24955,24956,7,6,0,0,24956,24957,7,17,
+        0,0,24957,3704,1,0,0,0,24958,24959,7,5,0,0,24959,24960,7,18,0,0,
+        24960,24961,7,5,0,0,24961,24962,5,95,0,0,24962,24963,7,2,0,0,24963,
+        24964,7,15,0,0,24964,24965,5,95,0,0,24965,24966,7,8,0,0,24966,24967,
+        7,11,0,0,24967,24968,5,50,0,0,24968,24969,7,8,0,0,24969,3706,1,0,
+        0,0,24970,24971,7,5,0,0,24971,24972,7,18,0,0,24972,24973,7,5,0,0,
+        24973,24974,5,95,0,0,24974,24975,7,2,0,0,24975,24976,7,15,0,0,24976,
+        24977,5,95,0,0,24977,24978,7,8,0,0,24978,24979,7,2,0,0,24979,24980,
+        7,14,0,0,24980,24981,7,1,0,0,24981,24982,7,10,0,0,24982,24983,7,
+        7,0,0,24983,24984,7,6,0,0,24984,24985,7,9,0,0,24985,24986,5,95,0,
+        0,24986,24987,7,19,0,0,24987,24988,7,0,0,0,24988,24989,7,5,0,0,24989,
+        24990,7,19,0,0,24990,3708,1,0,0,0,24991,24992,7,5,0,0,24992,24993,
+        7,18,0,0,24993,24994,7,5,0,0,24994,24995,5,95,0,0,24995,24996,7,
+        2,0,0,24996,24997,7,15,0,0,24997,24998,5,95,0,0,24998,24999,7,8,
+        0,0,24999,25000,7,2,0,0,25000,25001,7,14,0,0,25001,25002,7,15,0,
+        0,25002,3710,1,0,0,0,25003,25004,7,5,0,0,25004,25005,7,18,0,0,25005,
+        25006,7,5,0,0,25006,25007,5,95,0,0,25007,25008,7,2,0,0,25008,25009,
+        7,15,0,0,25009,25010,5,95,0,0,25010,25011,7,8,0,0,25011,25012,7,
+        2,0,0,25012,25013,7,7,0,0,25013,25014,7,13,0,0,25014,25015,7,6,0,
+        0,25015,25016,7,3,0,0,25016,25017,7,4,0,0,25017,3712,1,0,0,0,25018,
+        25019,7,5,0,0,25019,25020,7,18,0,0,25020,25021,7,5,0,0,25021,25022,
+        5,95,0,0,25022,25023,7,2,0,0,25023,25024,7,15,0,0,25024,25025,5,
+        95,0,0,25025,25026,7,8,0,0,25026,25027,7,2,0,0,25027,25028,7,12,
+        0,0,25028,25029,7,7,0,0,25029,25030,7,4,0,0,25030,25031,7,8,0,0,
+        25031,25032,7,19,0,0,25032,25033,7,17,0,0,25033,3714,1,0,0,0,25034,
+        25035,7,5,0,0,25035,25036,7,18,0,0,25036,25037,7,5,0,0,25037,25038,
+        5,95,0,0,25038,25039,7,2,0,0,25039,25040,7,15,0,0,25040,25041,5,
+        95,0,0,25041,25042,7,8,0,0,25042,25043,7,5,0,0,25043,25044,7,8,0,
+        0,25044,25045,7,2,0,0,25045,25046,7,7,0,0,25046,25047,7,13,0,0,25047,
+        3716,1,0,0,0,25048,25049,7,5,0,0,25049,25050,7,18,0,0,25050,25051,
+        7,5,0,0,25051,25052,5,95,0,0,25052,25053,7,2,0,0,25053,25054,7,15,
+        0,0,25054,25055,5,95,0,0,25055,25056,7,8,0,0,25056,25057,7,5,0,0,
+        25057,25058,7,8,0,0,25058,25059,7,2,0,0,25059,25060,7,7,0,0,25060,
+        25061,7,13,0,0,25061,25062,7,4,0,0,25062,25063,7,6,0,0,25063,25064,
+        7,5,0,0,25064,25065,7,4,0,0,25065,3718,1,0,0,0,25066,25067,7,5,0,
+        0,25067,25068,7,18,0,0,25068,25069,7,5,0,0,25069,25070,5,95,0,0,
+        25070,25071,7,2,0,0,25071,25072,7,15,0,0,25072,25073,5,95,0,0,25073,
+        25074,7,8,0,0,25074,25075,7,5,0,0,25075,25076,7,3,0,0,25076,3720,
+        1,0,0,0,25077,25078,7,5,0,0,25078,25079,7,18,0,0,25079,25080,7,5,
+        0,0,25080,25081,5,95,0,0,25081,25082,7,2,0,0,25082,25083,7,15,0,
+        0,25083,25084,5,95,0,0,25084,25085,7,8,0,0,25085,25086,7,5,0,0,25086,
+        25087,7,25,0,0,25087,25088,5,95,0,0,25088,25089,7,15,0,0,25089,25090,
+        7,0,0,0,25090,25091,7,4,0,0,25091,25092,7,8,0,0,25092,25093,7,19,
+        0,0,25093,3722,1,0,0,0,25094,25095,7,5,0,0,25095,25096,7,18,0,0,
+        25096,25097,7,5,0,0,25097,25098,5,95,0,0,25098,25099,7,2,0,0,25099,
+        25100,7,15,0,0,25100,25101,5,95,0,0,25101,25102,7,8,0,0,25102,25103,
+        7,18,0,0,25103,25104,7,8,0,0,25104,25105,7,11,0,0,25105,25106,7,
+        6,0,0,25106,25107,7,9,0,0,25107,25108,5,95,0,0,25108,25109,7,5,0,
+        0,25109,25110,7,6,0,0,25110,25111,7,24,0,0,25111,3724,1,0,0,0,25112,
+        25113,7,5,0,0,25113,25114,7,18,0,0,25114,25115,7,5,0,0,25115,25116,
+        5,95,0,0,25116,25117,7,2,0,0,25117,25118,7,15,0,0,25118,25119,5,
+        95,0,0,25119,25120,7,9,0,0,25120,25121,7,6,0,0,25121,25122,7,8,0,
+        0,25122,25123,7,2,0,0,25123,25124,7,14,0,0,25124,25125,7,15,0,0,
+        25125,3726,1,0,0,0,25126,25127,7,5,0,0,25127,25128,7,18,0,0,25128,
+        25129,7,5,0,0,25129,25130,5,95,0,0,25130,25131,7,2,0,0,25131,25132,
+        7,15,0,0,25132,25133,5,95,0,0,25133,25134,7,9,0,0,25134,25135,7,
+        6,0,0,25135,25136,7,5,0,0,25136,25137,7,8,0,0,25137,25138,7,6,0,
+        0,25138,25139,7,7,0,0,25139,25140,7,9,0,0,25140,3728,1,0,0,0,25141,
+        25142,7,5,0,0,25142,25143,7,18,0,0,25143,25144,7,5,0,0,25144,25145,
+        5,95,0,0,25145,25146,7,2,0,0,25146,25147,7,15,0,0,25147,25148,5,
+        95,0,0,25148,25149,7,9,0,0,25149,25150,7,10,0,0,25150,25151,7,5,
+        0,0,25151,25152,7,4,0,0,25152,25153,7,10,0,0,25153,25154,7,7,0,0,
+        25154,25155,7,8,0,0,25155,25156,7,4,0,0,25156,3730,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,2,0,0,25162,25163,7,15,0,0,25163,25164,5,
+        95,0,0,25164,25165,7,9,0,0,25165,25166,7,3,0,0,25166,25167,7,0,0,
+        0,25167,3732,1,0,0,0,25168,25169,7,5,0,0,25169,25170,7,18,0,0,25170,
+        25171,7,5,0,0,25171,25172,5,95,0,0,25172,25173,7,2,0,0,25173,25174,
+        7,15,0,0,25174,25175,5,95,0,0,25175,25176,7,9,0,0,25176,25177,7,
+        12,0,0,25177,25178,7,14,0,0,25178,25179,7,15,0,0,25179,3734,1,0,
+        0,0,25180,25181,7,5,0,0,25181,25182,7,18,0,0,25182,25183,7,5,0,0,
+        25183,25184,5,95,0,0,25184,25185,7,2,0,0,25185,25186,7,15,0,0,25186,
+        25187,5,95,0,0,25187,25188,7,9,0,0,25188,25189,7,13,0,0,25189,25190,
+        5,95,0,0,25190,25191,7,8,0,0,25191,25192,7,19,0,0,25192,25193,7,
+        6,0,0,25193,25194,7,8,0,0,25194,25195,7,21,0,0,25195,3736,1,0,0,
+        0,25196,25197,7,5,0,0,25197,25198,7,18,0,0,25198,25199,7,5,0,0,25199,
+        25200,5,95,0,0,25200,25201,7,2,0,0,25201,25202,7,15,0,0,25202,25203,
+        5,95,0,0,25203,25204,7,6,0,0,25204,25205,7,7,0,0,25205,25206,7,16,
+        0,0,25206,25207,7,2,0,0,25207,25208,7,3,0,0,25208,25209,7,8,0,0,
+        25209,25210,7,6,0,0,25210,25211,5,95,0,0,25211,25212,7,7,0,0,25212,
+        25213,7,2,0,0,25213,25214,7,4,0,0,25214,25215,5,95,0,0,25215,25216,
+        7,7,0,0,25216,25217,7,12,0,0,25217,25218,7,11,0,0,25218,25219,7,
+        11,0,0,25219,25220,5,36,0,0,25220,3738,1,0,0,0,25221,25222,7,5,0,
+        0,25222,25223,7,18,0,0,25223,25224,7,5,0,0,25224,25225,7,2,0,0,25225,
+        25226,7,15,0,0,25226,25227,7,6,0,0,25227,25228,7,3,0,0,25228,3740,
+        1,0,0,0,25229,25230,7,5,0,0,25230,25231,7,18,0,0,25231,25232,7,5,
+        0,0,25232,25233,5,95,0,0,25233,25234,7,2,0,0,25234,25235,7,15,0,
+        0,25235,25236,5,95,0,0,25236,25237,7,6,0,0,25237,25238,7,25,0,0,
+        25238,25239,7,4,0,0,25239,25240,7,3,0,0,25240,25241,7,0,0,0,25241,
+        25242,7,8,0,0,25242,25243,7,4,0,0,25243,3742,1,0,0,0,25244,25245,
+        7,5,0,0,25245,25246,7,18,0,0,25246,25247,7,5,0,0,25247,25248,5,95,
+        0,0,25248,25249,7,2,0,0,25249,25250,7,15,0,0,25250,25251,5,95,0,
+        0,25251,25252,7,17,0,0,25252,25253,7,3,0,0,25253,25254,7,2,0,0,25254,
+        25255,7,12,0,0,25255,25256,7,15,0,0,25256,25257,7,10,0,0,25257,25258,
+        7,7,0,0,25258,25259,7,17,0,0,25259,3744,1,0,0,0,25260,25261,7,5,
+        0,0,25261,25262,7,18,0,0,25262,25263,7,5,0,0,25263,25264,5,95,0,
+        0,25264,25265,7,2,0,0,25265,25266,7,15,0,0,25266,25267,5,95,0,0,
+        25267,25268,7,17,0,0,25268,25269,7,12,0,0,25269,25270,7,10,0,0,25270,
+        25271,7,9,0,0,25271,3746,1,0,0,0,25272,25273,7,5,0,0,25273,25274,
+        7,18,0,0,25274,25275,7,5,0,0,25275,25276,5,95,0,0,25276,25277,7,
+        2,0,0,25277,25278,7,15,0,0,25278,25279,5,95,0,0,25279,25280,7,19,
+        0,0,25280,25281,7,0,0,0,25281,25282,7,5,0,0,25282,25283,7,19,0,0,
+        25283,3748,1,0,0,0,25284,25285,7,5,0,0,25285,25286,7,18,0,0,25286,
+        25287,7,5,0,0,25287,25288,5,95,0,0,25288,25289,7,2,0,0,25289,25290,
+        7,15,0,0,25290,25291,5,95,0,0,25291,25292,7,10,0,0,25292,25293,7,
+        10,0,0,25293,25294,7,25,0,0,25294,3750,1,0,0,0,25295,25296,7,5,0,
+        0,25296,25297,7,18,0,0,25297,25298,7,5,0,0,25298,25299,5,95,0,0,
+        25299,25300,7,2,0,0,25300,25301,7,15,0,0,25301,25302,5,95,0,0,25302,
+        25303,7,10,0,0,25303,25304,7,4,0,0,25304,25305,7,3,0,0,25305,3752,
+        1,0,0,0,25306,25307,7,5,0,0,25307,25308,7,18,0,0,25308,25309,7,5,
+        0,0,25309,25310,5,95,0,0,25310,25311,7,2,0,0,25311,25312,7,15,0,
+        0,25312,25313,5,95,0,0,25313,25314,7,21,0,0,25314,25315,7,6,0,0,
+        25315,25316,7,18,0,0,25316,25317,5,95,0,0,25317,25318,7,13,0,0,25318,
+        25319,7,6,0,0,25319,25320,7,8,0,0,25320,25321,7,4,0,0,25321,25322,
+        7,2,0,0,25322,25323,7,3,0,0,25323,25324,5,95,0,0,25324,25325,7,8,
+        0,0,25325,25326,7,3,0,0,25326,25327,7,6,0,0,25327,25328,7,0,0,0,
+        25328,25329,7,4,0,0,25329,25330,7,6,0,0,25330,3754,1,0,0,0,25331,
+        25332,7,5,0,0,25332,25333,7,18,0,0,25333,25334,7,5,0,0,25334,25335,
+        5,95,0,0,25335,25336,7,2,0,0,25336,25337,7,15,0,0,25337,25338,5,
+        95,0,0,25338,25339,7,21,0,0,25339,25340,7,6,0,0,25340,25341,7,18,
+        0,0,25341,25342,5,95,0,0,25342,25343,7,13,0,0,25343,25344,7,6,0,
+        0,25344,25345,7,8,0,0,25345,25346,7,4,0,0,25346,25347,7,2,0,0,25347,
+        25348,7,3,0,0,25348,25349,5,95,0,0,25349,25350,7,16,0,0,25350,25351,
+        7,10,0,0,25351,25352,7,11,0,0,25352,25353,7,4,0,0,25353,25354,7,
+        6,0,0,25354,25355,7,3,0,0,25355,25356,5,95,0,0,25356,25357,7,11,
+        0,0,25357,25358,7,10,0,0,25358,25359,7,5,0,0,25359,25360,7,4,0,0,
+        25360,3756,1,0,0,0,25361,25362,7,5,0,0,25362,25363,7,18,0,0,25363,
+        25364,7,5,0,0,25364,25365,5,95,0,0,25365,25366,7,2,0,0,25366,25367,
+        7,15,0,0,25367,25368,5,95,0,0,25368,25369,7,21,0,0,25369,25370,7,
+        6,0,0,25370,25371,7,18,0,0,25371,25372,5,95,0,0,25372,25373,7,13,
+        0,0,25373,25374,7,6,0,0,25374,25375,7,8,0,0,25375,25376,7,4,0,0,
+        25376,25377,7,2,0,0,25377,25378,7,3,0,0,25378,25379,5,95,0,0,25379,
+        25380,7,16,0,0,25380,25381,7,10,0,0,25381,25382,7,11,0,0,25382,25383,
+        7,4,0,0,25383,25384,7,6,0,0,25384,25385,7,3,0,0,25385,3758,1,0,0,
+        0,25386,25387,7,5,0,0,25387,25388,7,18,0,0,25388,25389,7,5,0,0,25389,
+        25390,5,95,0,0,25390,25391,7,2,0,0,25391,25392,7,15,0,0,25392,25393,
+        5,95,0,0,25393,25394,7,21,0,0,25394,25395,7,6,0,0,25395,25396,7,
+        18,0,0,25396,25397,5,95,0,0,25397,25398,7,13,0,0,25398,25399,7,6,
+        0,0,25399,25400,7,8,0,0,25400,25401,7,4,0,0,25401,25402,7,2,0,0,
+        25402,25403,7,3,0,0,25403,25404,5,95,0,0,25404,25405,7,5,0,0,25405,
+        25406,7,12,0,0,25406,25407,7,8,0,0,25407,25408,7,8,0,0,25408,25409,
+        7,6,0,0,25409,25410,7,6,0,0,25410,25411,7,9,0,0,25411,25412,7,6,
+        0,0,25412,25413,7,9,0,0,25413,3760,1,0,0,0,25414,25415,7,5,0,0,25415,
+        25416,7,18,0,0,25416,25417,7,5,0,0,25417,25418,5,95,0,0,25418,25419,
+        7,2,0,0,25419,25420,7,15,0,0,25420,25421,5,95,0,0,25421,25422,7,
+        21,0,0,25422,25423,7,6,0,0,25423,25424,7,18,0,0,25424,25425,5,95,
+        0,0,25425,25426,7,13,0,0,25426,25427,7,6,0,0,25427,25428,7,8,0,0,
+        25428,25429,7,4,0,0,25429,25430,7,2,0,0,25430,25431,7,3,0,0,25431,
+        25432,5,95,0,0,25432,25433,7,12,0,0,25433,25434,7,5,0,0,25434,25435,
+        7,6,0,0,25435,3762,1,0,0,0,25436,25437,7,5,0,0,25437,25438,7,18,
+        0,0,25438,25439,7,5,0,0,25439,25440,5,95,0,0,25440,25441,7,2,0,0,
+        25441,25442,7,15,0,0,25442,25443,5,95,0,0,25443,25444,7,11,0,0,25444,
+        25445,7,1,0,0,25445,25446,7,10,0,0,25446,25447,7,9,0,0,25447,3764,
+        1,0,0,0,25448,25449,7,5,0,0,25449,25450,7,18,0,0,25450,25451,7,5,
+        0,0,25451,25452,5,95,0,0,25452,25453,7,2,0,0,25453,25454,7,15,0,
+        0,25454,25455,5,95,0,0,25455,25456,7,11,0,0,25456,25457,7,2,0,0,
+        25457,25458,7,1,0,0,25458,25459,7,11,0,0,25459,25460,7,2,0,0,25460,
+        25461,7,8,0,0,25461,25462,5,50,0,0,25462,25463,7,1,0,0,25463,25464,
+        7,11,0,0,25464,25465,7,2,0,0,25465,25466,7,1,0,0,25466,3766,1,0,
+        0,0,25467,25468,7,5,0,0,25468,25469,7,18,0,0,25469,25470,7,5,0,0,
+        25470,25471,5,95,0,0,25471,25472,7,2,0,0,25472,25473,7,15,0,0,25473,
+        25474,5,95,0,0,25474,25475,7,11,0,0,25475,25476,7,2,0,0,25476,25477,
+        7,1,0,0,25477,25478,7,11,0,0,25478,25479,7,2,0,0,25479,25480,7,8,
+        0,0,25480,25481,5,50,0,0,25481,25482,7,8,0,0,25482,25483,7,11,0,
+        0,25483,25484,7,2,0,0,25484,25485,7,1,0,0,25485,3768,1,0,0,0,25486,
+        25487,7,5,0,0,25487,25488,7,18,0,0,25488,25489,7,5,0,0,25489,25490,
+        5,95,0,0,25490,25491,7,2,0,0,25491,25492,7,15,0,0,25492,25493,5,
+        95,0,0,25493,25494,7,11,0,0,25494,25495,7,2,0,0,25495,25496,7,1,
+        0,0,25496,25497,7,11,0,0,25497,25498,7,2,0,0,25498,25499,7,8,0,0,
+        25499,25500,5,50,0,0,25500,25501,7,10,0,0,25501,25502,7,9,0,0,25502,
+        3770,1,0,0,0,25503,25504,7,5,0,0,25504,25505,7,18,0,0,25505,25506,
+        7,5,0,0,25506,25507,5,95,0,0,25507,25508,7,2,0,0,25508,25509,7,15,
+        0,0,25509,25510,5,95,0,0,25510,25511,7,11,0,0,25511,25512,7,2,0,
+        0,25512,25513,7,1,0,0,25513,25514,7,11,0,0,25514,25515,7,2,0,0,25515,
+        25516,7,8,0,0,25516,25517,5,50,0,0,25517,25518,7,7,0,0,25518,25519,
+        7,8,0,0,25519,25520,7,11,0,0,25520,25521,7,2,0,0,25521,25522,7,1,
+        0,0,25522,3772,1,0,0,0,25523,25524,7,5,0,0,25524,25525,7,18,0,0,
+        25525,25526,7,5,0,0,25526,25527,5,95,0,0,25527,25528,7,2,0,0,25528,
+        25529,7,15,0,0,25529,25530,5,95,0,0,25530,25531,7,11,0,0,25531,25532,
+        7,2,0,0,25532,25533,7,1,0,0,25533,25534,7,11,0,0,25534,25535,7,2,
+        0,0,25535,25536,7,8,0,0,25536,25537,5,50,0,0,25537,25538,7,4,0,0,
+        25538,25539,7,18,0,0,25539,25540,7,15,0,0,25540,3774,1,0,0,0,25541,
+        25542,7,5,0,0,25542,25543,7,18,0,0,25543,25544,7,5,0,0,25544,25545,
+        5,95,0,0,25545,25546,7,2,0,0,25546,25547,7,15,0,0,25547,25548,5,
+        95,0,0,25548,25549,7,11,0,0,25549,25550,7,5,0,0,25550,25551,7,13,
+        0,0,25551,25552,7,10,0,0,25552,3776,1,0,0,0,25553,25554,7,5,0,0,
+        25554,25555,7,18,0,0,25555,25556,7,5,0,0,25556,25557,5,95,0,0,25557,
+        25558,7,2,0,0,25558,25559,7,15,0,0,25559,25560,5,95,0,0,25560,25561,
+        7,11,0,0,25561,25562,7,13,0,0,25562,25563,7,11,0,0,25563,3778,1,
+        0,0,0,25564,25565,7,5,0,0,25565,25566,7,18,0,0,25566,25567,7,5,0,
+        0,25567,25568,5,95,0,0,25568,25569,7,2,0,0,25569,25570,7,15,0,0,
+        25570,25571,5,95,0,0,25571,25572,7,14,0,0,25572,25573,7,0,0,0,25573,
+        25574,7,21,0,0,25574,25575,7,6,0,0,25575,25576,7,2,0,0,25576,25577,
+        7,10,0,0,25577,25578,7,9,0,0,25578,3780,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,2,0,0,25584,25585,7,15,0,0,25585,25586,5,95,0,0,
+        25586,25587,7,14,0,0,25587,25588,7,0,0,0,25588,25589,7,15,0,0,25589,
+        25590,5,95,0,0,25590,25591,7,7,0,0,25591,25592,7,2,0,0,25592,25593,
+        7,7,0,0,25593,25594,7,7,0,0,25594,25595,7,12,0,0,25595,25596,7,11,
+        0,0,25596,25597,7,11,0,0,25597,3782,1,0,0,0,25598,25599,7,5,0,0,
+        25599,25600,7,18,0,0,25600,25601,7,5,0,0,25601,25602,5,95,0,0,25602,
+        25603,7,2,0,0,25603,25604,7,15,0,0,25604,25605,5,95,0,0,25605,25606,
+        7,14,0,0,25606,25607,7,5,0,0,25607,25608,7,3,0,0,25608,3784,1,0,
+        0,0,25609,25610,7,5,0,0,25610,25611,7,18,0,0,25611,25612,7,5,0,0,
+        25612,25613,5,95,0,0,25613,25614,7,2,0,0,25614,25615,7,15,0,0,25615,
+        25616,5,95,0,0,25616,25617,7,7,0,0,25617,25618,7,10,0,0,25618,25619,
+        7,8,0,0,25619,25620,7,2,0,0,25620,25621,7,14,0,0,25621,25622,7,1,
+        0,0,25622,25623,7,10,0,0,25623,25624,7,7,0,0,25624,25625,7,6,0,0,
+        25625,3786,1,0,0,0,25626,25627,7,5,0,0,25627,25628,7,18,0,0,25628,
+        25629,7,5,0,0,25629,25630,5,95,0,0,25630,25631,7,2,0,0,25631,25632,
+        7,15,0,0,25632,25633,5,95,0,0,25633,25634,7,7,0,0,25634,25635,7,
+        10,0,0,25635,25636,7,6,0,0,25636,25637,7,25,0,0,25637,25638,7,4,
+        0,0,25638,25639,7,3,0,0,25639,25640,7,0,0,0,25640,25641,7,8,0,0,
+        25641,25642,7,4,0,0,25642,3788,1,0,0,0,25643,25644,7,5,0,0,25644,
+        25645,7,18,0,0,25645,25646,7,5,0,0,25646,25647,5,95,0,0,25647,25648,
+        7,2,0,0,25648,25649,7,15,0,0,25649,25650,5,95,0,0,25650,25651,7,
+        7,0,0,25651,25652,7,10,0,0,25652,25653,7,10,0,0,25653,3790,1,0,0,
+        0,25654,25655,7,5,0,0,25655,25656,7,18,0,0,25656,25657,7,5,0,0,25657,
+        25658,5,95,0,0,25658,25659,7,2,0,0,25659,25660,7,15,0,0,25660,25661,
+        5,95,0,0,25661,25662,7,7,0,0,25662,25663,7,10,0,0,25663,25664,7,
+        25,0,0,25664,3792,1,0,0,0,25665,25666,7,5,0,0,25666,25667,7,18,0,
+        0,25667,25668,7,5,0,0,25668,25669,5,95,0,0,25669,25670,7,2,0,0,25670,
+        25671,7,15,0,0,25671,25672,5,95,0,0,25672,25673,7,7,0,0,25673,25674,
+        7,2,0,0,25674,25675,7,6,0,0,25675,25676,7,25,0,0,25676,25677,7,15,
+        0,0,25677,25678,7,0,0,0,25678,25679,7,7,0,0,25679,25680,7,9,0,0,
+        25680,3794,1,0,0,0,25681,25682,7,5,0,0,25682,25683,7,18,0,0,25683,
+        25684,7,5,0,0,25684,25685,5,95,0,0,25685,25686,7,2,0,0,25686,25687,
+        7,15,0,0,25687,25688,5,95,0,0,25688,25689,7,7,0,0,25689,25690,7,
+        4,0,0,25690,25691,7,8,0,0,25691,25692,7,10,0,0,25692,25693,7,14,
+        0,0,25693,25694,7,17,0,0,25694,25695,5,36,0,0,25695,3796,1,0,0,0,
+        25696,25697,7,5,0,0,25697,25698,7,18,0,0,25698,25699,7,5,0,0,25699,
+        25700,5,95,0,0,25700,25701,7,2,0,0,25701,25702,7,15,0,0,25702,25703,
+        5,95,0,0,25703,25704,7,7,0,0,25704,25705,7,12,0,0,25705,25706,7,
+        14,0,0,25706,25707,7,4,0,0,25707,25708,7,2,0,0,25708,25709,7,3,0,
+        0,25709,25710,7,0,0,0,25710,25711,7,22,0,0,25711,3798,1,0,0,0,25712,
+        25713,7,5,0,0,25713,25714,7,18,0,0,25714,25715,7,5,0,0,25715,25716,
+        5,95,0,0,25716,25717,7,2,0,0,25717,25718,7,15,0,0,25718,25719,5,
+        95,0,0,25719,25720,7,2,0,0,25720,25721,7,10,0,0,25721,25722,7,9,
+        0,0,25722,25723,7,13,0,0,25723,25724,7,0,0,0,25724,25725,7,11,0,
+        0,25725,25726,7,12,0,0,25726,25727,7,6,0,0,25727,3800,1,0,0,0,25728,
+        25729,7,5,0,0,25729,25730,7,18,0,0,25730,25731,7,5,0,0,25731,25732,
+        5,95,0,0,25732,25733,7,2,0,0,25733,25734,7,15,0,0,25734,25735,5,
+        95,0,0,25735,25736,7,2,0,0,25736,25737,7,15,0,0,25737,25738,7,7,
+        0,0,25738,25739,7,5,0,0,25739,25740,7,10,0,0,25740,25741,7,23,0,
+        0,25741,25742,7,6,0,0,25742,3802,1,0,0,0,25743,25744,7,5,0,0,25744,
+        25745,7,18,0,0,25745,25746,7,5,0,0,25746,25747,5,95,0,0,25747,25748,
+        7,2,0,0,25748,25749,7,15,0,0,25749,25750,5,95,0,0,25750,25751,7,
+        15,0,0,25751,25752,7,0,0,0,25752,25753,7,3,0,0,25753,25754,5,95,
+        0,0,25754,25755,5,49,0,0,25755,3804,1,0,0,0,25756,25757,7,5,0,0,
+        25757,25758,7,18,0,0,25758,25759,7,5,0,0,25759,25760,5,95,0,0,25760,
+        25761,7,2,0,0,25761,25762,7,15,0,0,25762,25763,5,95,0,0,25763,25764,
+        7,15,0,0,25764,25765,7,0,0,0,25765,25766,7,3,0,0,25766,25767,7,17,
+        0,0,25767,25768,7,10,0,0,25768,25769,7,9,0,0,25769,25770,5,95,0,
+        0,25770,25771,5,49,0,0,25771,3806,1,0,0,0,25772,25773,7,5,0,0,25773,
+        25774,7,18,0,0,25774,25775,7,5,0,0,25775,25776,5,95,0,0,25776,25777,
+        7,2,0,0,25777,25778,7,15,0,0,25778,25779,5,95,0,0,25779,25780,7,
+        15,0,0,25780,25781,7,0,0,0,25781,25782,7,3,0,0,25782,25783,7,17,
+        0,0,25783,25784,7,10,0,0,25784,25785,7,9,0,0,25785,3808,1,0,0,0,
+        25786,25787,7,5,0,0,25787,25788,7,18,0,0,25788,25789,7,5,0,0,25789,
+        25790,5,95,0,0,25790,25791,7,2,0,0,25791,25792,7,15,0,0,25792,25793,
+        5,95,0,0,25793,25794,7,15,0,0,25794,25795,7,0,0,0,25795,25796,7,
+        3,0,0,25796,3810,1,0,0,0,25797,25798,7,5,0,0,25798,25799,7,18,0,
+        0,25799,25800,7,5,0,0,25800,25801,5,95,0,0,25801,25802,7,2,0,0,25802,
+        25803,7,15,0,0,25803,25804,5,95,0,0,25804,25805,7,15,0,0,25805,25806,
+        7,0,0,0,25806,25807,7,3,0,0,25807,25808,7,4,0,0,25808,25809,5,95,
+        0,0,25809,25810,7,10,0,0,25810,25811,7,9,0,0,25811,3812,1,0,0,0,
+        25812,25813,7,5,0,0,25813,25814,7,18,0,0,25814,25815,7,5,0,0,25815,
+        25816,5,95,0,0,25816,25817,7,2,0,0,25817,25818,7,15,0,0,25818,25819,
+        5,95,0,0,25819,25820,7,15,0,0,25820,25821,7,10,0,0,25821,25822,7,
+        13,0,0,25822,25823,7,2,0,0,25823,25824,7,4,0,0,25824,3814,1,0,0,
+        0,25825,25826,7,5,0,0,25826,25827,7,18,0,0,25827,25828,7,5,0,0,25828,
+        25829,5,95,0,0,25829,25830,7,2,0,0,25830,25831,7,15,0,0,25831,25832,
+        5,95,0,0,25832,25833,7,3,0,0,25833,25834,5,50,0,0,25834,25835,7,
+        2,0,0,25835,3816,1,0,0,0,25836,25837,7,5,0,0,25837,25838,7,18,0,
+        0,25838,25839,7,5,0,0,25839,25840,5,95,0,0,25840,25841,7,2,0,0,25841,
+        25842,7,15,0,0,25842,25843,5,95,0,0,25843,25844,7,3,0,0,25844,25845,
+        7,0,0,0,25845,25846,7,22,0,0,25846,25847,7,4,0,0,25847,25848,7,2,
+        0,0,25848,25849,7,7,0,0,25849,25850,7,12,0,0,25850,25851,7,14,0,
+        0,25851,3818,1,0,0,0,25852,25853,7,5,0,0,25853,25854,7,18,0,0,25854,
+        25855,7,5,0,0,25855,25856,5,95,0,0,25856,25857,7,2,0,0,25857,25858,
+        7,15,0,0,25858,25859,5,95,0,0,25859,25860,7,3,0,0,25860,25861,7,
+        9,0,0,25861,25862,7,4,0,0,25862,25863,7,14,0,0,25863,3820,1,0,0,
+        0,25864,25865,7,5,0,0,25865,25866,7,18,0,0,25866,25867,7,5,0,0,25867,
+        25868,5,95,0,0,25868,25869,7,2,0,0,25869,25870,7,15,0,0,25870,25871,
+        5,95,0,0,25871,25872,7,3,0,0,25872,25873,7,6,0,0,25873,25874,7,16,
+        0,0,25874,3822,1,0,0,0,25875,25876,7,5,0,0,25876,25877,7,18,0,0,
+        25877,25878,7,5,0,0,25878,25879,5,95,0,0,25879,25880,7,2,0,0,25880,
+        25881,7,15,0,0,25881,25882,5,95,0,0,25882,25883,7,3,0,0,25883,25884,
+        7,14,0,0,25884,25885,7,4,0,0,25885,25886,7,9,0,0,25886,3824,1,0,
+        0,0,25887,25888,7,5,0,0,25888,25889,7,18,0,0,25889,25890,7,5,0,0,
+        25890,25891,5,95,0,0,25891,25892,7,2,0,0,25892,25893,7,15,0,0,25893,
+        25894,5,95,0,0,25894,25895,7,3,0,0,25895,25896,7,2,0,0,25896,25897,
+        7,22,0,0,25897,25898,7,10,0,0,25898,25899,7,9,0,0,25899,25900,7,
+        4,0,0,25900,25901,7,2,0,0,25901,25902,7,2,0,0,25902,25903,7,1,0,
+        0,25903,25904,7,20,0,0,25904,3826,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,2,0,0,25910,25911,7,15,0,0,25911,25912,5,95,0,0,25912,25913,7,
+        3,0,0,25913,25914,7,15,0,0,25914,25915,7,1,0,0,25915,3828,1,0,0,
+        0,25916,25917,7,5,0,0,25917,25918,7,18,0,0,25918,25919,7,5,0,0,25919,
+        25920,5,95,0,0,25920,25921,7,2,0,0,25921,25922,7,15,0,0,25922,25923,
+        7,4,0,0,25923,25924,7,11,0,0,25924,25925,7,2,0,0,25925,25926,7,1,
+        0,0,25926,25927,7,15,0,0,25927,25928,7,3,0,0,25928,25929,7,1,0,0,
+        25929,25930,7,5,0,0,25930,25931,7,8,0,0,25931,3830,1,0,0,0,25932,
+        25933,7,5,0,0,25933,25934,7,18,0,0,25934,25935,7,5,0,0,25935,25936,
+        5,95,0,0,25936,25937,7,2,0,0,25937,25938,7,15,0,0,25938,25939,5,
+        95,0,0,25939,25940,7,4,0,0,25940,25941,7,2,0,0,25941,25942,7,5,0,
+        0,25942,25943,7,6,0,0,25943,25944,7,4,0,0,25944,25945,7,10,0,0,25945,
+        25946,7,9,0,0,25946,3832,1,0,0,0,25947,25948,7,5,0,0,25948,25949,
+        7,18,0,0,25949,25950,7,5,0,0,25950,25951,5,95,0,0,25951,25952,7,
+        2,0,0,25952,25953,7,15,0,0,25953,25954,5,95,0,0,25954,25955,7,4,
+        0,0,25955,25956,7,15,0,0,25956,25957,7,3,0,0,25957,3834,1,0,0,0,
+        25958,25959,7,5,0,0,25959,25960,7,18,0,0,25960,25961,7,5,0,0,25961,
+        25962,5,95,0,0,25962,25963,7,2,0,0,25963,25964,7,15,0,0,25964,25965,
+        5,95,0,0,25965,25966,7,4,0,0,25966,25967,7,3,0,0,25967,25968,7,4,
+        0,0,25968,25969,7,1,0,0,25969,3836,1,0,0,0,25970,25971,7,5,0,0,25971,
+        25972,7,18,0,0,25972,25973,7,5,0,0,25973,25974,5,95,0,0,25974,25975,
+        7,2,0,0,25975,25976,7,15,0,0,25976,25977,7,4,0,0,25977,25978,7,25,
+        0,0,25978,25979,7,10,0,0,25979,25980,7,8,0,0,25980,25981,7,14,0,
+        0,25981,25982,7,15,0,0,25982,3838,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,2,0,0,25988,25989,7,15,0,0,25989,25990,7,4,0,0,25990,25991,7,25,
+        0,0,25991,25992,7,24,0,0,25992,25993,7,8,0,0,25993,25994,7,0,0,0,
+        25994,25995,7,5,0,0,25995,25996,7,4,0,0,25996,25997,7,0,0,0,25997,
+        25998,7,5,0,0,25998,25999,7,7,0,0,25999,26000,7,24,0,0,26000,3840,
+        1,0,0,0,26001,26002,7,5,0,0,26002,26003,7,18,0,0,26003,26004,7,5,
+        0,0,26004,26005,5,95,0,0,26005,26006,7,2,0,0,26006,26007,7,15,0,
+        0,26007,26008,5,95,0,0,26008,26009,7,12,0,0,26009,26010,7,7,0,0,
+        26010,26011,7,9,0,0,26011,26012,7,6,0,0,26012,26013,7,5,0,0,26013,
+        26014,7,8,0,0,26014,26015,7,6,0,0,26015,26016,7,7,0,0,26016,26017,
+        7,9,0,0,26017,3842,1,0,0,0,26018,26019,7,5,0,0,26019,26020,7,18,
+        0,0,26020,26021,7,5,0,0,26021,26022,5,95,0,0,26022,26023,7,2,0,0,
+        26023,26024,7,15,0,0,26024,26025,5,95,0,0,26025,26026,7,13,0,0,26026,
+        26027,7,6,0,0,26027,26028,7,8,0,0,26028,26029,7,0,0,0,26029,26030,
+        7,7,0,0,26030,26031,7,9,0,0,26031,3844,1,0,0,0,26032,26033,7,5,0,
+        0,26033,26034,7,18,0,0,26034,26035,7,5,0,0,26035,26036,5,95,0,0,
+        26036,26037,7,2,0,0,26037,26038,7,15,0,0,26038,26039,5,95,0,0,26039,
+        26040,7,13,0,0,26040,26041,7,6,0,0,26041,26042,7,8,0,0,26042,26043,
+        7,1,0,0,26043,26044,7,10,0,0,26044,26045,7,4,0,0,26045,3846,1,0,
+        0,0,26046,26047,7,5,0,0,26047,26048,7,18,0,0,26048,26049,7,5,0,0,
+        26049,26050,5,95,0,0,26050,26051,7,2,0,0,26051,26052,7,15,0,0,26052,
+        26053,5,95,0,0,26053,26054,7,13,0,0,26054,26055,7,6,0,0,26055,26056,
+        7,8,0,0,26056,26057,7,2,0,0,26057,26058,7,3,0,0,26058,3848,1,0,0,
+        0,26059,26060,7,5,0,0,26060,26061,7,18,0,0,26061,26062,7,5,0,0,26062,
+        26063,5,95,0,0,26063,26064,7,2,0,0,26064,26065,7,15,0,0,26065,26066,
+        5,95,0,0,26066,26067,7,13,0,0,26067,26068,7,6,0,0,26068,26069,7,
+        8,0,0,26069,26070,7,25,0,0,26070,26071,7,2,0,0,26071,26072,7,3,0,
+        0,26072,3850,1,0,0,0,26073,26074,7,5,0,0,26074,26075,7,18,0,0,26075,
+        26076,7,5,0,0,26076,26077,5,95,0,0,26077,26078,7,2,0,0,26078,26079,
+        7,15,0,0,26079,26080,5,95,0,0,26080,26081,7,13,0,0,26081,26082,7,
+        6,0,0,26082,26083,7,3,0,0,26083,26084,7,5,0,0,26084,26085,7,10,0,
+        0,26085,26086,7,2,0,0,26086,26087,7,7,0,0,26087,3852,1,0,0,0,26088,
+        26089,7,5,0,0,26089,26090,7,18,0,0,26090,26091,7,5,0,0,26091,26092,
+        5,95,0,0,26092,26093,7,2,0,0,26093,26094,7,15,0,0,26094,26095,5,
+        95,0,0,26095,26096,7,13,0,0,26096,26097,7,3,0,0,26097,26098,7,6,
+        0,0,26098,26099,7,16,0,0,26099,3854,1,0,0,0,26100,26101,7,5,0,0,
+        26101,26102,7,18,0,0,26102,26103,7,5,0,0,26103,26104,5,95,0,0,26104,
+        26105,7,2,0,0,26105,26106,7,15,0,0,26106,26107,5,95,0,0,26107,26108,
+        7,13,0,0,26108,26109,7,13,0,0,26109,26110,7,9,0,0,26110,3856,1,0,
+        0,0,26111,26112,7,5,0,0,26112,26113,7,18,0,0,26113,26114,7,5,0,0,
+        26114,26115,5,95,0,0,26115,26116,7,2,0,0,26116,26117,7,15,0,0,26117,
+        26118,5,95,0,0,26118,26119,7,25,0,0,26119,26120,7,14,0,0,26120,26121,
+        7,11,0,0,26121,26122,7,8,0,0,26122,26123,7,2,0,0,26123,26124,7,7,
+        0,0,26124,26125,7,5,0,0,26125,26126,5,95,0,0,26126,26127,7,16,0,
+        0,26127,26128,7,2,0,0,26128,26129,7,3,0,0,26129,26130,5,95,0,0,26130,
+        26131,7,8,0,0,26131,26132,7,5,0,0,26132,26133,7,25,0,0,26133,3858,
+        1,0,0,0,26134,26135,7,5,0,0,26135,26136,7,18,0,0,26136,26137,7,5,
+        0,0,26137,26138,5,95,0,0,26138,26139,7,2,0,0,26139,26140,7,15,0,
+        0,26140,26141,5,95,0,0,26141,26142,7,25,0,0,26142,26143,7,15,0,0,
+        26143,26144,7,4,0,0,26144,26145,7,19,0,0,26145,26146,7,0,0,0,26146,
+        26147,7,4,0,0,26147,26148,7,17,0,0,26148,3860,1,0,0,0,26149,26150,
+        7,5,0,0,26150,26151,7,18,0,0,26151,26152,7,5,0,0,26152,26153,5,95,
+        0,0,26153,26154,7,2,0,0,26154,26155,7,15,0,0,26155,26156,5,95,0,
+        0,26156,26157,7,25,0,0,26157,26158,7,15,0,0,26158,26159,7,4,0,0,
+        26159,26160,7,19,0,0,26160,26161,7,10,0,0,26161,26162,7,9,0,0,26162,
+        26163,7,25,0,0,26163,3862,1,0,0,0,26164,26165,7,5,0,0,26165,26166,
+        7,18,0,0,26166,26167,7,5,0,0,26167,26168,5,95,0,0,26168,26169,7,
+        2,0,0,26169,26170,7,15,0,0,26170,26171,5,95,0,0,26171,26172,7,25,
+        0,0,26172,26173,7,15,0,0,26173,26174,7,4,0,0,26174,26175,7,19,0,
+        0,26175,26176,7,2,0,0,26176,26177,7,15,0,0,26177,3864,1,0,0,0,26178,
+        26179,7,5,0,0,26179,26180,7,18,0,0,26180,26181,7,5,0,0,26181,26182,
+        5,95,0,0,26182,26183,7,2,0,0,26183,26184,7,15,0,0,26184,26185,5,
+        95,0,0,26185,26186,7,25,0,0,26186,26187,7,4,0,0,26187,26188,7,25,
+        0,0,26188,26189,7,4,0,0,26189,26190,5,50,0,0,26190,26191,7,5,0,0,
+        26191,26192,7,24,0,0,26192,26193,7,11,0,0,26193,26194,7,4,0,0,26194,
+        3866,1,0,0,0,26195,26196,7,5,0,0,26196,26197,7,18,0,0,26197,26198,
+        7,5,0,0,26198,26199,5,95,0,0,26199,26200,7,2,0,0,26200,26201,7,15,
+        0,0,26201,26202,5,95,0,0,26202,26203,7,23,0,0,26203,26204,7,2,0,
+        0,26204,26205,7,7,0,0,26205,26206,7,6,0,0,26206,26207,5,95,0,0,26207,
+        26208,7,10,0,0,26208,26209,7,9,0,0,26209,3868,1,0,0,0,26210,26211,
+        7,5,0,0,26211,26212,7,18,0,0,26212,26213,7,5,0,0,26213,26214,5,95,
+        0,0,26214,26215,7,2,0,0,26215,26216,7,3,0,0,26216,26217,7,9,0,0,
+        26217,26218,7,6,0,0,26218,26219,7,3,0,0,26219,26220,7,21,0,0,26220,
+        26221,7,6,0,0,26221,26222,7,18,0,0,26222,26223,5,95,0,0,26223,26224,
+        7,9,0,0,26224,26225,7,6,0,0,26225,26226,7,15,0,0,26226,26227,7,4,
+        0,0,26227,26228,7,19,0,0,26228,3870,1,0,0,0,26229,26230,7,5,0,0,
+        26230,26231,7,18,0,0,26231,26232,7,5,0,0,26232,26233,5,95,0,0,26233,
+        26234,7,2,0,0,26234,26235,7,3,0,0,26235,26236,7,9,0,0,26236,26237,
+        7,6,0,0,26237,26238,7,3,0,0,26238,26239,7,21,0,0,26239,26240,7,6,
+        0,0,26240,26241,7,18,0,0,26241,26242,5,95,0,0,26242,26243,7,14,0,
+        0,26243,26244,7,0,0,0,26244,26245,7,25,0,0,26245,26246,7,8,0,0,26246,
+        26247,7,19,0,0,26247,26248,7,10,0,0,26248,26249,7,11,0,0,26249,26250,
+        7,9,0,0,26250,3872,1,0,0,0,26251,26252,7,5,0,0,26252,26253,7,18,
+        0,0,26253,26254,7,5,0,0,26254,26255,5,95,0,0,26255,26256,7,2,0,0,
+        26256,26257,7,3,0,0,26257,26258,7,9,0,0,26258,26259,7,6,0,0,26259,
+        26260,7,3,0,0,26260,26261,7,21,0,0,26261,26262,7,6,0,0,26262,26263,
+        7,18,0,0,26263,26264,5,95,0,0,26264,26265,7,15,0,0,26265,26266,7,
+        0,0,0,26266,26267,7,3,0,0,26267,26268,7,6,0,0,26268,26269,7,7,0,
+        0,26269,26270,7,4,0,0,26270,3874,1,0,0,0,26271,26272,7,5,0,0,26272,
+        26273,7,18,0,0,26273,26274,7,5,0,0,26274,26275,5,95,0,0,26275,26276,
+        7,15,0,0,26276,26277,7,0,0,0,26277,26278,7,3,0,0,26278,26279,7,0,
+        0,0,26279,26280,7,11,0,0,26280,26281,7,11,0,0,26281,26282,7,6,0,
+        0,26282,26283,7,11,0,0,26283,26284,5,95,0,0,26284,26285,7,4,0,0,
+        26285,26286,7,25,0,0,26286,26287,7,7,0,0,26287,3876,1,0,0,0,26288,
+        26289,7,5,0,0,26289,26290,7,18,0,0,26290,26291,7,5,0,0,26291,26292,
+        5,95,0,0,26292,26293,7,15,0,0,26293,26294,7,0,0,0,26294,26295,7,
+        4,0,0,26295,26296,7,19,0,0,26296,26297,7,10,0,0,26297,26298,7,9,
+        0,0,26298,26299,5,95,0,0,26299,26300,7,10,0,0,26300,26301,7,5,0,
+        0,26301,26302,5,95,0,0,26302,26303,7,0,0,0,26303,26304,7,4,0,0,26304,
+        26305,7,4,0,0,26305,26306,7,3,0,0,26306,3878,1,0,0,0,26307,26308,
+        7,5,0,0,26308,26309,7,18,0,0,26309,26310,7,5,0,0,26310,26311,5,95,
+        0,0,26311,26312,7,15,0,0,26312,26313,7,0,0,0,26313,26314,7,4,0,0,
+        26314,26315,7,19,0,0,26315,26316,7,10,0,0,26316,26317,7,9,0,0,26317,
+        26318,5,95,0,0,26318,26319,7,10,0,0,26319,26320,7,5,0,0,26320,26321,
+        5,95,0,0,26321,26322,7,7,0,0,26322,26323,7,14,0,0,26323,26324,7,
+        5,0,0,26324,26325,7,15,0,0,26325,26326,7,8,0,0,26326,3880,1,0,0,
+        0,26327,26328,7,5,0,0,26328,26329,7,18,0,0,26329,26330,7,5,0,0,26330,
+        26331,5,95,0,0,26331,26332,7,15,0,0,26332,26333,7,0,0,0,26333,26334,
+        7,4,0,0,26334,26335,7,19,0,0,26335,26336,7,10,0,0,26336,26337,7,
+        9,0,0,26337,26338,5,95,0,0,26338,26339,7,11,0,0,26339,26340,7,0,
+        0,0,26340,26341,7,5,0,0,26341,26342,7,4,0,0,26342,26343,7,7,0,0,
+        26343,26344,7,0,0,0,26344,26345,7,14,0,0,26345,26346,7,6,0,0,26346,
+        3882,1,0,0,0,26347,26348,7,5,0,0,26348,26349,7,18,0,0,26349,26350,
+        7,5,0,0,26350,26351,5,95,0,0,26351,26352,7,15,0,0,26352,26353,7,
+        0,0,0,26353,26354,7,4,0,0,26354,26355,7,19,0,0,26355,26356,7,10,
+        0,0,26356,26357,7,9,0,0,26357,26358,5,95,0,0,26358,26359,7,11,0,
+        0,26359,26360,7,0,0,0,26360,26361,7,5,0,0,26361,26362,7,4,0,0,26362,
+        26363,7,7,0,0,26363,26364,7,14,0,0,26364,26365,7,5,0,0,26365,26366,
+        7,15,0,0,26366,26367,7,8,0,0,26367,3884,1,0,0,0,26368,26369,7,5,
+        0,0,26369,26370,7,18,0,0,26370,26371,7,5,0,0,26371,26372,5,95,0,
+        0,26372,26373,7,15,0,0,26373,26374,7,0,0,0,26374,26375,7,4,0,0,26375,
+        26376,7,19,0,0,26376,26377,5,95,0,0,26377,26378,7,3,0,0,26378,26379,
+        7,6,0,0,26379,26380,7,13,0,0,26380,26381,7,6,0,0,26381,26382,7,3,
+        0,0,26382,26383,7,5,0,0,26383,26384,7,6,0,0,26384,3886,1,0,0,0,26385,
+        26386,7,5,0,0,26386,26387,7,18,0,0,26387,26388,7,5,0,0,26388,26389,
+        5,95,0,0,26389,26390,7,15,0,0,26390,26391,7,25,0,0,26391,26392,7,
+        24,0,0,26392,26393,7,6,0,0,26393,26394,7,25,0,0,26394,26395,7,4,
+        0,0,26395,26396,7,3,0,0,26396,26397,7,0,0,0,26397,26398,7,8,0,0,
+        26398,26399,7,4,0,0,26399,3888,1,0,0,0,26400,26401,7,5,0,0,26401,
+        26402,7,18,0,0,26402,26403,7,5,0,0,26403,26404,5,95,0,0,26404,26405,
+        7,3,0,0,26405,26406,7,0,0,0,26406,26407,7,22,0,0,26407,26408,5,95,
+        0,0,26408,26409,7,4,0,0,26409,26410,7,2,0,0,26410,26411,5,95,0,0,
+        26411,26412,7,25,0,0,26412,26413,7,5,0,0,26413,26414,7,10,0,0,26414,
+        26415,7,9,0,0,26415,3890,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,
+        3,0,0,26421,26422,7,10,0,0,26422,26423,7,9,0,0,26423,26424,5,95,
+        0,0,26424,26425,7,2,0,0,26425,26426,7,3,0,0,26426,26427,7,9,0,0,
+        26427,26428,7,6,0,0,26428,26429,7,3,0,0,26429,3892,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,3,0,0,26435,26436,7,2,0,0,26436,26437,7,22,
+        0,0,26437,26438,5,95,0,0,26438,26439,7,9,0,0,26439,26440,7,6,0,0,
+        26440,26441,7,11,0,0,26441,26442,7,4,0,0,26442,26443,7,0,0,0,26443,
+        3894,1,0,0,0,26444,26445,7,5,0,0,26445,26446,7,18,0,0,26446,26447,
+        7,5,0,0,26447,26448,5,95,0,0,26448,26449,7,5,0,0,26449,26450,7,8,
+        0,0,26450,26451,5,95,0,0,26451,26452,5,50,0,0,26452,26453,5,95,0,
+        0,26453,26454,7,25,0,0,26454,26455,7,14,0,0,26455,26456,7,11,0,0,
+        26456,26457,7,4,0,0,26457,3896,1,0,0,0,26458,26459,7,5,0,0,26459,
+        26460,7,18,0,0,26460,26461,7,5,0,0,26461,26462,5,95,0,0,26462,26463,
+        7,5,0,0,26463,26464,7,18,0,0,26464,26465,7,7,0,0,26465,26466,7,3,
+        0,0,26466,26467,7,8,0,0,26467,26468,7,10,0,0,26468,26469,7,3,0,0,
+        26469,26470,7,6,0,0,26470,26471,7,9,0,0,26471,26472,7,2,0,0,26472,
+        3898,1,0,0,0,26473,26474,7,5,0,0,26474,26475,7,18,0,0,26475,26476,
+        7,5,0,0,26476,26477,7,4,0,0,26477,26478,7,6,0,0,26478,26479,7,14,
+        0,0,26479,26480,5,95,0,0,26480,26481,7,9,0,0,26481,26482,7,6,0,0,
+        26482,26483,7,16,0,0,26483,26484,7,10,0,0,26484,26485,7,7,0,0,26485,
+        26486,7,6,0,0,26486,26487,7,9,0,0,26487,3900,1,0,0,0,26488,26489,
+        7,5,0,0,26489,26490,7,18,0,0,26490,26491,7,5,0,0,26491,26492,7,4,
+        0,0,26492,26493,7,6,0,0,26493,26494,7,14,0,0,26494,3902,1,0,0,0,
+        26495,26496,7,5,0,0,26496,26497,7,18,0,0,26497,26498,7,5,0,0,26498,
+        26499,7,4,0,0,26499,26500,7,10,0,0,26500,26501,7,14,0,0,26501,26502,
+        7,6,0,0,26502,26503,7,5,0,0,26503,26504,7,4,0,0,26504,26505,7,0,
+        0,0,26505,26506,7,14,0,0,26506,26507,7,15,0,0,26507,3904,1,0,0,0,
+        26508,26509,7,5,0,0,26509,26510,7,18,0,0,26510,26511,7,5,0,0,26511,
+        26512,5,95,0,0,26512,26513,7,4,0,0,26513,26514,7,18,0,0,26514,26515,
+        7,15,0,0,26515,26516,7,6,0,0,26516,26517,7,10,0,0,26517,26518,7,
+        9,0,0,26518,3906,1,0,0,0,26519,26520,7,5,0,0,26520,26521,7,18,0,
+        0,26521,26522,7,5,0,0,26522,26523,5,95,0,0,26523,26524,7,12,0,0,
+        26524,26525,7,14,0,0,26525,26526,7,0,0,0,26526,26527,7,21,0,0,26527,
+        26528,7,6,0,0,26528,26529,7,25,0,0,26529,26530,7,14,0,0,26530,26531,
+        7,11,0,0,26531,3908,1,0,0,0,26532,26533,7,5,0,0,26533,26534,7,18,
+        0,0,26534,26535,7,5,0,0,26535,26536,5,95,0,0,26536,26537,7,25,0,
+        0,26537,26538,7,14,0,0,26538,26539,7,11,0,0,26539,26540,7,0,0,0,
+        26540,26541,7,7,0,0,26541,26542,7,0,0,0,26542,26543,7,11,0,0,26543,
+        26544,7,18,0,0,26544,26545,7,23,0,0,26545,26546,7,6,0,0,26546,3910,
+        1,0,0,0,26547,26548,7,5,0,0,26548,26549,7,18,0,0,26549,26550,7,5,
+        0,0,26550,26551,5,95,0,0,26551,26552,7,25,0,0,26552,26553,7,14,0,
+        0,26553,26554,7,11,0,0,26554,26555,7,8,0,0,26555,26556,7,2,0,0,26556,
+        26557,7,7,0,0,26557,26558,7,4,0,0,26558,26559,7,0,0,0,26559,26560,
+        7,10,0,0,26560,26561,7,7,0,0,26561,26562,7,5,0,0,26562,3912,1,0,
+        0,0,26563,26564,7,5,0,0,26564,26565,7,18,0,0,26565,26566,7,5,0,0,
+        26566,26567,5,95,0,0,26567,26568,7,25,0,0,26568,26569,7,14,0,0,26569,
+        26570,7,11,0,0,26570,26571,7,8,0,0,26571,26572,7,2,0,0,26572,26573,
+        7,7,0,0,26573,26574,7,13,0,0,26574,3914,1,0,0,0,26575,26576,7,5,
+        0,0,26576,26577,7,18,0,0,26577,26578,7,5,0,0,26578,26579,5,95,0,
+        0,26579,26580,7,25,0,0,26580,26581,7,14,0,0,26581,26582,7,11,0,0,
+        26582,26583,7,6,0,0,26583,26584,7,25,0,0,26584,26585,7,7,0,0,26585,
+        26586,7,5,0,0,26586,26587,7,12,0,0,26587,26588,7,3,0,0,26588,26589,
+        7,10,0,0,26589,3916,1,0,0,0,26590,26591,7,5,0,0,26591,26592,7,18,
+        0,0,26592,26593,7,5,0,0,26593,26594,5,95,0,0,26594,26595,7,25,0,
+        0,26595,26596,7,14,0,0,26596,26597,7,11,0,0,26597,26598,7,17,0,0,
+        26598,26599,7,6,0,0,26599,26600,7,7,0,0,26600,3918,1,0,0,0,26601,
+        26602,7,5,0,0,26602,26603,7,18,0,0,26603,26604,7,5,0,0,26604,26605,
+        5,95,0,0,26605,26606,7,25,0,0,26606,26607,7,14,0,0,26607,26608,7,
+        11,0,0,26608,26609,7,10,0,0,26609,26610,5,95,0,0,26610,26611,7,11,
+        0,0,26611,26612,7,2,0,0,26612,26613,7,8,0,0,26613,26614,5,95,0,0,
+        26614,26615,7,10,0,0,26615,26616,7,5,0,0,26616,26617,7,7,0,0,26617,
+        26618,7,2,0,0,26618,26619,7,9,0,0,26619,26620,7,6,0,0,26620,3920,
+        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,14,0,
+        0,26627,26628,7,11,0,0,26628,26629,7,10,0,0,26629,26630,5,95,0,0,
+        26630,26631,7,11,0,0,26631,26632,7,2,0,0,26632,26633,7,8,0,0,26633,
+        26634,5,95,0,0,26634,26635,7,10,0,0,26635,26636,7,5,0,0,26636,26637,
+        7,4,0,0,26637,26638,7,6,0,0,26638,26639,7,25,0,0,26639,26640,7,4,
+        0,0,26640,3922,1,0,0,0,26641,26642,7,5,0,0,26642,26643,7,18,0,0,
+        26643,26644,7,5,0,0,26644,26645,5,95,0,0,26645,26646,7,25,0,0,26646,
+        26647,7,14,0,0,26647,26648,7,11,0,0,26648,26649,7,10,0,0,26649,26650,
+        7,7,0,0,26650,26651,7,5,0,0,26651,26652,7,4,0,0,26652,26653,7,3,
+        0,0,26653,3924,1,0,0,0,26654,26655,7,5,0,0,26655,26656,7,18,0,0,
+        26656,26657,7,5,0,0,26657,26658,5,95,0,0,26658,26659,7,25,0,0,26659,
+        26660,7,14,0,0,26660,26661,7,11,0,0,26661,26662,7,11,0,0,26662,26663,
+        7,2,0,0,26663,26664,7,8,0,0,26664,26665,7,0,0,0,26665,26666,7,4,
+        0,0,26666,26667,7,2,0,0,26667,26668,7,3,0,0,26668,26669,5,95,0,0,
+        26669,26670,7,17,0,0,26670,26671,7,6,0,0,26671,26672,7,4,0,0,26672,
+        26673,7,5,0,0,26673,26674,7,13,0,0,26674,26675,7,0,0,0,26675,26676,
+        7,11,0,0,26676,3926,1,0,0,0,26677,26678,7,5,0,0,26678,26679,7,18,
+        0,0,26679,26680,7,5,0,0,26680,26681,5,95,0,0,26681,26682,7,25,0,
+        0,26682,26683,7,14,0,0,26683,26684,7,11,0,0,26684,26685,7,7,0,0,
+        26685,26686,7,2,0,0,26686,26687,7,9,0,0,26687,26688,7,6,0,0,26688,
+        26689,7,10,0,0,26689,26690,7,9,0,0,26690,26691,5,95,0,0,26691,26692,
+        7,17,0,0,26692,26693,7,6,0,0,26693,26694,7,4,0,0,26694,26695,7,8,
+        0,0,26695,26696,7,10,0,0,26696,26697,7,9,0,0,26697,3928,1,0,0,0,
+        26698,26699,7,5,0,0,26699,26700,7,18,0,0,26700,26701,7,5,0,0,26701,
+        26702,5,95,0,0,26702,26703,7,25,0,0,26703,26704,7,14,0,0,26704,26705,
+        7,11,0,0,26705,26706,7,7,0,0,26706,26707,7,2,0,0,26707,26708,7,9,
+        0,0,26708,26709,7,6,0,0,26709,26710,7,10,0,0,26710,26711,7,9,0,0,
+        26711,26712,5,95,0,0,26712,26713,7,17,0,0,26713,26714,7,6,0,0,26714,
+        26715,7,4,0,0,26715,26716,7,11,0,0,26716,26717,7,2,0,0,26717,26718,
+        7,8,0,0,26718,26719,7,0,0,0,26719,26720,7,4,0,0,26720,26721,7,2,
+        0,0,26721,26722,7,3,0,0,26722,3930,1,0,0,0,26723,26724,7,5,0,0,26724,
+        26725,7,18,0,0,26725,26726,7,5,0,0,26726,26727,5,95,0,0,26727,26728,
+        7,25,0,0,26728,26729,7,14,0,0,26729,26730,7,11,0,0,26730,26731,7,
+        7,0,0,26731,26732,7,2,0,0,26732,26733,7,9,0,0,26733,26734,7,6,0,
+        0,26734,26735,7,10,0,0,26735,26736,7,9,0,0,26736,26737,5,95,0,0,
+        26737,26738,7,17,0,0,26738,26739,7,6,0,0,26739,26740,7,4,0,0,26740,
+        26741,7,2,0,0,26741,26742,7,21,0,0,26742,26743,7,6,0,0,26743,26744,
+        7,18,0,0,26744,3932,1,0,0,0,26745,26746,7,5,0,0,26746,26747,7,18,
+        0,0,26747,26748,7,5,0,0,26748,26749,5,95,0,0,26749,26750,7,25,0,
+        0,26750,26751,7,14,0,0,26751,26752,7,11,0,0,26752,26753,7,7,0,0,
+        26753,26754,7,2,0,0,26754,26755,7,9,0,0,26755,26756,7,6,0,0,26756,
+        26757,7,10,0,0,26757,26758,7,9,0,0,26758,26759,5,95,0,0,26759,26760,
+        7,17,0,0,26760,26761,7,6,0,0,26761,26762,7,4,0,0,26762,26763,7,15,
+        0,0,26763,26764,7,0,0,0,26764,26765,7,4,0,0,26765,26766,7,19,0,0,
+        26766,26767,7,10,0,0,26767,26768,7,9,0,0,26768,3934,1,0,0,0,26769,
+        26770,7,5,0,0,26770,26771,7,18,0,0,26771,26772,7,5,0,0,26772,26773,
+        5,95,0,0,26773,26774,7,25,0,0,26774,26775,7,14,0,0,26775,26776,7,
+        11,0,0,26776,26777,7,7,0,0,26777,26778,7,2,0,0,26778,26779,7,9,0,
+        0,26779,26780,7,6,0,0,26780,26781,7,10,0,0,26781,26782,7,9,0,0,26782,
+        26783,5,95,0,0,26783,26784,7,17,0,0,26784,26785,7,6,0,0,26785,26786,
+        7,4,0,0,26786,26787,7,15,0,0,26787,26788,7,4,0,0,26788,26789,7,3,
+        0,0,26789,26790,7,10,0,0,26790,26791,7,9,0,0,26791,3936,1,0,0,0,
+        26792,26793,7,5,0,0,26793,26794,7,18,0,0,26794,26795,7,5,0,0,26795,
+        26796,5,95,0,0,26796,26797,7,25,0,0,26797,26798,7,14,0,0,26798,26799,
+        7,11,0,0,26799,26800,7,7,0,0,26800,26801,7,2,0,0,26801,26802,7,9,
+        0,0,26802,26803,7,6,0,0,26803,26804,7,10,0,0,26804,26805,7,9,0,0,
+        26805,26806,5,95,0,0,26806,26807,7,17,0,0,26807,26808,7,6,0,0,26808,
+        26809,7,4,0,0,26809,26810,7,3,0,0,26810,26811,7,10,0,0,26811,26812,
+        7,9,0,0,26812,3938,1,0,0,0,26813,26814,7,5,0,0,26814,26815,7,18,
+        0,0,26815,26816,7,5,0,0,26816,26817,5,95,0,0,26817,26818,7,25,0,
+        0,26818,26819,7,14,0,0,26819,26820,7,11,0,0,26820,26821,7,7,0,0,
+        26821,26822,7,2,0,0,26822,26823,7,9,0,0,26823,26824,7,6,0,0,26824,
+        26825,7,10,0,0,26825,26826,7,9,0,0,26826,26827,5,95,0,0,26827,26828,
+        7,17,0,0,26828,26829,7,6,0,0,26829,26830,7,4,0,0,26830,26831,7,5,
+        0,0,26831,26832,7,13,0,0,26832,26833,7,0,0,0,26833,26834,7,11,0,
+        0,26834,3940,1,0,0,0,26835,26836,7,5,0,0,26836,26837,7,18,0,0,26837,
+        26838,7,5,0,0,26838,26839,5,95,0,0,26839,26840,7,25,0,0,26840,26841,
+        7,14,0,0,26841,26842,7,11,0,0,26842,26843,7,7,0,0,26843,26844,7,
+        2,0,0,26844,26845,7,9,0,0,26845,26846,7,6,0,0,26846,26847,7,10,0,
+        0,26847,26848,7,9,0,0,26848,26849,5,95,0,0,26849,26850,7,17,0,0,
+        26850,26851,7,6,0,0,26851,26852,7,4,0,0,26852,26853,7,4,0,0,26853,
+        26854,7,10,0,0,26854,26855,7,9,0,0,26855,3942,1,0,0,0,26856,26857,
+        7,5,0,0,26857,26858,7,18,0,0,26858,26859,7,5,0,0,26859,26860,5,95,
+        0,0,26860,26861,7,25,0,0,26861,26862,7,14,0,0,26862,26863,7,11,0,
+        0,26863,26864,7,7,0,0,26864,26865,7,2,0,0,26865,26866,7,9,0,0,26866,
+        26867,7,6,0,0,26867,26868,7,10,0,0,26868,26869,7,9,0,0,26869,3944,
+        1,0,0,0,26870,26871,7,5,0,0,26871,26872,7,18,0,0,26872,26873,7,5,
+        0,0,26873,26874,5,95,0,0,26874,26875,7,25,0,0,26875,26876,7,14,0,
+        0,26876,26877,7,11,0,0,26877,26878,7,4,0,0,26878,26879,5,95,0,0,
+        26879,26880,5,50,0,0,26880,26881,5,95,0,0,26881,26882,7,5,0,0,26882,
+        26883,7,8,0,0,26883,3946,1,0,0,0,26884,26885,7,5,0,0,26885,26886,
+        7,18,0,0,26886,26887,7,5,0,0,26887,26888,5,95,0,0,26888,26889,7,
+        25,0,0,26889,26890,7,14,0,0,26890,26891,7,11,0,0,26891,26892,7,4,
+        0,0,26892,26893,7,3,0,0,26893,26894,7,0,0,0,26894,26895,7,7,0,0,
+        26895,26896,7,5,0,0,26896,26897,7,11,0,0,26897,26898,7,0,0,0,26898,
+        26899,7,4,0,0,26899,26900,7,6,0,0,26900,3948,1,0,0,0,26901,26902,
+        7,5,0,0,26902,26903,7,18,0,0,26903,26904,7,5,0,0,26904,26905,5,95,
+        0,0,26905,26906,7,25,0,0,26906,26907,7,14,0,0,26907,26908,7,11,0,
+        0,26908,26909,7,4,0,0,26909,26910,7,18,0,0,26910,26911,7,15,0,0,
+        26911,26912,7,6,0,0,26912,26913,5,50,0,0,26913,26914,7,5,0,0,26914,
+        26915,7,24,0,0,26915,26916,7,11,0,0,26916,3950,1,0,0,0,26917,26918,
+        7,5,0,0,26918,26919,7,18,0,0,26919,26920,7,5,0,0,26920,26921,5,95,
+        0,0,26921,26922,7,25,0,0,26922,26923,7,24,0,0,26923,26924,5,95,0,
+        0,26924,26925,7,0,0,0,26925,26926,7,5,0,0,26926,26927,7,24,0,0,26927,
+        26928,7,11,0,0,26928,26929,7,8,0,0,26929,26930,7,7,0,0,26930,26931,
+        7,13,0,0,26931,3952,1,0,0,0,26932,26933,7,5,0,0,26933,26934,7,18,
+        0,0,26934,26935,7,5,0,0,26935,26936,5,95,0,0,26936,26937,7,25,0,
+        0,26937,26938,7,24,0,0,26938,26939,5,95,0,0,26939,26940,7,0,0,0,
+        26940,26941,7,4,0,0,26941,26942,7,2,0,0,26942,26943,7,14,0,0,26943,
+        26944,7,8,0,0,26944,26945,7,7,0,0,26945,26946,7,13,0,0,26946,26947,
+        7,8,0,0,26947,26948,7,19,0,0,26948,26949,7,21,0,0,26949,3954,1,0,
+        0,0,26950,26951,7,5,0,0,26951,26952,7,18,0,0,26952,26953,7,5,0,0,
+        26953,26954,5,95,0,0,26954,26955,7,25,0,0,26955,26956,7,24,0,0,26956,
+        26957,7,1,0,0,26957,26958,7,0,0,0,26958,26959,7,5,0,0,26959,26960,
+        7,6,0,0,26960,26961,7,12,0,0,26961,26962,7,3,0,0,26962,26963,7,10,
+        0,0,26963,3956,1,0,0,0,26964,26965,7,5,0,0,26965,26966,7,18,0,0,
+        26966,26967,7,5,0,0,26967,26968,5,95,0,0,26968,26969,7,25,0,0,26969,
+        26970,7,24,0,0,26970,26971,7,8,0,0,26971,26972,7,0,0,0,26972,26973,
+        7,5,0,0,26973,26974,7,4,0,0,26974,26975,7,0,0,0,26975,26976,7,1,
+        0,0,26976,26977,7,11,0,0,26977,26978,7,6,0,0,26978,26979,7,6,0,0,
+        26979,26980,7,3,0,0,26980,26981,7,3,0,0,26981,26982,7,19,0,0,26982,
+        3958,1,0,0,0,26983,26984,7,5,0,0,26984,26985,7,18,0,0,26985,26986,
+        7,5,0,0,26986,26987,5,95,0,0,26987,26988,7,25,0,0,26988,26989,7,
+        24,0,0,26989,26990,7,8,0,0,26990,26991,7,2,0,0,26991,26992,7,9,0,
+        0,26992,26993,7,6,0,0,26993,26994,7,15,0,0,26994,26995,5,50,0,0,
+        26995,26996,7,5,0,0,26996,26997,7,4,0,0,26997,26998,7,3,0,0,26998,
+        3960,1,0,0,0,26999,27000,7,5,0,0,27000,27001,7,18,0,0,27001,27002,
+        7,5,0,0,27002,27003,5,95,0,0,27003,27004,7,25,0,0,27004,27005,7,
+        24,0,0,27005,27006,7,8,0,0,27006,27007,7,2,0,0,27007,27008,7,9,0,
+        0,27008,27009,7,6,0,0,27009,27010,7,15,0,0,27010,27011,7,6,0,0,27011,
+        27012,7,24,0,0,27012,3962,1,0,0,0,27013,27014,7,5,0,0,27014,27015,
+        7,18,0,0,27015,27016,7,5,0,0,27016,27017,5,95,0,0,27017,27018,7,
+        25,0,0,27018,27019,7,24,0,0,27019,27020,7,8,0,0,27020,27021,7,2,
+        0,0,27021,27022,7,7,0,0,27022,27023,5,50,0,0,27023,27024,7,5,0,0,
+        27024,27025,7,6,0,0,27025,27026,7,24,0,0,27026,3964,1,0,0,0,27027,
+        27028,7,5,0,0,27028,27029,7,18,0,0,27029,27030,7,5,0,0,27030,27031,
+        5,95,0,0,27031,27032,7,25,0,0,27032,27033,7,24,0,0,27033,27034,7,
+        8,0,0,27034,27035,7,2,0,0,27035,27036,7,7,0,0,27036,27037,7,8,0,
+        0,27037,27038,7,0,0,0,27038,27039,7,4,0,0,27039,3966,1,0,0,0,27040,
+        27041,7,5,0,0,27041,27042,7,18,0,0,27042,27043,7,5,0,0,27043,27044,
+        5,95,0,0,27044,27045,7,25,0,0,27045,27046,7,24,0,0,27046,27047,7,
+        9,0,0,27047,27048,7,6,0,0,27048,27049,7,11,0,0,27049,27050,7,6,0,
+        0,27050,27051,7,4,0,0,27051,27052,7,6,0,0,27052,3968,1,0,0,0,27053,
+        27054,7,5,0,0,27054,27055,7,18,0,0,27055,27056,7,5,0,0,27056,27057,
+        5,95,0,0,27057,27058,7,25,0,0,27058,27059,7,24,0,0,27059,27060,7,
+        9,0,0,27060,27061,7,16,0,0,27061,27062,7,11,0,0,27062,27063,7,4,
+        0,0,27063,27064,7,8,0,0,27064,27065,7,2,0,0,27065,27066,7,11,0,0,
+        27066,27067,7,0,0,0,27067,27068,7,4,0,0,27068,27069,7,10,0,0,27069,
+        27070,7,2,0,0,27070,27071,7,7,0,0,27071,3970,1,0,0,0,27072,27073,
+        7,5,0,0,27073,27074,7,18,0,0,27074,27075,7,5,0,0,27075,27076,5,95,
+        0,0,27076,27077,7,25,0,0,27077,27078,7,24,0,0,27078,27079,7,9,0,
+        0,27079,27080,7,2,0,0,27080,27081,7,8,0,0,27081,3972,1,0,0,0,27082,
+        27083,7,5,0,0,27083,27084,7,18,0,0,27084,27085,7,5,0,0,27085,27086,
+        5,95,0,0,27086,27087,7,25,0,0,27087,27088,7,24,0,0,27088,27089,7,
+        9,0,0,27089,27090,7,2,0,0,27090,27091,7,8,0,0,27091,27092,7,12,0,
+        0,27092,27093,7,3,0,0,27093,27094,7,10,0,0,27094,3974,1,0,0,0,27095,
+        27096,7,5,0,0,27096,27097,7,18,0,0,27097,27098,7,5,0,0,27098,27099,
+        5,95,0,0,27099,27100,7,25,0,0,27100,27101,7,24,0,0,27101,27102,7,
+        9,0,0,27102,27103,7,12,0,0,27103,27104,7,3,0,0,27104,27105,7,9,0,
+        0,27105,27106,7,10,0,0,27106,27107,7,13,0,0,27107,3976,1,0,0,0,27108,
+        27109,7,5,0,0,27109,27110,7,18,0,0,27110,27111,7,5,0,0,27111,27112,
+        5,95,0,0,27112,27113,7,25,0,0,27113,27114,7,24,0,0,27114,27115,7,
+        6,0,0,27115,27116,7,9,0,0,27116,27117,5,52,0,0,27117,27118,7,12,
+        0,0,27118,27119,7,3,0,0,27119,27120,7,10,0,0,27120,3978,1,0,0,0,
+        27121,27122,7,5,0,0,27122,27123,7,18,0,0,27123,27124,7,5,0,0,27124,
+        27125,5,95,0,0,27125,27126,7,25,0,0,27126,27127,7,24,0,0,27127,27128,
+        7,6,0,0,27128,27129,7,7,0,0,27129,27130,7,9,0,0,27130,27131,7,5,
+        0,0,27131,27132,7,22,0,0,27132,27133,7,10,0,0,27133,27134,7,4,0,
+        0,27134,27135,7,19,0,0,27135,3980,1,0,0,0,27136,27137,7,5,0,0,27137,
+        27138,7,18,0,0,27138,27139,7,5,0,0,27139,27140,5,95,0,0,27140,27141,
+        7,25,0,0,27141,27142,7,24,0,0,27142,27143,7,6,0,0,27143,27144,7,
+        3,0,0,27144,27145,7,3,0,0,27145,27146,7,19,0,0,27146,3982,1,0,0,
+        0,27147,27148,7,5,0,0,27148,27149,7,18,0,0,27149,27150,7,5,0,0,27150,
+        27151,5,95,0,0,27151,27152,7,25,0,0,27152,27153,7,24,0,0,27153,27154,
+        7,6,0,0,27154,27155,7,3,0,0,27155,27156,7,3,0,0,27156,3984,1,0,0,
+        0,27157,27158,7,5,0,0,27158,27159,7,18,0,0,27159,27160,7,5,0,0,27160,
+        27161,5,95,0,0,27161,27162,7,25,0,0,27162,27163,7,24,0,0,27163,27164,
+        7,6,0,0,27164,27165,7,5,0,0,27165,27166,7,19,0,0,27166,27167,7,4,
+        0,0,27167,27168,7,14,0,0,27168,27169,7,11,0,0,27169,27170,7,12,0,
+        0,27170,27171,7,3,0,0,27171,27172,7,10,0,0,27172,3986,1,0,0,0,27173,
+        27174,7,5,0,0,27174,27175,7,18,0,0,27175,27176,7,5,0,0,27176,27177,
+        5,95,0,0,27177,27178,7,25,0,0,27178,27179,7,24,0,0,27179,27180,7,
+        6,0,0,27180,27181,7,25,0,0,27181,27182,7,11,0,0,27182,27183,7,2,
+        0,0,27183,27184,7,1,0,0,27184,27185,7,13,0,0,27185,27186,7,0,0,0,
+        27186,27187,7,11,0,0,27187,3988,1,0,0,0,27188,27189,7,5,0,0,27189,
+        27190,7,18,0,0,27190,27191,7,5,0,0,27191,27192,5,95,0,0,27192,27193,
+        7,25,0,0,27193,27194,7,24,0,0,27194,27195,7,6,0,0,27195,27196,7,
+        25,0,0,27196,27197,7,5,0,0,27197,27198,7,4,0,0,27198,27199,7,22,
+        0,0,27199,27200,7,3,0,0,27200,27201,7,15,0,0,27201,3990,1,0,0,0,
+        27202,27203,7,5,0,0,27203,27204,7,18,0,0,27204,27205,7,5,0,0,27205,
+        27206,5,95,0,0,27206,27207,7,25,0,0,27207,27208,7,24,0,0,27208,27209,
+        7,6,0,0,27209,27210,7,25,0,0,27210,27211,7,4,0,0,27211,27212,7,3,
+        0,0,27212,27213,7,0,0,0,27213,27214,7,8,0,0,27214,27215,7,4,0,0,
+        27215,3992,1,0,0,0,27216,27217,7,5,0,0,27217,27218,7,18,0,0,27218,
+        27219,7,5,0,0,27219,27220,5,95,0,0,27220,27221,7,25,0,0,27221,27222,
+        7,24,0,0,27222,27223,7,6,0,0,27223,27224,7,25,0,0,27224,27225,7,
+        4,0,0,27225,27226,7,3,0,0,27226,27227,7,3,0,0,27227,27228,7,6,0,
+        0,27228,27229,7,16,0,0,27229,3994,1,0,0,0,27230,27231,7,5,0,0,27231,
+        27232,7,18,0,0,27232,27233,7,5,0,0,27233,27234,5,95,0,0,27234,27235,
+        7,25,0,0,27235,27236,7,24,0,0,27236,27237,7,6,0,0,27237,27238,7,
+        25,0,0,27238,27239,7,13,0,0,27239,27240,7,0,0,0,27240,27241,7,11,
+        0,0,27241,3996,1,0,0,0,27242,27243,7,5,0,0,27243,27244,7,18,0,0,
+        27244,27245,7,5,0,0,27245,27246,5,95,0,0,27246,27247,7,25,0,0,27247,
+        27248,7,24,0,0,27248,27249,7,16,0,0,27249,27250,7,1,0,0,27250,27251,
+        5,50,0,0,27251,27252,7,5,0,0,27252,27253,7,4,0,0,27253,27254,7,3,
+        0,0,27254,3998,1,0,0,0,27255,27256,7,5,0,0,27256,27257,7,18,0,0,
+        27257,27258,7,5,0,0,27258,27259,5,95,0,0,27259,27260,7,25,0,0,27260,
+        27261,7,24,0,0,27261,27262,7,16,0,0,27262,27263,7,7,0,0,27263,27264,
+        7,1,0,0,27264,27265,7,2,0,0,27265,27266,7,2,0,0,27266,27267,7,11,
+        0,0,27267,4000,1,0,0,0,27268,27269,7,5,0,0,27269,27270,7,18,0,0,
+        27270,27271,7,5,0,0,27271,27272,5,95,0,0,27272,27273,7,25,0,0,27273,
+        27274,7,24,0,0,27274,27275,7,16,0,0,27275,27276,7,7,0,0,27276,27277,
+        7,8,0,0,27277,27278,7,14,0,0,27278,27279,7,15,0,0,27279,4002,1,0,
+        0,0,27280,27281,7,5,0,0,27281,27282,7,18,0,0,27282,27283,7,5,0,0,
+        27283,27284,5,95,0,0,27284,27285,7,25,0,0,27285,27286,7,24,0,0,27286,
+        27287,7,16,0,0,27287,27288,7,7,0,0,27288,27289,7,9,0,0,27289,27290,
+        7,0,0,0,27290,27291,7,4,0,0,27291,27292,7,10,0,0,27292,27293,7,14,
+        0,0,27293,4004,1,0,0,0,27294,27295,7,5,0,0,27295,27296,7,18,0,0,
+        27296,27297,7,5,0,0,27297,27298,5,95,0,0,27298,27299,7,25,0,0,27299,
+        27300,7,24,0,0,27300,27301,7,16,0,0,27301,27302,7,7,0,0,27302,27303,
+        7,11,0,0,27303,27304,7,7,0,0,27304,27305,7,0,0,0,27305,27306,7,14,
+        0,0,27306,27307,7,6,0,0,27307,4006,1,0,0,0,27308,27309,7,5,0,0,27309,
+        27310,7,18,0,0,27310,27311,7,5,0,0,27311,27312,5,95,0,0,27312,27313,
+        7,25,0,0,27313,27314,7,24,0,0,27314,27315,7,16,0,0,27315,27316,7,
+        7,0,0,27316,27317,7,7,0,0,27317,27318,7,14,0,0,27318,4008,1,0,0,
+        0,27319,27320,7,5,0,0,27320,27321,7,18,0,0,27321,27322,7,5,0,0,27322,
+        27323,5,95,0,0,27323,27324,7,25,0,0,27324,27325,7,24,0,0,27325,27326,
+        7,16,0,0,27326,27327,7,7,0,0,27327,27328,7,7,0,0,27328,27329,7,5,
+        0,0,27329,27330,7,12,0,0,27330,27331,7,3,0,0,27331,27332,7,10,0,
+        0,27332,4010,1,0,0,0,27333,27334,7,5,0,0,27334,27335,7,18,0,0,27335,
+        27336,7,5,0,0,27336,27337,5,95,0,0,27337,27338,7,25,0,0,27338,27339,
+        7,24,0,0,27339,27340,7,16,0,0,27340,27341,7,7,0,0,27341,27342,7,
+        15,0,0,27342,27343,7,3,0,0,27343,27344,7,6,0,0,27344,27345,7,9,0,
+        0,27345,27346,7,4,0,0,27346,27347,7,3,0,0,27347,27348,7,12,0,0,27348,
+        27349,7,4,0,0,27349,27350,7,19,0,0,27350,4012,1,0,0,0,27351,27352,
+        7,5,0,0,27352,27353,7,18,0,0,27353,27354,7,5,0,0,27354,27355,5,95,
+        0,0,27355,27356,7,25,0,0,27356,27357,7,24,0,0,27357,27358,7,16,0,
+        0,27358,27359,7,7,0,0,27359,27360,7,24,0,0,27360,27361,7,7,0,0,27361,
+        27362,7,14,0,0,27362,4014,1,0,0,0,27363,27364,7,5,0,0,27364,27365,
+        7,18,0,0,27365,27366,7,5,0,0,27366,27367,5,95,0,0,27367,27368,7,
+        25,0,0,27368,27369,7,24,0,0,27369,27370,7,16,0,0,27370,27371,7,7,
+        0,0,27371,27372,7,3,0,0,27372,27373,7,2,0,0,27373,27374,7,2,0,0,
+        27374,27375,7,4,0,0,27375,4016,1,0,0,0,27376,27377,7,5,0,0,27377,
+        27378,7,18,0,0,27378,27379,7,5,0,0,27379,27380,5,95,0,0,27380,27381,
+        7,25,0,0,27381,27382,7,24,0,0,27382,27383,7,16,0,0,27383,27384,7,
+        2,0,0,27384,27385,7,3,0,0,27385,27386,7,14,0,0,27386,27387,7,0,0,
+        0,27387,27388,7,4,0,0,27388,27389,7,7,0,0,27389,27390,7,12,0,0,27390,
+        27391,7,14,0,0,27391,4018,1,0,0,0,27392,27393,7,5,0,0,27393,27394,
+        7,18,0,0,27394,27395,7,5,0,0,27395,27396,5,95,0,0,27396,27397,7,
+        25,0,0,27397,27398,7,24,0,0,27398,27399,7,16,0,0,27399,27400,7,4,
+        0,0,27400,27401,7,8,0,0,27401,27402,7,2,0,0,27402,27403,7,7,0,0,
+        27403,27404,7,4,0,0,27404,27405,7,0,0,0,27405,27406,7,10,0,0,27406,
+        27407,7,7,0,0,27407,4020,1,0,0,0,27408,27409,7,5,0,0,27409,27410,
+        7,18,0,0,27410,27411,7,5,0,0,27411,27412,5,95,0,0,27412,27413,7,
+        25,0,0,27413,27414,7,24,0,0,27414,27415,7,16,0,0,27415,27416,7,12,
+        0,0,27416,27417,7,7,0,0,27417,27418,7,8,0,0,27418,27419,7,3,0,0,
+        27419,4022,1,0,0,0,27420,27421,7,5,0,0,27421,27422,7,18,0,0,27422,
+        27423,7,5,0,0,27423,27424,5,95,0,0,27424,27425,7,25,0,0,27425,27426,
+        7,24,0,0,27426,27427,7,17,0,0,27427,27428,7,6,0,0,27428,27429,7,
+        4,0,0,27429,27430,7,8,0,0,27430,27431,7,2,0,0,27431,27432,7,7,0,
+        0,27432,27433,7,4,0,0,27433,27434,7,6,0,0,27434,27435,7,7,0,0,27435,
+        27436,7,4,0,0,27436,4024,1,0,0,0,27437,27438,7,5,0,0,27438,27439,
+        7,18,0,0,27439,27440,7,5,0,0,27440,27441,5,95,0,0,27441,27442,7,
+        25,0,0,27442,27443,7,24,0,0,27443,27444,7,10,0,0,27444,27445,7,7,
+        0,0,27445,27446,7,9,0,0,27446,27447,7,25,0,0,27447,27448,7,2,0,0,
+        27448,27449,7,16,0,0,27449,4026,1,0,0,0,27450,27451,7,5,0,0,27451,
+        27452,7,18,0,0,27452,27453,7,5,0,0,27453,27454,5,95,0,0,27454,27455,
+        7,25,0,0,27455,27456,7,24,0,0,27456,27457,7,10,0,0,27457,27458,7,
+        7,0,0,27458,27459,7,5,0,0,27459,27460,7,6,0,0,27460,27461,7,3,0,
+        0,27461,27462,7,4,0,0,27462,4028,1,0,0,0,27463,27464,7,5,0,0,27464,
+        27465,7,18,0,0,27465,27466,7,5,0,0,27466,27467,5,95,0,0,27467,27468,
+        7,25,0,0,27468,27469,7,24,0,0,27469,27470,7,10,0,0,27470,27471,7,
+        7,0,0,27471,27472,7,5,0,0,27472,27473,7,15,0,0,27473,27474,7,16,
+        0,0,27474,27475,7,25,0,0,27475,4030,1,0,0,0,27476,27477,7,5,0,0,
+        27477,27478,7,18,0,0,27478,27479,7,5,0,0,27479,27480,5,95,0,0,27480,
+        27481,7,25,0,0,27481,27482,7,24,0,0,27482,27483,7,10,0,0,27483,27484,
+        7,3,0,0,27484,27485,7,10,0,0,27485,27486,5,50,0,0,27486,27487,7,
+        12,0,0,27487,27488,7,3,0,0,27488,27489,7,10,0,0,27489,4032,1,0,0,
+        0,27490,27491,7,5,0,0,27491,27492,7,18,0,0,27492,27493,7,5,0,0,27493,
+        27494,5,95,0,0,27494,27495,7,25,0,0,27495,27496,7,24,0,0,27496,27497,
+        7,11,0,0,27497,27498,7,0,0,0,27498,27499,7,7,0,0,27499,27500,7,17,
+        0,0,27500,4034,1,0,0,0,27501,27502,7,5,0,0,27502,27503,7,18,0,0,
+        27503,27504,7,5,0,0,27504,27505,5,95,0,0,27505,27506,7,25,0,0,27506,
+        27507,7,24,0,0,27507,27508,7,11,0,0,27508,27509,7,11,0,0,27509,27510,
+        7,7,0,0,27510,27511,7,14,0,0,27511,27512,7,16,0,0,27512,27513,7,
+        3,0,0,27513,27514,7,14,0,0,27514,27515,7,24,0,0,27515,27516,7,7,
+        0,0,27516,27517,7,14,0,0,27517,4036,1,0,0,0,27518,27519,7,5,0,0,
+        27519,27520,7,18,0,0,27520,27521,7,5,0,0,27521,27522,5,95,0,0,27522,
+        27523,7,25,0,0,27523,27524,7,24,0,0,27524,27525,7,14,0,0,27525,27526,
+        7,21,0,0,27526,27527,7,7,0,0,27527,27528,7,2,0,0,27528,27529,7,9,
+        0,0,27529,27530,7,6,0,0,27530,27531,7,3,0,0,27531,27532,7,6,0,0,
+        27532,27533,7,16,0,0,27533,4038,1,0,0,0,27534,27535,7,5,0,0,27535,
+        27536,7,18,0,0,27536,27537,7,5,0,0,27537,27538,5,95,0,0,27538,27539,
+        7,25,0,0,27539,27540,7,24,0,0,27540,27541,7,7,0,0,27541,27542,7,
+        10,0,0,27542,27543,7,11,0,0,27543,27544,7,11,0,0,27544,27545,7,6,
+        0,0,27545,27546,7,9,0,0,27546,4040,1,0,0,0,27547,27548,7,5,0,0,27548,
+        27549,7,18,0,0,27549,27550,7,5,0,0,27550,27551,5,95,0,0,27551,27552,
+        7,25,0,0,27552,27553,7,24,0,0,27553,27554,7,7,0,0,27554,27555,7,
+        2,0,0,27555,27556,7,9,0,0,27556,27557,7,6,0,0,27557,27558,7,7,0,
+        0,27558,27559,7,0,0,0,27559,27560,7,14,0,0,27560,27561,7,6,0,0,27561,
+        4042,1,0,0,0,27562,27563,7,5,0,0,27563,27564,7,18,0,0,27564,27565,
+        7,5,0,0,27565,27566,5,95,0,0,27566,27567,7,25,0,0,27567,27568,7,
+        24,0,0,27568,27569,7,7,0,0,27569,27570,7,2,0,0,27570,27571,7,3,0,
+        0,27571,27572,7,14,0,0,27572,27573,7,5,0,0,27573,27574,7,15,0,0,
+        27574,27575,7,0,0,0,27575,27576,7,8,0,0,27576,27577,7,6,0,0,27577,
+        4044,1,0,0,0,27578,27579,7,5,0,0,27579,27580,7,18,0,0,27580,27581,
+        7,5,0,0,27581,27582,5,95,0,0,27582,27583,7,25,0,0,27583,27584,7,
+        24,0,0,27584,27585,7,7,0,0,27585,27586,7,2,0,0,27586,27587,7,3,0,
+        0,27587,27588,7,14,0,0,27588,27589,7,12,0,0,27589,27590,7,8,0,0,
+        27590,27591,7,2,0,0,27591,27592,7,9,0,0,27592,27593,7,6,0,0,27593,
+        4046,1,0,0,0,27594,27595,7,5,0,0,27595,27596,7,18,0,0,27596,27597,
+        7,5,0,0,27597,27598,5,95,0,0,27598,27599,7,25,0,0,27599,27600,7,
+        24,0,0,27600,27601,5,95,0,0,27601,27602,7,7,0,0,27602,27603,7,3,
+        0,0,27603,27604,7,7,0,0,27604,27605,7,17,0,0,27605,4048,1,0,0,0,
+        27606,27607,7,5,0,0,27607,27608,7,18,0,0,27608,27609,7,5,0,0,27609,
+        27610,5,95,0,0,27610,27611,7,25,0,0,27611,27612,7,24,0,0,27612,27613,
+        7,7,0,0,27613,27614,7,5,0,0,27614,27615,7,15,0,0,27615,27616,5,52,
+        0,0,27616,27617,7,15,0,0,27617,27618,7,16,0,0,27618,27619,7,25,0,
+        0,27619,4050,1,0,0,0,27620,27621,7,5,0,0,27621,27622,7,18,0,0,27622,
+        27623,7,5,0,0,27623,27624,5,95,0,0,27624,27625,7,25,0,0,27625,27626,
+        7,24,0,0,27626,27627,7,7,0,0,27627,27628,7,5,0,0,27628,27629,7,15,
+        0,0,27629,27630,7,16,0,0,27630,27631,7,3,0,0,27631,27632,7,14,0,
+        0,27632,27633,7,24,0,0,27633,27634,7,7,0,0,27634,27635,7,14,0,0,
+        27635,4052,1,0,0,0,27636,27637,7,5,0,0,27637,27638,7,18,0,0,27638,
+        27639,7,5,0,0,27639,27640,5,95,0,0,27640,27641,7,25,0,0,27641,27642,
+        7,24,0,0,27642,27643,7,15,0,0,27643,27644,7,16,0,0,27644,27645,7,
+        25,0,0,27645,27646,7,16,0,0,27646,27647,7,3,0,0,27647,27648,7,14,
+        0,0,27648,27649,7,24,0,0,27649,27650,7,7,0,0,27650,27651,7,14,0,
+        0,27651,4054,1,0,0,0,27652,27653,7,5,0,0,27653,27654,7,18,0,0,27654,
+        27655,7,5,0,0,27655,27656,5,95,0,0,27656,27657,7,25,0,0,27657,27658,
+        7,24,0,0,27658,27659,5,95,0,0,27659,27660,7,15,0,0,27660,27661,7,
+        21,0,0,27661,27662,7,5,0,0,27662,27663,7,24,0,0,27663,27664,7,11,
+        0,0,27664,27665,5,50,0,0,27665,27666,7,25,0,0,27666,27667,7,14,0,
+        0,27667,27668,7,11,0,0,27668,4056,1,0,0,0,27669,27670,7,5,0,0,27670,
+        27671,7,18,0,0,27671,27672,7,5,0,0,27672,27673,5,95,0,0,27673,27674,
+        7,25,0,0,27674,27675,7,24,0,0,27675,27676,7,15,0,0,27676,27677,7,
+        2,0,0,27677,27678,7,11,0,0,27678,27679,7,18,0,0,27679,27680,7,0,
+        0,0,27680,27681,7,1,0,0,27681,27682,7,5,0,0,27682,4058,1,0,0,0,27683,
+        27684,7,5,0,0,27684,27685,7,18,0,0,27685,27686,7,5,0,0,27686,27687,
+        5,95,0,0,27687,27688,7,25,0,0,27688,27689,7,24,0,0,27689,27690,7,
+        15,0,0,27690,27691,7,2,0,0,27691,27692,7,11,0,0,27692,27693,7,18,
+        0,0,27693,27694,7,0,0,0,27694,27695,7,9,0,0,27695,27696,7,9,0,0,
+        27696,4060,1,0,0,0,27697,27698,7,5,0,0,27698,27699,7,18,0,0,27699,
+        27700,7,5,0,0,27700,27701,5,95,0,0,27701,27702,7,25,0,0,27702,27703,
+        7,24,0,0,27703,27704,7,15,0,0,27704,27705,7,2,0,0,27705,27706,7,
+        11,0,0,27706,27707,7,18,0,0,27707,27708,7,8,0,0,27708,27709,7,6,
+        0,0,27709,27710,7,11,0,0,27710,4062,1,0,0,0,27711,27712,7,5,0,0,
+        27712,27713,7,18,0,0,27713,27714,7,5,0,0,27714,27715,5,95,0,0,27715,
+        27716,7,25,0,0,27716,27717,7,24,0,0,27717,27718,7,15,0,0,27718,27719,
+        7,2,0,0,27719,27720,7,11,0,0,27720,27721,7,18,0,0,27721,27722,7,
+        8,0,0,27722,27723,7,5,0,0,27723,27724,7,4,0,0,27724,27725,7,1,0,
+        0,27725,27726,7,11,0,0,27726,4064,1,0,0,0,27727,27728,7,5,0,0,27728,
+        27729,7,18,0,0,27729,27730,7,5,0,0,27730,27731,5,95,0,0,27731,27732,
+        7,25,0,0,27732,27733,7,24,0,0,27733,27734,7,15,0,0,27734,27735,7,
+        2,0,0,27735,27736,7,11,0,0,27736,27737,7,18,0,0,27737,27738,7,8,
+        0,0,27738,27739,7,5,0,0,27739,27740,7,4,0,0,27740,4066,1,0,0,0,27741,
+        27742,7,5,0,0,27742,27743,7,18,0,0,27743,27744,7,5,0,0,27744,27745,
+        5,95,0,0,27745,27746,7,25,0,0,27746,27747,7,24,0,0,27747,27748,7,
+        15,0,0,27748,27749,7,2,0,0,27749,27750,7,11,0,0,27750,27751,7,18,
+        0,0,27751,27752,7,9,0,0,27752,27753,7,10,0,0,27753,27754,7,13,0,
+        0,27754,4068,1,0,0,0,27755,27756,7,5,0,0,27756,27757,7,18,0,0,27757,
+        27758,7,5,0,0,27758,27759,5,95,0,0,27759,27760,7,25,0,0,27760,27761,
+        7,24,0,0,27761,27762,7,15,0,0,27762,27763,7,2,0,0,27763,27764,7,
+        11,0,0,27764,27765,7,18,0,0,27765,27766,7,16,0,0,27766,27767,7,11,
+        0,0,27767,27768,7,3,0,0,27768,4070,1,0,0,0,27769,27770,7,5,0,0,27770,
+        27771,7,18,0,0,27771,27772,7,5,0,0,27772,27773,5,95,0,0,27773,27774,
+        7,25,0,0,27774,27775,7,24,0,0,27775,27776,7,15,0,0,27776,27777,7,
+        2,0,0,27777,27778,7,11,0,0,27778,27779,7,18,0,0,27779,27780,7,14,
+        0,0,27780,27781,7,2,0,0,27781,27782,7,9,0,0,27782,4072,1,0,0,0,27783,
+        27784,7,5,0,0,27784,27785,7,18,0,0,27785,27786,7,5,0,0,27786,27787,
+        5,95,0,0,27787,27788,7,25,0,0,27788,27789,7,24,0,0,27789,27790,7,
+        15,0,0,27790,27791,7,2,0,0,27791,27792,7,11,0,0,27792,27793,7,18,
+        0,0,27793,27794,7,14,0,0,27794,27795,7,12,0,0,27795,27796,7,11,0,
+        0,27796,4074,1,0,0,0,27797,27798,7,5,0,0,27798,27799,7,18,0,0,27799,
+        27800,7,5,0,0,27800,27801,5,95,0,0,27801,27802,7,25,0,0,27802,27803,
+        7,24,0,0,27803,27804,7,15,0,0,27804,27805,7,2,0,0,27805,27806,7,
+        11,0,0,27806,27807,7,18,0,0,27807,27808,7,3,0,0,27808,27809,7,7,
+        0,0,27809,27810,7,9,0,0,27810,4076,1,0,0,0,27811,27812,7,5,0,0,27812,
+        27813,7,18,0,0,27813,27814,7,5,0,0,27814,27815,5,95,0,0,27815,27816,
+        7,25,0,0,27816,27817,7,24,0,0,27817,27818,7,15,0,0,27818,27819,7,
+        2,0,0,27819,27820,7,11,0,0,27820,27821,7,18,0,0,27821,27822,7,5,
+        0,0,27822,27823,7,24,0,0,27823,27824,7,3,0,0,27824,27825,7,4,0,0,
+        27825,4078,1,0,0,0,27826,27827,7,5,0,0,27827,27828,7,18,0,0,27828,
+        27829,7,5,0,0,27829,27830,5,95,0,0,27830,27831,7,25,0,0,27831,27832,
+        7,24,0,0,27832,27833,7,15,0,0,27833,27834,7,2,0,0,27834,27835,7,
+        11,0,0,27835,27836,7,18,0,0,27836,27837,7,5,0,0,27837,27838,7,12,
+        0,0,27838,27839,7,1,0,0,27839,4080,1,0,0,0,27840,27841,7,5,0,0,27841,
+        27842,7,18,0,0,27842,27843,7,5,0,0,27843,27844,5,95,0,0,27844,27845,
+        7,25,0,0,27845,27846,7,24,0,0,27846,27847,7,15,0,0,27847,27848,7,
+        2,0,0,27848,27849,7,11,0,0,27849,27850,7,18,0,0,27850,27851,7,12,
+        0,0,27851,27852,7,14,0,0,27852,27853,7,12,0,0,27853,27854,7,5,0,
+        0,27854,4082,1,0,0,0,27855,27856,7,5,0,0,27856,27857,7,18,0,0,27857,
+        27858,7,5,0,0,27858,27859,5,95,0,0,27859,27860,7,25,0,0,27860,27861,
+        7,24,0,0,27861,27862,7,15,0,0,27862,27863,7,2,0,0,27863,27864,7,
+        11,0,0,27864,27865,7,18,0,0,27865,27866,7,12,0,0,27866,27867,7,15,
+        0,0,27867,27868,7,11,0,0,27868,27869,7,5,0,0,27869,4084,1,0,0,0,
+        27870,27871,7,5,0,0,27871,27872,7,18,0,0,27872,27873,7,5,0,0,27873,
+        27874,5,95,0,0,27874,27875,7,25,0,0,27875,27876,7,24,0,0,27876,27877,
+        7,15,0,0,27877,27878,7,2,0,0,27878,27879,7,11,0,0,27879,27880,7,
+        18,0,0,27880,27881,7,13,0,0,27881,27882,7,6,0,0,27882,27883,7,24,
+        0,0,27883,4086,1,0,0,0,27884,27885,7,5,0,0,27885,27886,7,18,0,0,
+        27886,27887,7,5,0,0,27887,27888,5,95,0,0,27888,27889,7,25,0,0,27889,
+        27890,7,24,0,0,27890,27891,7,15,0,0,27891,27892,7,2,0,0,27892,27893,
+        7,11,0,0,27893,27894,7,18,0,0,27894,27895,7,13,0,0,27895,27896,7,
+        17,0,0,27896,27897,7,6,0,0,27897,4088,1,0,0,0,27898,27899,7,5,0,
+        0,27899,27900,7,18,0,0,27900,27901,7,5,0,0,27901,27902,5,95,0,0,
+        27902,27903,7,25,0,0,27903,27904,7,24,0,0,27904,27905,7,15,0,0,27905,
+        27906,7,2,0,0,27906,27907,7,11,0,0,27907,27908,7,18,0,0,27908,27909,
+        7,13,0,0,27909,27910,7,17,0,0,27910,27911,7,4,0,0,27911,4090,1,0,
+        0,0,27912,27913,7,5,0,0,27913,27914,7,18,0,0,27914,27915,7,5,0,0,
+        27915,27916,5,95,0,0,27916,27917,7,25,0,0,27917,27918,7,24,0,0,27918,
+        27919,7,15,0,0,27919,27920,7,2,0,0,27920,27921,7,11,0,0,27921,27922,
+        7,18,0,0,27922,27923,7,13,0,0,27923,27924,7,11,0,0,27924,27925,7,
+        6,0,0,27925,4092,1,0,0,0,27926,27927,7,5,0,0,27927,27928,7,18,0,
+        0,27928,27929,7,5,0,0,27929,27930,5,95,0,0,27930,27931,7,25,0,0,
+        27931,27932,7,24,0,0,27932,27933,7,15,0,0,27933,27934,7,2,0,0,27934,
+        27935,7,11,0,0,27935,27936,7,18,0,0,27936,27937,7,13,0,0,27937,27938,
+        7,11,0,0,27938,27939,7,4,0,0,27939,4094,1,0,0,0,27940,27941,7,5,
+        0,0,27941,27942,7,18,0,0,27942,27943,7,5,0,0,27943,27944,5,95,0,
+        0,27944,27945,7,25,0,0,27945,27946,7,24,0,0,27946,27947,7,15,0,0,
+        27947,27948,7,2,0,0,27948,27949,7,11,0,0,27949,27950,7,18,0,0,27950,
+        27951,7,13,0,0,27951,27952,7,7,0,0,27952,27953,7,6,0,0,27953,4096,
+        1,0,0,0,27954,27955,7,5,0,0,27955,27956,7,18,0,0,27956,27957,7,5,
+        0,0,27957,27958,5,95,0,0,27958,27959,7,25,0,0,27959,27960,7,24,0,
+        0,27960,27961,7,3,0,0,27961,27962,7,6,0,0,27962,27963,7,16,0,0,27963,
+        27964,5,50,0,0,27964,27965,7,13,0,0,27965,27966,7,0,0,0,27966,27967,
+        7,11,0,0,27967,4098,1,0,0,0,27968,27969,7,5,0,0,27969,27970,7,18,
+        0,0,27970,27971,7,5,0,0,27971,27972,5,95,0,0,27972,27973,7,25,0,
+        0,27973,27974,7,24,0,0,27974,27975,7,3,0,0,27975,27976,7,6,0,0,27976,
+        27977,7,7,0,0,27977,27978,7,0,0,0,27978,27979,7,14,0,0,27979,27980,
+        7,6,0,0,27980,4100,1,0,0,0,27981,27982,7,5,0,0,27982,27983,7,18,
+        0,0,27983,27984,7,5,0,0,27984,27985,5,95,0,0,27985,27986,7,25,0,
+        0,27986,27987,7,24,0,0,27987,27988,7,3,0,0,27988,27989,7,6,0,0,27989,
+        27990,7,15,0,0,27990,27991,7,11,0,0,27991,27992,7,0,0,0,27992,27993,
+        7,8,0,0,27993,27994,7,6,0,0,27994,4102,1,0,0,0,27995,27996,7,5,0,
+        0,27996,27997,7,18,0,0,27997,27998,7,5,0,0,27998,27999,5,95,0,0,
+        27999,28000,7,25,0,0,28000,28001,7,24,0,0,28001,28002,7,3,0,0,28002,
+        28003,7,6,0,0,28003,28004,7,5,0,0,28004,28005,7,13,0,0,28005,28006,
+        7,12,0,0,28006,28007,7,3,0,0,28007,28008,7,10,0,0,28008,4104,1,0,
+        0,0,28009,28010,7,5,0,0,28010,28011,7,18,0,0,28011,28012,7,5,0,0,
+        28012,28013,5,95,0,0,28013,28014,7,25,0,0,28014,28015,7,24,0,0,28015,
+        28016,7,3,0,0,28016,28017,7,7,0,0,28017,28018,7,9,0,0,28018,28019,
+        7,19,0,0,28019,28020,7,0,0,0,28020,28021,7,11,0,0,28021,28022,7,
+        16,0,0,28022,28023,5,50,0,0,28023,28024,7,6,0,0,28024,28025,7,13,
+        0,0,28025,28026,7,7,0,0,28026,4106,1,0,0,0,28027,28028,7,5,0,0,28028,
+        28029,7,18,0,0,28029,28030,7,5,0,0,28030,28031,5,95,0,0,28031,28032,
+        7,25,0,0,28032,28033,7,24,0,0,28033,28034,7,3,0,0,28034,28035,7,
+        5,0,0,28035,28036,7,11,0,0,28036,28037,7,13,0,0,28037,28038,7,24,
+        0,0,28038,28039,7,7,0,0,28039,28040,7,14,0,0,28040,4108,1,0,0,0,
+        28041,28042,7,5,0,0,28042,28043,7,18,0,0,28043,28044,7,5,0,0,28044,
+        28045,5,95,0,0,28045,28046,7,25,0,0,28046,28047,7,24,0,0,28047,28048,
+        7,3,0,0,28048,28049,7,18,0,0,28049,28050,7,6,0,0,28050,28051,7,7,
+        0,0,28051,28052,7,13,0,0,28052,28053,7,15,0,0,28053,28054,7,17,0,
+        0,28054,28055,7,6,0,0,28055,28056,7,4,0,0,28056,4110,1,0,0,0,28057,
+        28058,7,5,0,0,28058,28059,7,18,0,0,28059,28060,7,5,0,0,28060,28061,
+        5,95,0,0,28061,28062,7,25,0,0,28062,28063,7,24,0,0,28063,28064,7,
+        3,0,0,28064,28065,7,18,0,0,28065,28066,7,13,0,0,28066,28067,7,0,
+        0,0,28067,28068,7,3,0,0,28068,28069,7,17,0,0,28069,28070,7,6,0,0,
+        28070,28071,7,4,0,0,28071,4112,1,0,0,0,28072,28073,7,5,0,0,28073,
+        28074,7,18,0,0,28074,28075,7,5,0,0,28075,28076,5,95,0,0,28076,28077,
+        7,25,0,0,28077,28078,7,24,0,0,28078,28079,7,3,0,0,28079,28080,7,
+        18,0,0,28080,28081,7,22,0,0,28081,28082,7,3,0,0,28082,28083,7,15,
+        0,0,28083,4114,1,0,0,0,28084,28085,7,5,0,0,28085,28086,7,18,0,0,
+        28086,28087,7,5,0,0,28087,28088,5,95,0,0,28088,28089,7,25,0,0,28089,
+        28090,7,24,0,0,28090,28091,7,5,0,0,28091,28092,7,6,0,0,28092,28093,
+        7,24,0,0,28093,28094,5,50,0,0,28094,28095,7,8,0,0,28095,28096,7,
+        2,0,0,28096,28097,7,7,0,0,28097,28098,5,52,0,0,28098,28099,7,25,
+        0,0,28099,28100,7,8,0,0,28100,4116,1,0,0,0,28101,28102,7,5,0,0,28102,
+        28103,7,18,0,0,28103,28104,7,5,0,0,28104,28105,5,95,0,0,28105,28106,
+        7,25,0,0,28106,28107,7,24,0,0,28107,28108,7,5,0,0,28108,28109,7,
+        6,0,0,28109,28110,7,24,0,0,28110,28111,5,50,0,0,28111,28112,7,8,
+        0,0,28112,28113,7,2,0,0,28113,28114,7,7,0,0,28114,4118,1,0,0,0,28115,
+        28116,7,5,0,0,28116,28117,7,18,0,0,28117,28118,7,5,0,0,28118,28119,
+        5,95,0,0,28119,28120,7,25,0,0,28120,28121,7,24,0,0,28121,28122,7,
+        5,0,0,28122,28123,7,6,0,0,28123,28124,7,24,0,0,28124,28125,7,9,0,
+        0,28125,28126,7,6,0,0,28126,28127,7,6,0,0,28127,28128,7,15,0,0,28128,
+        28129,7,6,0,0,28129,28130,7,24,0,0,28130,4120,1,0,0,0,28131,28132,
+        7,5,0,0,28132,28133,7,18,0,0,28133,28134,7,5,0,0,28134,28135,5,95,
+        0,0,28135,28136,7,25,0,0,28136,28137,7,24,0,0,28137,28138,7,5,0,
+        0,28138,28139,7,6,0,0,28139,28140,7,24,0,0,28140,28141,7,10,0,0,
+        28141,28142,7,7,0,0,28142,28143,7,5,0,0,28143,28144,7,1,0,0,28144,
+        4122,1,0,0,0,28145,28146,7,5,0,0,28146,28147,7,18,0,0,28147,28148,
+        7,5,0,0,28148,28149,5,95,0,0,28149,28150,7,25,0,0,28150,28151,7,
+        24,0,0,28151,28152,7,5,0,0,28152,28153,7,6,0,0,28153,28154,7,24,
+        0,0,28154,28155,7,3,0,0,28155,28156,7,14,0,0,28156,4124,1,0,0,0,
+        28157,28158,7,5,0,0,28158,28159,7,18,0,0,28159,28160,7,5,0,0,28160,
+        28161,5,95,0,0,28161,28162,7,25,0,0,28162,28163,7,24,0,0,28163,28164,
+        7,5,0,0,28164,28165,7,6,0,0,28165,28166,7,24,0,0,28166,28167,7,3,
+        0,0,28167,28168,7,13,0,0,28168,28169,7,5,0,0,28169,4126,1,0,0,0,
+        28170,28171,7,5,0,0,28171,28172,7,18,0,0,28172,28173,7,5,0,0,28173,
+        28174,5,95,0,0,28174,28175,7,25,0,0,28175,28176,7,24,0,0,28176,28177,
+        7,5,0,0,28177,28178,7,6,0,0,28178,28179,7,24,0,0,28179,28180,7,5,
+        0,0,28180,28181,7,12,0,0,28181,28182,7,1,0,0,28182,4128,1,0,0,0,
+        28183,28184,7,5,0,0,28184,28185,7,18,0,0,28185,28186,7,5,0,0,28186,
+        28187,5,95,0,0,28187,28188,7,25,0,0,28188,28189,7,24,0,0,28189,28190,
+        7,5,0,0,28190,28191,7,6,0,0,28191,28192,7,24,0,0,28192,28193,7,4,
+        0,0,28193,28194,7,18,0,0,28194,28195,7,15,0,0,28195,28196,7,14,0,
+        0,28196,28197,7,0,0,0,28197,28198,7,4,0,0,28198,28199,7,8,0,0,28199,
+        28200,7,19,0,0,28200,4130,1,0,0,0,28201,28202,7,5,0,0,28202,28203,
+        7,18,0,0,28203,28204,7,5,0,0,28204,28205,5,95,0,0,28205,28206,7,
+        25,0,0,28206,28207,7,24,0,0,28207,28208,7,5,0,0,28208,28209,7,4,
+        0,0,28209,28210,7,0,0,0,28210,28211,7,3,0,0,28211,28212,7,4,0,0,
+        28212,28213,7,5,0,0,28213,28214,7,22,0,0,28214,28215,7,10,0,0,28215,
+        28216,7,4,0,0,28216,28217,7,19,0,0,28217,4132,1,0,0,0,28218,28219,
+        7,5,0,0,28219,28220,7,18,0,0,28220,28221,7,5,0,0,28221,28222,5,95,
+        0,0,28222,28223,7,25,0,0,28223,28224,7,24,0,0,28224,28225,7,5,0,
+        0,28225,28226,7,4,0,0,28226,28227,7,0,0,0,28227,28228,7,4,0,0,28228,
+        28229,7,1,0,0,28229,28230,7,12,0,0,28230,28231,7,3,0,0,28231,28232,
+        7,10,0,0,28232,4134,1,0,0,0,28233,28234,7,5,0,0,28234,28235,7,18,
+        0,0,28235,28236,7,5,0,0,28236,28237,5,95,0,0,28237,28238,7,25,0,
+        0,28238,28239,7,24,0,0,28239,28240,7,5,0,0,28240,28241,7,4,0,0,28241,
+        28242,7,3,0,0,28242,28243,5,50,0,0,28243,28244,7,8,0,0,28244,28245,
+        7,2,0,0,28245,28246,7,9,0,0,28246,28247,7,6,0,0,28247,28248,7,15,
+        0,0,28248,4136,1,0,0,0,28249,28250,7,5,0,0,28250,28251,7,18,0,0,
+        28251,28252,7,5,0,0,28252,28253,5,95,0,0,28253,28254,7,25,0,0,28254,
+        28255,7,24,0,0,28255,28256,7,5,0,0,28256,28257,7,4,0,0,28257,28258,
+        7,3,0,0,28258,28259,7,20,0,0,28259,28260,7,2,0,0,28260,28261,7,10,
+        0,0,28261,28262,7,7,0,0,28262,4138,1,0,0,0,28263,28264,7,5,0,0,28264,
+        28265,7,18,0,0,28265,28266,7,5,0,0,28266,28267,5,95,0,0,28267,28268,
+        7,25,0,0,28268,28269,7,24,0,0,28269,28270,7,5,0,0,28270,28271,7,
+        12,0,0,28271,28272,7,1,0,0,28272,28273,7,5,0,0,28273,28274,7,4,0,
+        0,28274,28275,7,3,0,0,28275,28276,7,0,0,0,28276,28277,7,16,0,0,28277,
+        28278,7,4,0,0,28278,4140,1,0,0,0,28279,28280,7,5,0,0,28280,28281,
+        7,18,0,0,28281,28282,7,5,0,0,28282,28283,5,95,0,0,28283,28284,7,
+        25,0,0,28284,28285,7,24,0,0,28285,28286,7,5,0,0,28286,28287,7,12,
+        0,0,28287,28288,7,1,0,0,28288,28289,7,5,0,0,28289,28290,7,4,0,0,
+        28290,28291,7,3,0,0,28291,28292,7,1,0,0,28292,28293,7,6,0,0,28293,
+        28294,7,16,0,0,28294,4142,1,0,0,0,28295,28296,7,5,0,0,28296,28297,
+        7,18,0,0,28297,28298,7,5,0,0,28298,28299,5,95,0,0,28299,28300,7,
+        25,0,0,28300,28301,7,24,0,0,28301,28302,7,4,0,0,28302,28303,7,2,
+        0,0,28303,28304,7,21,0,0,28304,28305,7,6,0,0,28305,28306,7,7,0,0,
+        28306,28307,7,10,0,0,28307,28308,7,23,0,0,28308,28309,7,6,0,0,28309,
+        4144,1,0,0,0,28310,28311,7,5,0,0,28311,28312,7,18,0,0,28312,28313,
+        7,5,0,0,28313,28314,5,95,0,0,28314,28315,7,25,0,0,28315,28316,7,
+        24,0,0,28316,28317,7,4,0,0,28317,28318,7,3,0,0,28318,28319,7,6,0,
+        0,28319,28320,7,0,0,0,28320,28321,7,4,0,0,28321,28322,7,0,0,0,28322,
+        28323,7,5,0,0,28323,4146,1,0,0,0,28324,28325,7,5,0,0,28325,28326,
+        7,18,0,0,28326,28327,7,5,0,0,28327,28328,5,95,0,0,28328,28329,7,
+        25,0,0,28329,28330,7,24,0,0,28330,28331,5,95,0,0,28331,28332,7,12,
+        0,0,28332,28333,7,15,0,0,28333,28334,7,21,0,0,28334,28335,7,25,0,
+        0,28335,28336,7,14,0,0,28336,28337,7,11,0,0,28337,28338,5,50,0,0,
+        28338,28339,7,5,0,0,28339,28340,7,24,0,0,28340,28341,7,11,0,0,28341,
+        4148,1,0,0,0,28342,28343,7,5,0,0,28343,28344,7,18,0,0,28344,28345,
+        7,5,0,0,28345,28346,5,95,0,0,28346,28347,7,25,0,0,28347,28348,7,
+        24,0,0,28348,28349,7,25,0,0,28349,28350,7,16,0,0,28350,28351,7,2,
+        0,0,28351,28352,7,3,0,0,28352,28353,7,14,0,0,28353,4150,1,0,0,0,
+        28354,28355,7,5,0,0,28355,28356,7,18,0,0,28356,28357,7,5,0,0,28357,
+        28358,5,95,0,0,28358,28359,7,25,0,0,28359,28360,7,5,0,0,28360,28361,
+        7,10,0,0,28361,28362,7,9,0,0,28362,28363,5,95,0,0,28363,28364,7,
+        4,0,0,28364,28365,7,2,0,0,28365,28366,5,95,0,0,28366,28367,7,3,0,
+        0,28367,28368,7,0,0,0,28368,28369,7,22,0,0,28369,4152,1,0,0,0,28370,
+        28371,7,5,0,0,28371,28372,7,18,0,0,28372,28373,7,5,0,0,28373,28374,
+        5,95,0,0,28374,28375,7,23,0,0,28375,28376,7,14,0,0,28376,28377,7,
+        0,0,0,28377,28378,7,15,0,0,28378,28379,5,95,0,0,28379,28380,7,16,
+        0,0,28380,28381,7,10,0,0,28381,28382,7,11,0,0,28382,28383,7,4,0,
+        0,28383,28384,7,6,0,0,28384,28385,7,3,0,0,28385,4154,1,0,0,0,28386,
+        28387,7,5,0,0,28387,28388,7,18,0,0,28388,28389,7,5,0,0,28389,28390,
+        5,95,0,0,28390,28391,7,23,0,0,28391,28392,7,14,0,0,28392,28393,7,
+        0,0,0,28393,28394,7,15,0,0,28394,28395,5,95,0,0,28395,28396,7,3,
+        0,0,28396,28397,7,6,0,0,28397,28398,7,16,0,0,28398,28399,7,3,0,0,
+        28399,28400,7,6,0,0,28400,28401,7,5,0,0,28401,28402,7,19,0,0,28402,
+        4156,1,0,0,0,28403,28404,7,4,0,0,28404,4158,1,0,0,0,28405,28406,
+        7,4,0,0,28406,28407,7,0,0,0,28407,28408,7,1,0,0,28408,28409,7,11,
+        0,0,28409,28410,7,6,0,0,28410,28411,5,95,0,0,28411,28412,7,11,0,
+        0,28412,28413,7,2,0,0,28413,28414,7,2,0,0,28414,28415,7,21,0,0,28415,
+        28416,7,12,0,0,28416,28417,7,15,0,0,28417,28418,5,95,0,0,28418,28419,
+        7,1,0,0,28419,28420,7,18,0,0,28420,28421,5,95,0,0,28421,28422,7,
+        7,0,0,28422,28423,7,11,0,0,28423,4160,1,0,0,0,28424,28425,7,4,0,
+        0,28425,28426,7,0,0,0,28426,28427,7,1,0,0,28427,28428,7,11,0,0,28428,
+        28429,7,6,0,0,28429,28430,7,5,0,0,28430,28431,7,15,0,0,28431,28432,
+        7,0,0,0,28432,28433,7,8,0,0,28433,28434,7,6,0,0,28434,28435,5,95,
+        0,0,28435,28436,7,7,0,0,28436,28437,7,2,0,0,28437,4162,1,0,0,0,28438,
+        28439,7,4,0,0,28439,28440,7,0,0,0,28440,28441,7,1,0,0,28441,28442,
+        7,11,0,0,28442,28443,7,6,0,0,28443,28444,7,5,0,0,28444,28445,7,15,
+        0,0,28445,28446,7,0,0,0,28446,28447,7,8,0,0,28447,28448,7,6,0,0,
+        28448,4164,1,0,0,0,28449,28450,7,4,0,0,28450,28451,7,0,0,0,28451,
+        28452,7,1,0,0,28452,28453,7,11,0,0,28453,28454,7,6,0,0,28454,28455,
+        7,5,0,0,28455,4166,1,0,0,0,28456,28457,7,4,0,0,28457,28458,7,0,0,
+        0,28458,28459,7,1,0,0,28459,28460,7,11,0,0,28460,28461,7,6,0,0,28461,
+        28462,5,95,0,0,28462,28463,7,5,0,0,28463,28464,7,4,0,0,28464,28465,
+        7,0,0,0,28465,28466,7,4,0,0,28466,28467,7,5,0,0,28467,4168,1,0,0,
+        0,28468,28469,7,4,0,0,28469,28470,7,0,0,0,28470,28471,7,1,0,0,28471,
+        28472,7,11,0,0,28472,28473,7,6,0,0,28473,4170,1,0,0,0,28474,28475,
+        7,4,0,0,28475,28476,7,0,0,0,28476,28477,7,1,0,0,28477,28478,7,7,
+        0,0,28478,28479,7,2,0,0,28479,4172,1,0,0,0,28480,28481,7,4,0,0,28481,
+        28482,7,0,0,0,28482,28483,7,17,0,0,28483,4174,1,0,0,0,28484,28485,
+        7,4,0,0,28485,28486,7,0,0,0,28486,28487,7,7,0,0,28487,28488,7,19,
+        0,0,28488,4176,1,0,0,0,28489,28490,7,4,0,0,28490,28491,7,0,0,0,28491,
+        28492,7,7,0,0,28492,4178,1,0,0,0,28493,28494,7,4,0,0,28494,28495,
+        7,1,0,0,28495,28496,7,11,0,0,28496,28497,5,36,0,0,28497,28498,7,
+        2,0,0,28498,28499,7,3,0,0,28499,28500,5,36,0,0,28500,28501,7,10,
+        0,0,28501,28502,7,9,0,0,28502,28503,7,25,0,0,28503,28504,5,36,0,
+        0,28504,28505,7,15,0,0,28505,28506,7,0,0,0,28506,28507,7,3,0,0,28507,
+        28508,7,4,0,0,28508,28509,5,36,0,0,28509,28510,7,7,0,0,28510,28511,
+        7,12,0,0,28511,28512,7,14,0,0,28512,4180,1,0,0,0,28513,28514,7,4,
+        0,0,28514,28515,7,6,0,0,28515,28516,7,14,0,0,28516,28517,7,15,0,
+        0,28517,28518,7,16,0,0,28518,28519,7,10,0,0,28519,28520,7,11,0,0,
+        28520,28521,7,6,0,0,28521,4182,1,0,0,0,28522,28523,7,4,0,0,28523,
+        28524,7,6,0,0,28524,28525,7,14,0,0,28525,28526,7,15,0,0,28526,28527,
+        7,11,0,0,28527,28528,7,0,0,0,28528,28529,7,4,0,0,28529,28530,7,6,
+        0,0,28530,4184,1,0,0,0,28531,28532,7,4,0,0,28532,28533,7,6,0,0,28533,
+        28534,7,14,0,0,28534,28535,7,15,0,0,28535,28536,7,11,0,0,28536,28537,
+        7,0,0,0,28537,28538,7,4,0,0,28538,28539,7,6,0,0,28539,28540,5,95,
+        0,0,28540,28541,7,4,0,0,28541,28542,7,0,0,0,28542,28543,7,1,0,0,
+        28543,28544,7,11,0,0,28544,28545,7,6,0,0,28545,4186,1,0,0,0,28546,
+        28547,7,4,0,0,28547,28548,7,6,0,0,28548,28549,7,14,0,0,28549,28550,
+        7,15,0,0,28550,28551,7,2,0,0,28551,28552,7,3,0,0,28552,28553,7,0,
+        0,0,28553,28554,7,3,0,0,28554,28555,7,18,0,0,28555,4188,1,0,0,0,
+        28556,28557,7,4,0,0,28557,28558,7,6,0,0,28558,28559,7,14,0,0,28559,
+        28560,7,15,0,0,28560,28561,5,95,0,0,28561,28562,7,4,0,0,28562,28563,
+        7,0,0,0,28563,28564,7,1,0,0,28564,28565,7,11,0,0,28565,28566,7,6,
+        0,0,28566,4190,1,0,0,0,28567,28568,7,4,0,0,28568,28569,7,6,0,0,28569,
+        28570,7,3,0,0,28570,28571,7,14,0,0,28571,28572,7,10,0,0,28572,28573,
+        7,7,0,0,28573,28574,7,0,0,0,28574,28575,7,4,0,0,28575,28576,7,6,
+        0,0,28576,28577,7,9,0,0,28577,4192,1,0,0,0,28578,28579,7,4,0,0,28579,
+        28580,7,6,0,0,28580,28581,7,5,0,0,28581,28582,7,4,0,0,28582,4194,
+        1,0,0,0,28583,28584,7,4,0,0,28584,28585,7,6,0,0,28585,28586,7,25,
+        0,0,28586,28587,7,4,0,0,28587,4196,1,0,0,0,28588,28589,7,4,0,0,28589,
+        28590,7,6,0,0,28590,28591,7,25,0,0,28591,28592,7,4,0,0,28592,28593,
+        7,16,0,0,28593,28594,7,10,0,0,28594,28595,7,11,0,0,28595,28596,7,
+        6,0,0,28596,4198,1,0,0,0,28597,28598,7,4,0,0,28598,28599,7,19,0,
+        0,28599,28600,7,0,0,0,28600,28601,7,7,0,0,28601,4200,1,0,0,0,28602,
+        28603,7,4,0,0,28603,28604,7,19,0,0,28604,28605,7,6,0,0,28605,28606,
+        7,7,0,0,28606,4202,1,0,0,0,28607,28608,7,4,0,0,28608,28609,7,19,
+        0,0,28609,28610,7,6,0,0,28610,4204,1,0,0,0,28611,28612,7,4,0,0,28612,
+        28613,7,19,0,0,28613,28614,7,6,0,0,28614,28615,7,5,0,0,28615,28616,
+        7,6,0,0,28616,4206,1,0,0,0,28617,28618,7,4,0,0,28618,28619,7,19,
+        0,0,28619,28620,7,3,0,0,28620,28621,7,6,0,0,28621,28622,7,0,0,0,
+        28622,28623,7,9,0,0,28623,4208,1,0,0,0,28624,28625,7,4,0,0,28625,
+        28626,7,19,0,0,28626,28627,7,3,0,0,28627,28628,7,2,0,0,28628,28629,
+        7,12,0,0,28629,28630,7,17,0,0,28630,28631,7,19,0,0,28631,4210,1,
+        0,0,0,28632,28633,7,4,0,0,28633,28634,7,10,0,0,28634,28635,7,6,0,
+        0,28635,28636,7,3,0,0,28636,4212,1,0,0,0,28637,28638,7,4,0,0,28638,
+        28639,7,10,0,0,28639,28640,7,6,0,0,28640,28641,7,5,0,0,28641,4214,
+        1,0,0,0,28642,28643,7,4,0,0,28643,28644,7,10,0,0,28644,28645,7,14,
+        0,0,28645,28646,7,6,0,0,28646,28647,7,2,0,0,28647,28648,7,12,0,0,
+        28648,28649,7,4,0,0,28649,4216,1,0,0,0,28650,28651,7,4,0,0,28651,
+        28652,7,10,0,0,28652,28653,7,14,0,0,28653,28654,7,6,0,0,28654,28655,
+        7,5,0,0,28655,28656,7,4,0,0,28656,28657,7,0,0,0,28657,28658,7,14,
+        0,0,28658,28659,7,15,0,0,28659,28660,5,95,0,0,28660,28661,7,11,0,
+        0,28661,28662,7,4,0,0,28662,28663,7,23,0,0,28663,28664,5,95,0,0,
+        28664,28665,7,12,0,0,28665,28666,7,7,0,0,28666,28667,7,8,0,0,28667,
+        28668,7,2,0,0,28668,28669,7,7,0,0,28669,28670,7,5,0,0,28670,28671,
+        7,4,0,0,28671,28672,7,3,0,0,28672,28673,7,0,0,0,28673,28674,7,10,
+        0,0,28674,28675,7,7,0,0,28675,28676,7,6,0,0,28676,28677,7,9,0,0,
+        28677,4218,1,0,0,0,28678,28679,7,4,0,0,28679,28680,7,10,0,0,28680,
+        28681,7,14,0,0,28681,28682,7,6,0,0,28682,28683,7,5,0,0,28683,28684,
+        7,4,0,0,28684,28685,7,0,0,0,28685,28686,7,14,0,0,28686,28687,7,15,
+        0,0,28687,4220,1,0,0,0,28688,28689,7,4,0,0,28689,28690,7,10,0,0,
+        28690,28691,7,14,0,0,28691,28692,7,6,0,0,28692,28693,7,5,0,0,28693,
+        28694,7,4,0,0,28694,28695,7,0,0,0,28695,28696,7,14,0,0,28696,28697,
+        7,15,0,0,28697,28698,5,95,0,0,28698,28699,7,4,0,0,28699,28700,7,
+        23,0,0,28700,28701,5,95,0,0,28701,28702,7,12,0,0,28702,28703,7,7,
+        0,0,28703,28704,7,8,0,0,28704,28705,7,2,0,0,28705,28706,7,7,0,0,
+        28706,28707,7,5,0,0,28707,28708,7,4,0,0,28708,28709,7,3,0,0,28709,
+        28710,7,0,0,0,28710,28711,7,10,0,0,28711,28712,7,7,0,0,28712,28713,
+        7,6,0,0,28713,28714,7,9,0,0,28714,4222,1,0,0,0,28715,28716,7,4,0,
+        0,28716,28717,7,10,0,0,28717,28718,7,14,0,0,28718,28719,7,6,0,0,
+        28719,28720,7,5,0,0,28720,28721,7,4,0,0,28721,28722,7,0,0,0,28722,
+        28723,7,14,0,0,28723,28724,7,15,0,0,28724,28725,5,95,0,0,28725,28726,
+        7,12,0,0,28726,28727,7,7,0,0,28727,28728,7,8,0,0,28728,28729,7,2,
+        0,0,28729,28730,7,7,0,0,28730,28731,7,5,0,0,28731,28732,7,4,0,0,
+        28732,28733,7,3,0,0,28733,28734,7,0,0,0,28734,28735,7,10,0,0,28735,
+        28736,7,7,0,0,28736,28737,7,6,0,0,28737,28738,7,9,0,0,28738,4224,
+        1,0,0,0,28739,28740,7,4,0,0,28740,28741,7,10,0,0,28741,28742,7,14,
+        0,0,28742,28743,7,6,0,0,28743,28744,7,5,0,0,28744,4226,1,0,0,0,28745,
+        28746,7,4,0,0,28746,28747,7,10,0,0,28747,28748,7,14,0,0,28748,28749,
+        7,6,0,0,28749,4228,1,0,0,0,28750,28751,7,4,0,0,28751,28752,7,10,
+        0,0,28752,28753,7,14,0,0,28753,28754,7,6,0,0,28754,28755,7,23,0,
+        0,28755,28756,7,2,0,0,28756,28757,7,7,0,0,28757,28758,7,6,0,0,28758,
+        4230,1,0,0,0,28759,28760,7,4,0,0,28760,28761,7,10,0,0,28761,28762,
+        7,14,0,0,28762,28763,7,6,0,0,28763,28764,7,23,0,0,28764,28765,7,
+        2,0,0,28765,28766,7,7,0,0,28766,28767,7,6,0,0,28767,28768,5,95,0,
+        0,28768,28769,7,0,0,0,28769,28770,7,1,0,0,28770,28771,7,1,0,0,28771,
+        28772,7,3,0,0,28772,4232,1,0,0,0,28773,28774,7,4,0,0,28774,28775,
+        7,10,0,0,28775,28776,7,14,0,0,28776,28777,7,6,0,0,28777,28778,7,
+        23,0,0,28778,28779,7,2,0,0,28779,28780,7,7,0,0,28780,28781,7,6,0,
+        0,28781,28782,5,95,0,0,28782,28783,7,19,0,0,28783,28784,7,2,0,0,
+        28784,28785,7,12,0,0,28785,28786,7,3,0,0,28786,4234,1,0,0,0,28787,
+        28788,7,4,0,0,28788,28789,7,10,0,0,28789,28790,7,14,0,0,28790,28791,
+        7,6,0,0,28791,28792,7,23,0,0,28792,28793,7,2,0,0,28793,28794,7,7,
+        0,0,28794,28795,7,6,0,0,28795,28796,5,95,0,0,28796,28797,7,14,0,
+        0,28797,28798,7,10,0,0,28798,28799,7,7,0,0,28799,28800,7,12,0,0,
+        28800,28801,7,4,0,0,28801,28802,7,6,0,0,28802,4236,1,0,0,0,28803,
+        28804,7,4,0,0,28804,28805,7,10,0,0,28805,28806,7,14,0,0,28806,28807,
+        7,6,0,0,28807,28808,7,23,0,0,28808,28809,7,2,0,0,28809,28810,7,7,
+        0,0,28810,28811,7,6,0,0,28811,28812,5,95,0,0,28812,28813,7,2,0,0,
+        28813,28814,7,16,0,0,28814,28815,7,16,0,0,28815,28816,7,5,0,0,28816,
+        28817,7,6,0,0,28817,28818,7,4,0,0,28818,4238,1,0,0,0,28819,28820,
+        7,4,0,0,28820,28821,7,10,0,0,28821,28822,7,14,0,0,28822,28823,7,
+        6,0,0,28823,28824,7,23,0,0,28824,28825,7,2,0,0,28825,28826,7,7,0,
+        0,28826,28827,7,6,0,0,28827,28828,5,95,0,0,28828,28829,7,3,0,0,28829,
+        28830,7,6,0,0,28830,28831,7,17,0,0,28831,28832,7,10,0,0,28832,28833,
+        7,2,0,0,28833,28834,7,7,0,0,28834,4240,1,0,0,0,28835,28836,7,4,0,
+        0,28836,28837,7,10,0,0,28837,28838,7,14,0,0,28838,28839,7,6,0,0,
+        28839,28840,5,95,0,0,28840,28841,7,23,0,0,28841,28842,7,2,0,0,28842,
+        28843,7,7,0,0,28843,28844,7,6,0,0,28844,4242,1,0,0,0,28845,28846,
+        7,4,0,0,28846,28847,7,10,0,0,28847,28848,7,14,0,0,28848,28849,7,
+        10,0,0,28849,28850,7,7,0,0,28850,28851,7,17,0,0,28851,4244,1,0,0,
+        0,28852,28853,7,4,0,0,28853,28854,7,10,0,0,28854,28855,7,7,0,0,28855,
+        28856,7,18,0,0,28856,28857,7,10,0,0,28857,28858,7,7,0,0,28858,28859,
+        7,4,0,0,28859,4246,1,0,0,0,28860,28861,7,4,0,0,28861,28862,7,10,
+        0,0,28862,28863,7,13,0,0,28863,28864,5,95,0,0,28864,28865,7,17,0,
+        0,28865,28866,7,1,0,0,28866,4248,1,0,0,0,28867,28868,7,4,0,0,28868,
+        28869,7,10,0,0,28869,28870,7,13,0,0,28870,28871,5,95,0,0,28871,28872,
+        7,5,0,0,28872,28873,7,5,0,0,28873,28874,7,16,0,0,28874,4250,1,0,
+        0,0,28875,28876,7,4,0,0,28876,28877,7,2,0,0,28877,28878,5,95,0,0,
+        28878,28879,7,0,0,0,28879,28880,7,8,0,0,28880,28881,7,11,0,0,28881,
+        28882,7,10,0,0,28882,28883,7,9,0,0,28883,4252,1,0,0,0,28884,28885,
+        7,4,0,0,28885,28886,7,2,0,0,28886,28887,5,95,0,0,28887,28888,7,1,
+        0,0,28888,28889,7,10,0,0,28889,28890,7,7,0,0,28890,28891,7,0,0,0,
+        28891,28892,7,3,0,0,28892,28893,7,18,0,0,28893,28894,5,95,0,0,28894,
+        28895,7,9,0,0,28895,28896,7,2,0,0,28896,28897,7,12,0,0,28897,28898,
+        7,1,0,0,28898,28899,7,11,0,0,28899,28900,7,6,0,0,28900,4254,1,0,
+        0,0,28901,28902,7,4,0,0,28902,28903,7,2,0,0,28903,28904,5,95,0,0,
+        28904,28905,7,1,0,0,28905,28906,7,10,0,0,28906,28907,7,7,0,0,28907,
+        28908,7,0,0,0,28908,28909,7,3,0,0,28909,28910,7,18,0,0,28910,28911,
+        5,95,0,0,28911,28912,7,16,0,0,28912,28913,7,11,0,0,28913,28914,7,
+        2,0,0,28914,28915,7,0,0,0,28915,28916,7,4,0,0,28916,4256,1,0,0,0,
+        28917,28918,7,4,0,0,28918,28919,7,2,0,0,28919,28920,5,95,0,0,28920,
+        28921,7,1,0,0,28921,28922,7,11,0,0,28922,28923,7,2,0,0,28923,28924,
+        7,1,0,0,28924,4258,1,0,0,0,28925,28926,7,4,0,0,28926,28927,7,2,0,
+        0,28927,28928,5,95,0,0,28928,28929,7,8,0,0,28929,28930,7,11,0,0,
+        28930,28931,7,2,0,0,28931,28932,7,1,0,0,28932,4260,1,0,0,0,28933,
+        28934,7,4,0,0,28934,28935,7,2,0,0,28935,28936,5,95,0,0,28936,28937,
+        7,9,0,0,28937,28938,7,5,0,0,28938,28939,7,10,0,0,28939,28940,7,7,
+        0,0,28940,28941,7,4,0,0,28941,28942,7,6,0,0,28942,28943,7,3,0,0,
+        28943,28944,7,13,0,0,28944,28945,7,0,0,0,28945,28946,7,11,0,0,28946,
+        4262,1,0,0,0,28947,28948,7,4,0,0,28948,28949,7,2,0,0,28949,28950,
+        5,95,0,0,28950,28951,7,11,0,0,28951,28952,7,2,0,0,28952,28953,7,
+        1,0,0,28953,4264,1,0,0,0,28954,28955,7,4,0,0,28955,28956,7,2,0,0,
+        28956,28957,5,95,0,0,28957,28958,7,14,0,0,28958,28959,7,12,0,0,28959,
+        28960,7,11,0,0,28960,28961,7,4,0,0,28961,28962,7,10,0,0,28962,28963,
+        5,95,0,0,28963,28964,7,1,0,0,28964,28965,7,18,0,0,28965,28966,7,
+        4,0,0,28966,28967,7,6,0,0,28967,4266,1,0,0,0,28968,28969,7,4,0,0,
+        28969,28970,7,2,0,0,28970,28971,5,95,0,0,28971,28972,7,7,0,0,28972,
+        28973,7,8,0,0,28973,28974,7,19,0,0,28974,28975,7,0,0,0,28975,28976,
+        7,3,0,0,28976,4268,1,0,0,0,28977,28978,7,4,0,0,28978,28979,7,2,0,
+        0,28979,28980,5,95,0,0,28980,28981,7,7,0,0,28981,28982,7,8,0,0,28982,
+        28983,7,11,0,0,28983,28984,7,2,0,0,28984,28985,7,1,0,0,28985,4270,
+        1,0,0,0,28986,28987,7,4,0,0,28987,28988,7,2,0,0,28988,28989,5,95,
+        0,0,28989,28990,7,7,0,0,28990,28991,7,12,0,0,28991,28992,7,14,0,
+        0,28992,28993,7,1,0,0,28993,28994,7,6,0,0,28994,28995,7,3,0,0,28995,
+        4272,1,0,0,0,28996,28997,7,4,0,0,28997,28998,7,2,0,0,28998,28999,
+        7,15,0,0,28999,29000,7,11,0,0,29000,29001,7,6,0,0,29001,29002,7,
+        13,0,0,29002,29003,7,6,0,0,29003,29004,7,11,0,0,29004,4274,1,0,0,
+        0,29005,29006,7,4,0,0,29006,29007,7,2,0,0,29007,29008,5,95,0,0,29008,
+        29009,7,5,0,0,29009,29010,7,10,0,0,29010,29011,7,7,0,0,29011,29012,
+        7,17,0,0,29012,29013,7,11,0,0,29013,29014,7,6,0,0,29014,29015,5,
+        95,0,0,29015,29016,7,1,0,0,29016,29017,7,18,0,0,29017,29018,7,4,
+        0,0,29018,29019,7,6,0,0,29019,4276,1,0,0,0,29020,29021,7,4,0,0,29021,
+        29022,7,2,0,0,29022,29023,5,95,0,0,29023,29024,7,4,0,0,29024,29025,
+        7,10,0,0,29025,29026,7,14,0,0,29026,29027,7,6,0,0,29027,29028,7,
+        5,0,0,29028,29029,7,4,0,0,29029,29030,7,0,0,0,29030,29031,7,14,0,
+        0,29031,29032,7,15,0,0,29032,4278,1,0,0,0,29033,29034,7,4,0,0,29034,
+        29035,7,2,0,0,29035,29036,5,95,0,0,29036,29037,7,4,0,0,29037,29038,
+        7,10,0,0,29038,29039,7,14,0,0,29039,29040,7,6,0,0,29040,29041,7,
+        5,0,0,29041,29042,7,4,0,0,29042,29043,7,0,0,0,29043,29044,7,14,0,
+        0,29044,29045,7,15,0,0,29045,29046,5,95,0,0,29046,29047,7,4,0,0,
+        29047,29048,7,23,0,0,29048,4280,1,0,0,0,29049,29050,7,4,0,0,29050,
+        29051,7,2,0,0,29051,29052,5,95,0,0,29052,29053,7,4,0,0,29053,29054,
+        7,10,0,0,29054,29055,7,14,0,0,29055,29056,7,6,0,0,29056,4282,1,0,
+        0,0,29057,29058,7,4,0,0,29058,29059,7,2,0,0,29059,29060,5,95,0,0,
+        29060,29061,7,4,0,0,29061,29062,7,10,0,0,29062,29063,7,14,0,0,29063,
+        29064,7,6,0,0,29064,29065,5,95,0,0,29065,29066,7,4,0,0,29066,29067,
+        7,23,0,0,29067,4284,1,0,0,0,29068,29069,7,4,0,0,29069,29070,7,2,
+        0,0,29070,4286,1,0,0,0,29071,29072,7,4,0,0,29072,29073,7,2,0,0,29073,
+        29074,5,95,0,0,29074,29075,7,18,0,0,29075,29076,7,14,0,0,29076,29077,
+        7,10,0,0,29077,29078,7,7,0,0,29078,29079,7,4,0,0,29079,29080,7,6,
+        0,0,29080,29081,7,3,0,0,29081,29082,7,13,0,0,29082,29083,7,0,0,0,
+        29083,29084,7,11,0,0,29084,4288,1,0,0,0,29085,29086,7,4,0,0,29086,
+        29087,7,3,0,0,29087,29088,7,0,0,0,29088,29089,7,8,0,0,29089,29090,
+        7,6,0,0,29090,4290,1,0,0,0,29091,29092,7,4,0,0,29092,29093,7,3,0,
+        0,29093,29094,7,0,0,0,29094,29095,7,8,0,0,29095,29096,7,10,0,0,29096,
+        29097,7,7,0,0,29097,29098,7,17,0,0,29098,4292,1,0,0,0,29099,29100,
+        7,4,0,0,29100,29101,7,3,0,0,29101,29102,7,0,0,0,29102,29103,7,8,
+        0,0,29103,29104,7,21,0,0,29104,29105,7,10,0,0,29105,29106,7,7,0,
+        0,29106,29107,7,17,0,0,29107,4294,1,0,0,0,29108,29109,7,4,0,0,29109,
+        29110,7,3,0,0,29110,29111,7,0,0,0,29111,29112,7,10,0,0,29112,29113,
+        7,11,0,0,29113,29114,7,10,0,0,29114,29115,7,7,0,0,29115,29116,7,
+        17,0,0,29116,4296,1,0,0,0,29117,29118,7,4,0,0,29118,29119,7,3,0,
+        0,29119,29120,7,0,0,0,29120,29121,7,7,0,0,29121,29122,7,5,0,0,29122,
+        29123,7,0,0,0,29123,29124,7,8,0,0,29124,29125,7,4,0,0,29125,29126,
+        7,10,0,0,29126,29127,7,2,0,0,29127,29128,7,7,0,0,29128,4298,1,0,
+        0,0,29129,29130,7,4,0,0,29130,29131,7,3,0,0,29131,29132,7,0,0,0,
+        29132,29133,7,7,0,0,29133,29134,7,5,0,0,29134,29135,7,16,0,0,29135,
+        29136,7,2,0,0,29136,29137,7,3,0,0,29137,29138,7,14,0,0,29138,4300,
+        1,0,0,0,29139,29140,7,4,0,0,29140,29141,7,3,0,0,29141,29142,7,0,
+        0,0,29142,29143,7,7,0,0,29143,29144,7,5,0,0,29144,29145,7,16,0,0,
+        29145,29146,7,2,0,0,29146,29147,7,3,0,0,29147,29148,7,14,0,0,29148,
+        29149,7,5,0,0,29149,4302,1,0,0,0,29150,29151,7,4,0,0,29151,29152,
+        7,3,0,0,29152,29153,7,0,0,0,29153,29154,7,7,0,0,29154,29155,7,5,
+        0,0,29155,29156,7,16,0,0,29156,29157,7,2,0,0,29157,29158,7,3,0,0,
+        29158,29159,7,14,0,0,29159,29160,5,95,0,0,29160,29161,7,9,0,0,29161,
+        29162,7,10,0,0,29162,29163,7,5,0,0,29163,29164,7,4,0,0,29164,29165,
+        7,10,0,0,29165,29166,7,7,0,0,29166,29167,7,8,0,0,29167,29168,7,4,
+        0,0,29168,29169,5,95,0,0,29169,29170,7,0,0,0,29170,29171,7,17,0,
+        0,29171,29172,7,17,0,0,29172,4304,1,0,0,0,29173,29174,7,4,0,0,29174,
+        29175,7,3,0,0,29175,29176,7,0,0,0,29176,29177,7,7,0,0,29177,29178,
+        7,5,0,0,29178,29179,7,10,0,0,29179,29180,7,4,0,0,29180,29181,7,10,
+        0,0,29181,29182,7,2,0,0,29182,29183,7,7,0,0,29183,29184,7,0,0,0,
+        29184,29185,7,11,0,0,29185,4306,1,0,0,0,29186,29187,7,4,0,0,29187,
+        29188,7,3,0,0,29188,29189,7,0,0,0,29189,29190,7,7,0,0,29190,29191,
+        7,5,0,0,29191,29192,7,10,0,0,29192,29193,7,4,0,0,29193,29194,7,10,
+        0,0,29194,29195,7,2,0,0,29195,29196,7,7,0,0,29196,4308,1,0,0,0,29197,
+        29198,7,4,0,0,29198,29199,7,3,0,0,29199,29200,7,0,0,0,29200,29201,
+        7,7,0,0,29201,29202,7,5,0,0,29202,29203,7,11,0,0,29203,29204,7,0,
+        0,0,29204,29205,7,4,0,0,29205,29206,7,6,0,0,29206,4310,1,0,0,0,29207,
+        29208,7,4,0,0,29208,29209,7,3,0,0,29209,29210,7,0,0,0,29210,29211,
+        7,7,0,0,29211,29212,7,5,0,0,29212,29213,7,11,0,0,29213,29214,7,0,
+        0,0,29214,29215,7,4,0,0,29215,29216,7,10,0,0,29216,29217,7,2,0,0,
+        29217,29218,7,7,0,0,29218,4312,1,0,0,0,29219,29220,7,4,0,0,29220,
+        29221,7,3,0,0,29221,29222,7,6,0,0,29222,29223,7,0,0,0,29223,29224,
+        7,4,0,0,29224,4314,1,0,0,0,29225,29226,7,4,0,0,29226,29227,7,3,0,
+        0,29227,29228,7,10,0,0,29228,29229,7,17,0,0,29229,29230,7,17,0,0,
+        29230,29231,7,6,0,0,29231,29232,7,3,0,0,29232,29233,7,5,0,0,29233,
+        4316,1,0,0,0,29234,29235,7,4,0,0,29235,29236,7,3,0,0,29236,29237,
+        7,10,0,0,29237,29238,7,17,0,0,29238,29239,7,17,0,0,29239,29240,7,
+        6,0,0,29240,29241,7,3,0,0,29241,4318,1,0,0,0,29242,29243,7,4,0,0,
+        29243,29244,7,3,0,0,29244,29245,7,12,0,0,29245,29246,7,6,0,0,29246,
+        4320,1,0,0,0,29247,29248,7,4,0,0,29248,29249,7,3,0,0,29249,29250,
+        7,12,0,0,29250,29251,7,7,0,0,29251,29252,7,8,0,0,29252,29253,7,0,
+        0,0,29253,29254,7,4,0,0,29254,29255,7,6,0,0,29255,4322,1,0,0,0,29256,
+        29257,7,4,0,0,29257,29258,7,3,0,0,29258,29259,7,12,0,0,29259,29260,
+        7,7,0,0,29260,29261,7,8,0,0,29261,4324,1,0,0,0,29262,29263,7,4,0,
+        0,29263,29264,7,3,0,0,29264,29265,7,12,0,0,29265,29266,7,5,0,0,29266,
+        29267,7,4,0,0,29267,29268,7,6,0,0,29268,29269,7,9,0,0,29269,4326,
+        1,0,0,0,29270,29271,7,4,0,0,29271,29272,7,3,0,0,29272,29273,7,12,
+        0,0,29273,29274,7,5,0,0,29274,29275,7,4,0,0,29275,4328,1,0,0,0,29276,
+        29277,7,4,0,0,29277,29278,7,12,0,0,29278,29279,7,7,0,0,29279,29280,
+        7,10,0,0,29280,29281,7,7,0,0,29281,29282,7,17,0,0,29282,4330,1,0,
+        0,0,29283,29284,7,4,0,0,29284,29285,7,25,0,0,29285,4332,1,0,0,0,
+        29286,29287,7,4,0,0,29287,29288,7,18,0,0,29288,29289,7,15,0,0,29289,
+        29290,7,6,0,0,29290,29291,7,5,0,0,29291,4334,1,0,0,0,29292,29293,
+        7,4,0,0,29293,29294,7,18,0,0,29294,29295,7,15,0,0,29295,29296,7,
+        6,0,0,29296,4336,1,0,0,0,29297,29298,7,4,0,0,29298,29299,7,23,0,
+        0,29299,29300,5,95,0,0,29300,29301,7,2,0,0,29301,29302,7,16,0,0,
+        29302,29303,7,16,0,0,29303,29304,7,5,0,0,29304,29305,7,6,0,0,29305,
+        29306,7,4,0,0,29306,4338,1,0,0,0,29307,29308,7,12,0,0,29308,29309,
+        7,1,0,0,29309,29310,5,50,0,0,29310,4340,1,0,0,0,29311,29312,7,12,
+        0,0,29312,29313,7,1,0,0,29313,29314,7,0,0,0,29314,4342,1,0,0,0,29315,
+        29316,7,12,0,0,29316,29317,7,8,0,0,29317,29318,7,5,0,0,29318,29319,
+        5,50,0,0,29319,4344,1,0,0,0,29320,29321,7,12,0,0,29321,29322,7,9,
+        0,0,29322,29323,7,16,0,0,29323,4346,1,0,0,0,29324,29325,7,12,0,0,
+        29325,29326,7,10,0,0,29326,29327,7,9,0,0,29327,4348,1,0,0,0,29328,
+        29329,7,12,0,0,29329,29330,7,7,0,0,29330,29331,7,0,0,0,29331,29332,
+        7,3,0,0,29332,29333,7,8,0,0,29333,29334,7,19,0,0,29334,29335,7,10,
+        0,0,29335,29336,7,13,0,0,29336,29337,7,6,0,0,29337,29338,7,9,0,0,
+        29338,4350,1,0,0,0,29339,29340,7,12,0,0,29340,29341,7,7,0,0,29341,
+        29342,7,1,0,0,29342,29343,7,2,0,0,29343,29344,7,12,0,0,29344,29345,
+        7,7,0,0,29345,29346,7,9,0,0,29346,29347,7,6,0,0,29347,29348,7,9,
+        0,0,29348,4352,1,0,0,0,29349,29350,7,12,0,0,29350,29351,7,7,0,0,
+        29351,29352,7,1,0,0,29352,29353,7,2,0,0,29353,29354,7,12,0,0,29354,
+        29355,7,7,0,0,29355,29356,7,9,0,0,29356,4354,1,0,0,0,29357,29358,
+        7,12,0,0,29358,29359,7,7,0,0,29359,29360,7,8,0,0,29360,29361,7,2,
+        0,0,29361,29362,7,7,0,0,29362,29363,7,9,0,0,29363,29364,7,10,0,0,
+        29364,29365,7,4,0,0,29365,29366,7,10,0,0,29366,29367,7,2,0,0,29367,
+        29368,7,7,0,0,29368,29369,7,0,0,0,29369,29370,7,11,0,0,29370,4356,
+        1,0,0,0,29371,29372,7,12,0,0,29372,29373,7,7,0,0,29373,29374,7,9,
+        0,0,29374,29375,7,6,0,0,29375,29376,7,3,0,0,29376,4358,1,0,0,0,29377,
+        29378,7,12,0,0,29378,29379,7,7,0,0,29379,29380,7,9,0,0,29380,29381,
+        7,2,0,0,29381,4360,1,0,0,0,29382,29383,7,12,0,0,29383,29384,7,7,
+        0,0,29384,29385,7,9,0,0,29385,29386,7,3,0,0,29386,29387,7,2,0,0,
+        29387,29388,7,15,0,0,29388,4362,1,0,0,0,29389,29390,7,12,0,0,29390,
+        29391,7,7,0,0,29391,29392,7,10,0,0,29392,29393,7,16,0,0,29393,29394,
+        7,2,0,0,29394,29395,7,3,0,0,29395,29396,7,14,0,0,29396,4364,1,0,
+        0,0,29397,29398,7,12,0,0,29398,29399,7,7,0,0,29399,29400,7,10,0,
+        0,29400,29401,7,2,0,0,29401,29402,7,7,0,0,29402,4366,1,0,0,0,29403,
+        29404,7,12,0,0,29404,29405,7,7,0,0,29405,29406,7,10,0,0,29406,29407,
+        7,2,0,0,29407,29408,7,7,0,0,29408,29409,7,4,0,0,29409,29410,7,18,
+        0,0,29410,29411,7,15,0,0,29411,29412,7,6,0,0,29412,4368,1,0,0,0,
+        29413,29414,7,12,0,0,29414,29415,7,7,0,0,29415,29416,7,10,0,0,29416,
+        29417,7,24,0,0,29417,29418,7,12,0,0,29418,29419,7,6,0,0,29419,4370,
+        1,0,0,0,29420,29421,7,12,0,0,29421,29422,7,7,0,0,29422,29423,7,10,
+        0,0,29423,29424,7,5,0,0,29424,29425,7,4,0,0,29425,29426,7,3,0,0,
+        29426,4372,1,0,0,0,29427,29428,7,12,0,0,29428,29429,7,7,0,0,29429,
+        29430,7,11,0,0,29430,29431,7,10,0,0,29431,29432,7,14,0,0,29432,29433,
+        7,10,0,0,29433,29434,7,4,0,0,29434,29435,7,6,0,0,29435,29436,7,9,
+        0,0,29436,4374,1,0,0,0,29437,29438,7,12,0,0,29438,29439,7,7,0,0,
+        29439,29440,7,11,0,0,29440,29441,7,2,0,0,29441,29442,7,0,0,0,29442,
+        29443,7,9,0,0,29443,4376,1,0,0,0,29444,29445,7,12,0,0,29445,29446,
+        7,7,0,0,29446,29447,7,11,0,0,29447,29448,7,2,0,0,29448,29449,7,8,
+        0,0,29449,29450,7,21,0,0,29450,4378,1,0,0,0,29451,29452,7,12,0,0,
+        29452,29453,7,7,0,0,29453,29454,7,14,0,0,29454,29455,7,0,0,0,29455,
+        29456,7,4,0,0,29456,29457,7,8,0,0,29457,29458,7,19,0,0,29458,29459,
+        7,6,0,0,29459,29460,7,9,0,0,29460,4380,1,0,0,0,29461,29462,7,12,
+        0,0,29462,29463,7,7,0,0,29463,29464,7,7,0,0,29464,29465,7,6,0,0,
+        29465,29466,7,5,0,0,29466,29467,7,4,0,0,29467,29468,5,95,0,0,29468,
+        29469,7,10,0,0,29469,29470,7,7,0,0,29470,29471,7,7,0,0,29471,29472,
+        7,6,0,0,29472,29473,7,3,0,0,29473,29474,7,20,0,0,29474,29475,5,95,
+        0,0,29475,29476,7,9,0,0,29476,29477,7,10,0,0,29477,29478,7,5,0,0,
+        29478,29479,7,4,0,0,29479,29480,7,10,0,0,29480,29481,7,7,0,0,29481,
+        29482,7,8,0,0,29482,29483,7,4,0,0,29483,29484,5,95,0,0,29484,29485,
+        7,13,0,0,29485,29486,7,10,0,0,29486,29487,7,6,0,0,29487,29488,7,
+        22,0,0,29488,4382,1,0,0,0,29489,29490,7,12,0,0,29490,29491,7,7,0,
+        0,29491,29492,7,7,0,0,29492,29493,7,6,0,0,29493,29494,7,5,0,0,29494,
+        29495,7,4,0,0,29495,29496,5,95,0,0,29496,29497,7,7,0,0,29497,29498,
+        7,2,0,0,29498,29499,7,5,0,0,29499,29500,7,6,0,0,29500,29501,7,14,
+        0,0,29501,29502,7,10,0,0,29502,29503,7,20,0,0,29503,29504,5,95,0,
+        0,29504,29505,7,7,0,0,29505,29506,7,2,0,0,29506,29507,7,9,0,0,29507,
+        29508,7,10,0,0,29508,29509,7,5,0,0,29509,29510,7,4,0,0,29510,29511,
+        7,10,0,0,29511,29512,7,7,0,0,29512,29513,7,8,0,0,29513,29514,7,4,
+        0,0,29514,29515,7,13,0,0,29515,29516,7,10,0,0,29516,29517,7,6,0,
+        0,29517,29518,7,22,0,0,29518,4384,1,0,0,0,29519,29520,7,12,0,0,29520,
+        29521,7,7,0,0,29521,29522,7,7,0,0,29522,29523,7,6,0,0,29523,29524,
+        7,5,0,0,29524,29525,7,4,0,0,29525,29526,5,95,0,0,29526,29527,7,5,
+        0,0,29527,29528,7,6,0,0,29528,29529,7,14,0,0,29529,29530,7,10,0,
+        0,29530,29531,7,20,0,0,29531,29532,5,95,0,0,29532,29533,7,13,0,0,
+        29533,29534,7,10,0,0,29534,29535,7,6,0,0,29535,29536,7,22,0,0,29536,
+        4386,1,0,0,0,29537,29538,7,12,0,0,29538,29539,7,7,0,0,29539,29540,
+        7,7,0,0,29540,29541,7,6,0,0,29541,29542,7,5,0,0,29542,29543,7,4,
+        0,0,29543,4388,1,0,0,0,29544,29545,7,12,0,0,29545,29546,7,7,0,0,
+        29546,29547,7,15,0,0,29547,29548,7,0,0,0,29548,29549,7,8,0,0,29549,
+        29550,7,21,0,0,29550,29551,7,6,0,0,29551,29552,7,9,0,0,29552,4390,
+        1,0,0,0,29553,29554,7,12,0,0,29554,29555,7,7,0,0,29555,29556,7,15,
+        0,0,29556,29557,7,10,0,0,29557,29558,7,13,0,0,29558,29559,7,2,0,
+        0,29559,29560,7,4,0,0,29560,4392,1,0,0,0,29561,29562,7,12,0,0,29562,
+        29563,7,7,0,0,29563,29564,7,15,0,0,29564,29565,7,11,0,0,29565,29566,
+        7,12,0,0,29566,29567,7,17,0,0,29567,4394,1,0,0,0,29568,29569,7,12,
+        0,0,29569,29570,7,7,0,0,29570,29571,7,15,0,0,29571,29572,7,3,0,0,
+        29572,29573,7,2,0,0,29573,29574,7,4,0,0,29574,29575,7,6,0,0,29575,
+        29576,7,8,0,0,29576,29577,7,4,0,0,29577,29578,7,6,0,0,29578,29579,
+        7,9,0,0,29579,4396,1,0,0,0,29580,29581,7,12,0,0,29581,29582,7,7,
+        0,0,29582,29583,7,24,0,0,29583,29584,7,12,0,0,29584,29585,7,10,0,
+        0,29585,29586,7,6,0,0,29586,29587,7,5,0,0,29587,29588,7,8,0,0,29588,
+        29589,7,6,0,0,29589,4398,1,0,0,0,29590,29591,7,12,0,0,29591,29592,
+        7,7,0,0,29592,29593,7,3,0,0,29593,29594,7,6,0,0,29594,29595,7,8,
+        0,0,29595,29596,7,2,0,0,29596,29597,7,13,0,0,29597,29598,7,6,0,0,
+        29598,29599,7,3,0,0,29599,29600,7,0,0,0,29600,29601,7,1,0,0,29601,
+        29602,7,11,0,0,29602,29603,7,6,0,0,29603,4400,1,0,0,0,29604,29605,
+        7,12,0,0,29605,29606,7,7,0,0,29606,29607,7,3,0,0,29607,29608,7,6,
+        0,0,29608,29609,7,5,0,0,29609,29610,7,4,0,0,29610,29611,7,3,0,0,
+        29611,29612,7,10,0,0,29612,29613,7,8,0,0,29613,29614,7,4,0,0,29614,
+        29615,7,6,0,0,29615,29616,7,9,0,0,29616,4402,1,0,0,0,29617,29618,
+        7,12,0,0,29618,29619,7,7,0,0,29619,29620,7,5,0,0,29620,29621,7,10,
+        0,0,29621,29622,7,17,0,0,29622,29623,7,7,0,0,29623,29624,7,6,0,0,
+        29624,29625,7,9,0,0,29625,4404,1,0,0,0,29626,29627,7,12,0,0,29627,
+        29628,7,7,0,0,29628,29629,7,5,0,0,29629,29630,7,12,0,0,29630,29631,
+        7,1,0,0,29631,29632,7,5,0,0,29632,29633,7,8,0,0,29633,29634,7,3,
+        0,0,29634,29635,7,10,0,0,29635,29636,7,1,0,0,29636,29637,7,6,0,0,
+        29637,4406,1,0,0,0,29638,29639,7,12,0,0,29639,29640,7,7,0,0,29640,
+        29641,7,4,0,0,29641,29642,7,10,0,0,29642,29643,7,11,0,0,29643,4408,
+        1,0,0,0,29644,29645,7,12,0,0,29645,29646,7,7,0,0,29646,29647,7,12,
+        0,0,29647,29648,7,5,0,0,29648,29649,7,0,0,0,29649,29650,7,1,0,0,
+        29650,29651,7,11,0,0,29651,29652,7,6,0,0,29652,4410,1,0,0,0,29653,
+        29654,7,12,0,0,29654,29655,7,7,0,0,29655,29656,7,12,0,0,29656,29657,
+        7,5,0,0,29657,29658,7,6,0,0,29658,29659,7,9,0,0,29659,4412,1,0,0,
+        0,29660,29661,7,12,0,0,29661,29662,7,15,0,0,29662,29663,7,9,0,0,
+        29663,29664,7,0,0,0,29664,29665,7,4,0,0,29665,29666,7,0,0,0,29666,
+        29667,7,1,0,0,29667,29668,7,11,0,0,29668,29669,7,6,0,0,29669,4414,
+        1,0,0,0,29670,29671,7,12,0,0,29671,29672,7,15,0,0,29672,29673,7,
+        9,0,0,29673,29674,7,0,0,0,29674,29675,7,4,0,0,29675,29676,7,6,0,
+        0,29676,29677,7,9,0,0,29677,4416,1,0,0,0,29678,29679,7,12,0,0,29679,
+        29680,7,15,0,0,29680,29681,7,9,0,0,29681,29682,7,0,0,0,29682,29683,
+        7,4,0,0,29683,29684,7,6,0,0,29684,4418,1,0,0,0,29685,29686,7,12,
+        0,0,29686,29687,7,15,0,0,29687,29688,7,9,0,0,29688,29689,7,0,0,0,
+        29689,29690,7,4,0,0,29690,29691,7,6,0,0,29691,29692,7,25,0,0,29692,
+        29693,7,14,0,0,29693,29694,7,11,0,0,29694,4420,1,0,0,0,29695,29696,
+        7,12,0,0,29696,29697,7,15,0,0,29697,29698,7,9,0,0,29698,29699,5,
+        95,0,0,29699,29700,7,10,0,0,29700,29701,7,7,0,0,29701,29702,7,9,
+        0,0,29702,29703,7,6,0,0,29703,29704,7,25,0,0,29704,29705,7,6,0,0,
+        29705,29706,7,5,0,0,29706,4422,1,0,0,0,29707,29708,7,12,0,0,29708,
+        29709,7,15,0,0,29709,29710,7,9,0,0,29710,29711,5,95,0,0,29711,29712,
+        7,20,0,0,29712,29713,7,2,0,0,29713,29714,7,10,0,0,29714,29715,7,
+        7,0,0,29715,29716,7,10,0,0,29716,29717,7,7,0,0,29717,29718,7,9,0,
+        0,29718,29719,7,6,0,0,29719,29720,7,25,0,0,29720,4424,1,0,0,0,29721,
+        29722,7,12,0,0,29722,29723,7,15,0,0,29723,29724,7,17,0,0,29724,29725,
+        7,3,0,0,29725,29726,7,0,0,0,29726,29727,7,9,0,0,29727,29728,7,6,
+        0,0,29728,4426,1,0,0,0,29729,29730,7,12,0,0,29730,29731,7,15,0,0,
+        29731,29732,7,15,0,0,29732,29733,7,6,0,0,29733,29734,7,3,0,0,29734,
+        4428,1,0,0,0,29735,29736,7,12,0,0,29736,29737,7,15,0,0,29737,29738,
+        7,5,0,0,29738,29739,7,6,0,0,29739,29740,7,3,0,0,29740,29741,7,4,
+        0,0,29741,4430,1,0,0,0,29742,29743,7,12,0,0,29743,29744,7,3,0,0,
+        29744,29745,7,2,0,0,29745,29746,7,22,0,0,29746,29747,7,10,0,0,29747,
+        29748,7,9,0,0,29748,4432,1,0,0,0,29749,29750,7,12,0,0,29750,29751,
+        7,5,0,0,29751,29752,7,0,0,0,29752,29753,7,1,0,0,29753,29754,7,11,
+        0,0,29754,29755,7,6,0,0,29755,4434,1,0,0,0,29756,29757,7,12,0,0,
+        29757,29758,7,5,0,0,29758,29759,7,0,0,0,29759,29760,7,17,0,0,29760,
+        29761,7,6,0,0,29761,4436,1,0,0,0,29762,29763,7,12,0,0,29763,29764,
+        7,5,0,0,29764,29765,7,6,0,0,29765,29766,5,95,0,0,29766,29767,7,0,
+        0,0,29767,29768,7,7,0,0,29768,29769,7,4,0,0,29769,29770,7,10,0,0,
+        29770,4438,1,0,0,0,29771,29772,7,12,0,0,29772,29773,7,5,0,0,29773,
+        29774,7,6,0,0,29774,29775,5,95,0,0,29775,29776,7,8,0,0,29776,29777,
+        7,2,0,0,29777,29778,7,7,0,0,29778,29779,7,8,0,0,29779,29780,7,0,
+        0,0,29780,29781,7,4,0,0,29781,4440,1,0,0,0,29782,29783,7,12,0,0,
+        29783,29784,7,5,0,0,29784,29785,7,6,0,0,29785,29786,5,95,0,0,29786,
+        29787,7,8,0,0,29787,29788,7,12,0,0,29788,29789,7,1,0,0,29789,29790,
+        7,6,0,0,29790,4442,1,0,0,0,29791,29792,7,12,0,0,29792,29793,7,5,
+        0,0,29793,29794,7,6,0,0,29794,29795,5,95,0,0,29795,29796,7,19,0,
+        0,29796,29797,7,0,0,0,29797,29798,7,5,0,0,29798,29799,7,19,0,0,29799,
+        29800,5,95,0,0,29800,29801,7,0,0,0,29801,29802,7,17,0,0,29802,29803,
+        7,17,0,0,29803,29804,7,3,0,0,29804,29805,7,6,0,0,29805,29806,7,17,
+        0,0,29806,29807,7,0,0,0,29807,29808,7,4,0,0,29808,29809,7,10,0,0,
+        29809,29810,7,2,0,0,29810,29811,7,7,0,0,29811,4444,1,0,0,0,29812,
+        29813,7,12,0,0,29813,29814,7,5,0,0,29814,29815,7,6,0,0,29815,29816,
+        5,95,0,0,29816,29817,7,19,0,0,29817,29818,7,0,0,0,29818,29819,7,
+        5,0,0,29819,29820,7,19,0,0,29820,29821,5,95,0,0,29821,29822,7,17,
+        0,0,29822,29823,7,1,0,0,29823,29824,7,18,0,0,29824,29825,5,95,0,
+        0,29825,29826,7,16,0,0,29826,29827,7,2,0,0,29827,29828,7,3,0,0,29828,
+        29829,5,95,0,0,29829,29830,7,15,0,0,29830,29831,7,12,0,0,29831,29832,
+        7,5,0,0,29832,29833,7,19,0,0,29833,29834,7,9,0,0,29834,29835,7,2,
+        0,0,29835,29836,7,22,0,0,29836,29837,7,7,0,0,29837,4446,1,0,0,0,
+        29838,29839,7,12,0,0,29839,29840,7,5,0,0,29840,29841,7,6,0,0,29841,
+        29842,5,95,0,0,29842,29843,7,19,0,0,29843,29844,7,0,0,0,29844,29845,
+        7,5,0,0,29845,29846,7,19,0,0,29846,4448,1,0,0,0,29847,29848,7,12,
+        0,0,29848,29849,7,5,0,0,29849,29850,7,6,0,0,29850,29851,5,95,0,0,
+        29851,29852,7,19,0,0,29852,29853,7,10,0,0,29853,29854,7,9,0,0,29854,
+        29855,7,9,0,0,29855,29856,7,6,0,0,29856,29857,7,7,0,0,29857,29858,
+        5,95,0,0,29858,29859,7,15,0,0,29859,29860,7,0,0,0,29860,29861,7,
+        3,0,0,29861,29862,7,4,0,0,29862,29863,7,10,0,0,29863,29864,7,4,0,
+        0,29864,29865,7,10,0,0,29865,29866,7,2,0,0,29866,29867,7,7,0,0,29867,
+        29868,7,5,0,0,29868,4450,1,0,0,0,29869,29870,7,12,0,0,29870,29871,
+        7,5,0,0,29871,29872,7,6,0,0,29872,29873,5,95,0,0,29873,29874,7,10,
+        0,0,29874,29875,7,7,0,0,29875,29876,7,13,0,0,29876,29877,7,10,0,
+        0,29877,29878,7,5,0,0,29878,29879,7,10,0,0,29879,29880,7,1,0,0,29880,
+        29881,7,11,0,0,29881,29882,7,6,0,0,29882,29883,5,95,0,0,29883,29884,
+        7,10,0,0,29884,29885,7,7,0,0,29885,29886,7,9,0,0,29886,29887,7,6,
+        0,0,29887,29888,7,25,0,0,29888,29889,7,6,0,0,29889,29890,7,5,0,0,
+        29890,4452,1,0,0,0,29891,29892,7,12,0,0,29892,29893,7,5,0,0,29893,
+        29894,7,6,0,0,29894,29895,5,95,0,0,29895,29896,7,14,0,0,29896,29897,
+        7,6,0,0,29897,29898,7,3,0,0,29898,29899,7,17,0,0,29899,29900,7,6,
+        0,0,29900,29901,5,95,0,0,29901,29902,7,8,0,0,29902,29903,7,0,0,0,
+        29903,29904,7,3,0,0,29904,29905,7,4,0,0,29905,29906,7,6,0,0,29906,
+        29907,7,5,0,0,29907,29908,7,10,0,0,29908,29909,7,0,0,0,29909,29910,
+        7,7,0,0,29910,4454,1,0,0,0,29911,29912,7,12,0,0,29912,29913,7,5,
+        0,0,29913,29914,7,6,0,0,29914,29915,5,95,0,0,29915,29916,7,14,0,
+        0,29916,29917,7,6,0,0,29917,29918,7,3,0,0,29918,29919,7,17,0,0,29919,
+        29920,7,6,0,0,29920,4456,1,0,0,0,29921,29922,7,12,0,0,29922,29923,
+        7,5,0,0,29923,29924,7,6,0,0,29924,29925,5,95,0,0,29925,29926,7,7,
+        0,0,29926,29927,7,11,0,0,29927,4458,1,0,0,0,29928,29929,7,12,0,0,
+        29929,29930,7,5,0,0,29930,29931,7,6,0,0,29931,29932,5,95,0,0,29932,
+        29933,7,7,0,0,29933,29934,7,11,0,0,29934,29935,5,95,0,0,29935,29936,
+        7,22,0,0,29936,29937,7,10,0,0,29937,29938,7,4,0,0,29938,29939,7,
+        19,0,0,29939,29940,5,95,0,0,29940,29941,7,10,0,0,29941,29942,7,7,
+        0,0,29942,29943,7,9,0,0,29943,29944,7,6,0,0,29944,29945,7,25,0,0,
+        29945,4460,1,0,0,0,29946,29947,7,12,0,0,29947,29948,7,5,0,0,29948,
+        29949,7,6,0,0,29949,29950,5,95,0,0,29950,29951,7,15,0,0,29951,29952,
+        7,3,0,0,29952,29953,7,10,0,0,29953,29954,7,13,0,0,29954,29955,7,
+        0,0,0,29955,29956,7,4,0,0,29956,29957,7,6,0,0,29957,29958,5,95,0,
+        0,29958,29959,7,2,0,0,29959,29960,7,12,0,0,29960,29961,7,4,0,0,29961,
+        29962,7,11,0,0,29962,29963,7,10,0,0,29963,29964,7,7,0,0,29964,29965,
+        7,6,0,0,29965,29966,7,5,0,0,29966,4462,1,0,0,0,29967,29968,7,12,
+        0,0,29968,29969,7,5,0,0,29969,29970,7,6,0,0,29970,29971,7,3,0,0,
+        29971,29972,5,95,0,0,29972,29973,7,9,0,0,29973,29974,7,0,0,0,29974,
+        29975,7,4,0,0,29975,29976,7,0,0,0,29976,4464,1,0,0,0,29977,29978,
+        7,12,0,0,29978,29979,7,5,0,0,29979,29980,7,6,0,0,29980,29981,7,3,
+        0,0,29981,29982,5,95,0,0,29982,29983,7,9,0,0,29983,29984,7,6,0,0,
+        29984,29985,7,16,0,0,29985,29986,7,10,0,0,29986,29987,7,7,0,0,29987,
+        29988,7,6,0,0,29988,29989,7,9,0,0,29989,4466,1,0,0,0,29990,29991,
+        7,12,0,0,29991,29992,7,5,0,0,29992,29993,7,6,0,0,29993,29994,7,3,
+        0,0,29994,29995,7,6,0,0,29995,29996,7,7,0,0,29996,29997,7,13,0,0,
+        29997,4468,1,0,0,0,29998,29999,7,12,0,0,29999,30000,7,5,0,0,30000,
+        30001,7,6,0,0,30001,30002,7,3,0,0,30002,30003,7,17,0,0,30003,30004,
+        7,3,0,0,30004,30005,7,2,0,0,30005,30006,7,12,0,0,30006,30007,7,15,
+        0,0,30007,4470,1,0,0,0,30008,30009,7,12,0,0,30009,30010,7,5,0,0,
+        30010,30011,7,6,0,0,30011,30012,7,3,0,0,30012,30013,5,95,0,0,30013,
+        30014,7,3,0,0,30014,30015,7,6,0,0,30015,30016,7,8,0,0,30016,30017,
+        7,18,0,0,30017,30018,7,8,0,0,30018,30019,7,11,0,0,30019,30020,7,
+        6,0,0,30020,30021,7,1,0,0,30021,30022,7,10,0,0,30022,30023,7,7,0,
+        0,30023,4472,1,0,0,0,30024,30025,7,12,0,0,30025,30026,7,5,0,0,30026,
+        30027,7,6,0,0,30027,30028,7,3,0,0,30028,30029,7,5,0,0,30029,4474,
+        1,0,0,0,30030,30031,7,12,0,0,30031,30032,7,5,0,0,30032,30033,7,6,
+        0,0,30033,30034,7,3,0,0,30034,30035,5,95,0,0,30035,30036,7,4,0,0,
+        30036,30037,7,0,0,0,30037,30038,7,1,0,0,30038,30039,7,11,0,0,30039,
+        30040,7,6,0,0,30040,30041,7,5,0,0,30041,30042,7,15,0,0,30042,30043,
+        7,0,0,0,30043,30044,7,8,0,0,30044,30045,7,6,0,0,30045,30046,7,5,
+        0,0,30046,4476,1,0,0,0,30047,30048,7,12,0,0,30048,30049,7,5,0,0,
+        30049,30050,7,6,0,0,30050,30051,7,3,0,0,30051,4478,1,0,0,0,30052,
+        30053,7,12,0,0,30053,30054,7,5,0,0,30054,30055,7,6,0,0,30055,30056,
+        5,95,0,0,30056,30057,7,5,0,0,30057,30058,7,6,0,0,30058,30059,7,14,
+        0,0,30059,30060,7,10,0,0,30060,4480,1,0,0,0,30061,30062,7,12,0,0,
+        30062,30063,7,5,0,0,30063,30064,7,6,0,0,30064,30065,5,95,0,0,30065,
+        30066,7,5,0,0,30066,30067,7,4,0,0,30067,30068,7,2,0,0,30068,30069,
+        7,3,0,0,30069,30070,7,6,0,0,30070,30071,7,9,0,0,30071,30072,5,95,
+        0,0,30072,30073,7,2,0,0,30073,30074,7,12,0,0,30074,30075,7,4,0,0,
+        30075,30076,7,11,0,0,30076,30077,7,10,0,0,30077,30078,7,7,0,0,30078,
+        30079,7,6,0,0,30079,30080,7,5,0,0,30080,4482,1,0,0,0,30081,30082,
+        7,12,0,0,30082,30083,7,5,0,0,30083,30084,7,6,0,0,30084,30085,5,95,
+        0,0,30085,30086,7,4,0,0,30086,30087,7,4,0,0,30087,30088,7,4,0,0,
+        30088,30089,5,95,0,0,30089,30090,7,16,0,0,30090,30091,7,2,0,0,30091,
+        30092,7,3,0,0,30092,30093,5,95,0,0,30093,30094,7,17,0,0,30094,30095,
+        7,5,0,0,30095,30096,7,6,0,0,30096,30097,7,4,0,0,30097,30098,7,5,
+        0,0,30098,4484,1,0,0,0,30099,30100,7,12,0,0,30100,30101,7,5,0,0,
+        30101,30102,7,6,0,0,30102,4486,1,0,0,0,30103,30104,7,12,0,0,30104,
+        30105,7,5,0,0,30105,30106,7,6,0,0,30106,30107,5,95,0,0,30107,30108,
+        7,13,0,0,30108,30109,7,6,0,0,30109,30110,7,8,0,0,30110,30111,7,4,
+        0,0,30111,30112,7,2,0,0,30112,30113,7,3,0,0,30113,30114,5,95,0,0,
+        30114,30115,7,0,0,0,30115,30116,7,17,0,0,30116,30117,7,17,0,0,30117,
+        30118,7,3,0,0,30118,30119,7,6,0,0,30119,30120,7,17,0,0,30120,30121,
+        7,0,0,0,30121,30122,7,4,0,0,30122,30123,7,10,0,0,30123,30124,7,2,
+        0,0,30124,30125,7,7,0,0,30125,4488,1,0,0,0,30126,30127,7,12,0,0,
+        30127,30128,7,5,0,0,30128,30129,7,6,0,0,30129,30130,5,95,0,0,30130,
+        30131,7,22,0,0,30131,30132,7,6,0,0,30132,30133,7,0,0,0,30133,30134,
+        7,21,0,0,30134,30135,5,95,0,0,30135,30136,7,7,0,0,30136,30137,7,
+        0,0,0,30137,30138,7,14,0,0,30138,30139,7,6,0,0,30139,30140,5,95,
+        0,0,30140,30141,7,3,0,0,30141,30142,7,6,0,0,30142,30143,7,5,0,0,
+        30143,30144,7,11,0,0,30144,4490,1,0,0,0,30145,30146,7,12,0,0,30146,
+        30147,7,5,0,0,30147,30148,7,10,0,0,30148,30149,7,7,0,0,30149,30150,
+        7,17,0,0,30150,30151,5,95,0,0,30151,30152,7,7,0,0,30152,30153,7,
+        2,0,0,30153,30154,5,95,0,0,30154,30155,7,6,0,0,30155,30156,7,25,
+        0,0,30156,30157,7,15,0,0,30157,30158,7,0,0,0,30158,30159,7,7,0,0,
+        30159,30160,7,9,0,0,30160,4492,1,0,0,0,30161,30162,7,12,0,0,30162,
+        30163,7,5,0,0,30163,30164,7,10,0,0,30164,30165,7,7,0,0,30165,30166,
+        7,17,0,0,30166,30167,5,95,0,0,30167,30168,7,7,0,0,30168,30169,7,
+        11,0,0,30169,30170,7,5,0,0,30170,30171,5,95,0,0,30171,30172,7,8,
+        0,0,30172,30173,7,2,0,0,30173,30174,7,14,0,0,30174,30175,7,15,0,
+        0,30175,4494,1,0,0,0,30176,30177,7,12,0,0,30177,30178,7,5,0,0,30178,
+        30179,7,10,0,0,30179,30180,7,7,0,0,30180,30181,7,17,0,0,30181,4496,
+        1,0,0,0,30182,30183,7,12,0,0,30183,30184,7,4,0,0,30184,30185,7,16,
+        0,0,30185,30186,5,49,0,0,30186,30187,5,54,0,0,30187,30188,7,1,0,
+        0,30188,30189,7,6,0,0,30189,4498,1,0,0,0,30190,30191,7,12,0,0,30191,
+        30192,7,4,0,0,30192,30193,7,16,0,0,30193,30194,5,49,0,0,30194,30195,
+        5,54,0,0,30195,30196,7,11,0,0,30196,30197,7,6,0,0,30197,4500,1,0,
+        0,0,30198,30199,7,12,0,0,30199,30200,7,4,0,0,30200,30201,7,16,0,
+        0,30201,30202,5,51,0,0,30202,30203,5,50,0,0,30203,4502,1,0,0,0,30204,
+        30205,7,12,0,0,30205,30206,7,4,0,0,30206,30207,7,16,0,0,30207,30208,
+        5,56,0,0,30208,4504,1,0,0,0,30209,30210,7,13,0,0,30210,30211,5,49,
+        0,0,30211,4506,1,0,0,0,30212,30213,7,13,0,0,30213,30214,5,50,0,0,
+        30214,4508,1,0,0,0,30215,30216,7,13,0,0,30216,30217,7,0,0,0,30217,
+        30218,7,11,0,0,30218,30219,7,10,0,0,30219,30220,7,9,0,0,30220,30221,
+        7,0,0,0,30221,30222,7,4,0,0,30222,30223,7,6,0,0,30223,4510,1,0,0,
+        0,30224,30225,7,13,0,0,30225,30226,7,0,0,0,30226,30227,7,11,0,0,
+        30227,30228,7,10,0,0,30228,30229,7,9,0,0,30229,30230,7,0,0,0,30230,
+        30231,7,4,0,0,30231,30232,7,6,0,0,30232,30233,5,95,0,0,30233,30234,
+        7,8,0,0,30234,30235,7,2,0,0,30235,30236,7,7,0,0,30236,30237,7,13,
+        0,0,30237,30238,7,6,0,0,30238,30239,7,3,0,0,30239,30240,7,5,0,0,
+        30240,30241,7,10,0,0,30241,30242,7,2,0,0,30242,30243,7,7,0,0,30243,
+        4512,1,0,0,0,30244,30245,7,13,0,0,30245,30246,7,0,0,0,30246,30247,
+        7,11,0,0,30247,30248,7,10,0,0,30248,30249,7,9,0,0,30249,30250,7,
+        0,0,0,30250,30251,7,4,0,0,30251,30252,7,10,0,0,30252,30253,7,2,0,
+        0,30253,30254,7,7,0,0,30254,4514,1,0,0,0,30255,30256,7,13,0,0,30256,
+        30257,7,0,0,0,30257,30258,7,11,0,0,30258,30259,7,10,0,0,30259,30260,
+        7,9,0,0,30260,30261,5,95,0,0,30261,30262,7,4,0,0,30262,30263,7,10,
+        0,0,30263,30264,7,14,0,0,30264,30265,7,6,0,0,30265,30266,5,95,0,
+        0,30266,30267,7,6,0,0,30267,30268,7,7,0,0,30268,30269,7,9,0,0,30269,
+        4516,1,0,0,0,30270,30271,7,13,0,0,30271,30272,7,0,0,0,30272,30273,
+        7,11,0,0,30273,30274,7,12,0,0,30274,30275,7,6,0,0,30275,30276,7,
+        5,0,0,30276,4518,1,0,0,0,30277,30278,7,13,0,0,30278,30279,7,0,0,
+        0,30279,30280,7,11,0,0,30280,30281,7,12,0,0,30281,30282,7,6,0,0,
+        30282,4520,1,0,0,0,30283,30284,7,13,0,0,30284,30285,7,0,0,0,30285,
+        30286,7,3,0,0,30286,30287,7,8,0,0,30287,30288,7,19,0,0,30288,30289,
+        7,0,0,0,30289,30290,7,3,0,0,30290,30291,5,50,0,0,30291,4522,1,0,
+        0,0,30292,30293,7,13,0,0,30293,30294,7,0,0,0,30294,30295,7,3,0,0,
+        30295,30296,7,8,0,0,30296,30297,7,19,0,0,30297,30298,7,0,0,0,30298,
+        30299,7,3,0,0,30299,4524,1,0,0,0,30300,30301,7,13,0,0,30301,30302,
+        7,0,0,0,30302,30303,7,3,0,0,30303,30304,7,8,0,0,30304,30305,7,19,
+        0,0,30305,30306,7,0,0,0,30306,30307,7,3,0,0,30307,30308,7,8,0,0,
+        30308,4526,1,0,0,0,30309,30310,7,13,0,0,30310,30311,7,0,0,0,30311,
+        30312,7,3,0,0,30312,30313,7,10,0,0,30313,30314,7,0,0,0,30314,30315,
+        7,1,0,0,30315,30316,7,11,0,0,30316,30317,7,6,0,0,30317,4528,1,0,
+        0,0,30318,30319,7,13,0,0,30319,30320,7,0,0,0,30320,30321,7,3,0,0,
+        30321,30322,7,3,0,0,30322,30323,7,0,0,0,30323,30324,7,22,0,0,30324,
+        4530,1,0,0,0,30325,30326,7,13,0,0,30326,30327,7,0,0,0,30327,30328,
+        7,3,0,0,30328,30329,7,3,0,0,30329,30330,7,0,0,0,30330,30331,7,22,
+        0,0,30331,30332,7,8,0,0,30332,4532,1,0,0,0,30333,30334,7,13,0,0,
+        30334,30335,7,0,0,0,30335,30336,7,3,0,0,30336,30337,5,95,0,0,30337,
+        30338,7,15,0,0,30338,30339,7,2,0,0,30339,30340,7,15,0,0,30340,4534,
+        1,0,0,0,30341,30342,7,13,0,0,30342,30343,7,0,0,0,30343,30344,7,3,
+        0,0,30344,30345,7,3,0,0,30345,30346,7,0,0,0,30346,30347,7,18,0,0,
+        30347,30348,7,5,0,0,30348,4536,1,0,0,0,30349,30350,7,13,0,0,30350,
+        30351,7,0,0,0,30351,30352,7,3,0,0,30352,30353,7,3,0,0,30353,30354,
+        7,0,0,0,30354,30355,7,18,0,0,30355,4538,1,0,0,0,30356,30357,7,13,
+        0,0,30357,30358,7,0,0,0,30358,30359,7,3,0,0,30359,30360,5,95,0,0,
+        30360,30361,7,5,0,0,30361,30362,7,0,0,0,30362,30363,7,14,0,0,30363,
+        30364,7,15,0,0,30364,4540,1,0,0,0,30365,30366,7,13,0,0,30366,30367,
+        7,0,0,0,30367,30368,7,3,0,0,30368,30369,7,18,0,0,30369,30370,7,10,
+        0,0,30370,30371,7,7,0,0,30371,30372,7,17,0,0,30372,4542,1,0,0,0,
+        30373,30374,7,13,0,0,30374,30375,7,6,0,0,30375,30376,7,8,0,0,30376,
+        30377,7,4,0,0,30377,30378,7,2,0,0,30378,30379,7,3,0,0,30379,30380,
+        5,95,0,0,30380,30381,7,3,0,0,30381,30382,7,6,0,0,30382,30383,7,0,
+        0,0,30383,30384,7,9,0,0,30384,30385,5,95,0,0,30385,30386,7,4,0,0,
+        30386,30387,7,3,0,0,30387,30388,7,0,0,0,30388,30389,7,8,0,0,30389,
+        30390,7,6,0,0,30390,4544,1,0,0,0,30391,30392,7,13,0,0,30392,30393,
+        7,6,0,0,30393,30394,7,8,0,0,30394,30395,7,4,0,0,30395,30396,7,2,
+        0,0,30396,30397,7,3,0,0,30397,30398,5,95,0,0,30398,30399,7,3,0,0,
+        30399,30400,7,6,0,0,30400,30401,7,0,0,0,30401,30402,7,9,0,0,30402,
+        4546,1,0,0,0,30403,30404,7,13,0,0,30404,30405,7,6,0,0,30405,30406,
+        7,8,0,0,30406,30407,7,4,0,0,30407,30408,7,2,0,0,30408,30409,7,3,
+        0,0,30409,30410,5,95,0,0,30410,30411,7,4,0,0,30411,30412,7,3,0,0,
+        30412,30413,7,0,0,0,30413,30414,7,7,0,0,30414,30415,7,5,0,0,30415,
+        30416,7,16,0,0,30416,30417,7,2,0,0,30417,30418,7,3,0,0,30418,30419,
+        7,14,0,0,30419,30420,5,95,0,0,30420,30421,7,9,0,0,30421,30422,7,
+        10,0,0,30422,30423,7,14,0,0,30423,30424,7,5,0,0,30424,4548,1,0,0,
+        0,30425,30426,7,13,0,0,30426,30427,7,6,0,0,30427,30428,7,8,0,0,30428,
+        30429,7,4,0,0,30429,30430,7,2,0,0,30430,30431,7,3,0,0,30431,30432,
+        5,95,0,0,30432,30433,7,4,0,0,30433,30434,7,3,0,0,30434,30435,7,0,
+        0,0,30435,30436,7,7,0,0,30436,30437,7,5,0,0,30437,30438,7,16,0,0,
+        30438,30439,7,2,0,0,30439,30440,7,3,0,0,30440,30441,7,14,0,0,30441,
+        30442,5,95,0,0,30442,30443,7,16,0,0,30443,30444,7,0,0,0,30444,30445,
+        7,8,0,0,30445,30446,7,4,0,0,30446,4550,1,0,0,0,30447,30448,7,13,
+        0,0,30448,30449,7,6,0,0,30449,30450,7,8,0,0,30450,30451,7,4,0,0,
+        30451,30452,7,2,0,0,30452,30453,7,3,0,0,30453,30454,5,95,0,0,30454,
+        30455,7,4,0,0,30455,30456,7,3,0,0,30456,30457,7,0,0,0,30457,30458,
+        7,7,0,0,30458,30459,7,5,0,0,30459,30460,7,16,0,0,30460,30461,7,2,
+        0,0,30461,30462,7,3,0,0,30462,30463,7,14,0,0,30463,4552,1,0,0,0,
+        30464,30465,7,13,0,0,30465,30466,7,6,0,0,30466,30467,7,3,0,0,30467,
+        30468,7,10,0,0,30468,30469,7,16,0,0,30469,30470,7,10,0,0,30470,30471,
+        7,6,0,0,30471,30472,7,3,0,0,30472,4554,1,0,0,0,30473,30474,7,13,
+        0,0,30474,30475,7,6,0,0,30475,30476,7,3,0,0,30476,30477,7,10,0,0,
+        30477,30478,7,16,0,0,30478,30479,7,18,0,0,30479,4556,1,0,0,0,30480,
+        30481,7,13,0,0,30481,30482,7,6,0,0,30482,30483,7,3,0,0,30483,30484,
+        7,5,0,0,30484,30485,7,10,0,0,30485,30486,7,2,0,0,30486,30487,7,7,
+        0,0,30487,30488,7,10,0,0,30488,30489,7,7,0,0,30489,30490,7,17,0,
+        0,30490,4558,1,0,0,0,30491,30492,7,13,0,0,30492,30493,7,6,0,0,30493,
+        30494,7,3,0,0,30494,30495,7,5,0,0,30495,30496,7,10,0,0,30496,30497,
+        7,2,0,0,30497,30498,7,7,0,0,30498,30499,7,5,0,0,30499,30500,5,95,
+        0,0,30500,30501,7,6,0,0,30501,30502,7,7,0,0,30502,30503,7,9,0,0,
+        30503,30504,7,5,0,0,30504,30505,7,8,0,0,30505,30506,7,7,0,0,30506,
+        4560,1,0,0,0,30507,30508,7,13,0,0,30508,30509,7,6,0,0,30509,30510,
+        7,3,0,0,30510,30511,7,5,0,0,30511,30512,7,10,0,0,30512,30513,7,2,
+        0,0,30513,30514,7,7,0,0,30514,30515,7,5,0,0,30515,30516,5,95,0,0,
+        30516,30517,7,6,0,0,30517,30518,7,7,0,0,30518,30519,7,9,0,0,30519,
+        30520,7,4,0,0,30520,30521,7,10,0,0,30521,30522,7,14,0,0,30522,30523,
+        7,6,0,0,30523,4562,1,0,0,0,30524,30525,7,13,0,0,30525,30526,7,6,
+        0,0,30526,30527,7,3,0,0,30527,30528,7,5,0,0,30528,30529,7,10,0,0,
+        30529,30530,7,2,0,0,30530,30531,7,7,0,0,30531,30532,7,5,0,0,30532,
+        30533,5,95,0,0,30533,30534,7,2,0,0,30534,30535,7,15,0,0,30535,30536,
+        7,6,0,0,30536,30537,7,3,0,0,30537,30538,7,0,0,0,30538,30539,7,4,
+        0,0,30539,30540,7,10,0,0,30540,30541,7,2,0,0,30541,30542,7,7,0,0,
+        30542,4564,1,0,0,0,30543,30544,7,13,0,0,30544,30545,7,6,0,0,30545,
+        30546,7,3,0,0,30546,30547,7,5,0,0,30547,30548,7,10,0,0,30548,30549,
+        7,2,0,0,30549,30550,7,7,0,0,30550,30551,7,5,0,0,30551,30552,5,95,
+        0,0,30552,30553,7,5,0,0,30553,30554,7,4,0,0,30554,30555,7,0,0,0,
+        30555,30556,7,3,0,0,30556,30557,7,4,0,0,30557,30558,7,5,0,0,30558,
+        30559,7,8,0,0,30559,30560,7,7,0,0,30560,4566,1,0,0,0,30561,30562,
+        7,13,0,0,30562,30563,7,6,0,0,30563,30564,7,3,0,0,30564,30565,7,5,
+        0,0,30565,30566,7,10,0,0,30566,30567,7,2,0,0,30567,30568,7,7,0,0,
+        30568,30569,7,5,0,0,30569,30570,5,95,0,0,30570,30571,7,5,0,0,30571,
+        30572,7,4,0,0,30572,30573,7,0,0,0,30573,30574,7,3,0,0,30574,30575,
+        7,4,0,0,30575,30576,7,4,0,0,30576,30577,7,10,0,0,30577,30578,7,14,
+        0,0,30578,30579,7,6,0,0,30579,4568,1,0,0,0,30580,30581,7,13,0,0,
+        30581,30582,7,6,0,0,30582,30583,7,3,0,0,30583,30584,7,5,0,0,30584,
+        30585,7,10,0,0,30585,30586,7,2,0,0,30586,30587,7,7,0,0,30587,30588,
+        7,5,0,0,30588,4570,1,0,0,0,30589,30590,7,13,0,0,30590,30591,7,6,
+        0,0,30591,30592,7,3,0,0,30592,30593,7,5,0,0,30593,30594,7,10,0,0,
+        30594,30595,7,2,0,0,30595,30596,7,7,0,0,30596,30597,7,5,0,0,30597,
+        30598,5,95,0,0,30598,30599,7,25,0,0,30599,30600,7,10,0,0,30600,30601,
+        7,9,0,0,30601,4572,1,0,0,0,30602,30603,7,13,0,0,30603,30604,7,6,
+        0,0,30604,30605,7,3,0,0,30605,30606,7,5,0,0,30606,30607,7,10,0,0,
+        30607,30608,7,2,0,0,30608,30609,7,7,0,0,30609,4574,1,0,0,0,30610,
+        30611,7,13,0,0,30611,30612,7,10,0,0,30612,30613,7,6,0,0,30613,30614,
+        7,22,0,0,30614,4576,1,0,0,0,30615,30616,7,13,0,0,30616,30617,7,10,
+        0,0,30617,30618,7,2,0,0,30618,30619,7,11,0,0,30619,30620,7,0,0,0,
+        30620,30621,7,4,0,0,30621,30622,7,10,0,0,30622,30623,7,2,0,0,30623,
+        30624,7,7,0,0,30624,4578,1,0,0,0,30625,30626,7,13,0,0,30626,30627,
+        7,10,0,0,30627,30628,7,3,0,0,30628,30629,7,4,0,0,30629,30630,7,12,
+        0,0,30630,30631,7,0,0,0,30631,30632,7,11,0,0,30632,4580,1,0,0,0,
+        30633,30634,7,13,0,0,30634,30635,7,10,0,0,30635,30636,7,5,0,0,30636,
+        30637,7,10,0,0,30637,30638,7,1,0,0,30638,30639,7,10,0,0,30639,30640,
+        7,11,0,0,30640,30641,7,10,0,0,30641,30642,7,4,0,0,30642,30643,7,
+        18,0,0,30643,4582,1,0,0,0,30644,30645,7,13,0,0,30645,30646,7,10,
+        0,0,30646,30647,7,5,0,0,30647,30648,7,10,0,0,30648,30649,7,1,0,0,
+        30649,30650,7,11,0,0,30650,30651,7,6,0,0,30651,4584,1,0,0,0,30652,
+        30653,7,13,0,0,30653,30654,7,2,0,0,30654,30655,7,11,0,0,30655,30656,
+        7,12,0,0,30656,30657,7,14,0,0,30657,30658,7,6,0,0,30658,4586,1,0,
+        0,0,30659,30660,7,13,0,0,30660,30661,7,5,0,0,30661,30662,7,10,0,
+        0,30662,30663,7,23,0,0,30663,30664,7,6,0,0,30664,4588,1,0,0,0,30665,
+        30666,7,22,0,0,30666,30667,7,0,0,0,30667,30668,7,10,0,0,30668,30669,
+        7,4,0,0,30669,4590,1,0,0,0,30670,30671,7,22,0,0,30671,30672,7,0,
+        0,0,30672,30673,7,11,0,0,30673,30674,7,11,0,0,30674,30675,7,6,0,
+        0,30675,30676,7,4,0,0,30676,4592,1,0,0,0,30677,30678,7,22,0,0,30678,
+        30679,7,0,0,0,30679,30680,7,3,0,0,30680,30681,7,7,0,0,30681,30682,
+        7,10,0,0,30682,30683,7,7,0,0,30683,30684,7,17,0,0,30684,4594,1,0,
+        0,0,30685,30686,7,22,0,0,30686,30687,7,6,0,0,30687,30688,7,6,0,0,
+        30688,30689,7,21,0,0,30689,30690,7,5,0,0,30690,4596,1,0,0,0,30691,
+        30692,7,22,0,0,30692,30693,7,6,0,0,30693,30694,7,6,0,0,30694,30695,
+        7,21,0,0,30695,4598,1,0,0,0,30696,30697,7,22,0,0,30697,30698,7,6,
+        0,0,30698,30699,7,11,0,0,30699,30700,7,11,0,0,30700,30701,7,16,0,
+        0,30701,30702,7,2,0,0,30702,30703,7,3,0,0,30703,30704,7,14,0,0,30704,
+        30705,7,6,0,0,30705,30706,7,9,0,0,30706,4600,1,0,0,0,30707,30708,
+        7,22,0,0,30708,30709,7,19,0,0,30709,30710,7,6,0,0,30710,30711,7,
+        7,0,0,30711,30712,7,6,0,0,30712,30713,7,13,0,0,30713,30714,7,6,0,
+        0,30714,30715,7,3,0,0,30715,4602,1,0,0,0,30716,30717,7,22,0,0,30717,
+        30718,7,19,0,0,30718,30719,7,6,0,0,30719,30720,7,7,0,0,30720,4604,
+        1,0,0,0,30721,30722,7,22,0,0,30722,30723,7,19,0,0,30723,30724,7,
+        6,0,0,30724,30725,7,3,0,0,30725,30726,7,6,0,0,30726,4606,1,0,0,0,
+        30727,30728,7,22,0,0,30728,30729,7,19,0,0,30729,30730,7,10,0,0,30730,
+        30731,7,11,0,0,30731,30732,7,6,0,0,30732,4608,1,0,0,0,30733,30734,
+        7,22,0,0,30734,30735,7,19,0,0,30735,30736,7,10,0,0,30736,30737,7,
+        4,0,0,30737,30738,7,6,0,0,30738,30739,7,5,0,0,30739,30740,7,15,0,
+        0,30740,30741,7,0,0,0,30741,30742,7,8,0,0,30742,30743,7,6,0,0,30743,
+        4610,1,0,0,0,30744,30745,7,22,0,0,30745,30746,7,10,0,0,30746,30747,
+        7,9,0,0,30747,30748,7,4,0,0,30748,30749,7,19,0,0,30749,30750,5,95,
+        0,0,30750,30751,7,1,0,0,30751,30752,7,12,0,0,30752,30753,7,8,0,0,
+        30753,30754,7,21,0,0,30754,30755,7,6,0,0,30755,30756,7,4,0,0,30756,
+        4612,1,0,0,0,30757,30758,7,22,0,0,30758,30759,7,10,0,0,30759,30760,
+        7,4,0,0,30760,30761,7,19,0,0,30761,30762,7,10,0,0,30762,30763,7,
+        7,0,0,30763,4614,1,0,0,0,30764,30765,7,22,0,0,30765,30766,7,10,0,
+        0,30766,30767,7,4,0,0,30767,30768,7,19,0,0,30768,30769,7,2,0,0,30769,
+        30770,7,12,0,0,30770,30771,7,4,0,0,30771,4616,1,0,0,0,30772,30773,
+        7,22,0,0,30773,30774,7,10,0,0,30774,30775,7,4,0,0,30775,30776,7,
+        19,0,0,30776,30777,5,95,0,0,30777,30778,7,15,0,0,30778,30779,7,11,
+        0,0,30779,30780,7,5,0,0,30780,30781,7,24,0,0,30781,30782,7,11,0,
+        0,30782,4618,1,0,0,0,30783,30784,7,22,0,0,30784,30785,7,10,0,0,30785,
+        30786,7,4,0,0,30786,30787,7,19,0,0,30787,4620,1,0,0,0,30788,30789,
+        7,22,0,0,30789,30790,7,2,0,0,30790,30791,7,3,0,0,30791,30792,7,21,
+        0,0,30792,4622,1,0,0,0,30793,30794,7,22,0,0,30794,30795,7,2,0,0,
+        30795,30796,7,3,0,0,30796,30797,7,21,0,0,30797,30798,7,6,0,0,30798,
+        30799,7,3,0,0,30799,30800,7,10,0,0,30800,30801,7,9,0,0,30801,4624,
+        1,0,0,0,30802,30803,7,22,0,0,30803,30804,7,3,0,0,30804,30805,7,0,
+        0,0,30805,30806,7,15,0,0,30806,30807,7,15,0,0,30807,30808,7,6,0,
+        0,30808,30809,7,9,0,0,30809,4626,1,0,0,0,30810,30811,7,22,0,0,30811,
+        30812,7,3,0,0,30812,30813,7,0,0,0,30813,30814,7,15,0,0,30814,30815,
+        7,15,0,0,30815,30816,7,6,0,0,30816,30817,7,3,0,0,30817,4628,1,0,
+        0,0,30818,30819,7,22,0,0,30819,30820,7,3,0,0,30820,30821,7,10,0,
+        0,30821,30822,7,4,0,0,30822,30823,7,6,0,0,30823,4630,1,0,0,0,30824,
+        30825,7,25,0,0,30825,30826,7,9,0,0,30826,30827,7,1,0,0,30827,30828,
+        5,95,0,0,30828,30829,7,16,0,0,30829,30830,7,0,0,0,30830,30831,7,
+        5,0,0,30831,30832,7,4,0,0,30832,30833,7,15,0,0,30833,30834,7,0,0,
+        0,30834,30835,7,4,0,0,30835,30836,7,19,0,0,30836,30837,5,95,0,0,
+        30837,30838,7,10,0,0,30838,30839,7,7,0,0,30839,30840,7,5,0,0,30840,
+        30841,7,6,0,0,30841,30842,7,3,0,0,30842,30843,7,4,0,0,30843,4632,
+        1,0,0,0,30844,30845,7,25,0,0,30845,30846,7,9,0,0,30846,30847,7,1,
+        0,0,30847,4634,1,0,0,0,30848,30849,7,25,0,0,30849,30850,5,95,0,0,
+        30850,30851,7,9,0,0,30851,30852,7,18,0,0,30852,30853,7,7,0,0,30853,
+        30854,5,95,0,0,30854,30855,7,15,0,0,30855,30856,7,3,0,0,30856,30857,
+        7,12,0,0,30857,30858,7,7,0,0,30858,30859,7,6,0,0,30859,4636,1,0,
+        0,0,30860,30861,7,25,0,0,30861,30862,7,10,0,0,30862,30863,7,9,0,
+        0,30863,4638,1,0,0,0,30864,30865,7,25,0,0,30865,30866,7,14,0,0,30866,
+        30867,7,11,0,0,30867,30868,5,50,0,0,30868,30869,7,2,0,0,30869,30870,
+        7,1,0,0,30870,30871,7,20,0,0,30871,30872,7,6,0,0,30872,30873,7,8,
+        0,0,30873,30874,7,4,0,0,30874,4640,1,0,0,0,30875,30876,7,25,0,0,
+        30876,30877,7,14,0,0,30877,30878,7,11,0,0,30878,30879,7,0,0,0,30879,
+        30880,7,17,0,0,30880,30881,7,17,0,0,30881,4642,1,0,0,0,30882,30883,
+        7,25,0,0,30883,30884,7,14,0,0,30884,30885,7,11,0,0,30885,30886,7,
+        0,0,0,30886,30887,7,4,0,0,30887,30888,7,4,0,0,30888,30889,7,3,0,
+        0,30889,30890,7,10,0,0,30890,30891,7,1,0,0,30891,30892,7,12,0,0,
+        30892,30893,7,4,0,0,30893,30894,7,6,0,0,30894,30895,7,5,0,0,30895,
+        4644,1,0,0,0,30896,30897,7,25,0,0,30897,30898,7,14,0,0,30898,30899,
+        7,11,0,0,30899,30900,7,8,0,0,30900,30901,7,0,0,0,30901,30902,7,5,
+        0,0,30902,30903,7,4,0,0,30903,4646,1,0,0,0,30904,30905,7,25,0,0,
+        30905,30906,7,14,0,0,30906,30907,7,11,0,0,30907,30908,7,8,0,0,30908,
+        30909,7,9,0,0,30909,30910,7,0,0,0,30910,30911,7,4,0,0,30911,30912,
+        7,0,0,0,30912,4648,1,0,0,0,30913,30914,7,25,0,0,30914,30915,7,14,
+        0,0,30915,30916,7,11,0,0,30916,30917,7,8,0,0,30917,30918,7,2,0,0,
+        30918,30919,7,11,0,0,30919,30920,7,0,0,0,30920,30921,7,4,0,0,30921,
+        30922,7,4,0,0,30922,30923,7,13,0,0,30923,30924,7,0,0,0,30924,30925,
+        7,11,0,0,30925,4650,1,0,0,0,30926,30927,7,25,0,0,30927,30928,7,14,
+        0,0,30928,30929,7,11,0,0,30929,30930,7,8,0,0,30930,30931,7,2,0,0,
+        30931,30932,7,14,0,0,30932,30933,7,14,0,0,30933,30934,7,6,0,0,30934,
+        30935,7,7,0,0,30935,30936,7,4,0,0,30936,4652,1,0,0,0,30937,30938,
+        7,25,0,0,30938,30939,7,14,0,0,30939,30940,7,11,0,0,30940,30941,7,
+        8,0,0,30941,30942,7,2,0,0,30942,30943,7,7,0,0,30943,30944,7,8,0,
+        0,30944,30945,7,0,0,0,30945,30946,7,4,0,0,30946,4654,1,0,0,0,30947,
+        30948,7,25,0,0,30948,30949,7,14,0,0,30949,30950,7,11,0,0,30950,30951,
+        7,9,0,0,30951,30952,7,10,0,0,30952,30953,7,16,0,0,30953,30954,7,
+        16,0,0,30954,4656,1,0,0,0,30955,30956,7,25,0,0,30956,30957,7,14,
+        0,0,30957,30958,7,11,0,0,30958,30959,5,95,0,0,30959,30960,7,9,0,
+        0,30960,30961,7,14,0,0,30961,30962,7,11,0,0,30962,30963,5,95,0,0,
+        30963,30964,7,3,0,0,30964,30965,7,22,0,0,30965,30966,7,4,0,0,30966,
+        30967,5,95,0,0,30967,30968,7,5,0,0,30968,30969,7,4,0,0,30969,30970,
+        7,14,0,0,30970,30971,7,4,0,0,30971,4658,1,0,0,0,30972,30973,7,25,
+        0,0,30973,30974,7,14,0,0,30974,30975,7,11,0,0,30975,30976,7,6,0,
+        0,30976,30977,7,11,0,0,30977,30978,7,6,0,0,30978,30979,7,14,0,0,
+        30979,30980,7,6,0,0,30980,30981,7,7,0,0,30981,30982,7,4,0,0,30982,
+        4660,1,0,0,0,30983,30984,7,25,0,0,30984,30985,7,14,0,0,30985,30986,
+        7,11,0,0,30986,30987,7,6,0,0,30987,30988,7,25,0,0,30988,30989,7,
+        10,0,0,30989,30990,7,5,0,0,30990,30991,7,4,0,0,30991,30992,7,5,0,
+        0,30992,30993,5,50,0,0,30993,4662,1,0,0,0,30994,30995,7,25,0,0,30995,
+        30996,7,14,0,0,30996,30997,7,11,0,0,30997,30998,7,6,0,0,30998,30999,
+        7,25,0,0,30999,31000,7,10,0,0,31000,31001,7,5,0,0,31001,31002,7,
+        4,0,0,31002,31003,7,5,0,0,31003,4664,1,0,0,0,31004,31005,7,25,0,
+        0,31005,31006,7,14,0,0,31006,31007,7,11,0,0,31007,31008,7,16,0,0,
+        31008,31009,7,2,0,0,31009,31010,7,3,0,0,31010,31011,7,6,0,0,31011,
+        31012,7,5,0,0,31012,31013,7,4,0,0,31013,4666,1,0,0,0,31014,31015,
+        7,25,0,0,31015,31016,7,14,0,0,31016,31017,7,11,0,0,31017,31018,7,
+        10,0,0,31018,31019,7,7,0,0,31019,31020,7,9,0,0,31020,31021,7,6,0,
+        0,31021,31022,7,25,0,0,31022,4668,1,0,0,0,31023,31024,7,25,0,0,31024,
+        31025,7,14,0,0,31025,31026,7,11,0,0,31026,31027,7,10,0,0,31027,31028,
+        7,7,0,0,31028,31029,7,9,0,0,31029,31030,7,6,0,0,31030,31031,7,25,
+        0,0,31031,31032,5,95,0,0,31032,31033,7,3,0,0,31033,31034,7,6,0,0,
+        31034,31035,7,22,0,0,31035,31036,7,3,0,0,31036,31037,7,10,0,0,31037,
+        31038,7,4,0,0,31038,31039,7,6,0,0,31039,31040,5,95,0,0,31040,31041,
+        7,10,0,0,31041,31042,7,7,0,0,31042,31043,5,95,0,0,31043,31044,7,
+        5,0,0,31044,31045,7,6,0,0,31045,31046,7,11,0,0,31046,31047,7,6,0,
+        0,31047,31048,7,8,0,0,31048,31049,7,4,0,0,31049,4670,1,0,0,0,31050,
+        31051,7,25,0,0,31051,31052,7,14,0,0,31052,31053,7,11,0,0,31053,31054,
+        7,10,0,0,31054,31055,7,7,0,0,31055,31056,7,9,0,0,31056,31057,7,6,
+        0,0,31057,31058,7,25,0,0,31058,31059,5,95,0,0,31059,31060,7,3,0,
+        0,31060,31061,7,6,0,0,31061,31062,7,22,0,0,31062,31063,7,3,0,0,31063,
+        31064,7,10,0,0,31064,31065,7,4,0,0,31065,31066,7,6,0,0,31066,4672,
+        1,0,0,0,31067,31068,7,25,0,0,31068,31069,7,14,0,0,31069,31070,7,
+        11,0,0,31070,31071,7,10,0,0,31071,31072,7,7,0,0,31072,31073,7,9,
+        0,0,31073,31074,7,6,0,0,31074,31075,7,25,0,0,31075,31076,5,95,0,
+        0,31076,31077,7,5,0,0,31077,31078,7,6,0,0,31078,31079,7,11,0,0,31079,
+        31080,5,95,0,0,31080,31081,7,10,0,0,31081,31082,7,9,0,0,31082,31083,
+        7,25,0,0,31083,31084,5,95,0,0,31084,31085,7,4,0,0,31085,31086,7,
+        1,0,0,31086,31087,7,11,0,0,31087,4674,1,0,0,0,31088,31089,7,25,0,
+        0,31089,31090,7,14,0,0,31090,31091,7,11,0,0,31091,31092,7,10,0,0,
+        31092,31093,7,5,0,0,31093,31094,7,7,0,0,31094,31095,7,2,0,0,31095,
+        31096,7,9,0,0,31096,31097,7,6,0,0,31097,4676,1,0,0,0,31098,31099,
+        7,25,0,0,31099,31100,7,14,0,0,31100,31101,7,11,0,0,31101,31102,7,
+        10,0,0,31102,31103,7,5,0,0,31103,31104,7,13,0,0,31104,31105,7,0,
+        0,0,31105,31106,7,11,0,0,31106,31107,7,10,0,0,31107,31108,7,9,0,
+        0,31108,4678,1,0,0,0,31109,31110,7,25,0,0,31110,31111,7,14,0,0,31111,
+        31112,7,11,0,0,31112,31113,7,7,0,0,31113,31114,7,0,0,0,31114,31115,
+        7,14,0,0,31115,31116,7,6,0,0,31116,31117,7,5,0,0,31117,31118,7,15,
+        0,0,31118,31119,7,0,0,0,31119,31120,7,8,0,0,31120,31121,7,6,0,0,
+        31121,31122,7,5,0,0,31122,4680,1,0,0,0,31123,31124,7,25,0,0,31124,
+        31125,7,14,0,0,31125,31126,7,11,0,0,31126,31127,7,15,0,0,31127,31128,
+        7,0,0,0,31128,31129,7,3,0,0,31129,31130,7,5,0,0,31130,31131,7,6,
+        0,0,31131,4682,1,0,0,0,31132,31133,7,25,0,0,31133,31134,7,14,0,0,
+        31134,31135,7,11,0,0,31135,31136,7,15,0,0,31136,31137,7,0,0,0,31137,
+        31138,7,4,0,0,31138,31139,7,8,0,0,31139,31140,7,19,0,0,31140,4684,
+        1,0,0,0,31141,31142,7,25,0,0,31142,31143,7,14,0,0,31143,31144,7,
+        11,0,0,31144,31145,7,15,0,0,31145,31146,7,10,0,0,31146,4686,1,0,
+        0,0,31147,31148,7,25,0,0,31148,31149,7,14,0,0,31149,31150,7,11,0,
+        0,31150,31151,7,24,0,0,31151,31152,7,12,0,0,31152,31153,7,6,0,0,
+        31153,31154,7,3,0,0,31154,31155,7,18,0,0,31155,31156,7,13,0,0,31156,
+        31157,7,0,0,0,31157,31158,7,11,0,0,31158,4688,1,0,0,0,31159,31160,
+        7,25,0,0,31160,31161,7,14,0,0,31161,31162,7,11,0,0,31162,31163,7,
+        24,0,0,31163,31164,7,12,0,0,31164,31165,7,6,0,0,31165,31166,7,3,
+        0,0,31166,31167,7,18,0,0,31167,4690,1,0,0,0,31168,31169,7,25,0,0,
+        31169,31170,7,14,0,0,31170,31171,7,11,0,0,31171,31172,7,3,0,0,31172,
+        31173,7,2,0,0,31173,31174,7,2,0,0,31174,31175,7,4,0,0,31175,4692,
+        1,0,0,0,31176,31177,7,25,0,0,31177,31178,7,14,0,0,31178,31179,7,
+        11,0,0,31179,31180,7,5,0,0,31180,31181,7,8,0,0,31181,31182,7,19,
+        0,0,31182,31183,7,6,0,0,31183,31184,7,14,0,0,31184,31185,7,0,0,0,
+        31185,4694,1,0,0,0,31186,31187,7,25,0,0,31187,31188,7,14,0,0,31188,
+        31189,7,11,0,0,31189,31190,7,5,0,0,31190,31191,7,6,0,0,31191,31192,
+        7,3,0,0,31192,31193,7,10,0,0,31193,31194,7,0,0,0,31194,31195,7,11,
+        0,0,31195,31196,7,10,0,0,31196,31197,7,23,0,0,31197,31198,7,6,0,
+        0,31198,4696,1,0,0,0,31199,31200,7,25,0,0,31200,31201,7,14,0,0,31201,
+        31202,7,11,0,0,31202,31203,7,4,0,0,31203,31204,7,0,0,0,31204,31205,
+        7,1,0,0,31205,31206,7,11,0,0,31206,31207,7,6,0,0,31207,4698,1,0,
+        0,0,31208,31209,7,25,0,0,31209,31210,7,14,0,0,31210,31211,7,11,0,
+        0,31211,31212,7,4,0,0,31212,31213,7,0,0,0,31213,31214,7,17,0,0,31214,
+        4700,1,0,0,0,31215,31216,7,25,0,0,31216,31217,7,14,0,0,31217,31218,
+        7,11,0,0,31218,31219,7,4,0,0,31219,31220,7,3,0,0,31220,31221,7,0,
+        0,0,31221,31222,7,7,0,0,31222,31223,7,5,0,0,31223,31224,7,16,0,0,
+        31224,31225,7,2,0,0,31225,31226,7,3,0,0,31226,31227,7,14,0,0,31227,
+        31228,7,1,0,0,31228,31229,7,11,0,0,31229,31230,7,2,0,0,31230,31231,
+        7,1,0,0,31231,4702,1,0,0,0,31232,31233,7,25,0,0,31233,31234,7,14,
+        0,0,31234,31235,7,11,0,0,31235,31236,7,4,0,0,31236,31237,7,3,0,0,
+        31237,31238,7,0,0,0,31238,31239,7,7,0,0,31239,31240,7,5,0,0,31240,
+        31241,7,16,0,0,31241,31242,7,2,0,0,31242,31243,7,3,0,0,31243,31244,
+        7,14,0,0,31244,4704,1,0,0,0,31245,31246,7,25,0,0,31246,31247,7,14,
+        0,0,31247,31248,7,11,0,0,31248,31249,7,4,0,0,31249,31250,7,18,0,
+        0,31250,31251,7,15,0,0,31251,31252,7,6,0,0,31252,4706,1,0,0,0,31253,
+        31254,7,25,0,0,31254,31255,7,14,0,0,31255,31256,7,11,0,0,31256,4708,
+        1,0,0,0,31257,31258,7,25,0,0,31258,31259,7,15,0,0,31259,31260,7,
+        0,0,0,31260,31261,7,4,0,0,31261,31262,7,19,0,0,31262,31263,7,4,0,
+        0,31263,31264,7,0,0,0,31264,31265,7,1,0,0,31265,31266,7,11,0,0,31266,
+        31267,7,6,0,0,31267,4710,1,0,0,0,31268,31269,7,25,0,0,31269,31270,
+        7,5,0,0,31270,31271,5,95,0,0,31271,31272,7,5,0,0,31272,31273,7,18,
+        0,0,31273,31274,7,5,0,0,31274,31275,5,95,0,0,31275,31276,7,8,0,0,
+        31276,31277,7,2,0,0,31277,31278,7,7,0,0,31278,31279,7,4,0,0,31279,
+        31280,7,6,0,0,31280,31281,7,25,0,0,31281,31282,7,4,0,0,31282,4712,
+        1,0,0,0,31283,31284,7,25,0,0,31284,31285,7,5,0,0,31285,4714,1,0,
+        0,0,31286,31287,7,25,0,0,31287,31288,7,4,0,0,31288,31289,7,3,0,0,
+        31289,31290,7,0,0,0,31290,31291,7,7,0,0,31291,31292,7,5,0,0,31292,
+        31293,7,15,0,0,31293,31294,7,2,0,0,31294,31295,7,3,0,0,31295,31296,
+        7,4,0,0,31296,4716,1,0,0,0,31297,31298,7,18,0,0,31298,31299,7,6,
+        0,0,31299,31300,7,0,0,0,31300,31301,7,3,0,0,31301,31302,7,5,0,0,
+        31302,4718,1,0,0,0,31303,31304,7,18,0,0,31304,31305,7,6,0,0,31305,
+        31306,7,0,0,0,31306,31307,7,3,0,0,31307,4720,1,0,0,0,31308,31309,
+        7,18,0,0,31309,31310,7,6,0,0,31310,31311,7,0,0,0,31311,31312,7,3,
+        0,0,31312,31313,5,95,0,0,31313,31314,7,4,0,0,31314,31315,7,2,0,0,
+        31315,31316,5,95,0,0,31316,31317,7,14,0,0,31317,31318,7,2,0,0,31318,
+        31319,7,7,0,0,31319,31320,7,4,0,0,31320,31321,7,19,0,0,31321,4722,
+        1,0,0,0,31322,31323,7,18,0,0,31323,31324,7,6,0,0,31324,31325,7,5,
+        0,0,31325,4724,1,0,0,0,31326,31327,7,18,0,0,31327,31328,7,14,0,0,
+        31328,31329,7,10,0,0,31329,31330,7,7,0,0,31330,31331,7,4,0,0,31331,
+        31332,7,6,0,0,31332,31333,7,3,0,0,31333,31334,7,13,0,0,31334,31335,
+        7,0,0,0,31335,31336,7,11,0,0,31336,31337,5,95,0,0,31337,31338,7,
+        12,0,0,31338,31339,7,7,0,0,31339,31340,7,8,0,0,31340,31341,7,2,0,
+        0,31341,31342,7,7,0,0,31342,31343,7,5,0,0,31343,31344,7,4,0,0,31344,
+        31345,7,3,0,0,31345,31346,7,0,0,0,31346,31347,7,10,0,0,31347,31348,
+        7,7,0,0,31348,31349,7,6,0,0,31349,31350,7,9,0,0,31350,4726,1,0,0,
+        0,31351,31352,7,23,0,0,31352,31353,7,2,0,0,31353,31354,7,7,0,0,31354,
+        31355,7,6,0,0,31355,31356,7,14,0,0,31356,31357,7,0,0,0,31357,31358,
+        7,15,0,0,31358,4728,1,0,0,0,31359,31360,7,23,0,0,31360,31361,7,2,
+        0,0,31361,31362,7,7,0,0,31362,31363,7,6,0,0,31363,4730,1,0,0,0,31364,
+        31365,7,23,0,0,31365,31366,7,2,0,0,31366,31367,7,7,0,0,31367,31368,
+        7,6,0,0,31368,31369,7,9,0,0,31369,4732,1,0,0,0,31370,31371,7,15,
+        0,0,31371,31372,7,3,0,0,31372,31373,7,6,0,0,31373,31374,7,9,0,0,
+        31374,31375,7,10,0,0,31375,31376,7,8,0,0,31376,31377,7,4,0,0,31377,
+        31378,7,10,0,0,31378,31379,7,2,0,0,31379,31380,7,7,0,0,31380,4734,
+        1,0,0,0,31381,31382,7,15,0,0,31382,31383,7,3,0,0,31383,31384,7,6,
+        0,0,31384,31385,7,9,0,0,31385,31386,7,10,0,0,31386,31387,7,8,0,0,
+        31387,31388,7,4,0,0,31388,31389,7,10,0,0,31389,31390,7,2,0,0,31390,
+        31391,7,7,0,0,31391,31392,5,95,0,0,31392,31393,7,1,0,0,31393,31394,
+        7,2,0,0,31394,31395,7,12,0,0,31395,31396,7,7,0,0,31396,31397,7,9,
+        0,0,31397,31398,7,5,0,0,31398,4736,1,0,0,0,31399,31400,7,15,0,0,
+        31400,31401,7,3,0,0,31401,31402,7,6,0,0,31402,31403,7,9,0,0,31403,
+        31404,7,10,0,0,31404,31405,7,8,0,0,31405,31406,7,4,0,0,31406,31407,
+        7,10,0,0,31407,31408,7,2,0,0,31408,31409,7,7,0,0,31409,31410,5,95,
+        0,0,31410,31411,7,8,0,0,31411,31412,7,2,0,0,31412,31413,7,5,0,0,
+        31413,31414,7,4,0,0,31414,4738,1,0,0,0,31415,31416,7,15,0,0,31416,
+        31417,7,3,0,0,31417,31418,7,6,0,0,31418,31419,7,9,0,0,31419,31420,
+        7,10,0,0,31420,31421,7,8,0,0,31421,31422,7,4,0,0,31422,31423,7,10,
+        0,0,31423,31424,7,2,0,0,31424,31425,7,7,0,0,31425,31426,5,95,0,0,
+        31426,31427,7,9,0,0,31427,31428,7,6,0,0,31428,31429,7,4,0,0,31429,
+        31430,7,0,0,0,31430,31431,7,10,0,0,31431,31432,7,11,0,0,31432,31433,
+        7,5,0,0,31433,4740,1,0,0,0,31434,31435,7,15,0,0,31435,31436,7,3,
+        0,0,31436,31437,7,6,0,0,31437,31438,7,9,0,0,31438,31439,7,10,0,0,
+        31439,31440,7,8,0,0,31440,31441,7,4,0,0,31441,31442,7,10,0,0,31442,
+        31443,7,2,0,0,31443,31444,7,7,0,0,31444,31445,5,95,0,0,31445,31446,
+        7,15,0,0,31446,31447,7,3,0,0,31447,31448,7,2,0,0,31448,31449,7,1,
+        0,0,31449,31450,7,0,0,0,31450,31451,7,1,0,0,31451,31452,7,10,0,0,
+        31452,31453,7,11,0,0,31453,31454,7,10,0,0,31454,31455,7,4,0,0,31455,
+        31456,7,18,0,0,31456,4742,1,0,0,0,31457,31458,7,15,0,0,31458,31459,
+        7,3,0,0,31459,31460,7,6,0,0,31460,31461,7,9,0,0,31461,31462,7,10,
+        0,0,31462,31463,7,8,0,0,31463,31464,7,4,0,0,31464,31465,7,10,0,0,
+        31465,31466,7,2,0,0,31466,31467,7,7,0,0,31467,31468,5,95,0,0,31468,
+        31469,7,5,0,0,31469,31470,7,6,0,0,31470,31471,7,4,0,0,31471,4744,
+        1,0,0,0,31472,31473,7,1,0,0,31473,31474,7,11,0,0,31474,31475,7,2,
+        0,0,31475,31476,7,8,0,0,31476,31477,7,21,0,0,31477,31478,7,8,0,0,
+        31478,31479,7,19,0,0,31479,31480,7,0,0,0,31480,31481,7,10,0,0,31481,
+        31482,7,7,0,0,31482,4746,1,0,0,0,31483,31484,7,8,0,0,31484,31485,
+        7,2,0,0,31485,31486,7,11,0,0,31486,31487,7,11,0,0,31487,31488,7,
+        0,0,0,31488,31489,7,4,0,0,31489,31490,7,6,0,0,31490,4748,1,0,0,0,
+        31491,31492,7,8,0,0,31492,31493,7,2,0,0,31493,31494,7,11,0,0,31494,
+        31495,7,11,0,0,31495,31496,7,0,0,0,31496,31497,7,4,0,0,31497,31498,
+        7,10,0,0,31498,31499,7,2,0,0,31499,31500,7,7,0,0,31500,4750,1,0,
+        0,0,31501,31502,7,9,0,0,31502,31503,7,6,0,0,31503,31504,7,16,0,0,
+        31504,31505,7,10,0,0,31505,31506,7,7,0,0,31506,31507,7,10,0,0,31507,
+        31508,7,4,0,0,31508,31509,7,10,0,0,31509,31510,7,2,0,0,31510,31511,
+        7,7,0,0,31511,4752,1,0,0,0,31512,31513,7,9,0,0,31513,31514,7,12,
+        0,0,31514,31515,7,15,0,0,31515,31516,7,11,0,0,31516,31517,7,10,0,
+        0,31517,31518,7,8,0,0,31518,31519,7,0,0,0,31519,31520,7,4,0,0,31520,
+        31521,7,6,0,0,31521,31522,7,9,0,0,31522,4754,1,0,0,0,31523,31524,
+        7,6,0,0,31524,31525,7,25,0,0,31525,31526,7,4,0,0,31526,31527,7,6,
+        0,0,31527,31528,7,7,0,0,31528,31529,7,9,0,0,31529,31530,7,6,0,0,
+        31530,31531,7,9,0,0,31531,4756,1,0,0,0,31532,31533,7,19,0,0,31533,
+        31534,7,0,0,0,31534,31535,7,5,0,0,31535,31536,7,19,0,0,31536,31537,
+        7,10,0,0,31537,31538,7,7,0,0,31538,31539,7,17,0,0,31539,4758,1,0,
+        0,0,31540,31541,7,10,0,0,31541,31542,7,9,0,0,31542,31543,7,11,0,
+        0,31543,31544,7,6,0,0,31544,4760,1,0,0,0,31545,31546,7,10,0,0,31546,
+        31547,7,14,0,0,31547,31548,7,14,0,0,31548,31549,7,12,0,0,31549,31550,
+        7,4,0,0,31550,31551,7,0,0,0,31551,31552,7,1,0,0,31552,31553,7,11,
+        0,0,31553,31554,7,6,0,0,31554,4762,1,0,0,0,31555,31556,7,2,0,0,31556,
+        31557,7,3,0,0,31557,31558,7,0,0,0,31558,31559,7,8,0,0,31559,31560,
+        7,11,0,0,31560,31561,7,6,0,0,31561,31562,5,95,0,0,31562,31563,7,
+        9,0,0,31563,31564,7,0,0,0,31564,31565,7,4,0,0,31565,31566,7,0,0,
+        0,31566,31567,7,15,0,0,31567,31568,7,12,0,0,31568,31569,7,14,0,0,
+        31569,31570,7,15,0,0,31570,4764,1,0,0,0,31571,31572,7,2,0,0,31572,
+        31573,7,3,0,0,31573,31574,7,0,0,0,31574,31575,7,8,0,0,31575,31576,
+        7,11,0,0,31576,31577,7,6,0,0,31577,31578,5,95,0,0,31578,31579,7,
+        19,0,0,31579,31580,7,9,0,0,31580,31581,7,16,0,0,31581,31582,7,5,
+        0,0,31582,4766,1,0,0,0,31583,31584,7,2,0,0,31584,31585,7,3,0,0,31585,
+        31586,7,0,0,0,31586,31587,7,8,0,0,31587,31588,7,11,0,0,31588,31589,
+        7,6,0,0,31589,31590,5,95,0,0,31590,31591,7,19,0,0,31591,31592,7,
+        10,0,0,31592,31593,7,13,0,0,31593,31594,7,6,0,0,31594,4768,1,0,0,
+        0,31595,31596,7,2,0,0,31596,31597,7,3,0,0,31597,31598,7,0,0,0,31598,
+        31599,7,8,0,0,31599,31600,7,11,0,0,31600,31601,7,6,0,0,31601,31602,
+        5,95,0,0,31602,31603,7,11,0,0,31603,31604,7,2,0,0,31604,31605,7,
+        0,0,0,31605,31606,7,9,0,0,31606,31607,7,6,0,0,31607,31608,7,3,0,
+        0,31608,4770,1,0,0,0,31609,31610,5,34,0,0,31610,31611,7,5,0,0,31611,
+        31612,7,19,0,0,31612,31613,7,0,0,0,31613,31614,5,50,0,0,31614,31615,
+        5,95,0,0,31615,31616,5,53,0,0,31616,31617,5,49,0,0,31617,31618,5,
+        50,0,0,31618,31619,5,34,0,0,31619,4772,1,0,0,0,31620,31621,7,5,0,
+        0,31621,31622,7,19,0,0,31622,31623,7,0,0,0,31623,31624,7,3,0,0,31624,
+        31625,7,9,0,0,31625,31626,7,6,0,0,31626,31627,7,9,0,0,31627,4774,
+        1,0,0,0,31628,31629,5,34,0,0,31629,31630,7,13,0,0,31630,31631,5,
+        49,0,0,31631,31632,5,34,0,0,31632,4776,1,0,0,0,31633,31634,7,10,
+        0,0,31634,31635,7,5,0,0,31635,31636,7,2,0,0,31636,31637,7,11,0,0,
+        31637,31638,7,0,0,0,31638,31639,7,4,0,0,31639,31640,7,6,0,0,31640,
+        4778,1,0,0,0,31641,31642,7,3,0,0,31642,31643,7,2,0,0,31643,31644,
+        7,2,0,0,31644,31645,7,4,0,0,31645,4780,1,0,0,0,31646,31647,7,12,
+        0,0,31647,31648,7,7,0,0,31648,31649,7,10,0,0,31649,31650,7,4,0,0,
+        31650,31651,7,6,0,0,31651,4782,1,0,0,0,31652,31653,7,0,0,0,31653,
+        31654,7,11,0,0,31654,31655,7,17,0,0,31655,31656,7,2,0,0,31656,31657,
+        7,3,0,0,31657,31658,7,10,0,0,31658,31659,7,4,0,0,31659,31660,7,19,
+        0,0,31660,31661,7,14,0,0,31661,4784,1,0,0,0,31662,31663,7,8,0,0,
+        31663,31664,7,12,0,0,31664,31665,7,14,0,0,31665,31666,7,6,0,0,31666,
+        31667,5,95,0,0,31667,31668,7,9,0,0,31668,31669,7,10,0,0,31669,31670,
+        7,5,0,0,31670,31671,7,4,0,0,31671,4786,1,0,0,0,31672,31673,7,9,0,
+        0,31673,31674,7,6,0,0,31674,31675,7,7,0,0,31675,31676,7,5,0,0,31676,
+        31677,7,6,0,0,31677,31678,5,95,0,0,31678,31679,7,3,0,0,31679,31680,
+        7,0,0,0,31680,31681,7,7,0,0,31681,31682,7,21,0,0,31682,4788,1,0,
+        0,0,31683,31684,7,11,0,0,31684,31685,7,10,0,0,31685,31686,7,5,0,
+        0,31686,31687,7,4,0,0,31687,31688,7,0,0,0,31688,31689,7,17,0,0,31689,
+        31690,7,17,0,0,31690,4790,1,0,0,0,31691,31692,7,15,0,0,31692,31693,
+        7,6,0,0,31693,31694,7,3,0,0,31694,31695,7,8,0,0,31695,31696,7,6,
+        0,0,31696,31697,7,7,0,0,31697,31698,7,4,0,0,31698,31699,5,95,0,0,
+        31699,31700,7,3,0,0,31700,31701,7,0,0,0,31701,31702,7,7,0,0,31702,
+        31703,7,21,0,0,31703,4792,1,0,0,0,31704,31705,7,15,0,0,31705,31706,
+        7,6,0,0,31706,31707,7,3,0,0,31707,31708,7,8,0,0,31708,31709,7,6,
+        0,0,31709,31710,7,7,0,0,31710,31711,7,4,0,0,31711,31712,7,10,0,0,
+        31712,31713,7,11,0,0,31713,31714,7,6,0,0,31714,31715,5,95,0,0,31715,
+        31716,7,8,0,0,31716,31717,7,2,0,0,31717,31718,7,7,0,0,31718,31719,
+        7,4,0,0,31719,4794,1,0,0,0,31720,31721,7,15,0,0,31721,31722,7,6,
+        0,0,31722,31723,7,3,0,0,31723,31724,7,8,0,0,31724,31725,7,6,0,0,
+        31725,31726,7,7,0,0,31726,31727,7,4,0,0,31727,31728,7,10,0,0,31728,
+        31729,7,11,0,0,31729,31730,7,6,0,0,31730,31731,5,95,0,0,31731,31732,
+        7,9,0,0,31732,31733,7,10,0,0,31733,31734,7,5,0,0,31734,31735,7,8,
+        0,0,31735,4796,1,0,0,0,31736,31737,7,3,0,0,31737,31738,7,0,0,0,31738,
+        31739,7,7,0,0,31739,31740,7,21,0,0,31740,4798,1,0,0,0,31741,31742,
+        7,0,0,0,31742,31743,7,13,0,0,31743,31744,7,17,0,0,31744,4800,1,0,
+        0,0,31745,31746,7,8,0,0,31746,31747,7,2,0,0,31747,31748,7,3,0,0,
+        31748,31749,7,3,0,0,31749,4802,1,0,0,0,31750,31751,7,8,0,0,31751,
+        31752,7,2,0,0,31752,31753,7,13,0,0,31753,31754,7,0,0,0,31754,31755,
+        7,3,0,0,31755,31756,5,95,0,0,31756,4804,1,0,0,0,31757,31758,7,9,
+        0,0,31758,31759,7,6,0,0,31759,31760,7,8,0,0,31760,31761,7,2,0,0,
+        31761,31762,7,9,0,0,31762,31763,7,6,0,0,31763,4806,1,0,0,0,31764,
+        31765,7,11,0,0,31765,31766,7,0,0,0,31766,31767,7,17,0,0,31767,4808,
+        1,0,0,0,31768,31769,7,11,0,0,31769,31770,7,0,0,0,31770,31771,7,17,
+        0,0,31771,31772,5,95,0,0,31772,31773,7,9,0,0,31773,31774,7,10,0,
+        0,31774,31775,7,16,0,0,31775,31776,7,16,0,0,31776,4810,1,0,0,0,31777,
+        31778,7,11,0,0,31778,31779,7,0,0,0,31779,31780,7,17,0,0,31780,31781,
+        5,95,0,0,31781,31782,7,9,0,0,31782,31783,7,10,0,0,31783,31784,7,
+        16,0,0,31784,31785,7,16,0,0,31785,31786,5,95,0,0,31786,31787,7,15,
+        0,0,31787,31788,7,6,0,0,31788,31789,7,3,0,0,31789,31790,7,8,0,0,
+        31790,31791,7,6,0,0,31791,31792,7,7,0,0,31792,31793,7,4,0,0,31793,
+        4812,1,0,0,0,31794,31795,7,11,0,0,31795,31796,7,6,0,0,31796,31797,
+        7,0,0,0,31797,31798,7,9,0,0,31798,4814,1,0,0,0,31799,31800,7,14,
+        0,0,31800,31801,7,0,0,0,31801,31802,7,25,0,0,31802,4816,1,0,0,0,
+        31803,31804,7,14,0,0,31804,31805,7,6,0,0,31805,31806,7,9,0,0,31806,
+        31807,7,10,0,0,31807,31808,7,0,0,0,31808,31809,7,7,0,0,31809,4818,
+        1,0,0,0,31810,31811,7,14,0,0,31811,31812,7,6,0,0,31812,31813,7,14,
+        0,0,31813,31814,7,2,0,0,31814,31815,7,15,0,0,31815,31816,7,4,0,0,
+        31816,31817,7,10,0,0,31817,31818,7,14,0,0,31818,31819,7,10,0,0,31819,
+        31820,7,23,0,0,31820,31821,7,6,0,0,31821,4820,1,0,0,0,31822,31823,
+        7,14,0,0,31823,31824,7,10,0,0,31824,31825,7,7,0,0,31825,4822,1,0,
+        0,0,31826,31827,7,7,0,0,31827,31828,7,4,0,0,31828,31829,7,10,0,0,
+        31829,31830,7,11,0,0,31830,31831,7,6,0,0,31831,4824,1,0,0,0,31832,
+        31833,7,7,0,0,31833,31834,7,13,0,0,31834,31835,7,11,0,0,31835,4826,
+        1,0,0,0,31836,31837,7,3,0,0,31837,31838,7,0,0,0,31838,31839,7,4,
+        0,0,31839,31840,7,10,0,0,31840,31841,7,2,0,0,31841,31842,5,95,0,
+        0,31842,31843,7,4,0,0,31843,31844,7,2,0,0,31844,31845,5,95,0,0,31845,
+        31846,7,3,0,0,31846,31847,7,6,0,0,31847,31848,7,15,0,0,31848,31849,
+        7,2,0,0,31849,31850,7,3,0,0,31850,31851,7,4,0,0,31851,4828,1,0,0,
+        0,31852,31853,7,3,0,0,31853,31854,7,6,0,0,31854,31855,7,17,0,0,31855,
+        31856,7,3,0,0,31856,31857,5,95,0,0,31857,4830,1,0,0,0,31858,31859,
+        7,3,0,0,31859,31860,7,2,0,0,31860,31861,7,12,0,0,31861,31862,7,7,
+        0,0,31862,31863,7,9,0,0,31863,4832,1,0,0,0,31864,31865,7,3,0,0,31865,
+        31866,7,2,0,0,31866,31867,7,22,0,0,31867,31868,5,95,0,0,31868,31869,
+        7,7,0,0,31869,31870,7,12,0,0,31870,31871,7,14,0,0,31871,31872,7,
+        1,0,0,31872,31873,7,6,0,0,31873,31874,7,3,0,0,31874,4834,1,0,0,0,
+        31875,31876,7,5,0,0,31876,31877,7,12,0,0,31877,31878,7,1,0,0,31878,
+        31879,7,5,0,0,31879,31880,7,4,0,0,31880,31881,7,3,0,0,31881,4836,
+        1,0,0,0,31882,31883,7,4,0,0,31883,31884,7,2,0,0,31884,31885,5,95,
+        0,0,31885,31886,7,8,0,0,31886,31887,7,19,0,0,31887,31888,7,0,0,0,
+        31888,31889,7,3,0,0,31889,4838,1,0,0,0,31890,31891,7,4,0,0,31891,
+        31892,7,3,0,0,31892,31893,7,10,0,0,31893,31894,7,14,0,0,31894,4840,
+        1,0,0,0,31895,31896,7,5,0,0,31896,31897,7,12,0,0,31897,31898,7,14,
+        0,0,31898,4842,1,0,0,0,31899,31900,7,5,0,0,31900,31901,7,4,0,0,31901,
+        31902,7,9,0,0,31902,31903,7,9,0,0,31903,31904,7,6,0,0,31904,31905,
+        7,13,0,0,31905,4844,1,0,0,0,31906,31907,7,13,0,0,31907,31908,7,0,
+        0,0,31908,31909,7,3,0,0,31909,31910,5,95,0,0,31910,4846,1,0,0,0,
+        31911,31912,7,13,0,0,31912,31913,7,0,0,0,31913,31914,7,3,0,0,31914,
+        31915,7,10,0,0,31915,31916,7,0,0,0,31916,31917,7,7,0,0,31917,31918,
+        7,8,0,0,31918,31919,7,6,0,0,31919,4848,1,0,0,0,31920,31921,7,11,
+        0,0,31921,31922,7,6,0,0,31922,31923,7,0,0,0,31923,31924,7,5,0,0,
+        31924,31925,7,4,0,0,31925,4850,1,0,0,0,31926,31927,7,17,0,0,31927,
+        31928,7,3,0,0,31928,31929,7,6,0,0,31929,31930,7,0,0,0,31930,31931,
+        7,4,0,0,31931,31932,7,6,0,0,31932,31933,7,5,0,0,31933,31934,7,4,
+        0,0,31934,4852,1,0,0,0,31935,31936,7,4,0,0,31936,31937,7,2,0,0,31937,
+        31938,5,95,0,0,31938,31939,7,9,0,0,31939,31940,7,0,0,0,31940,31941,
+        7,4,0,0,31941,31942,7,6,0,0,31942,4854,1,0,0,0,31943,31944,7,8,0,
+        0,31944,31945,7,19,0,0,31945,31946,7,0,0,0,31946,31947,7,3,0,0,31947,
+        31948,7,5,0,0,31948,31949,7,6,0,0,31949,31950,7,4,0,0,31950,31951,
+        7,10,0,0,31951,31952,7,9,0,0,31952,4856,1,0,0,0,31953,31954,7,8,
+        0,0,31954,31955,7,19,0,0,31955,31956,7,0,0,0,31956,31957,7,3,0,0,
+        31957,31958,7,5,0,0,31958,31959,7,6,0,0,31959,31960,7,4,0,0,31960,
+        31961,7,16,0,0,31961,31962,7,2,0,0,31962,31963,7,3,0,0,31963,31964,
+        7,14,0,0,31964,4858,1,0,0,0,31965,31966,7,9,0,0,31966,31967,7,12,
+        0,0,31967,31968,7,3,0,0,31968,31969,7,0,0,0,31969,31970,7,4,0,0,
+        31970,31971,7,10,0,0,31971,31972,7,2,0,0,31972,31973,7,7,0,0,31973,
+        4860,1,0,0,0,31974,31975,7,6,0,0,31975,31976,7,25,0,0,31976,31977,
+        7,4,0,0,31977,31978,7,6,0,0,31978,31979,7,7,0,0,31979,31980,7,9,
+        0,0,31980,4862,1,0,0,0,31981,31982,7,14,0,0,31982,31983,7,0,0,0,
+        31983,31984,7,25,0,0,31984,31985,7,11,0,0,31985,31986,7,6,0,0,31986,
+        31987,7,7,0,0,31987,4864,1,0,0,0,31988,31989,7,15,0,0,31989,31990,
+        7,6,0,0,31990,31991,7,3,0,0,31991,31992,7,5,0,0,31992,31993,7,10,
+        0,0,31993,31994,7,5,0,0,31994,31995,7,4,0,0,31995,31996,7,0,0,0,
+        31996,31997,7,1,0,0,31997,31998,7,11,0,0,31998,31999,7,6,0,0,31999,
+        4866,1,0,0,0,32000,32001,7,15,0,0,32001,32002,7,2,0,0,32002,32003,
+        7,11,0,0,32003,32004,7,18,0,0,32004,32005,7,14,0,0,32005,32006,7,
+        2,0,0,32006,32007,7,3,0,0,32007,32008,7,15,0,0,32008,32009,7,19,
+        0,0,32009,32010,7,10,0,0,32010,32011,7,8,0,0,32011,4868,1,0,0,0,
+        32012,32013,7,5,0,0,32013,32014,7,4,0,0,32014,32015,7,3,0,0,32015,
+        32016,7,12,0,0,32016,32017,7,8,0,0,32017,32018,7,4,0,0,32018,4870,
+        1,0,0,0,32019,32020,7,4,0,0,32020,32021,7,9,0,0,32021,32022,7,2,
+        0,0,32022,4872,1,0,0,0,32023,32024,7,22,0,0,32024,32025,7,14,0,0,
+        32025,32026,5,95,0,0,32026,32027,7,8,0,0,32027,32028,7,2,0,0,32028,
+        32029,7,7,0,0,32029,32030,7,8,0,0,32030,32031,7,0,0,0,32031,32032,
+        7,4,0,0,32032,4874,1,0,0,0,32033,32034,7,7,0,0,32034,32041,5,39,
+        0,0,32035,32040,8,26,0,0,32036,32037,5,39,0,0,32037,32040,5,39,0,
+        0,32038,32040,3,4979,2489,0,32039,32035,1,0,0,0,32039,32036,1,0,
+        0,0,32039,32038,1,0,0,0,32040,32043,1,0,0,0,32041,32039,1,0,0,0,
+        32041,32042,1,0,0,0,32042,32044,1,0,0,0,32043,32041,1,0,0,0,32044,
+        32045,5,39,0,0,32045,4876,1,0,0,0,32046,32055,7,1,0,0,32047,32051,
+        5,39,0,0,32048,32050,7,27,0,0,32049,32048,1,0,0,0,32050,32053,1,
+        0,0,0,32051,32049,1,0,0,0,32051,32052,1,0,0,0,32052,32054,1,0,0,
+        0,32053,32051,1,0,0,0,32054,32056,5,39,0,0,32055,32047,1,0,0,0,32056,
+        32057,1,0,0,0,32057,32055,1,0,0,0,32057,32058,1,0,0,0,32058,4878,
+        1,0,0,0,32059,32063,7,25,0,0,32060,32061,5,48,0,0,32061,32063,7,
+        25,0,0,32062,32059,1,0,0,0,32062,32060,1,0,0,0,32063,32072,1,0,0,
+        0,32064,32068,5,39,0,0,32065,32067,7,28,0,0,32066,32065,1,0,0,0,
+        32067,32070,1,0,0,0,32068,32066,1,0,0,0,32068,32069,1,0,0,0,32069,
+        32071,1,0,0,0,32070,32068,1,0,0,0,32071,32073,5,39,0,0,32072,32064,
+        1,0,0,0,32073,32074,1,0,0,0,32074,32072,1,0,0,0,32074,32075,1,0,
+        0,0,32075,4880,1,0,0,0,32076,32077,5,46,0,0,32077,32078,5,46,0,0,
+        32078,4882,1,0,0,0,32079,32080,5,46,0,0,32080,4884,1,0,0,0,32081,
+        32083,7,29,0,0,32082,32081,1,0,0,0,32083,32084,1,0,0,0,32084,32082,
+        1,0,0,0,32084,32085,1,0,0,0,32085,4886,1,0,0,0,32086,32099,3,4977,
+        2488,0,32087,32089,7,6,0,0,32088,32090,7,30,0,0,32089,32088,1,0,
+        0,0,32089,32090,1,0,0,0,32090,32097,1,0,0,0,32091,32098,3,4977,2488,
+        0,32092,32094,7,29,0,0,32093,32092,1,0,0,0,32094,32095,1,0,0,0,32095,
+        32093,1,0,0,0,32095,32096,1,0,0,0,32096,32098,1,0,0,0,32097,32091,
+        1,0,0,0,32097,32093,1,0,0,0,32098,32100,1,0,0,0,32099,32087,1,0,
+        0,0,32099,32100,1,0,0,0,32100,32102,1,0,0,0,32101,32103,7,31,0,0,
+        32102,32101,1,0,0,0,32102,32103,1,0,0,0,32103,4888,1,0,0,0,32104,
+        32111,5,39,0,0,32105,32110,8,26,0,0,32106,32107,5,39,0,0,32107,32110,
+        5,39,0,0,32108,32110,3,4979,2489,0,32109,32105,1,0,0,0,32109,32106,
+        1,0,0,0,32109,32108,1,0,0,0,32110,32113,1,0,0,0,32111,32109,1,0,
+        0,0,32111,32112,1,0,0,0,32112,32114,1,0,0,0,32113,32111,1,0,0,0,
+        32114,32115,5,39,0,0,32115,4890,1,0,0,0,32116,32117,7,24,0,0,32117,
+        32118,5,39,0,0,32118,32122,8,32,0,0,32119,32121,9,0,0,0,32120,32119,
+        1,0,0,0,32121,32124,1,0,0,0,32122,32123,1,0,0,0,32122,32120,1,0,
+        0,0,32123,32125,1,0,0,0,32124,32122,1,0,0,0,32125,32126,9,0,0,0,
+        32126,32127,5,39,0,0,32127,32128,4,2445,0,0,32128,32129,1,0,0,0,
+        32129,32130,6,2445,0,0,32130,4892,1,0,0,0,32131,32135,5,34,0,0,32132,
+        32136,8,33,0,0,32133,32134,5,34,0,0,32134,32136,5,34,0,0,32135,32132,
+        1,0,0,0,32135,32133,1,0,0,0,32136,32137,1,0,0,0,32137,32135,1,0,
+        0,0,32137,32138,1,0,0,0,32138,32139,1,0,0,0,32139,32140,5,34,0,0,
+        32140,4894,1,0,0,0,32141,32142,5,37,0,0,32142,4896,1,0,0,0,32143,
+        32144,5,38,0,0,32144,4898,1,0,0,0,32145,32146,5,40,0,0,32146,4900,
+        1,0,0,0,32147,32148,5,41,0,0,32148,4902,1,0,0,0,32149,32150,5,42,
+        0,0,32150,32151,5,42,0,0,32151,4904,1,0,0,0,32152,32153,5,42,0,0,
+        32153,4906,1,0,0,0,32154,32155,5,43,0,0,32155,4908,1,0,0,0,32156,
+        32157,5,45,0,0,32157,4910,1,0,0,0,32158,32159,5,44,0,0,32159,4912,
+        1,0,0,0,32160,32161,5,47,0,0,32161,4914,1,0,0,0,32162,32163,5,92,
+        0,0,32163,4916,1,0,0,0,32164,32165,5,64,0,0,32165,4918,1,0,0,0,32166,
+        32167,5,58,0,0,32167,32168,5,61,0,0,32168,4920,1,0,0,0,32169,32170,
+        5,35,0,0,32170,4922,1,0,0,0,32171,32172,5,123,0,0,32172,4924,1,0,
+        0,0,32173,32174,5,125,0,0,32174,4926,1,0,0,0,32175,32176,5,39,0,
+        0,32176,4928,1,0,0,0,32177,32178,5,58,0,0,32178,32183,3,4975,2487,
+        0,32179,32182,3,4975,2487,0,32180,32182,7,34,0,0,32181,32179,1,0,
+        0,0,32181,32180,1,0,0,0,32182,32185,1,0,0,0,32183,32181,1,0,0,0,
+        32183,32184,1,0,0,0,32184,32192,1,0,0,0,32185,32183,1,0,0,0,32186,
+        32187,5,58,0,0,32187,32192,3,4893,2446,0,32188,32189,5,58,0,0,32189,
+        32192,3,4885,2442,0,32190,32192,3,4973,2486,0,32191,32177,1,0,0,
+        0,32191,32186,1,0,0,0,32191,32188,1,0,0,0,32191,32190,1,0,0,0,32192,
+        4930,1,0,0,0,32193,32194,5,33,0,0,32194,32202,5,61,0,0,32195,32196,
+        5,60,0,0,32196,32202,5,62,0,0,32197,32198,5,94,0,0,32198,32202,5,
+        61,0,0,32199,32200,5,126,0,0,32200,32202,5,61,0,0,32201,32193,1,
+        0,0,0,32201,32195,1,0,0,0,32201,32197,1,0,0,0,32201,32199,1,0,0,
+        0,32202,4932,1,0,0,0,32203,32204,5,94,0,0,32204,4934,1,0,0,0,32205,
+        32206,5,126,0,0,32206,4936,1,0,0,0,32207,32208,5,33,0,0,32208,4938,
+        1,0,0,0,32209,32210,5,62,0,0,32210,4940,1,0,0,0,32211,32212,5,60,
+        0,0,32212,4942,1,0,0,0,32213,32214,5,58,0,0,32214,4944,1,0,0,0,32215,
+        32216,5,59,0,0,32216,4946,1,0,0,0,32217,32218,5,124,0,0,32218,4948,
+        1,0,0,0,32219,32220,5,61,0,0,32220,4950,1,0,0,0,32221,32222,5,91,
+        0,0,32222,4952,1,0,0,0,32223,32224,5,93,0,0,32224,4954,1,0,0,0,32225,
+        32226,5,95,0,0,32226,4956,1,0,0,0,32227,32228,5,45,0,0,32228,32229,
+        5,45,0,0,32229,32233,1,0,0,0,32230,32232,8,35,0,0,32231,32230,1,
+        0,0,0,32232,32235,1,0,0,0,32233,32231,1,0,0,0,32233,32234,1,0,0,
+        0,32234,32236,1,0,0,0,32235,32233,1,0,0,0,32236,32237,3,4971,2485,
+        0,32237,32238,1,0,0,0,32238,32239,6,2478,1,0,32239,4958,1,0,0,0,
+        32240,32241,5,47,0,0,32241,32242,5,42,0,0,32242,32246,1,0,0,0,32243,
+        32245,9,0,0,0,32244,32243,1,0,0,0,32245,32248,1,0,0,0,32246,32247,
+        1,0,0,0,32246,32244,1,0,0,0,32247,32249,1,0,0,0,32248,32246,1,0,
+        0,0,32249,32250,5,42,0,0,32250,32251,5,47,0,0,32251,32252,1,0,0,
+        0,32252,32253,6,2479,1,0,32253,4960,1,0,0,0,32254,32255,7,3,0,0,
+        32255,32256,7,6,0,0,32256,32257,7,14,0,0,32257,32258,1,0,0,0,32258,
+        32262,4,2480,1,0,32259,32260,7,0,0,0,32260,32261,7,3,0,0,32261,32263,
+        7,21,0,0,32262,32259,1,0,0,0,32262,32263,1,0,0,0,32263,32271,1,0,
+        0,0,32264,32268,7,36,0,0,32265,32267,8,35,0,0,32266,32265,1,0,0,
+        0,32267,32270,1,0,0,0,32268,32266,1,0,0,0,32268,32269,1,0,0,0,32269,
+        32272,1,0,0,0,32270,32268,1,0,0,0,32271,32264,1,0,0,0,32271,32272,
+        1,0,0,0,32272,32273,1,0,0,0,32273,32274,3,4971,2485,0,32274,32275,
+        1,0,0,0,32275,32276,6,2480,1,0,32276,4962,1,0,0,0,32277,32278,7,
+        15,0,0,32278,32279,7,3,0,0,32279,32280,7,2,0,0,32280,32281,1,0,0,
+        0,32281,32285,4,2481,2,0,32282,32283,7,14,0,0,32283,32284,7,15,0,
+        0,32284,32286,7,4,0,0,32285,32282,1,0,0,0,32285,32286,1,0,0,0,32286,
+        32294,1,0,0,0,32287,32291,7,36,0,0,32288,32290,8,35,0,0,32289,32288,
+        1,0,0,0,32290,32293,1,0,0,0,32291,32289,1,0,0,0,32291,32292,1,0,
+        0,0,32292,32295,1,0,0,0,32293,32291,1,0,0,0,32294,32287,1,0,0,0,
+        32294,32295,1,0,0,0,32295,32296,1,0,0,0,32296,32297,3,4971,2485,
+        0,32297,4964,1,0,0,0,32298,32303,3,4975,2487,0,32299,32302,3,4975,
+        2487,0,32300,32302,7,37,0,0,32301,32299,1,0,0,0,32301,32300,1,0,
+        0,0,32302,32305,1,0,0,0,32303,32301,1,0,0,0,32303,32304,1,0,0,0,
+        32304,4966,1,0,0,0,32305,32303,1,0,0,0,32306,32307,5,36,0,0,32307,
+        32308,5,36,0,0,32308,32311,1,0,0,0,32309,32312,3,4975,2487,0,32310,
+        32312,5,95,0,0,32311,32309,1,0,0,0,32311,32310,1,0,0,0,32312,32313,
+        1,0,0,0,32313,32311,1,0,0,0,32313,32314,1,0,0,0,32314,4968,1,0,0,
+        0,32315,32317,7,38,0,0,32316,32315,1,0,0,0,32317,32318,1,0,0,0,32318,
+        32316,1,0,0,0,32318,32319,1,0,0,0,32319,32320,1,0,0,0,32320,32321,
+        6,2484,1,0,32321,4970,1,0,0,0,32322,32325,3,4979,2489,0,32323,32325,
+        5,0,0,1,32324,32322,1,0,0,0,32324,32323,1,0,0,0,32325,4972,1,0,0,
+        0,32326,32327,5,63,0,0,32327,4974,1,0,0,0,32328,32329,7,39,0,0,32329,
+        4976,1,0,0,0,32330,32332,3,4885,2442,0,32331,32330,1,0,0,0,32332,
+        32335,1,0,0,0,32333,32331,1,0,0,0,32333,32334,1,0,0,0,32334,32337,
+        1,0,0,0,32335,32333,1,0,0,0,32336,32338,5,46,0,0,32337,32336,1,0,
+        0,0,32337,32338,1,0,0,0,32338,32340,1,0,0,0,32339,32341,3,4885,2442,
+        0,32340,32339,1,0,0,0,32341,32342,1,0,0,0,32342,32340,1,0,0,0,32342,
+        32343,1,0,0,0,32343,4978,1,0,0,0,32344,32346,5,13,0,0,32345,32344,
+        1,0,0,0,32345,32346,1,0,0,0,32346,32347,1,0,0,0,32347,32348,5,10,
+        0,0,32348,4980,1,0,0,0,32349,32350,7,36,0,0,32350,4982,1,0,0,0,50,
+        0,19920,19933,19947,19985,20001,20016,20028,20051,23377,32039,32041,
+        32051,32057,32062,32068,32074,32084,32089,32095,32097,32099,32102,
+        32109,32111,32122,32135,32137,32181,32183,32191,32201,32233,32246,
+        32262,32268,32271,32285,32291,32294,32301,32303,32311,32313,32318,
+        32324,32333,32337,32342,32345,2,7,2445,0,0,1,0
+    ];
+
+    private static __ATN: antlr.ATN;
+    public static get _ATN(): antlr.ATN {
+        if (!PlSqlLexer.__ATN) {
+            PlSqlLexer.__ATN = new antlr.ATNDeserializer().deserialize(PlSqlLexer._serializedATN);
+        }
+
+        return PlSqlLexer.__ATN;
+    }
+
+
+    private static readonly vocabulary = new antlr.Vocabulary(PlSqlLexer.literalNames, PlSqlLexer.symbolicNames, []);
+
+    public override get vocabulary(): antlr.Vocabulary {
+        return PlSqlLexer.vocabulary;
+    }
+
+    private static readonly decisionsToDFA = PlSqlLexer._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
+}
\ No newline at end of file
diff --git a/gitnexus/src/core/ingestion/plsql/generated/PlSqlLexerBase.ts b/gitnexus/src/core/ingestion/plsql/generated/PlSqlLexerBase.ts
new file mode 100644
index 000000000..ce13a0938
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/generated/PlSqlLexerBase.ts
@@ -0,0 +1,21 @@
+import { CommonToken, Lexer, CharStream, Token, CommonTokenStream } from "antlr4ng";
+
+export abstract class PlSqlLexerBase extends Lexer {
+  IsNewlineAtPos(pos: number): boolean {
+    const la = this.inputStream.LA(pos);
+    return la == -1 || String.fromCharCode(la) == '\n';
+  }
+
+  IsQQuoteDelimiter(): boolean {
+    const opening = this.inputStream.LA(this.tokenStartCharIndex + 2 - this.inputStream.index);
+    const closing = this.inputStream.LA(-2);
+    switch (opening) {
+      case 91: return closing == 93;
+      case 123: return closing == 125;
+      case 60: return closing == 62;
+      case 40: return closing == 41;
+      default: return closing == opening;
+    }
+  }
+
+}
diff --git a/gitnexus/src/core/ingestion/plsql/generated/PlSqlParser.ts b/gitnexus/src/core/ingestion/plsql/generated/PlSqlParser.ts
new file mode 100644
index 000000000..f7d187934
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/generated/PlSqlParser.ts
@@ -0,0 +1,309538 @@
+
+import * as antlr from "antlr4ng";
+import { Token } from "antlr4ng";
+
+import { PlSqlParserListener } from "./PlSqlParserListener.js";
+// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
+// eslint-disable-next-line no-unused-vars
+type int = number;
+
+import { PlSqlParserBase } from "./PlSqlParserBase.js"
+
+export class PlSqlParser extends PlSqlParserBase {
+    public static readonly ABORT = 1;
+    public static readonly ABS = 2;
+    public static readonly ABSENT = 3;
+    public static readonly ACCESS = 4;
+    public static readonly ACCESSED = 5;
+    public static readonly ACCESSIBLE = 6;
+    public static readonly ACCOUNT = 7;
+    public static readonly ACL = 8;
+    public static readonly ACOS = 9;
+    public static readonly ACROSS = 10;
+    public static readonly ACTION = 11;
+    public static readonly ACTIONS = 12;
+    public static readonly ACTIVATE = 13;
+    public static readonly ACTIVE = 14;
+    public static readonly ACTIVE_COMPONENT = 15;
+    public static readonly ACTIVE_DATA = 16;
+    public static readonly ACTIVE_FUNCTION = 17;
+    public static readonly ACTIVE_TAG = 18;
+    public static readonly ACTIVITY = 19;
+    public static readonly ADAPTIVE_PLAN = 20;
+    public static readonly ADD = 21;
+    public static readonly ADD_COLUMN = 22;
+    public static readonly ADD_GROUP = 23;
+    public static readonly ADD_MONTHS = 24;
+    public static readonly ADJ_DATE = 25;
+    public static readonly ADMIN = 26;
+    public static readonly ADMINISTER = 27;
+    public static readonly ADMINISTRATOR = 28;
+    public static readonly ADVANCED = 29;
+    public static readonly ADVISE = 30;
+    public static readonly ADVISOR = 31;
+    public static readonly AFD_DISKSTRING = 32;
+    public static readonly AFTER = 33;
+    public static readonly AGENT = 34;
+    public static readonly AGGREGATE = 35;
+    public static readonly A_LETTER = 36;
+    public static readonly ALIAS = 37;
+    public static readonly ALL = 38;
+    public static readonly ALLOCATE = 39;
+    public static readonly ALLOW = 40;
+    public static readonly ALL_ROWS = 41;
+    public static readonly ALTER = 42;
+    public static readonly ALTERNATE = 43;
+    public static readonly ALWAYS = 44;
+    public static readonly ANALYTIC = 45;
+    public static readonly ANALYZE = 46;
+    public static readonly ANCESTOR = 47;
+    public static readonly ANCILLARY = 48;
+    public static readonly AND = 49;
+    public static readonly AND_EQUAL = 50;
+    public static readonly ANNOTATIONS = 51;
+    public static readonly ANOMALY = 52;
+    public static readonly ANSI_REARCH = 53;
+    public static readonly ANTIJOIN = 54;
+    public static readonly ANY = 55;
+    public static readonly ANYSCHEMA = 56;
+    public static readonly APPEND = 57;
+    public static readonly APPENDCHILDXML = 58;
+    public static readonly APPEND_VALUES = 59;
+    public static readonly APPLICATION = 60;
+    public static readonly APPLY = 61;
+    public static readonly APPROX_COUNT_DISTINCT = 62;
+    public static readonly ARCHIVAL = 63;
+    public static readonly ARCHIVE = 64;
+    public static readonly ARCHIVED = 65;
+    public static readonly ARCHIVELOG = 66;
+    public static readonly ARE = 67;
+    public static readonly ARRAY = 68;
+    public static readonly AS = 69;
+    public static readonly ASC = 70;
+    public static readonly ASCII = 71;
+    public static readonly ASCIISTR = 72;
+    public static readonly ASIN = 73;
+    public static readonly ASIS = 74;
+    public static readonly ASSEMBLY = 75;
+    public static readonly ASSIGN = 76;
+    public static readonly ASSOCIATE = 77;
+    public static readonly ASYNC = 78;
+    public static readonly ASYNCHRONOUS = 79;
+    public static readonly ATAN2 = 80;
+    public static readonly ATAN = 81;
+    public static readonly AT = 82;
+    public static readonly ATTRIBUTE = 83;
+    public static readonly ATTRIBUTES = 84;
+    public static readonly AUDIT = 85;
+    public static readonly AUTHENTICATED = 86;
+    public static readonly AUTHENTICATION = 87;
+    public static readonly AUTHID = 88;
+    public static readonly AUTHORIZATION = 89;
+    public static readonly AUTOALLOCATE = 90;
+    public static readonly AUTO = 91;
+    public static readonly AUTOBACKUP = 92;
+    public static readonly AUTOEXTEND = 93;
+    public static readonly AUTO_LOGIN = 94;
+    public static readonly AUTOMATIC = 95;
+    public static readonly AUTONOMOUS_TRANSACTION = 96;
+    public static readonly AUTO_REOPTIMIZE = 97;
+    public static readonly AVAILABILITY = 98;
+    public static readonly AVRO = 99;
+    public static readonly BACKGROUND = 100;
+    public static readonly BACKINGFILE = 101;
+    public static readonly BACKUP = 102;
+    public static readonly BACKUPS = 103;
+    public static readonly BACKUPSET = 104;
+    public static readonly BADFILE = 105;
+    public static readonly BASIC = 106;
+    public static readonly BASICFILE = 107;
+    public static readonly BATCH = 108;
+    public static readonly BATCHSIZE = 109;
+    public static readonly BATCH_TABLE_ACCESS_BY_ROWID = 110;
+    public static readonly BECOME = 111;
+    public static readonly BEFORE = 112;
+    public static readonly BEGIN = 113;
+    public static readonly BEGINNING = 114;
+    public static readonly BEGIN_OUTLINE_DATA = 115;
+    public static readonly BEHALF = 116;
+    public static readonly BEQUEATH = 117;
+    public static readonly BETWEEN = 118;
+    public static readonly BFILE = 119;
+    public static readonly BFILENAME = 120;
+    public static readonly BIG = 121;
+    public static readonly BIGFILE = 122;
+    public static readonly BIGINT = 123;
+    public static readonly BINARY = 124;
+    public static readonly BINARY_DOUBLE = 125;
+    public static readonly BINARY_DOUBLE_INFINITY = 126;
+    public static readonly BINARY_DOUBLE_NAN = 127;
+    public static readonly BINARY_FLOAT = 128;
+    public static readonly BINARY_FLOAT_INFINITY = 129;
+    public static readonly BINARY_FLOAT_NAN = 130;
+    public static readonly BINARY_INTEGER = 131;
+    public static readonly BIND_AWARE = 132;
+    public static readonly BINDING = 133;
+    public static readonly BIN_TO_NUM = 134;
+    public static readonly BITAND = 135;
+    public static readonly BITMAP_AND = 136;
+    public static readonly BITMAP = 137;
+    public static readonly BITMAPS = 138;
+    public static readonly BITMAP_TREE = 139;
+    public static readonly BITS = 140;
+    public static readonly BLANKS = 141;
+    public static readonly BLOB = 142;
+    public static readonly BLOCK = 143;
+    public static readonly BLOCK_RANGE = 144;
+    public static readonly BLOCKS = 145;
+    public static readonly BLOCKSIZE = 146;
+    public static readonly BODY = 147;
+    public static readonly BOOLEAN = 148;
+    public static readonly BOTH = 149;
+    public static readonly BOUND = 150;
+    public static readonly BRANCH = 151;
+    public static readonly BREADTH = 152;
+    public static readonly BROADCAST = 153;
+    public static readonly BSON = 154;
+    public static readonly BUFFER = 155;
+    public static readonly BUFFER_CACHE = 156;
+    public static readonly BUFFER_POOL = 157;
+    public static readonly BUILD = 158;
+    public static readonly BULK = 159;
+    public static readonly BY = 160;
+    public static readonly BYPASS_RECURSIVE_CHECK = 161;
+    public static readonly BYPASS_UJVC = 162;
+    public static readonly BYTE = 163;
+    public static readonly BYTES = 164;
+    public static readonly BYTEORDERMARK = 165;
+    public static readonly CACHE = 166;
+    public static readonly CACHE_CB = 167;
+    public static readonly CACHE_INSTANCES = 168;
+    public static readonly CACHE_TEMP_TABLE = 169;
+    public static readonly CACHING = 170;
+    public static readonly CALCULATED = 171;
+    public static readonly CALLBACK = 172;
+    public static readonly CALL = 173;
+    public static readonly CANCEL = 174;
+    public static readonly CANONICAL = 175;
+    public static readonly CAPACITY = 176;
+    public static readonly CAPTION = 177;
+    public static readonly CARDINALITY = 178;
+    public static readonly CASCADE = 179;
+    public static readonly CASE = 180;
+    public static readonly CAST = 181;
+    public static readonly CASESENSITIVE = 182;
+    public static readonly CATEGORY = 183;
+    public static readonly CDBDEFAULT = 184;
+    public static readonly CEIL = 185;
+    public static readonly CELL_FLASH_CACHE = 186;
+    public static readonly CERTIFICATE = 187;
+    public static readonly CFILE = 188;
+    public static readonly CHAINED = 189;
+    public static readonly CHANGE = 190;
+    public static readonly CHANGETRACKING = 191;
+    public static readonly CHANGE_DUPKEY_ERROR_INDEX = 192;
+    public static readonly CHARACTER = 193;
+    public static readonly CHARACTERS = 194;
+    public static readonly CHARACTERSET = 195;
+    public static readonly CHAR = 196;
+    public static readonly CHAR_CS = 197;
+    public static readonly CHARTOROWID = 198;
+    public static readonly CHECK_ACL_REWRITE = 199;
+    public static readonly CHECK = 200;
+    public static readonly CHECKPOINT = 201;
+    public static readonly CHILD = 202;
+    public static readonly CHOOSE = 203;
+    public static readonly CHR = 204;
+    public static readonly CHUNK = 205;
+    public static readonly CLASS = 206;
+    public static readonly CLASSIFICATION = 207;
+    public static readonly CLASSIFIER = 208;
+    public static readonly CLAUSE = 209;
+    public static readonly CLEAN = 210;
+    public static readonly CLEANUP = 211;
+    public static readonly CLEAR = 212;
+    public static readonly C_LETTER = 213;
+    public static readonly CLIENT = 214;
+    public static readonly CLOB = 215;
+    public static readonly CLONE = 216;
+    public static readonly CLOSE_CACHED_OPEN_CURSORS = 217;
+    public static readonly CLOSE = 218;
+    public static readonly CLUSTER_BY_ROWID = 219;
+    public static readonly CLUSTER = 220;
+    public static readonly CLUSTER_DETAILS = 221;
+    public static readonly CLUSTER_DISTANCE = 222;
+    public static readonly CLUSTER_ID = 223;
+    public static readonly CLUSTERING = 224;
+    public static readonly CLUSTERING_FACTOR = 225;
+    public static readonly CLUSTER_PROBABILITY = 226;
+    public static readonly CLUSTER_SET = 227;
+    public static readonly COALESCE = 228;
+    public static readonly COALESCE_SQ = 229;
+    public static readonly COARSE = 230;
+    public static readonly CO_AUTH_IND = 231;
+    public static readonly COLD = 232;
+    public static readonly COLLECT = 233;
+    public static readonly COLLECTION = 234;
+    public static readonly COLUMNAR = 235;
+    public static readonly COLUMN_AUTH_INDICATOR = 236;
+    public static readonly COLUMN = 237;
+    public static readonly COLUMNS = 238;
+    public static readonly COLUMN_STATS = 239;
+    public static readonly COLUMN_VALUE = 240;
+    public static readonly COMMENT = 241;
+    public static readonly COMMIT = 242;
+    public static readonly COMMITTED = 243;
+    public static readonly COMMON = 244;
+    public static readonly COMMON_DATA = 245;
+    public static readonly COMPACT = 246;
+    public static readonly COMPATIBLE = 247;
+    public static readonly COMPATIBILITY = 248;
+    public static readonly COMPILE = 249;
+    public static readonly COMPLETE = 250;
+    public static readonly COMPLIANCE = 251;
+    public static readonly COMPONENT = 252;
+    public static readonly COMPONENTS = 253;
+    public static readonly COMPOSE = 254;
+    public static readonly COMPOSITE = 255;
+    public static readonly COMPOSITE_LIMIT = 256;
+    public static readonly COMPOUND = 257;
+    public static readonly COMPRESS = 258;
+    public static readonly COMPRESSION = 259;
+    public static readonly COMPUTE = 260;
+    public static readonly COMPUTATION = 261;
+    public static readonly CONCAT = 262;
+    public static readonly CONCURRENT = 263;
+    public static readonly CON_DBID_TO_ID = 264;
+    public static readonly CONDITIONAL = 265;
+    public static readonly CONDITION = 266;
+    public static readonly CONFIRM = 267;
+    public static readonly CONFORMING = 268;
+    public static readonly CON_GUID_TO_ID = 269;
+    public static readonly CON_ID = 270;
+    public static readonly CON_NAME_TO_ID = 271;
+    public static readonly CONNECT_BY_CB_WHR_ONLY = 272;
+    public static readonly CONNECT_BY_COMBINE_SW = 273;
+    public static readonly CONNECT_BY_COST_BASED = 274;
+    public static readonly CONNECT_BY_ELIM_DUPS = 275;
+    public static readonly CONNECT_BY_FILTERING = 276;
+    public static readonly CONNECT_BY_ISCYCLE = 277;
+    public static readonly CONNECT_BY_ISLEAF = 278;
+    public static readonly CONNECT_BY_ROOT = 279;
+    public static readonly CONNECT = 280;
+    public static readonly CONNECT_TIME = 281;
+    public static readonly CONSIDER = 282;
+    public static readonly CONSISTENT = 283;
+    public static readonly CONSTANT = 284;
+    public static readonly CONST = 285;
+    public static readonly CONSTRAINT = 286;
+    public static readonly CONSTRAINTS = 287;
+    public static readonly CONSTRUCTOR = 288;
+    public static readonly CONTAINER = 289;
+    public static readonly CONTAINERS = 290;
+    public static readonly CONTAINERS_DEFAULT = 291;
+    public static readonly CONTAINER_DATA = 292;
+    public static readonly CONTAINER_MAP = 293;
+    public static readonly CONTENT = 294;
+    public static readonly CONTENTS = 295;
+    public static readonly CONTEXT = 296;
+    public static readonly CONTINUE = 297;
+    public static readonly CONTROLFILE = 298;
+    public static readonly CON_UID_TO_ID = 299;
+    public static readonly CONVERT = 300;
+    public static readonly CONVERSION = 301;
+    public static readonly COOKIE = 302;
+    public static readonly COPY = 303;
+    public static readonly CORR_K = 304;
+    public static readonly CORR_S = 305;
+    public static readonly CORRUPTION = 306;
+    public static readonly CORRUPT_XID_ALL = 307;
+    public static readonly CORRUPT_XID = 308;
+    public static readonly COS = 309;
+    public static readonly COSH = 310;
+    public static readonly COST = 311;
+    public static readonly COST_XML_QUERY_REWRITE = 312;
+    public static readonly COUNT = 313;
+    public static readonly COUNTED = 314;
+    public static readonly COVAR_POP = 315;
+    public static readonly COVAR_SAMP = 316;
+    public static readonly CPU_COSTING = 317;
+    public static readonly CPU_PER_CALL = 318;
+    public static readonly CPU_PER_SESSION = 319;
+    public static readonly CRASH = 320;
+    public static readonly CREATE = 321;
+    public static readonly CREATE_FILE_DEST = 322;
+    public static readonly CREATE_STORED_OUTLINES = 323;
+    public static readonly CREATION = 324;
+    public static readonly CREDENTIAL = 325;
+    public static readonly CRITICAL = 326;
+    public static readonly CROSS = 327;
+    public static readonly CROSSEDITION = 328;
+    public static readonly CSCONVERT = 329;
+    public static readonly CSV = 330;
+    public static readonly CUBE_AJ = 331;
+    public static readonly CUBE = 332;
+    public static readonly CUBE_GB = 333;
+    public static readonly CUBE_SJ = 334;
+    public static readonly CUME_DISTM = 335;
+    public static readonly CURRENT = 336;
+    public static readonly CURRENT_DATE = 337;
+    public static readonly CURRENT_SCHEMA = 338;
+    public static readonly CURRENT_TIME = 339;
+    public static readonly CURRENT_TIMESTAMP = 340;
+    public static readonly CURRENT_USER = 341;
+    public static readonly CURRENTV = 342;
+    public static readonly CURSOR = 343;
+    public static readonly CURSOR_SHARING_EXACT = 344;
+    public static readonly CURSOR_SPECIFIC_SEGMENT = 345;
+    public static readonly CUSTOMDATUM = 346;
+    public static readonly CV = 347;
+    public static readonly CYCLE = 348;
+    public static readonly DANGLING = 349;
+    public static readonly DATABASE = 350;
+    public static readonly DATA = 351;
+    public static readonly DATAFILE = 352;
+    public static readonly DATAFILES = 353;
+    public static readonly DATAGUARDCONFIG = 354;
+    public static readonly DATAMOVEMENT = 355;
+    public static readonly DATAOBJNO = 356;
+    public static readonly DATAOBJ_TO_MAT_PARTITION = 357;
+    public static readonly DATAOBJ_TO_PARTITION = 358;
+    public static readonly DATAPUMP = 359;
+    public static readonly DATA_SECURITY_REWRITE_LIMIT = 360;
+    public static readonly DATE = 361;
+    public static readonly DATE_CACHE = 362;
+    public static readonly DATE_FORMAT = 363;
+    public static readonly DATE_MODE = 364;
+    public static readonly DAY = 365;
+    public static readonly DAYS = 366;
+    public static readonly DAY_TO_SECOND = 367;
+    public static readonly DBA = 368;
+    public static readonly DBA_RECYCLEBIN = 369;
+    public static readonly DBLINK = 370;
+    public static readonly DBMS_STATS = 371;
+    public static readonly DB_ROLE_CHANGE = 372;
+    public static readonly DBTIMEZONE = 373;
+    public static readonly DB_UNIQUE_NAME = 374;
+    public static readonly DB_VERSION = 375;
+    public static readonly DDL = 376;
+    public static readonly DEALLOCATE = 377;
+    public static readonly DEBUG = 378;
+    public static readonly DEBUGGER = 379;
+    public static readonly DEC = 380;
+    public static readonly DECIMAL = 381;
+    public static readonly DECLARE = 382;
+    public static readonly DECOMPOSE = 383;
+    public static readonly DECORRELATE = 384;
+    public static readonly DECR = 385;
+    public static readonly DECREMENT = 386;
+    public static readonly DECRYPT = 387;
+    public static readonly DEDUPLICATE = 388;
+    public static readonly DEFAULT = 389;
+    public static readonly DEFAULTIF = 390;
+    public static readonly DEFAULTS = 391;
+    public static readonly DEFAULT_COLLATION = 392;
+    public static readonly DEFAULT_CREDENTIAL = 393;
+    public static readonly DEFERRABLE = 394;
+    public static readonly DEFERRED = 395;
+    public static readonly DEFINED = 396;
+    public static readonly DEFINE = 397;
+    public static readonly DEFINER = 398;
+    public static readonly DEGREE = 399;
+    public static readonly DELAY = 400;
+    public static readonly DELEGATE = 401;
+    public static readonly DELETE_ALL = 402;
+    public static readonly DELETE = 403;
+    public static readonly DELETEXML = 404;
+    public static readonly DELIMITED = 405;
+    public static readonly DEMAND = 406;
+    public static readonly DENSE_RANKM = 407;
+    public static readonly DEPENDENT = 408;
+    public static readonly DEPRECATE = 409;
+    public static readonly DEPTH = 410;
+    public static readonly DEQUEUE = 411;
+    public static readonly DEREF = 412;
+    public static readonly DEREF_NO_REWRITE = 413;
+    public static readonly DESC = 414;
+    public static readonly DESCRIPTION = 415;
+    public static readonly DESTROY = 416;
+    public static readonly DETACHED = 417;
+    public static readonly DETECTED = 418;
+    public static readonly DETERMINES = 419;
+    public static readonly DETERMINISTIC = 420;
+    public static readonly DICTIONARY = 421;
+    public static readonly DIMENSION = 422;
+    public static readonly DIMENSIONS = 423;
+    public static readonly DIRECTIO = 424;
+    public static readonly DIRECT_LOAD = 425;
+    public static readonly DIRECTORY = 426;
+    public static readonly DIRECT_PATH = 427;
+    public static readonly DISABLE_ALL = 428;
+    public static readonly DISABLE = 429;
+    public static readonly DISABLED = 430;
+    public static readonly DISABLE_DIRECTORY_LINK_CHECK = 431;
+    public static readonly DISABLE_PARALLEL_DML = 432;
+    public static readonly DISABLE_PRESET = 433;
+    public static readonly DISABLE_RPKE = 434;
+    public static readonly DISALLOW = 435;
+    public static readonly DISASSOCIATE = 436;
+    public static readonly DISCARD = 437;
+    public static readonly DISCARDFILE = 438;
+    public static readonly DISCONNECT = 439;
+    public static readonly DISK = 440;
+    public static readonly DISKGROUP = 441;
+    public static readonly DISKGROUP_PLUS = 442;
+    public static readonly DISKS = 443;
+    public static readonly DISMOUNT = 444;
+    public static readonly DISTINCT = 445;
+    public static readonly DISTINGUISHED = 446;
+    public static readonly DISTRIBUTED = 447;
+    public static readonly DISTRIBUTE = 448;
+    public static readonly DML = 449;
+    public static readonly DML_UPDATE = 450;
+    public static readonly DNFS_DISABLE = 451;
+    public static readonly DNFS_ENABLE = 452;
+    public static readonly DNFS_READBUFFERS = 453;
+    public static readonly DOCFIDELITY = 454;
+    public static readonly DOCUMENT = 455;
+    public static readonly DOLLAR_ELSE = 456;
+    public static readonly DOLLAR_ELSIF = 457;
+    public static readonly DOLLAR_END = 458;
+    public static readonly DOLLAR_ERROR = 459;
+    public static readonly DOLLAR_IF = 460;
+    public static readonly DOLLAR_THEN = 461;
+    public static readonly DOMAIN_INDEX_FILTER = 462;
+    public static readonly DOMAIN_INDEX_NO_SORT = 463;
+    public static readonly DOMAIN_INDEX_SORT = 464;
+    public static readonly DOUBLE = 465;
+    public static readonly DOWNGRADE = 466;
+    public static readonly DRIVING_SITE = 467;
+    public static readonly DROP_COLUMN = 468;
+    public static readonly DROP = 469;
+    public static readonly DROP_GROUP = 470;
+    public static readonly DSINTERVAL_UNCONSTRAINED = 471;
+    public static readonly DST_UPGRADE_INSERT_CONV = 472;
+    public static readonly DUMP = 473;
+    public static readonly DUMPSET = 474;
+    public static readonly DUPLICATE = 475;
+    public static readonly DV = 476;
+    public static readonly DYNAMIC = 477;
+    public static readonly DYNAMIC_SAMPLING = 478;
+    public static readonly DYNAMIC_SAMPLING_EST_CDN = 479;
+    public static readonly E_LETTER = 480;
+    public static readonly EACH = 481;
+    public static readonly EDITIONABLE = 482;
+    public static readonly EDITION = 483;
+    public static readonly EDITIONING = 484;
+    public static readonly EDITIONS = 485;
+    public static readonly ELEMENT = 486;
+    public static readonly ELIM_GROUPBY = 487;
+    public static readonly ELIMINATE_JOIN = 488;
+    public static readonly ELIMINATE_OBY = 489;
+    public static readonly ELIMINATE_OUTER_JOIN = 490;
+    public static readonly ELSE = 491;
+    public static readonly ELSIF = 492;
+    public static readonly EM = 493;
+    public static readonly EMBEDDED = 494;
+    public static readonly EMPTY_BLOB = 495;
+    public static readonly EMPTY_CLOB = 496;
+    public static readonly EMPTY_ = 497;
+    public static readonly ENABLE_ALL = 498;
+    public static readonly ENABLE = 499;
+    public static readonly ENABLED = 500;
+    public static readonly ENABLE_PARALLEL_DML = 501;
+    public static readonly ENABLE_PRESET = 502;
+    public static readonly ENCLOSED = 503;
+    public static readonly ENCODING = 504;
+    public static readonly ENCRYPT = 505;
+    public static readonly ENCRYPTION = 506;
+    public static readonly ENCRYPTPASSWORDISNULL = 507;
+    public static readonly END = 508;
+    public static readonly END_OUTLINE_DATA = 509;
+    public static readonly ENDIAN = 510;
+    public static readonly ENFORCED = 511;
+    public static readonly ENFORCE = 512;
+    public static readonly ENQUEUE = 513;
+    public static readonly ENTERPRISE = 514;
+    public static readonly ENTITYESCAPING = 515;
+    public static readonly ENTRY = 516;
+    public static readonly EQUIPART = 517;
+    public static readonly ERR = 518;
+    public static readonly ERROR_ARGUMENT = 519;
+    public static readonly ERROR = 520;
+    public static readonly ERROR_ON_OVERLAP_TIME = 521;
+    public static readonly ERRORS = 522;
+    public static readonly ERROR_INDEX = 523;
+    public static readonly ERROR_CODE = 524;
+    public static readonly ESCAPE = 525;
+    public static readonly ESCAPED = 526;
+    public static readonly ESTIMATE = 527;
+    public static readonly EVAL = 528;
+    public static readonly EVALNAME = 529;
+    public static readonly EVALUATE = 530;
+    public static readonly EVALUATION = 531;
+    public static readonly EVENTS = 532;
+    public static readonly EVERY = 533;
+    public static readonly EXCEPT = 534;
+    public static readonly EXCEPTION = 535;
+    public static readonly EXCEPTION_INIT = 536;
+    public static readonly EXCEPTIONS = 537;
+    public static readonly EXCHANGE = 538;
+    public static readonly EXCLUDE = 539;
+    public static readonly EXCLUDING = 540;
+    public static readonly EXCLUSIVE = 541;
+    public static readonly EXEC = 542;
+    public static readonly EXECUTE = 543;
+    public static readonly EXEMPT = 544;
+    public static readonly EXISTING = 545;
+    public static readonly EXISTS = 546;
+    public static readonly EXISTSNODE = 547;
+    public static readonly EXIT = 548;
+    public static readonly EXPAND_GSET_TO_UNION = 549;
+    public static readonly EXPAND_TABLE = 550;
+    public static readonly EXP = 551;
+    public static readonly EXPIRE = 552;
+    public static readonly EXPLAIN = 553;
+    public static readonly EXPLOSION = 554;
+    public static readonly EXPORT = 555;
+    public static readonly EXPR_CORR_CHECK = 556;
+    public static readonly EXPRESS = 557;
+    public static readonly EXTENDS = 558;
+    public static readonly EXTENT = 559;
+    public static readonly EXTENTS = 560;
+    public static readonly EXTERNAL = 561;
+    public static readonly EXTERNALLY = 562;
+    public static readonly EXTRACTCLOBXML = 563;
+    public static readonly EXTRACT = 564;
+    public static readonly EXTRACTVALUE = 565;
+    public static readonly EXTRA = 566;
+    public static readonly FACILITY = 567;
+    public static readonly FACT = 568;
+    public static readonly FACTOR = 569;
+    public static readonly FACTORIZE_JOIN = 570;
+    public static readonly FAILED = 571;
+    public static readonly FAILED_LOGIN_ATTEMPTS = 572;
+    public static readonly FAILGROUP = 573;
+    public static readonly FAILOVER = 574;
+    public static readonly FAILURE = 575;
+    public static readonly FALSE = 576;
+    public static readonly FAMILY = 577;
+    public static readonly FAR = 578;
+    public static readonly FAST = 579;
+    public static readonly FASTSTART = 580;
+    public static readonly FBTSCAN = 581;
+    public static readonly FEATURE = 582;
+    public static readonly FEATURE_DETAILS = 583;
+    public static readonly FEATURE_ID = 584;
+    public static readonly FEATURE_SET = 585;
+    public static readonly FEATURE_VALUE = 586;
+    public static readonly FETCH = 587;
+    public static readonly FIELD = 588;
+    public static readonly FIELDS = 589;
+    public static readonly FILE = 590;
+    public static readonly FILE_NAME_CONVERT = 591;
+    public static readonly FILEGROUP = 592;
+    public static readonly FILESTORE = 593;
+    public static readonly FILESYSTEM_LIKE_LOGGING = 594;
+    public static readonly FILTER = 595;
+    public static readonly FINAL = 596;
+    public static readonly FINE = 597;
+    public static readonly FINISH = 598;
+    public static readonly FIRST = 599;
+    public static readonly FIRSTM = 600;
+    public static readonly FIRST_ROWS = 601;
+    public static readonly FIRST_VALUE = 602;
+    public static readonly FIXED = 603;
+    public static readonly FIXED_VIEW_DATA = 604;
+    public static readonly FLAGGER = 605;
+    public static readonly FLASHBACK = 606;
+    public static readonly FLASH_CACHE = 607;
+    public static readonly FLOAT = 608;
+    public static readonly FLOB = 609;
+    public static readonly FLEX = 610;
+    public static readonly FLOOR = 611;
+    public static readonly FLUSH = 612;
+    public static readonly FOLDER = 613;
+    public static readonly FOLLOWING = 614;
+    public static readonly FOLLOWS = 615;
+    public static readonly FORALL = 616;
+    public static readonly FORCE = 617;
+    public static readonly FORCE_XML_QUERY_REWRITE = 618;
+    public static readonly FOREIGN = 619;
+    public static readonly FOREVER = 620;
+    public static readonly FOR = 621;
+    public static readonly FORMAT = 622;
+    public static readonly FORWARD = 623;
+    public static readonly FRAGMENT_NUMBER = 624;
+    public static readonly FREELIST = 625;
+    public static readonly FREELISTS = 626;
+    public static readonly FREEPOOLS = 627;
+    public static readonly FRESH = 628;
+    public static readonly FROM = 629;
+    public static readonly FROM_TZ = 630;
+    public static readonly FULL = 631;
+    public static readonly FULL_OUTER_JOIN_TO_OUTER = 632;
+    public static readonly FUNCTION = 633;
+    public static readonly FUNCTIONS = 634;
+    public static readonly FTP = 635;
+    public static readonly G_LETTER = 636;
+    public static readonly GATHER_OPTIMIZER_STATISTICS = 637;
+    public static readonly GATHER_PLAN_STATISTICS = 638;
+    public static readonly GBY_CONC_ROLLUP = 639;
+    public static readonly GBY_PUSHDOWN = 640;
+    public static readonly GENERATED = 641;
+    public static readonly GET = 642;
+    public static readonly GLOBAL = 643;
+    public static readonly GLOBALLY = 644;
+    public static readonly GLOBAL_NAME = 645;
+    public static readonly GLOBAL_TOPIC_ENABLED = 646;
+    public static readonly GOTO = 647;
+    public static readonly GRANT = 648;
+    public static readonly GROUP_BY = 649;
+    public static readonly GROUP = 650;
+    public static readonly GROUP_ID = 651;
+    public static readonly GROUPING = 652;
+    public static readonly GROUPING_ID = 653;
+    public static readonly GROUPS = 654;
+    public static readonly GUARANTEED = 655;
+    public static readonly GUARANTEE = 656;
+    public static readonly GUARD = 657;
+    public static readonly HADOOP_TRAILERS = 658;
+    public static readonly HALF_YEARS = 659;
+    public static readonly HASH_AJ = 660;
+    public static readonly HASH = 661;
+    public static readonly HASHKEYS = 662;
+    public static readonly HASH_SJ = 663;
+    public static readonly HAVING = 664;
+    public static readonly HEADER = 665;
+    public static readonly HEAP = 666;
+    public static readonly HELP = 667;
+    public static readonly HEXTORAW = 668;
+    public static readonly HEXTOREF = 669;
+    public static readonly HIDDEN_KEYWORD = 670;
+    public static readonly HIDE = 671;
+    public static readonly HIER_ORDER = 672;
+    public static readonly HIERARCHICAL = 673;
+    public static readonly HIERARCHIES = 674;
+    public static readonly HIERARCHY = 675;
+    public static readonly HIGH = 676;
+    public static readonly HINTSET_BEGIN = 677;
+    public static readonly HINTSET_END = 678;
+    public static readonly HOT = 679;
+    public static readonly HOUR = 680;
+    public static readonly HOURS = 681;
+    public static readonly HTTP = 682;
+    public static readonly HWM_BROKERED = 683;
+    public static readonly HYBRID = 684;
+    public static readonly H_LETTER = 685;
+    public static readonly IDENTIFIED = 686;
+    public static readonly IDENTIFIER = 687;
+    public static readonly IDENTITY = 688;
+    public static readonly IDGENERATORS = 689;
+    public static readonly ID = 690;
+    public static readonly IDLE_TIME = 691;
+    public static readonly IF = 692;
+    public static readonly IGNORE = 693;
+    public static readonly IGNORE_CHARS_AFTER_EOR = 694;
+    public static readonly IGNORE_OPTIM_EMBEDDED_HINTS = 695;
+    public static readonly IGNORE_ROW_ON_DUPKEY_INDEX = 696;
+    public static readonly IGNORE_WHERE_CLAUSE = 697;
+    public static readonly ILM = 698;
+    public static readonly IMMEDIATE = 699;
+    public static readonly IMPACT = 700;
+    public static readonly IMPORT = 701;
+    public static readonly INACTIVE = 702;
+    public static readonly INACTIVE_ACCOUNT_TIME = 703;
+    public static readonly INCLUDE = 704;
+    public static readonly INCLUDE_VERSION = 705;
+    public static readonly INCLUDING = 706;
+    public static readonly INCREMENTAL = 707;
+    public static readonly INCREMENT = 708;
+    public static readonly INCR = 709;
+    public static readonly INDENT = 710;
+    public static readonly INDEX_ASC = 711;
+    public static readonly INDEX_COMBINE = 712;
+    public static readonly INDEX_DESC = 713;
+    public static readonly INDEXED = 714;
+    public static readonly INDEXES = 715;
+    public static readonly INDEX_FFS = 716;
+    public static readonly INDEX_FILTER = 717;
+    public static readonly INDEX = 718;
+    public static readonly INDEXING = 719;
+    public static readonly INDEX_JOIN = 720;
+    public static readonly INDEX_ROWS = 721;
+    public static readonly INDEX_RRS = 722;
+    public static readonly INDEX_RS_ASC = 723;
+    public static readonly INDEX_RS_DESC = 724;
+    public static readonly INDEX_RS = 725;
+    public static readonly INDEX_SCAN = 726;
+    public static readonly INDEX_SKIP_SCAN = 727;
+    public static readonly INDEX_SS_ASC = 728;
+    public static readonly INDEX_SS_DESC = 729;
+    public static readonly INDEX_SS = 730;
+    public static readonly INDEX_STATS = 731;
+    public static readonly INDEXTYPE = 732;
+    public static readonly INDEXTYPES = 733;
+    public static readonly INDICATOR = 734;
+    public static readonly INDICES = 735;
+    public static readonly INFINITE = 736;
+    public static readonly INFORMATIONAL = 737;
+    public static readonly INHERIT = 738;
+    public static readonly IN = 739;
+    public static readonly INITCAP = 740;
+    public static readonly INITIAL = 741;
+    public static readonly INITIALIZED = 742;
+    public static readonly INITIALLY = 743;
+    public static readonly INITRANS = 744;
+    public static readonly INLINE = 745;
+    public static readonly INLINE_XMLTYPE_NT = 746;
+    public static readonly INMEMORY = 747;
+    public static readonly IN_MEMORY_METADATA = 748;
+    public static readonly INMEMORY_PRUNING = 749;
+    public static readonly INNER = 750;
+    public static readonly INOUT = 751;
+    public static readonly INPLACE = 752;
+    public static readonly INPUTFORMAT = 753;
+    public static readonly INSERTCHILDXMLAFTER = 754;
+    public static readonly INSERTCHILDXMLBEFORE = 755;
+    public static readonly INSERTCHILDXML = 756;
+    public static readonly INSERT = 757;
+    public static readonly INSERTXMLAFTER = 758;
+    public static readonly INSERTXMLBEFORE = 759;
+    public static readonly INSTANCE = 760;
+    public static readonly INSTANCES = 761;
+    public static readonly INSTANTIABLE = 762;
+    public static readonly INSTANTLY = 763;
+    public static readonly INSTEAD = 764;
+    public static readonly INSTR2 = 765;
+    public static readonly INSTR4 = 766;
+    public static readonly INSTRB = 767;
+    public static readonly INSTRC = 768;
+    public static readonly INSTR = 769;
+    public static readonly INTEGER = 770;
+    public static readonly INTERLEAVED = 771;
+    public static readonly INTERMEDIATE = 772;
+    public static readonly INTERNAL_CONVERT = 773;
+    public static readonly INTERNAL_USE = 774;
+    public static readonly INTERPRETED = 775;
+    public static readonly INTERSECT = 776;
+    public static readonly INTERVAL = 777;
+    public static readonly INT = 778;
+    public static readonly INTERNAL = 779;
+    public static readonly INTO = 780;
+    public static readonly INVALIDATE = 781;
+    public static readonly INVALIDATION = 782;
+    public static readonly INVISIBLE = 783;
+    public static readonly IN_XQUERY = 784;
+    public static readonly IO_OPTIONS = 785;
+    public static readonly IS = 786;
+    public static readonly IS_LEAF = 787;
+    public static readonly ISOLATION = 788;
+    public static readonly ISOLATION_LEVEL = 789;
+    public static readonly ITEMS = 790;
+    public static readonly ITERATE = 791;
+    public static readonly ITERATION_NUMBER = 792;
+    public static readonly JAVA = 793;
+    public static readonly JOB = 794;
+    public static readonly JOIN = 795;
+    public static readonly JSON_ARRAYAGG = 796;
+    public static readonly JSON_ARRAY = 797;
+    public static readonly JSON_EQUAL = 798;
+    public static readonly JSON_EXISTS2 = 799;
+    public static readonly JSON_EXISTS = 800;
+    public static readonly JSONGET = 801;
+    public static readonly JSON = 802;
+    public static readonly JSON_OBJECTAGG = 803;
+    public static readonly JSON_OBJECT = 804;
+    public static readonly JSONPARSE = 805;
+    public static readonly JSON_QUERY = 806;
+    public static readonly JSON_SERIALIZE = 807;
+    public static readonly JSON_TABLE = 808;
+    public static readonly JSON_TEXTCONTAINS2 = 809;
+    public static readonly JSON_TEXTCONTAINS = 810;
+    public static readonly JSON_TRANSFORM = 811;
+    public static readonly JSON_VALUE = 812;
+    public static readonly K_LETTER = 813;
+    public static readonly KEEP_DUPLICATES = 814;
+    public static readonly KEEP = 815;
+    public static readonly KERBEROS = 816;
+    public static readonly KEY = 817;
+    public static readonly KEY_LENGTH = 818;
+    public static readonly KEYSIZE = 819;
+    public static readonly KEYS = 820;
+    public static readonly KEYSTORE = 821;
+    public static readonly KILL = 822;
+    public static readonly LABEL = 823;
+    public static readonly LANGUAGE = 824;
+    public static readonly LAST_DAY = 825;
+    public static readonly LAST = 826;
+    public static readonly LAST_VALUE = 827;
+    public static readonly LATERAL = 828;
+    public static readonly LATEST = 829;
+    public static readonly LAX = 830;
+    public static readonly LAYER = 831;
+    public static readonly LDAP_REGISTRATION_ENABLED = 832;
+    public static readonly LDAP_REGISTRATION = 833;
+    public static readonly LDAP_REG_SYNC_INTERVAL = 834;
+    public static readonly LDRTRIM = 835;
+    public static readonly LEAF = 836;
+    public static readonly LEAD_CDB = 837;
+    public static readonly LEAD_CDB_URI = 838;
+    public static readonly LEADING = 839;
+    public static readonly LEFT = 840;
+    public static readonly LENGTH2 = 841;
+    public static readonly LENGTH4 = 842;
+    public static readonly LENGTHB = 843;
+    public static readonly LENGTHC = 844;
+    public static readonly LENGTH = 845;
+    public static readonly LESS = 846;
+    public static readonly LEVEL = 847;
+    public static readonly LEVEL_NAME = 848;
+    public static readonly LEVELS = 849;
+    public static readonly LIBRARY = 850;
+    public static readonly LIFECYCLE = 851;
+    public static readonly LIFE = 852;
+    public static readonly LIFETIME = 853;
+    public static readonly LIKE2 = 854;
+    public static readonly LIKE4 = 855;
+    public static readonly LIKEC = 856;
+    public static readonly LIKE_EXPAND = 857;
+    public static readonly LIKE = 858;
+    public static readonly LIMIT = 859;
+    public static readonly LINEAR = 860;
+    public static readonly LINES = 861;
+    public static readonly LINK = 862;
+    public static readonly LIST = 863;
+    public static readonly LITTLE = 864;
+    public static readonly LLS = 865;
+    public static readonly LN = 866;
+    public static readonly LNNVL = 867;
+    public static readonly LOAD = 868;
+    public static readonly LOB = 869;
+    public static readonly LOBFILE = 870;
+    public static readonly LOBNVL = 871;
+    public static readonly LOBS = 872;
+    public static readonly LOCAL_INDEXES = 873;
+    public static readonly LOCAL = 874;
+    public static readonly LOCALTIME = 875;
+    public static readonly LOCALTIMESTAMP = 876;
+    public static readonly LOCATION = 877;
+    public static readonly LOCATOR = 878;
+    public static readonly LOCKDOWN = 879;
+    public static readonly LOCKED = 880;
+    public static readonly LOCKING = 881;
+    public static readonly LOCK = 882;
+    public static readonly LOGFILE = 883;
+    public static readonly LOGFILES = 884;
+    public static readonly LOGGING = 885;
+    public static readonly LOGICAL = 886;
+    public static readonly LOGICAL_READS_PER_CALL = 887;
+    public static readonly LOGICAL_READS_PER_SESSION = 888;
+    public static readonly LOG = 889;
+    public static readonly LOGMINING = 890;
+    public static readonly LOGOFF = 891;
+    public static readonly LOGON = 892;
+    public static readonly LOG_READ_ONLY_VIOLATIONS = 893;
+    public static readonly LONG = 894;
+    public static readonly LOOP = 895;
+    public static readonly LOST = 896;
+    public static readonly LOWER = 897;
+    public static readonly LOW = 898;
+    public static readonly LPAD = 899;
+    public static readonly LRTRIM = 900;
+    public static readonly LTRIM = 901;
+    public static readonly M_LETTER = 902;
+    public static readonly MAIN = 903;
+    public static readonly MAKE_REF = 904;
+    public static readonly MANAGED = 905;
+    public static readonly MANAGE = 906;
+    public static readonly MANAGEMENT = 907;
+    public static readonly MANAGER = 908;
+    public static readonly MANDATORY = 909;
+    public static readonly MANUAL = 910;
+    public static readonly MAP = 911;
+    public static readonly MAPPING = 912;
+    public static readonly MASK = 913;
+    public static readonly MASTER = 914;
+    public static readonly MATCHED = 915;
+    public static readonly MATCHES = 916;
+    public static readonly MATCH = 917;
+    public static readonly MATCH_NUMBER = 918;
+    public static readonly MATCH_RECOGNIZE = 919;
+    public static readonly MATERIALIZED = 920;
+    public static readonly MATERIALIZE = 921;
+    public static readonly MAXARCHLOGS = 922;
+    public static readonly MAXDATAFILES = 923;
+    public static readonly MAXEXTENTS = 924;
+    public static readonly MAXIMIZE = 925;
+    public static readonly MAXINSTANCES = 926;
+    public static readonly MAXLOGFILES = 927;
+    public static readonly MAXLOGHISTORY = 928;
+    public static readonly MAXLOGMEMBERS = 929;
+    public static readonly MAX_SHARED_TEMP_SIZE = 930;
+    public static readonly MAXSIZE = 931;
+    public static readonly MAXTRANS = 932;
+    public static readonly MAXVALUE = 933;
+    public static readonly MEASURE = 934;
+    public static readonly MEASURES = 935;
+    public static readonly MEDIUM = 936;
+    public static readonly MEMBER = 937;
+    public static readonly MEMBER_CAPTION = 938;
+    public static readonly MEMBER_DESCRIPTION = 939;
+    public static readonly MEMBER_NAME = 940;
+    public static readonly MEMBER_UNIQUE_NAME = 941;
+    public static readonly MEMCOMPRESS = 942;
+    public static readonly MEMORY = 943;
+    public static readonly MERGEACTIONS = 944;
+    public static readonly MERGE_AJ = 945;
+    public static readonly MERGE_CONST_ON = 946;
+    public static readonly MERGE = 947;
+    public static readonly MERGE_SJ = 948;
+    public static readonly METADATA = 949;
+    public static readonly METHOD = 950;
+    public static readonly MIGRATE = 951;
+    public static readonly MIGRATION = 952;
+    public static readonly MINEXTENTS = 953;
+    public static readonly MINIMIZE = 954;
+    public static readonly MINIMUM = 955;
+    public static readonly MINING = 956;
+    public static readonly MINUS = 957;
+    public static readonly MINUS_NULL = 958;
+    public static readonly MINUTE = 959;
+    public static readonly MINUTES = 960;
+    public static readonly MINVALUE = 961;
+    public static readonly MIRRORCOLD = 962;
+    public static readonly MIRRORHOT = 963;
+    public static readonly MIRROR = 964;
+    public static readonly MISSING = 965;
+    public static readonly MISMATCH = 966;
+    public static readonly MLSLABEL = 967;
+    public static readonly MODEL_COMPILE_SUBQUERY = 968;
+    public static readonly MODEL_DONTVERIFY_UNIQUENESS = 969;
+    public static readonly MODEL_DYNAMIC_SUBQUERY = 970;
+    public static readonly MODEL_MIN_ANALYSIS = 971;
+    public static readonly MODEL = 972;
+    public static readonly MODEL_NB = 973;
+    public static readonly MODEL_NO_ANALYSIS = 974;
+    public static readonly MODEL_PBY = 975;
+    public static readonly MODEL_PUSH_REF = 976;
+    public static readonly MODEL_SV = 977;
+    public static readonly MODE = 978;
+    public static readonly MODIFICATION = 979;
+    public static readonly MODIFY_COLUMN_TYPE = 980;
+    public static readonly MODIFY = 981;
+    public static readonly MOD = 982;
+    public static readonly MODULE = 983;
+    public static readonly MONITORING = 984;
+    public static readonly MONITOR = 985;
+    public static readonly MONTH = 986;
+    public static readonly MONTHS_BETWEEN = 987;
+    public static readonly MONTHS = 988;
+    public static readonly MOUNT = 989;
+    public static readonly MOUNTPATH = 990;
+    public static readonly MOUNTPOINT = 991;
+    public static readonly MOVEMENT = 992;
+    public static readonly MOVE = 993;
+    public static readonly MULTIDIMENSIONAL = 994;
+    public static readonly MULTISET = 995;
+    public static readonly MV_MERGE = 996;
+    public static readonly NAMED = 997;
+    public static readonly NAME = 998;
+    public static readonly NAMESPACE = 999;
+    public static readonly NAN_ = 1000;
+    public static readonly NANVL = 1001;
+    public static readonly NATIONAL = 1002;
+    public static readonly NATIVE_FULL_OUTER_JOIN = 1003;
+    public static readonly NATIVE = 1004;
+    public static readonly NATURAL = 1005;
+    public static readonly NATURALN = 1006;
+    public static readonly NAV = 1007;
+    public static readonly NCHAR_CS = 1008;
+    public static readonly NCHAR = 1009;
+    public static readonly NCHR = 1010;
+    public static readonly NCLOB = 1011;
+    public static readonly NEEDED = 1012;
+    public static readonly NEG = 1013;
+    public static readonly NESTED = 1014;
+    public static readonly NESTED_TABLE_FAST_INSERT = 1015;
+    public static readonly NESTED_TABLE_GET_REFS = 1016;
+    public static readonly NESTED_TABLE_ID = 1017;
+    public static readonly NESTED_TABLE_SET_REFS = 1018;
+    public static readonly NESTED_TABLE_SET_SETID = 1019;
+    public static readonly NETWORK = 1020;
+    public static readonly NEVER = 1021;
+    public static readonly NEW = 1022;
+    public static readonly NEWLINE_ = 1023;
+    public static readonly NEW_TIME = 1024;
+    public static readonly NEXT_DAY = 1025;
+    public static readonly NEXT = 1026;
+    public static readonly NL_AJ = 1027;
+    public static readonly NLJ_BATCHING = 1028;
+    public static readonly NLJ_INDEX_FILTER = 1029;
+    public static readonly NLJ_INDEX_SCAN = 1030;
+    public static readonly NLJ_PREFETCH = 1031;
+    public static readonly NLS_CALENDAR = 1032;
+    public static readonly NLS_CHARACTERSET = 1033;
+    public static readonly NLS_CHARSET_DECL_LEN = 1034;
+    public static readonly NLS_CHARSET_ID = 1035;
+    public static readonly NLS_CHARSET_NAME = 1036;
+    public static readonly NLS_COMP = 1037;
+    public static readonly NLS_CURRENCY = 1038;
+    public static readonly NLS_DATE_FORMAT = 1039;
+    public static readonly NLS_DATE_LANGUAGE = 1040;
+    public static readonly NLS_INITCAP = 1041;
+    public static readonly NLS_ISO_CURRENCY = 1042;
+    public static readonly NL_SJ = 1043;
+    public static readonly NLS_LANG = 1044;
+    public static readonly NLS_LANGUAGE = 1045;
+    public static readonly NLS_LENGTH_SEMANTICS = 1046;
+    public static readonly NLS_LOWER = 1047;
+    public static readonly NLS_NCHAR_CONV_EXCP = 1048;
+    public static readonly NLS_NUMERIC_CHARACTERS = 1049;
+    public static readonly NLS_SORT = 1050;
+    public static readonly NLSSORT = 1051;
+    public static readonly NLS_SPECIAL_CHARS = 1052;
+    public static readonly NLS_TERRITORY = 1053;
+    public static readonly NLS_UPPER = 1054;
+    public static readonly NO_ACCESS = 1055;
+    public static readonly NO_ADAPTIVE_PLAN = 1056;
+    public static readonly NO_ANSI_REARCH = 1057;
+    public static readonly NOAPPEND = 1058;
+    public static readonly NOARCHIVELOG = 1059;
+    public static readonly NOAUDIT = 1060;
+    public static readonly NOBADFILE = 1061;
+    public static readonly NO_AUTO_REOPTIMIZE = 1062;
+    public static readonly NO_BASETABLE_MULTIMV_REWRITE = 1063;
+    public static readonly NO_BATCH_TABLE_ACCESS_BY_ROWID = 1064;
+    public static readonly NO_BIND_AWARE = 1065;
+    public static readonly NO_BUFFER = 1066;
+    public static readonly NOCACHE = 1067;
+    public static readonly NOCHECK = 1068;
+    public static readonly NO_CARTESIAN = 1069;
+    public static readonly NO_CHECK_ACL_REWRITE = 1070;
+    public static readonly NO_CLUSTER_BY_ROWID = 1071;
+    public static readonly NO_CLUSTERING = 1072;
+    public static readonly NO_COALESCE_SQ = 1073;
+    public static readonly NO_COMMON_DATA = 1074;
+    public static readonly NOCOMPRESS = 1075;
+    public static readonly NO_CONNECT_BY_CB_WHR_ONLY = 1076;
+    public static readonly NO_CONNECT_BY_COMBINE_SW = 1077;
+    public static readonly NO_CONNECT_BY_COST_BASED = 1078;
+    public static readonly NO_CONNECT_BY_ELIM_DUPS = 1079;
+    public static readonly NO_CONNECT_BY_FILTERING = 1080;
+    public static readonly NOCOPY = 1081;
+    public static readonly NO_COST_XML_QUERY_REWRITE = 1082;
+    public static readonly NO_CPU_COSTING = 1083;
+    public static readonly NOCPU_COSTING = 1084;
+    public static readonly NOCYCLE = 1085;
+    public static readonly NO_DATA_SECURITY_REWRITE = 1086;
+    public static readonly NO_DECORRELATE = 1087;
+    public static readonly NODELAY = 1088;
+    public static readonly NODIRECTIO = 1089;
+    public static readonly NODISCARDFILE = 1090;
+    public static readonly NO_DOMAIN_INDEX_FILTER = 1091;
+    public static readonly NO_DST_UPGRADE_INSERT_CONV = 1092;
+    public static readonly NO_ELIM_GROUPBY = 1093;
+    public static readonly NO_ELIMINATE_JOIN = 1094;
+    public static readonly NO_ELIMINATE_OBY = 1095;
+    public static readonly NO_ELIMINATE_OUTER_JOIN = 1096;
+    public static readonly NOENTITYESCAPING = 1097;
+    public static readonly NO_EXPAND_GSET_TO_UNION = 1098;
+    public static readonly NO_EXPAND = 1099;
+    public static readonly NO_EXPAND_TABLE = 1100;
+    public static readonly NOEXTEND = 1101;
+    public static readonly NO_FACT = 1102;
+    public static readonly NO_FACTORIZE_JOIN = 1103;
+    public static readonly NO_FILTERING = 1104;
+    public static readonly NOFORCE = 1105;
+    public static readonly NO_FULL_OUTER_JOIN_TO_OUTER = 1106;
+    public static readonly NO_GATHER_OPTIMIZER_STATISTICS = 1107;
+    public static readonly NO_GBY_PUSHDOWN = 1108;
+    public static readonly NOGUARANTEE = 1109;
+    public static readonly NO_INDEX_FFS = 1110;
+    public static readonly NO_INDEX = 1111;
+    public static readonly NO_INDEX_SS = 1112;
+    public static readonly NO_INMEMORY = 1113;
+    public static readonly NO_INMEMORY_PRUNING = 1114;
+    public static readonly NOKEEP = 1115;
+    public static readonly NO_LOAD = 1116;
+    public static readonly NOLOCAL = 1117;
+    public static readonly NOLOG = 1118;
+    public static readonly NOLOGFILE = 1119;
+    public static readonly NOLOGGING = 1120;
+    public static readonly NOMAPPING = 1121;
+    public static readonly NOMAXVALUE = 1122;
+    public static readonly NO_MERGE = 1123;
+    public static readonly NOMINIMIZE = 1124;
+    public static readonly NOMINVALUE = 1125;
+    public static readonly NO_MODEL_PUSH_REF = 1126;
+    public static readonly NO_MONITORING = 1127;
+    public static readonly NOMONITORING = 1128;
+    public static readonly NO_MONITOR = 1129;
+    public static readonly NO_MULTIMV_REWRITE = 1130;
+    public static readonly NO_NATIVE_FULL_OUTER_JOIN = 1131;
+    public static readonly NONBLOCKING = 1132;
+    public static readonly NONEDITIONABLE = 1133;
+    public static readonly NONE = 1134;
+    public static readonly NONPARTITIONED = 1135;
+    public static readonly NONULLIF = 1136;
+    public static readonly NO_NLJ_BATCHING = 1137;
+    public static readonly NO_NLJ_PREFETCH = 1138;
+    public static readonly NO = 1139;
+    public static readonly NONSCHEMA = 1140;
+    public static readonly NO_OBJECT_LINK = 1141;
+    public static readonly NOORDER = 1142;
+    public static readonly NO_ORDER_ROLLUPS = 1143;
+    public static readonly NO_OUTER_JOIN_TO_ANTI = 1144;
+    public static readonly NO_OUTER_JOIN_TO_INNER = 1145;
+    public static readonly NOOVERRIDE = 1146;
+    public static readonly NO_PARALLEL_INDEX = 1147;
+    public static readonly NOPARALLEL_INDEX = 1148;
+    public static readonly NO_PARALLEL = 1149;
+    public static readonly NOPARALLEL = 1150;
+    public static readonly NO_PARTIAL_COMMIT = 1151;
+    public static readonly NO_PARTIAL_JOIN = 1152;
+    public static readonly NO_PARTIAL_ROLLUP_PUSHDOWN = 1153;
+    public static readonly NOPARTITION = 1154;
+    public static readonly NO_PLACE_DISTINCT = 1155;
+    public static readonly NO_PLACE_GROUP_BY = 1156;
+    public static readonly NO_PQ_CONCURRENT_UNION = 1157;
+    public static readonly NO_PQ_MAP = 1158;
+    public static readonly NOPROMPT = 1159;
+    public static readonly NO_PQ_REPLICATE = 1160;
+    public static readonly NO_PQ_SKEW = 1161;
+    public static readonly NO_PRUNE_GSETS = 1162;
+    public static readonly NO_PULL_PRED = 1163;
+    public static readonly NO_PUSH_PRED = 1164;
+    public static readonly NO_PUSH_SUBQ = 1165;
+    public static readonly NO_PX_FAULT_TOLERANCE = 1166;
+    public static readonly NO_PX_JOIN_FILTER = 1167;
+    public static readonly NO_QKN_BUFF = 1168;
+    public static readonly NO_QUERY_TRANSFORMATION = 1169;
+    public static readonly NO_REF_CASCADE = 1170;
+    public static readonly NORELOCATE = 1171;
+    public static readonly NORELY = 1172;
+    public static readonly NOREPAIR = 1173;
+    public static readonly NOREPLAY = 1174;
+    public static readonly NORESETLOGS = 1175;
+    public static readonly NO_RESULT_CACHE = 1176;
+    public static readonly NOREVERSE = 1177;
+    public static readonly NO_REWRITE = 1178;
+    public static readonly NOREWRITE = 1179;
+    public static readonly NORMAL = 1180;
+    public static readonly NO_ROOT_SW_FOR_LOCAL = 1181;
+    public static readonly NOROWDEPENDENCIES = 1182;
+    public static readonly NOSCALE = 1183;
+    public static readonly NOSCHEMACHECK = 1184;
+    public static readonly NOSEGMENT = 1185;
+    public static readonly NO_SEMIJOIN = 1186;
+    public static readonly NO_SEMI_TO_INNER = 1187;
+    public static readonly NO_SET_TO_JOIN = 1188;
+    public static readonly NOSHARD = 1189;
+    public static readonly NOSORT = 1190;
+    public static readonly NO_SQL_TRANSLATION = 1191;
+    public static readonly NO_SQL_TUNE = 1192;
+    public static readonly NO_STAR_TRANSFORMATION = 1193;
+    public static readonly NO_STATEMENT_QUEUING = 1194;
+    public static readonly NO_STATS_GSETS = 1195;
+    public static readonly NOSTRICT = 1196;
+    public static readonly NO_SUBQUERY_PRUNING = 1197;
+    public static readonly NO_SUBSTRB_PAD = 1198;
+    public static readonly NO_SWAP_JOIN_INPUTS = 1199;
+    public static readonly NOSWITCH = 1200;
+    public static readonly NO_TABLE_LOOKUP_BY_NL = 1201;
+    public static readonly NO_TEMP_TABLE = 1202;
+    public static readonly NOTHING = 1203;
+    public static readonly NOTIFICATION = 1204;
+    public static readonly NOTRIM = 1205;
+    public static readonly NOT = 1206;
+    public static readonly NO_TRANSFORM_DISTINCT_AGG = 1207;
+    public static readonly NO_UNNEST = 1208;
+    public static readonly NO_USE_CUBE = 1209;
+    public static readonly NO_USE_HASH_AGGREGATION = 1210;
+    public static readonly NO_USE_HASH_GBY_FOR_PUSHDOWN = 1211;
+    public static readonly NO_USE_HASH = 1212;
+    public static readonly NO_USE_INVISIBLE_INDEXES = 1213;
+    public static readonly NO_USE_MERGE = 1214;
+    public static readonly NO_USE_NL = 1215;
+    public static readonly NO_USE_VECTOR_AGGREGATION = 1216;
+    public static readonly NOVALIDATE = 1217;
+    public static readonly NO_VECTOR_TRANSFORM_DIMS = 1218;
+    public static readonly NO_VECTOR_TRANSFORM_FACT = 1219;
+    public static readonly NO_VECTOR_TRANSFORM = 1220;
+    public static readonly NOWAIT = 1221;
+    public static readonly NO_XDB_FASTPATH_INSERT = 1222;
+    public static readonly NO_XML_DML_REWRITE = 1223;
+    public static readonly NO_XMLINDEX_REWRITE_IN_SELECT = 1224;
+    public static readonly NO_XMLINDEX_REWRITE = 1225;
+    public static readonly NO_XML_QUERY_REWRITE = 1226;
+    public static readonly NO_ZONEMAP = 1227;
+    public static readonly NTH_VALUE = 1228;
+    public static readonly NULLIF = 1229;
+    public static readonly NULL_ = 1230;
+    public static readonly NULLS = 1231;
+    public static readonly NUMBER = 1232;
+    public static readonly NUMERIC = 1233;
+    public static readonly NUM_INDEX_KEYS = 1234;
+    public static readonly NUMTODSINTERVAL = 1235;
+    public static readonly NUMTOYMINTERVAL = 1236;
+    public static readonly NVARCHAR2 = 1237;
+    public static readonly NVL2 = 1238;
+    public static readonly OBJECT2XML = 1239;
+    public static readonly OBJECT = 1240;
+    public static readonly OBJ_ID = 1241;
+    public static readonly OBJNO = 1242;
+    public static readonly OBJNO_REUSE = 1243;
+    public static readonly OCCURENCES = 1244;
+    public static readonly OFFLINE = 1245;
+    public static readonly OFF = 1246;
+    public static readonly OFFSET = 1247;
+    public static readonly OF = 1248;
+    public static readonly OIDINDEX = 1249;
+    public static readonly OID = 1250;
+    public static readonly OLAP = 1251;
+    public static readonly OLD = 1252;
+    public static readonly OLD_PUSH_PRED = 1253;
+    public static readonly OLS = 1254;
+    public static readonly OLTP = 1255;
+    public static readonly OMIT = 1256;
+    public static readonly ONE = 1257;
+    public static readonly ONLINE = 1258;
+    public static readonly ONLINELOG = 1259;
+    public static readonly ONLY = 1260;
+    public static readonly ON = 1261;
+    public static readonly OPAQUE = 1262;
+    public static readonly OPAQUE_TRANSFORM = 1263;
+    public static readonly OPAQUE_XCANONICAL = 1264;
+    public static readonly OPCODE = 1265;
+    public static readonly OPEN = 1266;
+    public static readonly OPERATIONS = 1267;
+    public static readonly OPERATOR = 1268;
+    public static readonly OPT_ESTIMATE = 1269;
+    public static readonly OPTIMAL = 1270;
+    public static readonly OPTIMIZE = 1271;
+    public static readonly OPTIMIZER_FEATURES_ENABLE = 1272;
+    public static readonly OPTIMIZER_GOAL = 1273;
+    public static readonly OPTION = 1274;
+    public static readonly OPTIONALLY = 1275;
+    public static readonly OPT_PARAM = 1276;
+    public static readonly ORA_BRANCH = 1277;
+    public static readonly ORA_CHECK_ACL = 1278;
+    public static readonly ORA_CHECK_PRIVILEGE = 1279;
+    public static readonly ORA_CLUSTERING = 1280;
+    public static readonly ORADATA = 1281;
+    public static readonly ORC = 1282;
+    public static readonly ORACLE_DATE = 1283;
+    public static readonly ORACLE_NUMBER = 1284;
+    public static readonly ORADEBUG = 1285;
+    public static readonly ORA_DST_AFFECTED = 1286;
+    public static readonly ORA_DST_CONVERT = 1287;
+    public static readonly ORA_DST_ERROR = 1288;
+    public static readonly ORA_GET_ACLIDS = 1289;
+    public static readonly ORA_GET_PRIVILEGES = 1290;
+    public static readonly ORA_HASH = 1291;
+    public static readonly ORA_INVOKING_USERID = 1292;
+    public static readonly ORA_INVOKING_USER = 1293;
+    public static readonly ORA_INVOKING_XS_USER_GUID = 1294;
+    public static readonly ORA_INVOKING_XS_USER = 1295;
+    public static readonly ORA_RAWCOMPARE = 1296;
+    public static readonly ORA_RAWCONCAT = 1297;
+    public static readonly ORA_ROWSCN = 1298;
+    public static readonly ORA_ROWSCN_RAW = 1299;
+    public static readonly ORA_ROWVERSION = 1300;
+    public static readonly ORA_TABVERSION = 1301;
+    public static readonly ORA_WRITE_TIME = 1302;
+    public static readonly ORDERED = 1303;
+    public static readonly ORDERED_PREDICATES = 1304;
+    public static readonly ORDER = 1305;
+    public static readonly ORDINALITY = 1306;
+    public static readonly OR_EXPAND = 1307;
+    public static readonly ORGANIZATION = 1308;
+    public static readonly OR = 1309;
+    public static readonly OR_PREDICATES = 1310;
+    public static readonly OSERROR = 1311;
+    public static readonly OTHER = 1312;
+    public static readonly OUTER_JOIN_TO_ANTI = 1313;
+    public static readonly OUTER_JOIN_TO_INNER = 1314;
+    public static readonly OUTER = 1315;
+    public static readonly OUTLINE_LEAF = 1316;
+    public static readonly OUTLINE = 1317;
+    public static readonly OUTPUTFORMAT = 1318;
+    public static readonly OUT_OF_LINE = 1319;
+    public static readonly OUT = 1320;
+    public static readonly OVERFLOW_NOMOVE = 1321;
+    public static readonly OVERFLOW_ = 1322;
+    public static readonly OVERLAPS = 1323;
+    public static readonly OVER = 1324;
+    public static readonly OVERRIDE = 1325;
+    public static readonly OVERRIDING = 1326;
+    public static readonly OWNER = 1327;
+    public static readonly OWNERSHIP = 1328;
+    public static readonly OWN = 1329;
+    public static readonly P_LETTER = 1330;
+    public static readonly PACKAGE = 1331;
+    public static readonly PACKAGES = 1332;
+    public static readonly PARALLEL_ENABLE = 1333;
+    public static readonly PARALLEL_INDEX = 1334;
+    public static readonly PARALLEL = 1335;
+    public static readonly PARAMETERFILE = 1336;
+    public static readonly PARAMETERS = 1337;
+    public static readonly PARAM = 1338;
+    public static readonly PARENT = 1339;
+    public static readonly PARENT_LEVEL_NAME = 1340;
+    public static readonly PARENT_UNIQUE_NAME = 1341;
+    public static readonly PARITY = 1342;
+    public static readonly PARQUET = 1343;
+    public static readonly PARTIAL_JOIN = 1344;
+    public static readonly PARTIALLY = 1345;
+    public static readonly PARTIAL = 1346;
+    public static readonly PARTIAL_ROLLUP_PUSHDOWN = 1347;
+    public static readonly PARTITION_HASH = 1348;
+    public static readonly PARTITION_LIST = 1349;
+    public static readonly PARTITION = 1350;
+    public static readonly PARTITION_RANGE = 1351;
+    public static readonly PARTITIONS = 1352;
+    public static readonly PARTNUMINST = 1353;
+    public static readonly PASSING = 1354;
+    public static readonly PASSWORD_GRACE_TIME = 1355;
+    public static readonly PASSWORD_LIFE_TIME = 1356;
+    public static readonly PASSWORD_LOCK_TIME = 1357;
+    public static readonly PASSWORD = 1358;
+    public static readonly PASSWORD_REUSE_MAX = 1359;
+    public static readonly PASSWORD_REUSE_TIME = 1360;
+    public static readonly PASSWORD_ROLLOVER_TIME = 1361;
+    public static readonly PASSWORD_VERIFY_FUNCTION = 1362;
+    public static readonly PAST = 1363;
+    public static readonly PATCH = 1364;
+    public static readonly PATH = 1365;
+    public static readonly PATH_PREFIX = 1366;
+    public static readonly PATHS = 1367;
+    public static readonly PATTERN = 1368;
+    public static readonly PBL_HS_BEGIN = 1369;
+    public static readonly PBL_HS_END = 1370;
+    public static readonly PCTFREE = 1371;
+    public static readonly PCTINCREASE = 1372;
+    public static readonly PCTTHRESHOLD = 1373;
+    public static readonly PCTUSED = 1374;
+    public static readonly PCTVERSION = 1375;
+    public static readonly PENDING = 1376;
+    public static readonly PERCENT_FOUND = 1377;
+    public static readonly PERCENT_ISOPEN = 1378;
+    public static readonly PERCENT_NOTFOUND = 1379;
+    public static readonly PERCENT_KEYWORD = 1380;
+    public static readonly PERCENT_RANKM = 1381;
+    public static readonly PERCENT_ROWCOUNT = 1382;
+    public static readonly PERCENT_ROWTYPE = 1383;
+    public static readonly PERCENT_TYPE = 1384;
+    public static readonly PERCENT_BULK_EXCEPTIONS = 1385;
+    public static readonly PERCENT_BULK_ROWCOUNT = 1386;
+    public static readonly PERFORMANCE = 1387;
+    public static readonly PERIOD_KEYWORD = 1388;
+    public static readonly PERMANENT = 1389;
+    public static readonly PERMISSION = 1390;
+    public static readonly PERMUTE = 1391;
+    public static readonly PER = 1392;
+    public static readonly PFILE = 1393;
+    public static readonly PHYSICAL = 1394;
+    public static readonly PIKEY = 1395;
+    public static readonly PIPELINED = 1396;
+    public static readonly PIPE = 1397;
+    public static readonly PIV_GB = 1398;
+    public static readonly PIVOT = 1399;
+    public static readonly PIV_SSF = 1400;
+    public static readonly PLACE_DISTINCT = 1401;
+    public static readonly PLACE_GROUP_BY = 1402;
+    public static readonly PLAN = 1403;
+    public static readonly PLSCOPE_SETTINGS = 1404;
+    public static readonly PLS_INTEGER = 1405;
+    public static readonly PLSQL_CCFLAGS = 1406;
+    public static readonly PLSQL_CODE_TYPE = 1407;
+    public static readonly PLSQL_DEBUG = 1408;
+    public static readonly PLSQL_OPTIMIZE_LEVEL = 1409;
+    public static readonly PLSQL_WARNINGS = 1410;
+    public static readonly PLUGGABLE = 1411;
+    public static readonly PMEM = 1412;
+    public static readonly POINT = 1413;
+    public static readonly POLICY = 1414;
+    public static readonly POOL_16K = 1415;
+    public static readonly POOL_2K = 1416;
+    public static readonly POOL_32K = 1417;
+    public static readonly POOL_4K = 1418;
+    public static readonly POOL_8K = 1419;
+    public static readonly POSITION = 1420;
+    public static readonly POSITIVEN = 1421;
+    public static readonly POSITIVE = 1422;
+    public static readonly POST_TRANSACTION = 1423;
+    public static readonly POWERMULTISET_BY_CARDINALITY = 1424;
+    public static readonly POWERMULTISET = 1425;
+    public static readonly POWER = 1426;
+    public static readonly PQ_CONCURRENT_UNION = 1427;
+    public static readonly PQ_DISTRIBUTE = 1428;
+    public static readonly PQ_DISTRIBUTE_WINDOW = 1429;
+    public static readonly PQ_FILTER = 1430;
+    public static readonly PQ_MAP = 1431;
+    public static readonly PQ_NOMAP = 1432;
+    public static readonly PQ_REPLICATE = 1433;
+    public static readonly PQ_SKEW = 1434;
+    public static readonly PRAGMA = 1435;
+    public static readonly PREBUILT = 1436;
+    public static readonly PRECEDES = 1437;
+    public static readonly PRECEDING = 1438;
+    public static readonly PRECISION = 1439;
+    public static readonly PRECOMPUTE_SUBQUERY = 1440;
+    public static readonly PREDICATE_REORDERS = 1441;
+    public static readonly PRELOAD = 1442;
+    public static readonly PREPARE = 1443;
+    public static readonly PREPROCESSOR = 1444;
+    public static readonly PRESENTNNV = 1445;
+    public static readonly PRESENT = 1446;
+    public static readonly PRESENTV = 1447;
+    public static readonly PRESERVE_OID = 1448;
+    public static readonly PRESERVE = 1449;
+    public static readonly PRETTY = 1450;
+    public static readonly PREVIOUS = 1451;
+    public static readonly PREV = 1452;
+    public static readonly PRIMARY = 1453;
+    public static readonly PRINTBLOBTOCLOB = 1454;
+    public static readonly PRIORITY = 1455;
+    public static readonly PRIOR = 1456;
+    public static readonly PRIVATE = 1457;
+    public static readonly PRIVATE_SGA = 1458;
+    public static readonly PRIVILEGED = 1459;
+    public static readonly PRIVILEGE = 1460;
+    public static readonly PRIVILEGES = 1461;
+    public static readonly PROCEDURAL = 1462;
+    public static readonly PROCEDURE = 1463;
+    public static readonly PROCESS = 1464;
+    public static readonly PROFILE = 1465;
+    public static readonly PROGRAM = 1466;
+    public static readonly PROJECT = 1467;
+    public static readonly PROPAGATE = 1468;
+    public static readonly PROPERTY = 1469;
+    public static readonly PROTECTED = 1470;
+    public static readonly PROTECTION = 1471;
+    public static readonly PROTOCOL = 1472;
+    public static readonly PROXY = 1473;
+    public static readonly PRUNING = 1474;
+    public static readonly PUBLIC = 1475;
+    public static readonly PULL_PRED = 1476;
+    public static readonly PURGE = 1477;
+    public static readonly PUSH_PRED = 1478;
+    public static readonly PUSH_SUBQ = 1479;
+    public static readonly PX_FAULT_TOLERANCE = 1480;
+    public static readonly PX_GRANULE = 1481;
+    public static readonly PX_JOIN_FILTER = 1482;
+    public static readonly QB_NAME = 1483;
+    public static readonly QUARTERS = 1484;
+    public static readonly QUERY_BLOCK = 1485;
+    public static readonly QUERY = 1486;
+    public static readonly QUEUE_CURR = 1487;
+    public static readonly QUEUE = 1488;
+    public static readonly QUEUE_ROWP = 1489;
+    public static readonly QUIESCE = 1490;
+    public static readonly QUORUM = 1491;
+    public static readonly QUOTA = 1492;
+    public static readonly QUOTAGROUP = 1493;
+    public static readonly RAISE = 1494;
+    public static readonly RANDOM_LOCAL = 1495;
+    public static readonly RANDOM = 1496;
+    public static readonly RANGE = 1497;
+    public static readonly RANKM = 1498;
+    public static readonly RAPIDLY = 1499;
+    public static readonly RAW = 1500;
+    public static readonly RAWTOHEX = 1501;
+    public static readonly RAWTONHEX = 1502;
+    public static readonly RBA = 1503;
+    public static readonly RBO_OUTLINE = 1504;
+    public static readonly RCFILE = 1505;
+    public static readonly RDBA = 1506;
+    public static readonly READ = 1507;
+    public static readonly READS = 1508;
+    public static readonly READSIZE = 1509;
+    public static readonly REALM = 1510;
+    public static readonly REAL = 1511;
+    public static readonly REBALANCE = 1512;
+    public static readonly REBUILD = 1513;
+    public static readonly RECORD = 1514;
+    public static readonly RECORDS = 1515;
+    public static readonly RECORDS_PER_BLOCK = 1516;
+    public static readonly RECOVERABLE = 1517;
+    public static readonly RECOVER = 1518;
+    public static readonly RECOVERY = 1519;
+    public static readonly RECYCLEBIN = 1520;
+    public static readonly RECYCLE = 1521;
+    public static readonly REDACTION = 1522;
+    public static readonly REDEFINE = 1523;
+    public static readonly REDO = 1524;
+    public static readonly REDUCED = 1525;
+    public static readonly REDUNDANCY = 1526;
+    public static readonly REF_CASCADE_CURSOR = 1527;
+    public static readonly REFERENCED = 1528;
+    public static readonly REFERENCE = 1529;
+    public static readonly REFERENCES = 1530;
+    public static readonly REFERENCING = 1531;
+    public static readonly REF = 1532;
+    public static readonly REFRESH = 1533;
+    public static readonly REFTOHEX = 1534;
+    public static readonly REGEXP_COUNT = 1535;
+    public static readonly REGEXP_INSTR = 1536;
+    public static readonly REGEXP_LIKE = 1537;
+    public static readonly REGEXP_REPLACE = 1538;
+    public static readonly REGEXP_SUBSTR = 1539;
+    public static readonly REGISTER = 1540;
+    public static readonly REGR_AVGX = 1541;
+    public static readonly REGR_AVGY = 1542;
+    public static readonly REGR_COUNT = 1543;
+    public static readonly REGR_INTERCEPT = 1544;
+    public static readonly REGR_R2 = 1545;
+    public static readonly REGR_SLOPE = 1546;
+    public static readonly REGR_SXX = 1547;
+    public static readonly REGR_SXY = 1548;
+    public static readonly REGR_SYY = 1549;
+    public static readonly REGULAR = 1550;
+    public static readonly REJECT = 1551;
+    public static readonly REKEY = 1552;
+    public static readonly RELATIONAL = 1553;
+    public static readonly RELIES_ON = 1554;
+    public static readonly RELOCATE = 1555;
+    public static readonly RELY = 1556;
+    public static readonly REMAINDER = 1557;
+    public static readonly REMOTE = 1558;
+    public static readonly REMOTE_MAPPED = 1559;
+    public static readonly REMOVE = 1560;
+    public static readonly RENAME = 1561;
+    public static readonly REPAIR = 1562;
+    public static readonly REPEAT = 1563;
+    public static readonly REPLACE = 1564;
+    public static readonly REPLICATION = 1565;
+    public static readonly REQUIRED = 1566;
+    public static readonly RESETLOGS = 1567;
+    public static readonly RESET = 1568;
+    public static readonly RESIZE = 1569;
+    public static readonly RESOLVE = 1570;
+    public static readonly RESOLVER = 1571;
+    public static readonly RESOURCE = 1572;
+    public static readonly RESPECT = 1573;
+    public static readonly RESTART = 1574;
+    public static readonly RESTORE_AS_INTERVALS = 1575;
+    public static readonly RESTORE = 1576;
+    public static readonly RESTRICT_ALL_REF_CONS = 1577;
+    public static readonly RESTRICTED = 1578;
+    public static readonly RESTRICT_REFERENCES = 1579;
+    public static readonly RESTRICT = 1580;
+    public static readonly RESULT_CACHE = 1581;
+    public static readonly RESULT = 1582;
+    public static readonly RESUMABLE = 1583;
+    public static readonly RESUME = 1584;
+    public static readonly RETENTION = 1585;
+    public static readonly RETRY_ON_ROW_CHANGE = 1586;
+    public static readonly RETURNING = 1587;
+    public static readonly RETURN = 1588;
+    public static readonly REUSE = 1589;
+    public static readonly REVERSE = 1590;
+    public static readonly REVOKE = 1591;
+    public static readonly REWRITE_OR_ERROR = 1592;
+    public static readonly REWRITE = 1593;
+    public static readonly RIGHT = 1594;
+    public static readonly ROLE = 1595;
+    public static readonly ROLESET = 1596;
+    public static readonly ROLES = 1597;
+    public static readonly ROLLBACK = 1598;
+    public static readonly ROLLING = 1599;
+    public static readonly ROLLUP = 1600;
+    public static readonly ROWDEPENDENCIES = 1601;
+    public static readonly ROWID_MAPPING_TABLE = 1602;
+    public static readonly ROWID = 1603;
+    public static readonly ROWIDTOCHAR = 1604;
+    public static readonly ROWIDTONCHAR = 1605;
+    public static readonly ROW_LENGTH = 1606;
+    public static readonly ROWNUM = 1607;
+    public static readonly ROW = 1608;
+    public static readonly ROWS = 1609;
+    public static readonly RPAD = 1610;
+    public static readonly RTRIM = 1611;
+    public static readonly RULE = 1612;
+    public static readonly RULES = 1613;
+    public static readonly RUNNING = 1614;
+    public static readonly SALT = 1615;
+    public static readonly SAMPLE = 1616;
+    public static readonly SAVE_AS_INTERVALS = 1617;
+    public static readonly SAVEPOINT = 1618;
+    public static readonly SAVE = 1619;
+    public static readonly SB4 = 1620;
+    public static readonly SCALE_ROWS = 1621;
+    public static readonly SCALE = 1622;
+    public static readonly SCAN_INSTANCES = 1623;
+    public static readonly SCAN = 1624;
+    public static readonly SCHEDULER = 1625;
+    public static readonly SCHEMACHECK = 1626;
+    public static readonly SCHEMA = 1627;
+    public static readonly SCN_ASCENDING = 1628;
+    public static readonly SCN = 1629;
+    public static readonly SCOPE = 1630;
+    public static readonly SCRUB = 1631;
+    public static readonly SD_ALL = 1632;
+    public static readonly SD_INHIBIT = 1633;
+    public static readonly SDO_GEOM_MBR = 1634;
+    public static readonly SDO_GEOMETRY = 1635;
+    public static readonly SD_SHOW = 1636;
+    public static readonly SEARCH = 1637;
+    public static readonly SECOND = 1638;
+    public static readonly SECONDS = 1639;
+    public static readonly SECRET = 1640;
+    public static readonly SECUREFILE_DBA = 1641;
+    public static readonly SECUREFILE = 1642;
+    public static readonly SECURITY = 1643;
+    public static readonly SEED = 1644;
+    public static readonly SEG_BLOCK = 1645;
+    public static readonly SEG_FILE = 1646;
+    public static readonly SEGMENT = 1647;
+    public static readonly SELECTIVITY = 1648;
+    public static readonly SELECT = 1649;
+    public static readonly SELF = 1650;
+    public static readonly SEMIJOIN_DRIVER = 1651;
+    public static readonly SEMIJOIN = 1652;
+    public static readonly SEMI_TO_INNER = 1653;
+    public static readonly SEQUENCED = 1654;
+    public static readonly SEQUENCE = 1655;
+    public static readonly SEQUENCEFILE = 1656;
+    public static readonly SEQUENTIAL = 1657;
+    public static readonly SEQ = 1658;
+    public static readonly SERDE = 1659;
+    public static readonly SERDEPROPERTIES = 1660;
+    public static readonly SERIALIZABLE = 1661;
+    public static readonly SERIALLY_REUSABLE = 1662;
+    public static readonly SERIAL = 1663;
+    public static readonly SERVERERROR = 1664;
+    public static readonly SERVICE_NAME_CONVERT = 1665;
+    public static readonly SERVICE = 1666;
+    public static readonly SERVICES = 1667;
+    public static readonly SESSION_CACHED_CURSORS = 1668;
+    public static readonly SESSION = 1669;
+    public static readonly SESSIONS_PER_USER = 1670;
+    public static readonly SESSIONTIMEZONE = 1671;
+    public static readonly SESSIONTZNAME = 1672;
+    public static readonly SET = 1673;
+    public static readonly SETS = 1674;
+    public static readonly SETTINGS = 1675;
+    public static readonly SET_TO_JOIN = 1676;
+    public static readonly SEVERE = 1677;
+    public static readonly SHARD = 1678;
+    public static readonly SHARDSPACE = 1679;
+    public static readonly SHARED_POOL = 1680;
+    public static readonly SHARED = 1681;
+    public static readonly SHARE = 1682;
+    public static readonly SHARING = 1683;
+    public static readonly SHELFLIFE = 1684;
+    public static readonly SHOW = 1685;
+    public static readonly SHRINK = 1686;
+    public static readonly SHUTDOWN = 1687;
+    public static readonly SIBLINGS = 1688;
+    public static readonly SID = 1689;
+    public static readonly SITE = 1690;
+    public static readonly SIGNAL_COMPONENT = 1691;
+    public static readonly SIGNAL_FUNCTION = 1692;
+    public static readonly SIGN = 1693;
+    public static readonly SIGNTYPE = 1694;
+    public static readonly SIMPLE_INTEGER = 1695;
+    public static readonly SIMPLE = 1696;
+    public static readonly SINGLE = 1697;
+    public static readonly SINGLETASK = 1698;
+    public static readonly SINH = 1699;
+    public static readonly SIN = 1700;
+    public static readonly SIZE = 1701;
+    public static readonly SIZES = 1702;
+    public static readonly SKIP_EXT_OPTIMIZER = 1703;
+    public static readonly SKIP_ = 1704;
+    public static readonly SKIP_UNQ_UNUSABLE_IDX = 1705;
+    public static readonly SKIP_UNUSABLE_INDEXES = 1706;
+    public static readonly SMALLFILE = 1707;
+    public static readonly SMALLINT = 1708;
+    public static readonly SNAPSHOT = 1709;
+    public static readonly SOME = 1710;
+    public static readonly SORT = 1711;
+    public static readonly SOUNDEX = 1712;
+    public static readonly SOURCE_FILE_DIRECTORY = 1713;
+    public static readonly SOURCE_FILE_NAME_CONVERT = 1714;
+    public static readonly SOURCE = 1715;
+    public static readonly SPACE_KEYWORD = 1716;
+    public static readonly SPECIFICATION = 1717;
+    public static readonly SPFILE = 1718;
+    public static readonly SPLIT = 1719;
+    public static readonly SPREADSHEET = 1720;
+    public static readonly SQLDATA = 1721;
+    public static readonly SQLERROR = 1722;
+    public static readonly SQLLDR = 1723;
+    public static readonly SQL = 1724;
+    public static readonly FILE_EXT = 1725;
+    public static readonly SQL_MACRO = 1726;
+    public static readonly SQL_TRACE = 1727;
+    public static readonly SQL_TRANSLATION_PROFILE = 1728;
+    public static readonly SQRT = 1729;
+    public static readonly STALE = 1730;
+    public static readonly STANDALONE = 1731;
+    public static readonly STANDARD = 1732;
+    public static readonly STANDARD_HASH = 1733;
+    public static readonly STANDBY_MAX_DATA_DELAY = 1734;
+    public static readonly STANDBYS = 1735;
+    public static readonly STANDBY = 1736;
+    public static readonly STAR = 1737;
+    public static readonly STAR_TRANSFORMATION = 1738;
+    public static readonly START = 1739;
+    public static readonly STARTOF = 1740;
+    public static readonly STARTUP = 1741;
+    public static readonly STATEMENT_ID = 1742;
+    public static readonly STATEMENT_QUEUING = 1743;
+    public static readonly STATEMENTS = 1744;
+    public static readonly STATEMENT = 1745;
+    public static readonly STATE = 1746;
+    public static readonly STATIC = 1747;
+    public static readonly STATISTICS = 1748;
+    public static readonly STATS_BINOMIAL_TEST = 1749;
+    public static readonly STATS_CROSSTAB = 1750;
+    public static readonly STATS_F_TEST = 1751;
+    public static readonly STATS_KS_TEST = 1752;
+    public static readonly STATS_MODE = 1753;
+    public static readonly STATS_MW_TEST = 1754;
+    public static readonly STATS_ONE_WAY_ANOVA = 1755;
+    public static readonly STATS_T_TEST_INDEP = 1756;
+    public static readonly STATS_T_TEST_INDEPU = 1757;
+    public static readonly STATS_T_TEST_ONE = 1758;
+    public static readonly STATS_T_TEST_PAIRED = 1759;
+    public static readonly STATS_WSR_TEST = 1760;
+    public static readonly STDDEV_POP = 1761;
+    public static readonly STDDEV_SAMP = 1762;
+    public static readonly STOP = 1763;
+    public static readonly STORAGE = 1764;
+    public static readonly STORE = 1765;
+    public static readonly STREAMS = 1766;
+    public static readonly STREAM = 1767;
+    public static readonly STRICT = 1768;
+    public static readonly STRING = 1769;
+    public static readonly STRIPE_COLUMNS = 1770;
+    public static readonly STRIPE_WIDTH = 1771;
+    public static readonly STRIP = 1772;
+    public static readonly STRUCTURE = 1773;
+    public static readonly SUBMULTISET = 1774;
+    public static readonly SUBPARTITION_REL = 1775;
+    public static readonly SUBPARTITIONS = 1776;
+    public static readonly SUBPARTITION = 1777;
+    public static readonly SUBQUERIES = 1778;
+    public static readonly SUBQUERY_PRUNING = 1779;
+    public static readonly SUBSCRIBE = 1780;
+    public static readonly SUBSET = 1781;
+    public static readonly SUBSTITUTABLE = 1782;
+    public static readonly SUBSTR2 = 1783;
+    public static readonly SUBSTR4 = 1784;
+    public static readonly SUBSTRB = 1785;
+    public static readonly SUBSTRC = 1786;
+    public static readonly SUBTYPE = 1787;
+    public static readonly SUCCESSFUL = 1788;
+    public static readonly SUCCESS = 1789;
+    public static readonly SUMMARY = 1790;
+    public static readonly SUPPLEMENTAL = 1791;
+    public static readonly SUSPEND = 1792;
+    public static readonly SWAP_JOIN_INPUTS = 1793;
+    public static readonly SWITCHOVER = 1794;
+    public static readonly SWITCH = 1795;
+    public static readonly SYNCHRONOUS = 1796;
+    public static readonly SYNC = 1797;
+    public static readonly SYNONYM = 1798;
+    public static readonly SYS = 1799;
+    public static readonly SYSASM = 1800;
+    public static readonly SYS_AUDIT = 1801;
+    public static readonly SYSAUX = 1802;
+    public static readonly SYSBACKUP = 1803;
+    public static readonly SYS_CHECKACL = 1804;
+    public static readonly SYS_CHECK_PRIVILEGE = 1805;
+    public static readonly SYS_CONNECT_BY_PATH = 1806;
+    public static readonly SYS_CONTEXT = 1807;
+    public static readonly SYSDATE = 1808;
+    public static readonly SYSDBA = 1809;
+    public static readonly SYS_DBURIGEN = 1810;
+    public static readonly SYSDG = 1811;
+    public static readonly SYS_DL_CURSOR = 1812;
+    public static readonly SYS_DM_RXFORM_CHR = 1813;
+    public static readonly SYS_DM_RXFORM_NUM = 1814;
+    public static readonly SYS_DOM_COMPARE = 1815;
+    public static readonly SYS_DST_PRIM2SEC = 1816;
+    public static readonly SYS_DST_SEC2PRIM = 1817;
+    public static readonly SYS_ET_BFILE_TO_RAW = 1818;
+    public static readonly SYS_ET_BLOB_TO_IMAGE = 1819;
+    public static readonly SYS_ET_IMAGE_TO_BLOB = 1820;
+    public static readonly SYS_ET_RAW_TO_BFILE = 1821;
+    public static readonly SYS_EXTPDTXT = 1822;
+    public static readonly SYS_EXTRACT_UTC = 1823;
+    public static readonly SYS_FBT_INSDEL = 1824;
+    public static readonly SYS_FILTER_ACLS = 1825;
+    public static readonly SYS_FNMATCHES = 1826;
+    public static readonly SYS_FNREPLACE = 1827;
+    public static readonly SYS_GET_ACLIDS = 1828;
+    public static readonly SYS_GET_COL_ACLIDS = 1829;
+    public static readonly SYS_GET_PRIVILEGES = 1830;
+    public static readonly SYS_GETTOKENID = 1831;
+    public static readonly SYS_GETXTIVAL = 1832;
+    public static readonly SYS_GUID = 1833;
+    public static readonly SYSGUID = 1834;
+    public static readonly SYSKM = 1835;
+    public static readonly SYS_MAKE_XMLNODEID = 1836;
+    public static readonly SYS_MAKEXML = 1837;
+    public static readonly SYS_MKXMLATTR = 1838;
+    public static readonly SYS_MKXTI = 1839;
+    public static readonly SYSOBJ = 1840;
+    public static readonly SYS_OP_ADT2BIN = 1841;
+    public static readonly SYS_OP_ADTCONS = 1842;
+    public static readonly SYS_OP_ALSCRVAL = 1843;
+    public static readonly SYS_OP_ATG = 1844;
+    public static readonly SYS_OP_BIN2ADT = 1845;
+    public static readonly SYS_OP_BITVEC = 1846;
+    public static readonly SYS_OP_BL2R = 1847;
+    public static readonly SYS_OP_BLOOM_FILTER_LIST = 1848;
+    public static readonly SYS_OP_BLOOM_FILTER = 1849;
+    public static readonly SYS_OP_C2C = 1850;
+    public static readonly SYS_OP_CAST = 1851;
+    public static readonly SYS_OP_CEG = 1852;
+    public static readonly SYS_OP_CL2C = 1853;
+    public static readonly SYS_OP_COMBINED_HASH = 1854;
+    public static readonly SYS_OP_COMP = 1855;
+    public static readonly SYS_OP_CONVERT = 1856;
+    public static readonly SYS_OP_COUNTCHG = 1857;
+    public static readonly SYS_OP_CSCONV = 1858;
+    public static readonly SYS_OP_CSCONVTEST = 1859;
+    public static readonly SYS_OP_CSR = 1860;
+    public static readonly SYS_OP_CSX_PATCH = 1861;
+    public static readonly SYS_OP_CYCLED_SEQ = 1862;
+    public static readonly SYS_OP_DECOMP = 1863;
+    public static readonly SYS_OP_DESCEND = 1864;
+    public static readonly SYS_OP_DISTINCT = 1865;
+    public static readonly SYS_OP_DRA = 1866;
+    public static readonly SYS_OP_DUMP = 1867;
+    public static readonly SYS_OP_DV_CHECK = 1868;
+    public static readonly SYS_OP_ENFORCE_NOT_NULL = 1869;
+    public static readonly SYSOPER = 1870;
+    public static readonly SYS_OP_EXTRACT = 1871;
+    public static readonly SYS_OP_GROUPING = 1872;
+    public static readonly SYS_OP_GUID = 1873;
+    public static readonly SYS_OP_HASH = 1874;
+    public static readonly SYS_OP_IIX = 1875;
+    public static readonly SYS_OP_ITR = 1876;
+    public static readonly SYS_OP_KEY_VECTOR_CREATE = 1877;
+    public static readonly SYS_OP_KEY_VECTOR_FILTER_LIST = 1878;
+    public static readonly SYS_OP_KEY_VECTOR_FILTER = 1879;
+    public static readonly SYS_OP_KEY_VECTOR_SUCCEEDED = 1880;
+    public static readonly SYS_OP_KEY_VECTOR_USE = 1881;
+    public static readonly SYS_OP_LBID = 1882;
+    public static readonly SYS_OP_LOBLOC2BLOB = 1883;
+    public static readonly SYS_OP_LOBLOC2CLOB = 1884;
+    public static readonly SYS_OP_LOBLOC2ID = 1885;
+    public static readonly SYS_OP_LOBLOC2NCLOB = 1886;
+    public static readonly SYS_OP_LOBLOC2TYP = 1887;
+    public static readonly SYS_OP_LSVI = 1888;
+    public static readonly SYS_OP_LVL = 1889;
+    public static readonly SYS_OP_MAKEOID = 1890;
+    public static readonly SYS_OP_MAP_NONNULL = 1891;
+    public static readonly SYS_OP_MSR = 1892;
+    public static readonly SYS_OP_NICOMBINE = 1893;
+    public static readonly SYS_OP_NIEXTRACT = 1894;
+    public static readonly SYS_OP_NII = 1895;
+    public static readonly SYS_OP_NIX = 1896;
+    public static readonly SYS_OP_NOEXPAND = 1897;
+    public static readonly SYS_OP_NTCIMG = 1898;
+    public static readonly SYS_OP_NUMTORAW = 1899;
+    public static readonly SYS_OP_OIDVALUE = 1900;
+    public static readonly SYS_OP_OPNSIZE = 1901;
+    public static readonly SYS_OP_PAR_1 = 1902;
+    public static readonly SYS_OP_PARGID_1 = 1903;
+    public static readonly SYS_OP_PARGID = 1904;
+    public static readonly SYS_OP_PAR = 1905;
+    public static readonly SYS_OP_PART_ID = 1906;
+    public static readonly SYS_OP_PIVOT = 1907;
+    public static readonly SYS_OP_R2O = 1908;
+    public static readonly SYS_OP_RAWTONUM = 1909;
+    public static readonly SYS_OP_RDTM = 1910;
+    public static readonly SYS_OP_REF = 1911;
+    public static readonly SYS_OP_RMTD = 1912;
+    public static readonly SYS_OP_ROWIDTOOBJ = 1913;
+    public static readonly SYS_OP_RPB = 1914;
+    public static readonly SYS_OPTLOBPRBSC = 1915;
+    public static readonly SYS_OP_TOSETID = 1916;
+    public static readonly SYS_OP_TPR = 1917;
+    public static readonly SYS_OP_TRTB = 1918;
+    public static readonly SYS_OPTXICMP = 1919;
+    public static readonly SYS_OPTXQCASTASNQ = 1920;
+    public static readonly SYS_OP_UNDESCEND = 1921;
+    public static readonly SYS_OP_VECAND = 1922;
+    public static readonly SYS_OP_VECBIT = 1923;
+    public static readonly SYS_OP_VECOR = 1924;
+    public static readonly SYS_OP_VECXOR = 1925;
+    public static readonly SYS_OP_VERSION = 1926;
+    public static readonly SYS_OP_VREF = 1927;
+    public static readonly SYS_OP_VVD = 1928;
+    public static readonly SYS_OP_XMLCONS_FOR_CSX = 1929;
+    public static readonly SYS_OP_XPTHATG = 1930;
+    public static readonly SYS_OP_XPTHIDX = 1931;
+    public static readonly SYS_OP_XPTHOP = 1932;
+    public static readonly SYS_OP_XTXT2SQLT = 1933;
+    public static readonly SYS_OP_ZONE_ID = 1934;
+    public static readonly SYS_ORDERKEY_DEPTH = 1935;
+    public static readonly SYS_ORDERKEY_MAXCHILD = 1936;
+    public static readonly SYS_ORDERKEY_PARENT = 1937;
+    public static readonly SYS_PARALLEL_TXN = 1938;
+    public static readonly SYS_PATHID_IS_ATTR = 1939;
+    public static readonly SYS_PATHID_IS_NMSPC = 1940;
+    public static readonly SYS_PATHID_LASTNAME = 1941;
+    public static readonly SYS_PATHID_LASTNMSPC = 1942;
+    public static readonly SYS_PATH_REVERSE = 1943;
+    public static readonly SYS_PXQEXTRACT = 1944;
+    public static readonly SYS_RAW_TO_XSID = 1945;
+    public static readonly SYS_RID_ORDER = 1946;
+    public static readonly SYS_ROW_DELTA = 1947;
+    public static readonly SYS_SC_2_XMLT = 1948;
+    public static readonly SYS_SYNRCIREDO = 1949;
+    public static readonly SYSTEM_DEFINED = 1950;
+    public static readonly SYSTEM = 1951;
+    public static readonly SYSTIMESTAMP = 1952;
+    public static readonly SYS_TYPEID = 1953;
+    public static readonly SYS_UMAKEXML = 1954;
+    public static readonly SYS_XMLANALYZE = 1955;
+    public static readonly SYS_XMLCONTAINS = 1956;
+    public static readonly SYS_XMLCONV = 1957;
+    public static readonly SYS_XMLEXNSURI = 1958;
+    public static readonly SYS_XMLGEN = 1959;
+    public static readonly SYS_XMLI_LOC_ISNODE = 1960;
+    public static readonly SYS_XMLI_LOC_ISTEXT = 1961;
+    public static readonly SYS_XMLINSTR = 1962;
+    public static readonly SYS_XMLLOCATOR_GETSVAL = 1963;
+    public static readonly SYS_XMLNODEID_GETCID = 1964;
+    public static readonly SYS_XMLNODEID_GETLOCATOR = 1965;
+    public static readonly SYS_XMLNODEID_GETOKEY = 1966;
+    public static readonly SYS_XMLNODEID_GETPATHID = 1967;
+    public static readonly SYS_XMLNODEID_GETPTRID = 1968;
+    public static readonly SYS_XMLNODEID_GETRID = 1969;
+    public static readonly SYS_XMLNODEID_GETSVAL = 1970;
+    public static readonly SYS_XMLNODEID_GETTID = 1971;
+    public static readonly SYS_XMLNODEID = 1972;
+    public static readonly SYS_XMLT_2_SC = 1973;
+    public static readonly SYS_XMLTRANSLATE = 1974;
+    public static readonly SYS_XMLTYPE2SQL = 1975;
+    public static readonly SYS_XQ_ASQLCNV = 1976;
+    public static readonly SYS_XQ_ATOMCNVCHK = 1977;
+    public static readonly SYS_XQBASEURI = 1978;
+    public static readonly SYS_XQCASTABLEERRH = 1979;
+    public static readonly SYS_XQCODEP2STR = 1980;
+    public static readonly SYS_XQCODEPEQ = 1981;
+    public static readonly SYS_XQCON2SEQ = 1982;
+    public static readonly SYS_XQCONCAT = 1983;
+    public static readonly SYS_XQDELETE = 1984;
+    public static readonly SYS_XQDFLTCOLATION = 1985;
+    public static readonly SYS_XQDOC = 1986;
+    public static readonly SYS_XQDOCURI = 1987;
+    public static readonly SYS_XQDURDIV = 1988;
+    public static readonly SYS_XQED4URI = 1989;
+    public static readonly SYS_XQENDSWITH = 1990;
+    public static readonly SYS_XQERRH = 1991;
+    public static readonly SYS_XQERR = 1992;
+    public static readonly SYS_XQESHTMLURI = 1993;
+    public static readonly SYS_XQEXLOBVAL = 1994;
+    public static readonly SYS_XQEXSTWRP = 1995;
+    public static readonly SYS_XQEXTRACT = 1996;
+    public static readonly SYS_XQEXTRREF = 1997;
+    public static readonly SYS_XQEXVAL = 1998;
+    public static readonly SYS_XQFB2STR = 1999;
+    public static readonly SYS_XQFNBOOL = 2000;
+    public static readonly SYS_XQFNCMP = 2001;
+    public static readonly SYS_XQFNDATIM = 2002;
+    public static readonly SYS_XQFNLNAME = 2003;
+    public static readonly SYS_XQFNNM = 2004;
+    public static readonly SYS_XQFNNSURI = 2005;
+    public static readonly SYS_XQFNPREDTRUTH = 2006;
+    public static readonly SYS_XQFNQNM = 2007;
+    public static readonly SYS_XQFNROOT = 2008;
+    public static readonly SYS_XQFORMATNUM = 2009;
+    public static readonly SYS_XQFTCONTAIN = 2010;
+    public static readonly SYS_XQFUNCR = 2011;
+    public static readonly SYS_XQGETCONTENT = 2012;
+    public static readonly SYS_XQINDXOF = 2013;
+    public static readonly SYS_XQINSERT = 2014;
+    public static readonly SYS_XQINSPFX = 2015;
+    public static readonly SYS_XQIRI2URI = 2016;
+    public static readonly SYS_XQLANG = 2017;
+    public static readonly SYS_XQLLNMFRMQNM = 2018;
+    public static readonly SYS_XQMKNODEREF = 2019;
+    public static readonly SYS_XQNILLED = 2020;
+    public static readonly SYS_XQNODENAME = 2021;
+    public static readonly SYS_XQNORMSPACE = 2022;
+    public static readonly SYS_XQNORMUCODE = 2023;
+    public static readonly SYS_XQ_NRNG = 2024;
+    public static readonly SYS_XQNSP4PFX = 2025;
+    public static readonly SYS_XQNSPFRMQNM = 2026;
+    public static readonly SYS_XQPFXFRMQNM = 2027;
+    public static readonly SYS_XQ_PKSQL2XML = 2028;
+    public static readonly SYS_XQPOLYABS = 2029;
+    public static readonly SYS_XQPOLYADD = 2030;
+    public static readonly SYS_XQPOLYCEL = 2031;
+    public static readonly SYS_XQPOLYCSTBL = 2032;
+    public static readonly SYS_XQPOLYCST = 2033;
+    public static readonly SYS_XQPOLYDIV = 2034;
+    public static readonly SYS_XQPOLYFLR = 2035;
+    public static readonly SYS_XQPOLYMOD = 2036;
+    public static readonly SYS_XQPOLYMUL = 2037;
+    public static readonly SYS_XQPOLYRND = 2038;
+    public static readonly SYS_XQPOLYSQRT = 2039;
+    public static readonly SYS_XQPOLYSUB = 2040;
+    public static readonly SYS_XQPOLYUMUS = 2041;
+    public static readonly SYS_XQPOLYUPLS = 2042;
+    public static readonly SYS_XQPOLYVEQ = 2043;
+    public static readonly SYS_XQPOLYVGE = 2044;
+    public static readonly SYS_XQPOLYVGT = 2045;
+    public static readonly SYS_XQPOLYVLE = 2046;
+    public static readonly SYS_XQPOLYVLT = 2047;
+    public static readonly SYS_XQPOLYVNE = 2048;
+    public static readonly SYS_XQREF2VAL = 2049;
+    public static readonly SYS_XQRENAME = 2050;
+    public static readonly SYS_XQREPLACE = 2051;
+    public static readonly SYS_XQRESVURI = 2052;
+    public static readonly SYS_XQRNDHALF2EVN = 2053;
+    public static readonly SYS_XQRSLVQNM = 2054;
+    public static readonly SYS_XQRYENVPGET = 2055;
+    public static readonly SYS_XQRYVARGET = 2056;
+    public static readonly SYS_XQRYWRP = 2057;
+    public static readonly SYS_XQSEQ2CON4XC = 2058;
+    public static readonly SYS_XQSEQ2CON = 2059;
+    public static readonly SYS_XQSEQDEEPEQ = 2060;
+    public static readonly SYS_XQSEQINSB = 2061;
+    public static readonly SYS_XQSEQRM = 2062;
+    public static readonly SYS_XQSEQRVS = 2063;
+    public static readonly SYS_XQSEQSUB = 2064;
+    public static readonly SYS_XQSEQTYPMATCH = 2065;
+    public static readonly SYS_XQSTARTSWITH = 2066;
+    public static readonly SYS_XQSTATBURI = 2067;
+    public static readonly SYS_XQSTR2CODEP = 2068;
+    public static readonly SYS_XQSTRJOIN = 2069;
+    public static readonly SYS_XQSUBSTRAFT = 2070;
+    public static readonly SYS_XQSUBSTRBEF = 2071;
+    public static readonly SYS_XQTOKENIZE = 2072;
+    public static readonly SYS_XQTREATAS = 2073;
+    public static readonly SYS_XQ_UPKXML2SQL = 2074;
+    public static readonly SYS_XQXFORM = 2075;
+    public static readonly SYS_XSID_TO_RAW = 2076;
+    public static readonly SYS_ZMAP_FILTER = 2077;
+    public static readonly SYS_ZMAP_REFRESH = 2078;
+    public static readonly T_LETTER = 2079;
+    public static readonly TABLE_LOOKUP_BY_NL = 2080;
+    public static readonly TABLESPACE_NO = 2081;
+    public static readonly TABLESPACE = 2082;
+    public static readonly TABLES = 2083;
+    public static readonly TABLE_STATS = 2084;
+    public static readonly TABLE = 2085;
+    public static readonly TABNO = 2086;
+    public static readonly TAG = 2087;
+    public static readonly TANH = 2088;
+    public static readonly TAN = 2089;
+    public static readonly TBLORIDXPARTNUM = 2090;
+    public static readonly TEMPFILE = 2091;
+    public static readonly TEMPLATE = 2092;
+    public static readonly TEMPLATE_TABLE = 2093;
+    public static readonly TEMPORARY = 2094;
+    public static readonly TEMP_TABLE = 2095;
+    public static readonly TERMINATED = 2096;
+    public static readonly TEST = 2097;
+    public static readonly TEXT = 2098;
+    public static readonly TEXTFILE = 2099;
+    public static readonly THAN = 2100;
+    public static readonly THEN = 2101;
+    public static readonly THE = 2102;
+    public static readonly THESE = 2103;
+    public static readonly THREAD = 2104;
+    public static readonly THROUGH = 2105;
+    public static readonly TIER = 2106;
+    public static readonly TIES = 2107;
+    public static readonly TIMEOUT = 2108;
+    public static readonly TIMESTAMP_LTZ_UNCONSTRAINED = 2109;
+    public static readonly TIMESTAMP = 2110;
+    public static readonly TIMESTAMP_TZ_UNCONSTRAINED = 2111;
+    public static readonly TIMESTAMP_UNCONSTRAINED = 2112;
+    public static readonly TIMES = 2113;
+    public static readonly TIME = 2114;
+    public static readonly TIMEZONE = 2115;
+    public static readonly TIMEZONE_ABBR = 2116;
+    public static readonly TIMEZONE_HOUR = 2117;
+    public static readonly TIMEZONE_MINUTE = 2118;
+    public static readonly TIMEZONE_OFFSET = 2119;
+    public static readonly TIMEZONE_REGION = 2120;
+    public static readonly TIME_ZONE = 2121;
+    public static readonly TIMING = 2122;
+    public static readonly TINYINT = 2123;
+    public static readonly TIV_GB = 2124;
+    public static readonly TIV_SSF = 2125;
+    public static readonly TO_ACLID = 2126;
+    public static readonly TO_BINARY_DOUBLE = 2127;
+    public static readonly TO_BINARY_FLOAT = 2128;
+    public static readonly TO_BLOB = 2129;
+    public static readonly TO_CLOB = 2130;
+    public static readonly TO_DSINTERVAL = 2131;
+    public static readonly TO_LOB = 2132;
+    public static readonly TO_MULTI_BYTE = 2133;
+    public static readonly TO_NCHAR = 2134;
+    public static readonly TO_NCLOB = 2135;
+    public static readonly TO_NUMBER = 2136;
+    public static readonly TOPLEVEL = 2137;
+    public static readonly TO_SINGLE_BYTE = 2138;
+    public static readonly TO_TIMESTAMP = 2139;
+    public static readonly TO_TIMESTAMP_TZ = 2140;
+    public static readonly TO_TIME = 2141;
+    public static readonly TO_TIME_TZ = 2142;
+    public static readonly TO = 2143;
+    public static readonly TO_YMINTERVAL = 2144;
+    public static readonly TRACE = 2145;
+    public static readonly TRACING = 2146;
+    public static readonly TRACKING = 2147;
+    public static readonly TRAILING = 2148;
+    public static readonly TRANSACTION = 2149;
+    public static readonly TRANSFORM = 2150;
+    public static readonly TRANSFORMS = 2151;
+    public static readonly TRANSFORM_DISTINCT_AGG = 2152;
+    public static readonly TRANSITIONAL = 2153;
+    public static readonly TRANSITION = 2154;
+    public static readonly TRANSLATE = 2155;
+    public static readonly TRANSLATION = 2156;
+    public static readonly TREAT = 2157;
+    public static readonly TRIGGERS = 2158;
+    public static readonly TRIGGER = 2159;
+    public static readonly TRUE = 2160;
+    public static readonly TRUNCATE = 2161;
+    public static readonly TRUNC = 2162;
+    public static readonly TRUSTED = 2163;
+    public static readonly TRUST = 2164;
+    public static readonly TUNING = 2165;
+    public static readonly TX = 2166;
+    public static readonly TYPES = 2167;
+    public static readonly TYPE = 2168;
+    public static readonly TZ_OFFSET = 2169;
+    public static readonly UB2 = 2170;
+    public static readonly UBA = 2171;
+    public static readonly UCS2 = 2172;
+    public static readonly UDF = 2173;
+    public static readonly UID = 2174;
+    public static readonly UNARCHIVED = 2175;
+    public static readonly UNBOUNDED = 2176;
+    public static readonly UNBOUND = 2177;
+    public static readonly UNCONDITIONAL = 2178;
+    public static readonly UNDER = 2179;
+    public static readonly UNDO = 2180;
+    public static readonly UNDROP = 2181;
+    public static readonly UNIFORM = 2182;
+    public static readonly UNION = 2183;
+    public static readonly UNIONTYPE = 2184;
+    public static readonly UNIQUE = 2185;
+    public static readonly UNISTR = 2186;
+    public static readonly UNLIMITED = 2187;
+    public static readonly UNLOAD = 2188;
+    public static readonly UNLOCK = 2189;
+    public static readonly UNMATCHED = 2190;
+    public static readonly UNNEST_INNERJ_DISTINCT_VIEW = 2191;
+    public static readonly UNNEST_NOSEMIJ_NODISTINCTVIEW = 2192;
+    public static readonly UNNEST_SEMIJ_VIEW = 2193;
+    public static readonly UNNEST = 2194;
+    public static readonly UNPACKED = 2195;
+    public static readonly UNPIVOT = 2196;
+    public static readonly UNPLUG = 2197;
+    public static readonly UNPROTECTED = 2198;
+    public static readonly UNQUIESCE = 2199;
+    public static readonly UNRECOVERABLE = 2200;
+    public static readonly UNRESTRICTED = 2201;
+    public static readonly UNSIGNED = 2202;
+    public static readonly UNSUBSCRIBE = 2203;
+    public static readonly UNTIL = 2204;
+    public static readonly UNUSABLE = 2205;
+    public static readonly UNUSED = 2206;
+    public static readonly UPDATABLE = 2207;
+    public static readonly UPDATED = 2208;
+    public static readonly UPDATE = 2209;
+    public static readonly UPDATEXML = 2210;
+    public static readonly UPD_INDEXES = 2211;
+    public static readonly UPD_JOININDEX = 2212;
+    public static readonly UPGRADE = 2213;
+    public static readonly UPPER = 2214;
+    public static readonly UPSERT = 2215;
+    public static readonly UROWID = 2216;
+    public static readonly USABLE = 2217;
+    public static readonly USAGE = 2218;
+    public static readonly USE_ANTI = 2219;
+    public static readonly USE_CONCAT = 2220;
+    public static readonly USE_CUBE = 2221;
+    public static readonly USE_HASH_AGGREGATION = 2222;
+    public static readonly USE_HASH_GBY_FOR_PUSHDOWN = 2223;
+    public static readonly USE_HASH = 2224;
+    public static readonly USE_HIDDEN_PARTITIONS = 2225;
+    public static readonly USE_INVISIBLE_INDEXES = 2226;
+    public static readonly USE_MERGE_CARTESIAN = 2227;
+    public static readonly USE_MERGE = 2228;
+    public static readonly USE_NL = 2229;
+    public static readonly USE_NL_WITH_INDEX = 2230;
+    public static readonly USE_PRIVATE_OUTLINES = 2231;
+    public static readonly USER_DATA = 2232;
+    public static readonly USER_DEFINED = 2233;
+    public static readonly USERENV = 2234;
+    public static readonly USERGROUP = 2235;
+    public static readonly USER_RECYCLEBIN = 2236;
+    public static readonly USERS = 2237;
+    public static readonly USER_TABLESPACES = 2238;
+    public static readonly USER = 2239;
+    public static readonly USE_SEMI = 2240;
+    public static readonly USE_STORED_OUTLINES = 2241;
+    public static readonly USE_TTT_FOR_GSETS = 2242;
+    public static readonly USE = 2243;
+    public static readonly USE_VECTOR_AGGREGATION = 2244;
+    public static readonly USE_WEAK_NAME_RESL = 2245;
+    public static readonly USING_NO_EXPAND = 2246;
+    public static readonly USING_NLS_COMP = 2247;
+    public static readonly USING = 2248;
+    public static readonly UTF16BE = 2249;
+    public static readonly UTF16LE = 2250;
+    public static readonly UTF32 = 2251;
+    public static readonly UTF8 = 2252;
+    public static readonly V1 = 2253;
+    public static readonly V2 = 2254;
+    public static readonly VALIDATE = 2255;
+    public static readonly VALIDATE_CONVERSION = 2256;
+    public static readonly VALIDATION = 2257;
+    public static readonly VALID_TIME_END = 2258;
+    public static readonly VALUES = 2259;
+    public static readonly VALUE = 2260;
+    public static readonly VARCHAR2 = 2261;
+    public static readonly VARCHAR = 2262;
+    public static readonly VARCHARC = 2263;
+    public static readonly VARIABLE = 2264;
+    public static readonly VARRAW = 2265;
+    public static readonly VARRAWC = 2266;
+    public static readonly VAR_POP = 2267;
+    public static readonly VARRAYS = 2268;
+    public static readonly VARRAY = 2269;
+    public static readonly VAR_SAMP = 2270;
+    public static readonly VARYING = 2271;
+    public static readonly VECTOR_READ_TRACE = 2272;
+    public static readonly VECTOR_READ = 2273;
+    public static readonly VECTOR_TRANSFORM_DIMS = 2274;
+    public static readonly VECTOR_TRANSFORM_FACT = 2275;
+    public static readonly VECTOR_TRANSFORM = 2276;
+    public static readonly VERIFIER = 2277;
+    public static readonly VERIFY = 2278;
+    public static readonly VERSIONING = 2279;
+    public static readonly VERSIONS_ENDSCN = 2280;
+    public static readonly VERSIONS_ENDTIME = 2281;
+    public static readonly VERSIONS_OPERATION = 2282;
+    public static readonly VERSIONS_STARTSCN = 2283;
+    public static readonly VERSIONS_STARTTIME = 2284;
+    public static readonly VERSIONS = 2285;
+    public static readonly VERSIONS_XID = 2286;
+    public static readonly VERSION = 2287;
+    public static readonly VIEW = 2288;
+    public static readonly VIOLATION = 2289;
+    public static readonly VIRTUAL = 2290;
+    public static readonly VISIBILITY = 2291;
+    public static readonly VISIBLE = 2292;
+    public static readonly VOLUME = 2293;
+    public static readonly VSIZE = 2294;
+    public static readonly WAIT = 2295;
+    public static readonly WALLET = 2296;
+    public static readonly WARNING = 2297;
+    public static readonly WEEKS = 2298;
+    public static readonly WEEK = 2299;
+    public static readonly WELLFORMED = 2300;
+    public static readonly WHENEVER = 2301;
+    public static readonly WHEN = 2302;
+    public static readonly WHERE = 2303;
+    public static readonly WHILE = 2304;
+    public static readonly WHITESPACE = 2305;
+    public static readonly WIDTH_BUCKET = 2306;
+    public static readonly WITHIN = 2307;
+    public static readonly WITHOUT = 2308;
+    public static readonly WITH_PLSQL = 2309;
+    public static readonly WITH = 2310;
+    public static readonly WORK = 2311;
+    public static readonly WORKERID = 2312;
+    public static readonly WRAPPED = 2313;
+    public static readonly WRAPPER = 2314;
+    public static readonly WRITE = 2315;
+    public static readonly XDB_FASTPATH_INSERT = 2316;
+    public static readonly XDB = 2317;
+    public static readonly X_DYN_PRUNE = 2318;
+    public static readonly XID = 2319;
+    public static readonly XML2OBJECT = 2320;
+    public static readonly XMLAGG = 2321;
+    public static readonly XMLATTRIBUTES = 2322;
+    public static readonly XMLCAST = 2323;
+    public static readonly XMLCDATA = 2324;
+    public static readonly XMLCOLATTVAL = 2325;
+    public static readonly XMLCOMMENT = 2326;
+    public static readonly XMLCONCAT = 2327;
+    public static readonly XMLDIFF = 2328;
+    public static readonly XML_DML_RWT_STMT = 2329;
+    public static readonly XMLELEMENT = 2330;
+    public static readonly XMLEXISTS2 = 2331;
+    public static readonly XMLEXISTS = 2332;
+    public static readonly XMLFOREST = 2333;
+    public static readonly XMLINDEX = 2334;
+    public static readonly XMLINDEX_REWRITE_IN_SELECT = 2335;
+    public static readonly XMLINDEX_REWRITE = 2336;
+    public static readonly XMLINDEX_SEL_IDX_TBL = 2337;
+    public static readonly XMLISNODE = 2338;
+    public static readonly XMLISVALID = 2339;
+    public static readonly XMLNAMESPACES = 2340;
+    public static readonly XMLPARSE = 2341;
+    public static readonly XMLPATCH = 2342;
+    public static readonly XMLPI = 2343;
+    public static readonly XMLQUERYVAL = 2344;
+    public static readonly XMLQUERY = 2345;
+    public static readonly XMLROOT = 2346;
+    public static readonly XMLSCHEMA = 2347;
+    public static readonly XMLSERIALIZE = 2348;
+    public static readonly XMLTABLE = 2349;
+    public static readonly XMLTAG = 2350;
+    public static readonly XMLTRANSFORMBLOB = 2351;
+    public static readonly XMLTRANSFORM = 2352;
+    public static readonly XMLTYPE = 2353;
+    public static readonly XML = 2354;
+    public static readonly XPATHTABLE = 2355;
+    public static readonly XS_SYS_CONTEXT = 2356;
+    public static readonly XS = 2357;
+    public static readonly XTRANSPORT = 2358;
+    public static readonly YEARS = 2359;
+    public static readonly YEAR = 2360;
+    public static readonly YEAR_TO_MONTH = 2361;
+    public static readonly YES = 2362;
+    public static readonly YMINTERVAL_UNCONSTRAINED = 2363;
+    public static readonly ZONEMAP = 2364;
+    public static readonly ZONE = 2365;
+    public static readonly ZONED = 2366;
+    public static readonly PREDICTION = 2367;
+    public static readonly PREDICTION_BOUNDS = 2368;
+    public static readonly PREDICTION_COST = 2369;
+    public static readonly PREDICTION_DETAILS = 2370;
+    public static readonly PREDICTION_PROBABILITY = 2371;
+    public static readonly PREDICTION_SET = 2372;
+    public static readonly BLOCKCHAIN = 2373;
+    public static readonly COLLATE = 2374;
+    public static readonly COLLATION = 2375;
+    public static readonly DEFINITION = 2376;
+    public static readonly DUPLICATED = 2377;
+    public static readonly EXTENDED = 2378;
+    public static readonly HASHING = 2379;
+    public static readonly IDLE = 2380;
+    public static readonly IMMUTABLE = 2381;
+    public static readonly ORACLE_DATAPUMP = 2382;
+    public static readonly ORACLE_HDFS = 2383;
+    public static readonly ORACLE_HIVE = 2384;
+    public static readonly ORACLE_LOADER = 2385;
+    public static readonly SHA2_512_Q = 2386;
+    public static readonly SHARDED = 2387;
+    public static readonly V1_Q = 2388;
+    public static readonly ISOLATE = 2389;
+    public static readonly ROOT = 2390;
+    public static readonly UNITE = 2391;
+    public static readonly ALGORITHM = 2392;
+    public static readonly CUME_DIST = 2393;
+    public static readonly DENSE_RANK = 2394;
+    public static readonly LISTAGG = 2395;
+    public static readonly PERCENT_RANK = 2396;
+    public static readonly PERCENTILE_CONT = 2397;
+    public static readonly PERCENTILE_DISC = 2398;
+    public static readonly RANK = 2399;
+    public static readonly AVG = 2400;
+    public static readonly CORR = 2401;
+    public static readonly COVAR_ = 2402;
+    public static readonly DECODE = 2403;
+    public static readonly LAG = 2404;
+    public static readonly LAG_DIFF = 2405;
+    public static readonly LAG_DIFF_PERCENT = 2406;
+    public static readonly LEAD = 2407;
+    public static readonly MAX = 2408;
+    public static readonly MEDIAN = 2409;
+    public static readonly MEMOPTIMIZE = 2410;
+    public static readonly MIN = 2411;
+    public static readonly NTILE = 2412;
+    public static readonly NVL = 2413;
+    public static readonly RATIO_TO_REPORT = 2414;
+    public static readonly REGR_ = 2415;
+    public static readonly ROUND = 2416;
+    public static readonly ROW_NUMBER = 2417;
+    public static readonly SUBSTR = 2418;
+    public static readonly TO_CHAR = 2419;
+    public static readonly TRIM = 2420;
+    public static readonly SUM = 2421;
+    public static readonly STDDEV = 2422;
+    public static readonly VAR_ = 2423;
+    public static readonly VARIANCE = 2424;
+    public static readonly LEAST = 2425;
+    public static readonly GREATEST = 2426;
+    public static readonly TO_DATE = 2427;
+    public static readonly CHARSETID = 2428;
+    public static readonly CHARSETFORM = 2429;
+    public static readonly DURATION = 2430;
+    public static readonly EXTEND = 2431;
+    public static readonly MAXLEN = 2432;
+    public static readonly PERSISTABLE = 2433;
+    public static readonly POLYMORPHIC = 2434;
+    public static readonly STRUCT = 2435;
+    public static readonly TDO = 2436;
+    public static readonly WM_CONCAT = 2437;
+    public static readonly NATIONAL_CHAR_STRING_LIT = 2438;
+    public static readonly BIT_STRING_LIT = 2439;
+    public static readonly HEX_STRING_LIT = 2440;
+    public static readonly DOUBLE_PERIOD = 2441;
+    public static readonly PERIOD = 2442;
+    public static readonly UNSIGNED_INTEGER = 2443;
+    public static readonly APPROXIMATE_NUM_LIT = 2444;
+    public static readonly CHAR_STRING = 2445;
+    public static readonly DELIMITED_ID = 2446;
+    public static readonly PERCENT = 2447;
+    public static readonly AMPERSAND = 2448;
+    public static readonly LEFT_PAREN = 2449;
+    public static readonly RIGHT_PAREN = 2450;
+    public static readonly DOUBLE_ASTERISK = 2451;
+    public static readonly ASTERISK = 2452;
+    public static readonly PLUS_SIGN = 2453;
+    public static readonly MINUS_SIGN = 2454;
+    public static readonly COMMA = 2455;
+    public static readonly SOLIDUS = 2456;
+    public static readonly RSOLIDUS = 2457;
+    public static readonly AT_SIGN = 2458;
+    public static readonly ASSIGN_OP = 2459;
+    public static readonly HASH_OP = 2460;
+    public static readonly LEFT_CURLY_PAREN = 2461;
+    public static readonly RIGHT_CURLY_PAREN = 2462;
+    public static readonly SQ = 2463;
+    public static readonly BINDVAR = 2464;
+    public static readonly NOT_EQUAL_OP = 2465;
+    public static readonly CARRET_OPERATOR_PART = 2466;
+    public static readonly TILDE_OPERATOR_PART = 2467;
+    public static readonly EXCLAMATION_OPERATOR_PART = 2468;
+    public static readonly GREATER_THAN_OP = 2469;
+    public static readonly LESS_THAN_OP = 2470;
+    public static readonly COLON = 2471;
+    public static readonly SEMICOLON = 2472;
+    public static readonly BAR = 2473;
+    public static readonly EQUALS_OP = 2474;
+    public static readonly LEFT_BRACKET = 2475;
+    public static readonly RIGHT_BRACKET = 2476;
+    public static readonly INTRODUCER = 2477;
+    public static readonly SINGLE_LINE_COMMENT = 2478;
+    public static readonly MULTI_LINE_COMMENT = 2479;
+    public static readonly REMARK_COMMENT = 2480;
+    public static readonly PROMPT_MESSAGE = 2481;
+    public static readonly REGULAR_ID = 2482;
+    public static readonly INQUIRY_DIRECTIVE = 2483;
+    public static readonly SPACES = 2484;
+    public static readonly RULE_sql_script = 0;
+    public static readonly RULE_script_unit = 1;
+    public static readonly RULE_terminator = 2;
+    public static readonly RULE_plsql_unit = 3;
+    public static readonly RULE_sql_unit = 4;
+    public static readonly RULE_alter_diskgroup = 5;
+    public static readonly RULE_add_disk_clause = 6;
+    public static readonly RULE_drop_disk_clause = 7;
+    public static readonly RULE_resize_disk_clause = 8;
+    public static readonly RULE_replace_disk_clause = 9;
+    public static readonly RULE_wait_nowait = 10;
+    public static readonly RULE_rename_disk_clause = 11;
+    public static readonly RULE_disk_online_clause = 12;
+    public static readonly RULE_disk_offline_clause = 13;
+    public static readonly RULE_timeout_clause = 14;
+    public static readonly RULE_rebalance_diskgroup_clause = 15;
+    public static readonly RULE_phase = 16;
+    public static readonly RULE_check_diskgroup_clause = 17;
+    public static readonly RULE_diskgroup_template_clauses = 18;
+    public static readonly RULE_qualified_template_clause = 19;
+    public static readonly RULE_redundancy_clause = 20;
+    public static readonly RULE_striping_clause = 21;
+    public static readonly RULE_force_noforce = 22;
+    public static readonly RULE_diskgroup_directory_clauses = 23;
+    public static readonly RULE_dir_name = 24;
+    public static readonly RULE_diskgroup_alias_clauses = 25;
+    public static readonly RULE_diskgroup_volume_clauses = 26;
+    public static readonly RULE_add_volume_clause = 27;
+    public static readonly RULE_modify_volume_clause = 28;
+    public static readonly RULE_diskgroup_attributes = 29;
+    public static readonly RULE_drop_diskgroup_file_clause = 30;
+    public static readonly RULE_convert_redundancy_clause = 31;
+    public static readonly RULE_usergroup_clauses = 32;
+    public static readonly RULE_user_clauses = 33;
+    public static readonly RULE_file_permissions_clause = 34;
+    public static readonly RULE_file_owner_clause = 35;
+    public static readonly RULE_scrub_clause = 36;
+    public static readonly RULE_quotagroup_clauses = 37;
+    public static readonly RULE_property_name = 38;
+    public static readonly RULE_property_value = 39;
+    public static readonly RULE_filegroup_clauses = 40;
+    public static readonly RULE_add_filegroup_clause = 41;
+    public static readonly RULE_modify_filegroup_clause = 42;
+    public static readonly RULE_move_to_filegroup_clause = 43;
+    public static readonly RULE_drop_filegroup_clause = 44;
+    public static readonly RULE_quorum_regular = 45;
+    public static readonly RULE_undrop_disk_clause = 46;
+    public static readonly RULE_diskgroup_availability = 47;
+    public static readonly RULE_enable_disable_volume = 48;
+    public static readonly RULE_drop_function = 49;
+    public static readonly RULE_alter_flashback_archive = 50;
+    public static readonly RULE_alter_hierarchy = 51;
+    public static readonly RULE_alter_function = 52;
+    public static readonly RULE_alter_java = 53;
+    public static readonly RULE_match_string = 54;
+    public static readonly RULE_create_function_body = 55;
+    public static readonly RULE_sql_macro_body = 56;
+    public static readonly RULE_parallel_enable_clause = 57;
+    public static readonly RULE_partition_by_clause = 58;
+    public static readonly RULE_result_cache_clause = 59;
+    public static readonly RULE_accessible_by_clause = 60;
+    public static readonly RULE_default_collation_clause = 61;
+    public static readonly RULE_aggregate_clause = 62;
+    public static readonly RULE_pipelined_using_clause = 63;
+    public static readonly RULE_accessor = 64;
+    public static readonly RULE_relies_on_part = 65;
+    public static readonly RULE_streaming_clause = 66;
+    public static readonly RULE_alter_outline = 67;
+    public static readonly RULE_outline_options = 68;
+    public static readonly RULE_alter_lockdown_profile = 69;
+    public static readonly RULE_lockdown_feature = 70;
+    public static readonly RULE_lockdown_options = 71;
+    public static readonly RULE_lockdown_statements = 72;
+    public static readonly RULE_statement_clauses = 73;
+    public static readonly RULE_clause_options = 74;
+    public static readonly RULE_option_values = 75;
+    public static readonly RULE_string_list = 76;
+    public static readonly RULE_disable_enable = 77;
+    public static readonly RULE_drop_lockdown_profile = 78;
+    public static readonly RULE_drop_package = 79;
+    public static readonly RULE_alter_package = 80;
+    public static readonly RULE_create_package = 81;
+    public static readonly RULE_create_package_body = 82;
+    public static readonly RULE_package_obj_spec = 83;
+    public static readonly RULE_procedure_spec = 84;
+    public static readonly RULE_function_spec = 85;
+    public static readonly RULE_package_obj_body = 86;
+    public static readonly RULE_alter_pmem_filestore = 87;
+    public static readonly RULE_drop_pmem_filestore = 88;
+    public static readonly RULE_drop_procedure = 89;
+    public static readonly RULE_alter_procedure = 90;
+    public static readonly RULE_function_body = 91;
+    public static readonly RULE_procedure_body = 92;
+    public static readonly RULE_create_procedure_body = 93;
+    public static readonly RULE_alter_resource_cost = 94;
+    public static readonly RULE_drop_outline = 95;
+    public static readonly RULE_alter_rollback_segment = 96;
+    public static readonly RULE_drop_restore_point = 97;
+    public static readonly RULE_drop_rollback_segment = 98;
+    public static readonly RULE_drop_role = 99;
+    public static readonly RULE_create_pmem_filestore = 100;
+    public static readonly RULE_pmem_filestore_options = 101;
+    public static readonly RULE_file_path = 102;
+    public static readonly RULE_create_rollback_segment = 103;
+    public static readonly RULE_drop_trigger = 104;
+    public static readonly RULE_alter_trigger = 105;
+    public static readonly RULE_create_trigger = 106;
+    public static readonly RULE_trigger_follows_clause = 107;
+    public static readonly RULE_trigger_when_clause = 108;
+    public static readonly RULE_simple_dml_trigger = 109;
+    public static readonly RULE_for_each_row = 110;
+    public static readonly RULE_compound_dml_trigger = 111;
+    public static readonly RULE_non_dml_trigger = 112;
+    public static readonly RULE_trigger_body = 113;
+    public static readonly RULE_compound_trigger_block = 114;
+    public static readonly RULE_timing_point_section = 115;
+    public static readonly RULE_non_dml_event = 116;
+    public static readonly RULE_dml_event_clause = 117;
+    public static readonly RULE_dml_event_element = 118;
+    public static readonly RULE_dml_event_nested_clause = 119;
+    public static readonly RULE_referencing_clause = 120;
+    public static readonly RULE_referencing_element = 121;
+    public static readonly RULE_drop_type = 122;
+    public static readonly RULE_alter_type = 123;
+    public static readonly RULE_compile_type_clause = 124;
+    public static readonly RULE_replace_type_clause = 125;
+    public static readonly RULE_alter_method_spec = 126;
+    public static readonly RULE_alter_method_element = 127;
+    public static readonly RULE_alter_attribute_definition = 128;
+    public static readonly RULE_alter_collection_clauses = 129;
+    public static readonly RULE_dependent_handling_clause = 130;
+    public static readonly RULE_dependent_exceptions_part = 131;
+    public static readonly RULE_create_type = 132;
+    public static readonly RULE_create_type_spec = 133;
+    public static readonly RULE_create_type_body = 134;
+    public static readonly RULE_type_definition = 135;
+    public static readonly RULE_object_type_def = 136;
+    public static readonly RULE_object_as_part = 137;
+    public static readonly RULE_object_under_part = 138;
+    public static readonly RULE_nested_table_type_def = 139;
+    public static readonly RULE_sqlj_object_type = 140;
+    public static readonly RULE_type_body = 141;
+    public static readonly RULE_type_body_elements = 142;
+    public static readonly RULE_map_order_func_declaration = 143;
+    public static readonly RULE_subprog_decl_in_type = 144;
+    public static readonly RULE_proc_decl_in_type = 145;
+    public static readonly RULE_func_decl_in_type = 146;
+    public static readonly RULE_constructor_declaration = 147;
+    public static readonly RULE_modifier_clause = 148;
+    public static readonly RULE_object_member_spec = 149;
+    public static readonly RULE_sqlj_object_type_attr = 150;
+    public static readonly RULE_element_spec = 151;
+    public static readonly RULE_element_spec_options = 152;
+    public static readonly RULE_subprogram_spec = 153;
+    public static readonly RULE_overriding_subprogram_spec = 154;
+    public static readonly RULE_overriding_function_spec = 155;
+    public static readonly RULE_overriding_procedure_spec = 156;
+    public static readonly RULE_type_procedure_spec = 157;
+    public static readonly RULE_type_function_spec = 158;
+    public static readonly RULE_constructor_spec = 159;
+    public static readonly RULE_map_order_function_spec = 160;
+    public static readonly RULE_pragma_clause = 161;
+    public static readonly RULE_pragma_elements = 162;
+    public static readonly RULE_type_elements_parameter = 163;
+    public static readonly RULE_drop_sequence = 164;
+    public static readonly RULE_alter_sequence = 165;
+    public static readonly RULE_alter_session = 166;
+    public static readonly RULE_alter_session_set_clause = 167;
+    public static readonly RULE_create_sequence = 168;
+    public static readonly RULE_sequence_spec = 169;
+    public static readonly RULE_sequence_start_clause = 170;
+    public static readonly RULE_create_analytic_view = 171;
+    public static readonly RULE_classification_clause = 172;
+    public static readonly RULE_caption_clause = 173;
+    public static readonly RULE_description_clause = 174;
+    public static readonly RULE_classification_item = 175;
+    public static readonly RULE_language = 176;
+    public static readonly RULE_cav_using_clause = 177;
+    public static readonly RULE_dim_by_clause = 178;
+    public static readonly RULE_dim_key = 179;
+    public static readonly RULE_dim_ref = 180;
+    public static readonly RULE_hier_ref = 181;
+    public static readonly RULE_measures_clause = 182;
+    public static readonly RULE_av_measure = 183;
+    public static readonly RULE_base_meas_clause = 184;
+    public static readonly RULE_meas_aggregate_clause = 185;
+    public static readonly RULE_calc_meas_clause = 186;
+    public static readonly RULE_default_measure_clause = 187;
+    public static readonly RULE_default_aggregate_clause = 188;
+    public static readonly RULE_cache_clause = 189;
+    public static readonly RULE_cache_specification = 190;
+    public static readonly RULE_levels_clause = 191;
+    public static readonly RULE_level_specification = 192;
+    public static readonly RULE_level_group_type = 193;
+    public static readonly RULE_fact_columns_clause = 194;
+    public static readonly RULE_qry_transform_clause = 195;
+    public static readonly RULE_create_attribute_dimension = 196;
+    public static readonly RULE_ad_using_clause = 197;
+    public static readonly RULE_source_clause = 198;
+    public static readonly RULE_join_path_clause = 199;
+    public static readonly RULE_join_condition = 200;
+    public static readonly RULE_join_condition_item = 201;
+    public static readonly RULE_attributes_clause = 202;
+    public static readonly RULE_ad_attributes_clause = 203;
+    public static readonly RULE_ad_level_clause = 204;
+    public static readonly RULE_key_clause = 205;
+    public static readonly RULE_alternate_key_clause = 206;
+    public static readonly RULE_dim_order_clause = 207;
+    public static readonly RULE_all_clause = 208;
+    public static readonly RULE_create_audit_policy = 209;
+    public static readonly RULE_privilege_audit_clause = 210;
+    public static readonly RULE_action_audit_clause = 211;
+    public static readonly RULE_system_actions = 212;
+    public static readonly RULE_standard_actions = 213;
+    public static readonly RULE_actions_clause = 214;
+    public static readonly RULE_object_action = 215;
+    public static readonly RULE_system_action = 216;
+    public static readonly RULE_component_actions = 217;
+    public static readonly RULE_component_action = 218;
+    public static readonly RULE_role_audit_clause = 219;
+    public static readonly RULE_create_controlfile = 220;
+    public static readonly RULE_controlfile_options = 221;
+    public static readonly RULE_logfile_clause = 222;
+    public static readonly RULE_character_set_clause = 223;
+    public static readonly RULE_file_specification = 224;
+    public static readonly RULE_create_diskgroup = 225;
+    public static readonly RULE_qualified_disk_clause = 226;
+    public static readonly RULE_create_edition = 227;
+    public static readonly RULE_create_flashback_archive = 228;
+    public static readonly RULE_flashback_archive_quota = 229;
+    public static readonly RULE_flashback_archive_retention = 230;
+    public static readonly RULE_create_hierarchy = 231;
+    public static readonly RULE_hier_using_clause = 232;
+    public static readonly RULE_level_hier_clause = 233;
+    public static readonly RULE_hier_attrs_clause = 234;
+    public static readonly RULE_hier_attr_clause = 235;
+    public static readonly RULE_hier_attr_name = 236;
+    public static readonly RULE_create_index = 237;
+    public static readonly RULE_cluster_index_clause = 238;
+    public static readonly RULE_cluster_name = 239;
+    public static readonly RULE_table_index_clause = 240;
+    public static readonly RULE_bitmap_join_index_clause = 241;
+    public static readonly RULE_index_expr = 242;
+    public static readonly RULE_index_properties = 243;
+    public static readonly RULE_domain_index_clause = 244;
+    public static readonly RULE_local_domain_index_clause = 245;
+    public static readonly RULE_xmlindex_clause = 246;
+    public static readonly RULE_local_xmlindex_clause = 247;
+    public static readonly RULE_global_partitioned_index = 248;
+    public static readonly RULE_index_partitioning_clause = 249;
+    public static readonly RULE_index_partitioning_values_list = 250;
+    public static readonly RULE_local_partitioned_index = 251;
+    public static readonly RULE_on_range_partitioned_table = 252;
+    public static readonly RULE_on_list_partitioned_table = 253;
+    public static readonly RULE_partitioned_table = 254;
+    public static readonly RULE_on_hash_partitioned_table = 255;
+    public static readonly RULE_on_hash_partitioned_clause = 256;
+    public static readonly RULE_on_comp_partitioned_table = 257;
+    public static readonly RULE_on_comp_partitioned_clause = 258;
+    public static readonly RULE_index_subpartition_clause = 259;
+    public static readonly RULE_index_subpartition_subclause = 260;
+    public static readonly RULE_odci_parameters = 261;
+    public static readonly RULE_indextype = 262;
+    public static readonly RULE_alter_index = 263;
+    public static readonly RULE_alter_index_ops_set1 = 264;
+    public static readonly RULE_alter_index_ops_set2 = 265;
+    public static readonly RULE_visible_or_invisible = 266;
+    public static readonly RULE_monitoring_nomonitoring = 267;
+    public static readonly RULE_rebuild_clause = 268;
+    public static readonly RULE_alter_index_partitioning = 269;
+    public static readonly RULE_modify_index_default_attrs = 270;
+    public static readonly RULE_add_hash_index_partition = 271;
+    public static readonly RULE_coalesce_index_partition = 272;
+    public static readonly RULE_modify_index_partition = 273;
+    public static readonly RULE_modify_index_partitions_ops = 274;
+    public static readonly RULE_rename_index_partition = 275;
+    public static readonly RULE_drop_index_partition = 276;
+    public static readonly RULE_split_index_partition = 277;
+    public static readonly RULE_index_partition_description = 278;
+    public static readonly RULE_modify_index_subpartition = 279;
+    public static readonly RULE_partition_name_old = 280;
+    public static readonly RULE_new_partition_name = 281;
+    public static readonly RULE_new_index_name = 282;
+    public static readonly RULE_alter_inmemory_join_group = 283;
+    public static readonly RULE_create_user = 284;
+    public static readonly RULE_alter_user = 285;
+    public static readonly RULE_drop_user = 286;
+    public static readonly RULE_alter_identified_by = 287;
+    public static readonly RULE_identified_by = 288;
+    public static readonly RULE_identified_other_clause = 289;
+    public static readonly RULE_user_tablespace_clause = 290;
+    public static readonly RULE_quota_clause = 291;
+    public static readonly RULE_profile_clause = 292;
+    public static readonly RULE_role_clause = 293;
+    public static readonly RULE_user_default_role_clause = 294;
+    public static readonly RULE_password_expire_clause = 295;
+    public static readonly RULE_user_lock_clause = 296;
+    public static readonly RULE_user_editions_clause = 297;
+    public static readonly RULE_alter_user_editions_clause = 298;
+    public static readonly RULE_proxy_clause = 299;
+    public static readonly RULE_container_names = 300;
+    public static readonly RULE_set_container_data = 301;
+    public static readonly RULE_add_rem_container_data = 302;
+    public static readonly RULE_container_data_clause = 303;
+    public static readonly RULE_administer_key_management = 304;
+    public static readonly RULE_keystore_management_clauses = 305;
+    public static readonly RULE_create_keystore = 306;
+    public static readonly RULE_open_keystore = 307;
+    public static readonly RULE_force_keystore = 308;
+    public static readonly RULE_close_keystore = 309;
+    public static readonly RULE_backup_keystore = 310;
+    public static readonly RULE_alter_keystore_password = 311;
+    public static readonly RULE_merge_into_new_keystore = 312;
+    public static readonly RULE_merge_into_existing_keystore = 313;
+    public static readonly RULE_isolate_keystore = 314;
+    public static readonly RULE_unite_keystore = 315;
+    public static readonly RULE_key_management_clauses = 316;
+    public static readonly RULE_set_key = 317;
+    public static readonly RULE_create_key = 318;
+    public static readonly RULE_mkid = 319;
+    public static readonly RULE_mk = 320;
+    public static readonly RULE_use_key = 321;
+    public static readonly RULE_set_key_tag = 322;
+    public static readonly RULE_export_keys = 323;
+    public static readonly RULE_import_keys = 324;
+    public static readonly RULE_migrate_keys = 325;
+    public static readonly RULE_reverse_migrate_keys = 326;
+    public static readonly RULE_move_keys = 327;
+    public static readonly RULE_identified_by_store = 328;
+    public static readonly RULE_using_algorithm_clause = 329;
+    public static readonly RULE_using_tag_clause = 330;
+    public static readonly RULE_secret_management_clauses = 331;
+    public static readonly RULE_add_update_secret = 332;
+    public static readonly RULE_delete_secret = 333;
+    public static readonly RULE_add_update_secret_seps = 334;
+    public static readonly RULE_delete_secret_seps = 335;
+    public static readonly RULE_zero_downtime_software_patching_clauses = 336;
+    public static readonly RULE_with_backup_clause = 337;
+    public static readonly RULE_identified_by_password_clause = 338;
+    public static readonly RULE_keystore_password = 339;
+    public static readonly RULE_path = 340;
+    public static readonly RULE_secret = 341;
+    public static readonly RULE_analyze = 342;
+    public static readonly RULE_partition_extention_clause = 343;
+    public static readonly RULE_validation_clauses = 344;
+    public static readonly RULE_compute_clauses = 345;
+    public static readonly RULE_for_clause = 346;
+    public static readonly RULE_online_or_offline = 347;
+    public static readonly RULE_into_clause1 = 348;
+    public static readonly RULE_partition_key_value = 349;
+    public static readonly RULE_subpartition_key_value = 350;
+    public static readonly RULE_associate_statistics = 351;
+    public static readonly RULE_column_association = 352;
+    public static readonly RULE_function_association = 353;
+    public static readonly RULE_indextype_name = 354;
+    public static readonly RULE_using_statistics_type = 355;
+    public static readonly RULE_statistics_type_name = 356;
+    public static readonly RULE_default_cost_clause = 357;
+    public static readonly RULE_cpu_cost = 358;
+    public static readonly RULE_io_cost = 359;
+    public static readonly RULE_network_cost = 360;
+    public static readonly RULE_default_selectivity_clause = 361;
+    public static readonly RULE_default_selectivity = 362;
+    public static readonly RULE_storage_table_clause = 363;
+    public static readonly RULE_unified_auditing = 364;
+    public static readonly RULE_policy_name = 365;
+    public static readonly RULE_audit_traditional = 366;
+    public static readonly RULE_audit_direct_path = 367;
+    public static readonly RULE_audit_container_clause = 368;
+    public static readonly RULE_audit_operation_clause = 369;
+    public static readonly RULE_auditing_by_clause = 370;
+    public static readonly RULE_audit_user = 371;
+    public static readonly RULE_audit_schema_object_clause = 372;
+    public static readonly RULE_sql_operation = 373;
+    public static readonly RULE_auditing_on_clause = 374;
+    public static readonly RULE_model_name = 375;
+    public static readonly RULE_object_name = 376;
+    public static readonly RULE_profile_name = 377;
+    public static readonly RULE_sql_statement_shortcut = 378;
+    public static readonly RULE_drop_index = 379;
+    public static readonly RULE_disassociate_statistics = 380;
+    public static readonly RULE_drop_indextype = 381;
+    public static readonly RULE_drop_inmemory_join_group = 382;
+    public static readonly RULE_flashback_table = 383;
+    public static readonly RULE_restore_point = 384;
+    public static readonly RULE_purge_statement = 385;
+    public static readonly RULE_noaudit_statement = 386;
+    public static readonly RULE_rename_object = 387;
+    public static readonly RULE_grant_statement = 388;
+    public static readonly RULE_container_clause = 389;
+    public static readonly RULE_revoke_statement = 390;
+    public static readonly RULE_revoke_system_privilege = 391;
+    public static readonly RULE_revokee_clause = 392;
+    public static readonly RULE_revoke_object_privileges = 393;
+    public static readonly RULE_on_object_clause = 394;
+    public static readonly RULE_revoke_roles_from_programs = 395;
+    public static readonly RULE_program_unit = 396;
+    public static readonly RULE_create_dimension = 397;
+    public static readonly RULE_create_directory = 398;
+    public static readonly RULE_directory_name = 399;
+    public static readonly RULE_directory_path = 400;
+    public static readonly RULE_create_inmemory_join_group = 401;
+    public static readonly RULE_drop_hierarchy = 402;
+    public static readonly RULE_alter_library = 403;
+    public static readonly RULE_drop_java = 404;
+    public static readonly RULE_drop_library = 405;
+    public static readonly RULE_create_java = 406;
+    public static readonly RULE_create_library = 407;
+    public static readonly RULE_plsql_library_source = 408;
+    public static readonly RULE_credential_name = 409;
+    public static readonly RULE_library_editionable = 410;
+    public static readonly RULE_library_debug = 411;
+    public static readonly RULE_compiler_parameters_clause = 412;
+    public static readonly RULE_parameter_value = 413;
+    public static readonly RULE_library_name = 414;
+    public static readonly RULE_alter_dimension = 415;
+    public static readonly RULE_level_clause = 416;
+    public static readonly RULE_hierarchy_clause = 417;
+    public static readonly RULE_dimension_join_clause = 418;
+    public static readonly RULE_attribute_clause = 419;
+    public static readonly RULE_extended_attribute_clause = 420;
+    public static readonly RULE_column_one_or_more_sub_clause = 421;
+    public static readonly RULE_alter_view = 422;
+    public static readonly RULE_alter_view_editionable = 423;
+    public static readonly RULE_create_view = 424;
+    public static readonly RULE_editioning_clause = 425;
+    public static readonly RULE_view_options = 426;
+    public static readonly RULE_view_alias_constraint = 427;
+    public static readonly RULE_object_view_clause = 428;
+    public static readonly RULE_inline_constraint = 429;
+    public static readonly RULE_inline_ref_constraint = 430;
+    public static readonly RULE_out_of_line_ref_constraint = 431;
+    public static readonly RULE_out_of_line_constraint = 432;
+    public static readonly RULE_constraint_state = 433;
+    public static readonly RULE_xmltype_view_clause = 434;
+    public static readonly RULE_xml_schema_spec = 435;
+    public static readonly RULE_xml_schema_url = 436;
+    public static readonly RULE_element = 437;
+    public static readonly RULE_alter_tablespace = 438;
+    public static readonly RULE_datafile_tempfile_clauses = 439;
+    public static readonly RULE_tablespace_logging_clauses = 440;
+    public static readonly RULE_tablespace_group_clause = 441;
+    public static readonly RULE_tablespace_group_name = 442;
+    public static readonly RULE_tablespace_state_clauses = 443;
+    public static readonly RULE_flashback_mode_clause = 444;
+    public static readonly RULE_new_tablespace_name = 445;
+    public static readonly RULE_create_tablespace = 446;
+    public static readonly RULE_permanent_tablespace_clause = 447;
+    public static readonly RULE_tablespace_encryption_spec = 448;
+    public static readonly RULE_logging_clause = 449;
+    public static readonly RULE_extent_management_clause = 450;
+    public static readonly RULE_segment_management_clause = 451;
+    public static readonly RULE_temporary_tablespace_clause = 452;
+    public static readonly RULE_undo_tablespace_clause = 453;
+    public static readonly RULE_tablespace_retention_clause = 454;
+    public static readonly RULE_create_tablespace_set = 455;
+    public static readonly RULE_permanent_tablespace_attrs = 456;
+    public static readonly RULE_tablespace_encryption_clause = 457;
+    public static readonly RULE_default_tablespace_params = 458;
+    public static readonly RULE_default_table_compression = 459;
+    public static readonly RULE_low_high = 460;
+    public static readonly RULE_default_index_compression = 461;
+    public static readonly RULE_inmmemory_clause = 462;
+    public static readonly RULE_datafile_specification = 463;
+    public static readonly RULE_tempfile_specification = 464;
+    public static readonly RULE_datafile_tempfile_spec = 465;
+    public static readonly RULE_redo_log_file_spec = 466;
+    public static readonly RULE_autoextend_clause = 467;
+    public static readonly RULE_maxsize_clause = 468;
+    public static readonly RULE_build_clause = 469;
+    public static readonly RULE_parallel_clause = 470;
+    public static readonly RULE_parallel_instances_clause = 471;
+    public static readonly RULE_alter_materialized_view = 472;
+    public static readonly RULE_alter_mv_option1 = 473;
+    public static readonly RULE_alter_mv_refresh = 474;
+    public static readonly RULE_rollback_segment = 475;
+    public static readonly RULE_modify_mv_column_clause = 476;
+    public static readonly RULE_alter_materialized_view_log = 477;
+    public static readonly RULE_add_mv_log_column_clause = 478;
+    public static readonly RULE_move_mv_log_clause = 479;
+    public static readonly RULE_mv_log_augmentation = 480;
+    public static readonly RULE_create_materialized_view_log = 481;
+    public static readonly RULE_new_values_clause = 482;
+    public static readonly RULE_mv_log_purge_clause = 483;
+    public static readonly RULE_create_materialized_zonemap = 484;
+    public static readonly RULE_alter_materialized_zonemap = 485;
+    public static readonly RULE_drop_materialized_zonemap = 486;
+    public static readonly RULE_zonemap_refresh_clause = 487;
+    public static readonly RULE_zonemap_attributes = 488;
+    public static readonly RULE_zonemap_name = 489;
+    public static readonly RULE_operator_name = 490;
+    public static readonly RULE_operator_function_name = 491;
+    public static readonly RULE_create_zonemap_on_table = 492;
+    public static readonly RULE_create_zonemap_as_subquery = 493;
+    public static readonly RULE_alter_operator = 494;
+    public static readonly RULE_drop_operator = 495;
+    public static readonly RULE_create_operator = 496;
+    public static readonly RULE_binding_clause = 497;
+    public static readonly RULE_add_binding_clause = 498;
+    public static readonly RULE_implementation_clause = 499;
+    public static readonly RULE_primary_operator_list = 500;
+    public static readonly RULE_primary_operator_item = 501;
+    public static readonly RULE_operator_context_clause = 502;
+    public static readonly RULE_using_function_clause = 503;
+    public static readonly RULE_drop_binding_clause = 504;
+    public static readonly RULE_create_materialized_view = 505;
+    public static readonly RULE_scoped_table_ref_constraint = 506;
+    public static readonly RULE_mv_column_alias = 507;
+    public static readonly RULE_create_mv_refresh = 508;
+    public static readonly RULE_query_rewrite_clause = 509;
+    public static readonly RULE_unusable_editions_clause = 510;
+    public static readonly RULE_drop_materialized_view = 511;
+    public static readonly RULE_drop_materialized_view_log = 512;
+    public static readonly RULE_create_context = 513;
+    public static readonly RULE_oracle_namespace = 514;
+    public static readonly RULE_create_cluster = 515;
+    public static readonly RULE_create_profile = 516;
+    public static readonly RULE_resource_parameters = 517;
+    public static readonly RULE_password_parameters = 518;
+    public static readonly RULE_create_lockdown_profile = 519;
+    public static readonly RULE_static_base_profile = 520;
+    public static readonly RULE_dynamic_base_profile = 521;
+    public static readonly RULE_create_outline = 522;
+    public static readonly RULE_create_restore_point = 523;
+    public static readonly RULE_create_role = 524;
+    public static readonly RULE_create_table = 525;
+    public static readonly RULE_xmltype_table = 526;
+    public static readonly RULE_xmltype_virtual_columns = 527;
+    public static readonly RULE_xmltype_column_properties = 528;
+    public static readonly RULE_xmltype_storage = 529;
+    public static readonly RULE_xmlschema_spec = 530;
+    public static readonly RULE_object_table = 531;
+    public static readonly RULE_object_type = 532;
+    public static readonly RULE_oid_index_clause = 533;
+    public static readonly RULE_oid_clause = 534;
+    public static readonly RULE_object_properties = 535;
+    public static readonly RULE_object_table_substitution = 536;
+    public static readonly RULE_relational_table = 537;
+    public static readonly RULE_relational_table_properties = 538;
+    public static readonly RULE_relational_table_property = 539;
+    public static readonly RULE_immutable_table_clauses = 540;
+    public static readonly RULE_immutable_table_no_drop_clause = 541;
+    public static readonly RULE_immutable_table_no_delete_clause = 542;
+    public static readonly RULE_blockchain_table_clauses = 543;
+    public static readonly RULE_blockchain_drop_table_clause = 544;
+    public static readonly RULE_blockchain_row_retention_clause = 545;
+    public static readonly RULE_blockchain_hash_and_data_format_clause = 546;
+    public static readonly RULE_collation_name = 547;
+    public static readonly RULE_table_properties = 548;
+    public static readonly RULE_read_only_clause = 549;
+    public static readonly RULE_indexing_clause = 550;
+    public static readonly RULE_attribute_clustering_clause = 551;
+    public static readonly RULE_clustering_join = 552;
+    public static readonly RULE_clustering_join_item = 553;
+    public static readonly RULE_equijoin_condition = 554;
+    public static readonly RULE_cluster_clause = 555;
+    public static readonly RULE_clustering_columns = 556;
+    public static readonly RULE_clustering_column_group = 557;
+    public static readonly RULE_yes_no = 558;
+    public static readonly RULE_zonemap_clause = 559;
+    public static readonly RULE_logical_replication_clause = 560;
+    public static readonly RULE_table_name = 561;
+    public static readonly RULE_relational_property = 562;
+    public static readonly RULE_table_partitioning_clauses = 563;
+    public static readonly RULE_range_partitions = 564;
+    public static readonly RULE_list_partitions = 565;
+    public static readonly RULE_hash_partitions = 566;
+    public static readonly RULE_individual_hash_partitions = 567;
+    public static readonly RULE_hash_partitions_by_quantity = 568;
+    public static readonly RULE_hash_partition_quantity = 569;
+    public static readonly RULE_composite_range_partitions = 570;
+    public static readonly RULE_composite_list_partitions = 571;
+    public static readonly RULE_composite_hash_partitions = 572;
+    public static readonly RULE_reference_partitioning = 573;
+    public static readonly RULE_reference_partition_desc = 574;
+    public static readonly RULE_system_partitioning = 575;
+    public static readonly RULE_range_partition_desc = 576;
+    public static readonly RULE_list_partition_desc = 577;
+    public static readonly RULE_subpartition_template = 578;
+    public static readonly RULE_hash_subpartition_quantity = 579;
+    public static readonly RULE_subpartition_by_range = 580;
+    public static readonly RULE_subpartition_by_list = 581;
+    public static readonly RULE_subpartition_by_hash = 582;
+    public static readonly RULE_subpartition_name = 583;
+    public static readonly RULE_range_subpartition_desc = 584;
+    public static readonly RULE_list_subpartition_desc = 585;
+    public static readonly RULE_individual_hash_subparts = 586;
+    public static readonly RULE_hash_subparts_by_quantity = 587;
+    public static readonly RULE_range_values_clause = 588;
+    public static readonly RULE_range_values_list = 589;
+    public static readonly RULE_list_values_clause = 590;
+    public static readonly RULE_table_partition_description = 591;
+    public static readonly RULE_partitioning_storage_clause = 592;
+    public static readonly RULE_lob_partitioning_storage = 593;
+    public static readonly RULE_size_clause = 594;
+    public static readonly RULE_table_compression = 595;
+    public static readonly RULE_inmemory_table_clause = 596;
+    public static readonly RULE_inmemory_attributes = 597;
+    public static readonly RULE_inmemory_memcompress = 598;
+    public static readonly RULE_inmemory_priority = 599;
+    public static readonly RULE_inmemory_distribute = 600;
+    public static readonly RULE_inmemory_duplicate = 601;
+    public static readonly RULE_inmemory_column_clause = 602;
+    public static readonly RULE_physical_attributes_clause = 603;
+    public static readonly RULE_storage_clause = 604;
+    public static readonly RULE_deferred_segment_creation = 605;
+    public static readonly RULE_segment_attributes_clause = 606;
+    public static readonly RULE_physical_properties = 607;
+    public static readonly RULE_ilm_clause = 608;
+    public static readonly RULE_ilm_policy_clause = 609;
+    public static readonly RULE_ilm_compression_policy = 610;
+    public static readonly RULE_ilm_tiering_policy = 611;
+    public static readonly RULE_ilm_after_on = 612;
+    public static readonly RULE_segment_group = 613;
+    public static readonly RULE_ilm_inmemory_policy = 614;
+    public static readonly RULE_ilm_time_period = 615;
+    public static readonly RULE_heap_org_table_clause = 616;
+    public static readonly RULE_external_table_clause = 617;
+    public static readonly RULE_access_driver_type = 618;
+    public static readonly RULE_external_table_data_props = 619;
+    public static readonly RULE_external_table_data_format = 620;
+    public static readonly RULE_external_table_transform = 621;
+    public static readonly RULE_external_table_field = 622;
+    public static readonly RULE_external_table_field_list = 623;
+    public static readonly RULE_external_table_fields_clause = 624;
+    public static readonly RULE_external_table_position_clause = 625;
+    public static readonly RULE_external_table_datatype_clause = 626;
+    public static readonly RULE_external_table_delimit_clause = 627;
+    public static readonly RULE_external_table_trim_clause = 628;
+    public static readonly RULE_external_table_date_format_clause = 629;
+    public static readonly RULE_external_table_init_clause = 630;
+    public static readonly RULE_external_table_condition_clause = 631;
+    public static readonly RULE_external_table_lls_clause = 632;
+    public static readonly RULE_external_table_records = 633;
+    public static readonly RULE_external_table_record_options_clause = 634;
+    public static readonly RULE_external_table_output_files = 635;
+    public static readonly RULE_external_table_fields = 636;
+    public static readonly RULE_external_table_datapump = 637;
+    public static readonly RULE_external_table_hive = 638;
+    public static readonly RULE_external_table_hive_parameter_map = 639;
+    public static readonly RULE_external_table_hive_parameter_map_entry = 640;
+    public static readonly RULE_external_table_directory = 641;
+    public static readonly RULE_row_movement_clause = 642;
+    public static readonly RULE_flashback_archive_clause = 643;
+    public static readonly RULE_log_grp = 644;
+    public static readonly RULE_supplemental_table_logging = 645;
+    public static readonly RULE_supplemental_log_grp_clause = 646;
+    public static readonly RULE_supplemental_id_key_clause = 647;
+    public static readonly RULE_allocate_extent_clause = 648;
+    public static readonly RULE_deallocate_unused_clause = 649;
+    public static readonly RULE_shrink_clause = 650;
+    public static readonly RULE_records_per_block_clause = 651;
+    public static readonly RULE_upgrade_table_clause = 652;
+    public static readonly RULE_truncate_table = 653;
+    public static readonly RULE_drop_table = 654;
+    public static readonly RULE_drop_tablespace = 655;
+    public static readonly RULE_drop_tablespace_set = 656;
+    public static readonly RULE_including_contents_clause = 657;
+    public static readonly RULE_drop_view = 658;
+    public static readonly RULE_comment_on_column = 659;
+    public static readonly RULE_enable_or_disable = 660;
+    public static readonly RULE_allow_or_disallow = 661;
+    public static readonly RULE_alter_synonym = 662;
+    public static readonly RULE_create_synonym = 663;
+    public static readonly RULE_drop_synonym = 664;
+    public static readonly RULE_create_spfile = 665;
+    public static readonly RULE_spfile_name = 666;
+    public static readonly RULE_pfile_name = 667;
+    public static readonly RULE_comment_on_table = 668;
+    public static readonly RULE_comment_on_materialized = 669;
+    public static readonly RULE_alter_analytic_view = 670;
+    public static readonly RULE_alter_add_cache_clause = 671;
+    public static readonly RULE_levels_item = 672;
+    public static readonly RULE_measure_list = 673;
+    public static readonly RULE_alter_drop_cache_clause = 674;
+    public static readonly RULE_alter_attribute_dimension = 675;
+    public static readonly RULE_alter_audit_policy = 676;
+    public static readonly RULE_alter_cluster = 677;
+    public static readonly RULE_drop_analytic_view = 678;
+    public static readonly RULE_drop_attribute_dimension = 679;
+    public static readonly RULE_drop_audit_policy = 680;
+    public static readonly RULE_drop_flashback_archive = 681;
+    public static readonly RULE_drop_cluster = 682;
+    public static readonly RULE_drop_context = 683;
+    public static readonly RULE_drop_directory = 684;
+    public static readonly RULE_drop_diskgroup = 685;
+    public static readonly RULE_drop_edition = 686;
+    public static readonly RULE_truncate_cluster = 687;
+    public static readonly RULE_cache_or_nocache = 688;
+    public static readonly RULE_database_name = 689;
+    public static readonly RULE_alter_database = 690;
+    public static readonly RULE_database_clause = 691;
+    public static readonly RULE_startup_clauses = 692;
+    public static readonly RULE_resetlogs_or_noresetlogs = 693;
+    public static readonly RULE_upgrade_or_downgrade = 694;
+    public static readonly RULE_recovery_clauses = 695;
+    public static readonly RULE_begin_or_end = 696;
+    public static readonly RULE_general_recovery = 697;
+    public static readonly RULE_full_database_recovery = 698;
+    public static readonly RULE_partial_database_recovery = 699;
+    public static readonly RULE_partial_database_recovery_10g = 700;
+    public static readonly RULE_managed_standby_recovery = 701;
+    public static readonly RULE_db_name = 702;
+    public static readonly RULE_database_file_clauses = 703;
+    public static readonly RULE_create_datafile_clause = 704;
+    public static readonly RULE_alter_datafile_clause = 705;
+    public static readonly RULE_alter_tempfile_clause = 706;
+    public static readonly RULE_move_datafile_clause = 707;
+    public static readonly RULE_logfile_clauses = 708;
+    public static readonly RULE_add_logfile_clauses = 709;
+    public static readonly RULE_group_redo_logfile = 710;
+    public static readonly RULE_drop_logfile_clauses = 711;
+    public static readonly RULE_switch_logfile_clause = 712;
+    public static readonly RULE_supplemental_db_logging = 713;
+    public static readonly RULE_add_or_drop = 714;
+    public static readonly RULE_supplemental_plsql_clause = 715;
+    public static readonly RULE_logfile_descriptor = 716;
+    public static readonly RULE_controlfile_clauses = 717;
+    public static readonly RULE_trace_file_clause = 718;
+    public static readonly RULE_standby_database_clauses = 719;
+    public static readonly RULE_activate_standby_db_clause = 720;
+    public static readonly RULE_maximize_standby_db_clause = 721;
+    public static readonly RULE_register_logfile_clause = 722;
+    public static readonly RULE_commit_switchover_clause = 723;
+    public static readonly RULE_start_standby_clause = 724;
+    public static readonly RULE_stop_standby_clause = 725;
+    public static readonly RULE_convert_database_clause = 726;
+    public static readonly RULE_default_settings_clause = 727;
+    public static readonly RULE_set_time_zone_clause = 728;
+    public static readonly RULE_instance_clauses = 729;
+    public static readonly RULE_security_clause = 730;
+    public static readonly RULE_domain = 731;
+    public static readonly RULE_database = 732;
+    public static readonly RULE_edition_name = 733;
+    public static readonly RULE_filenumber = 734;
+    public static readonly RULE_filename = 735;
+    public static readonly RULE_prepare_clause = 736;
+    public static readonly RULE_drop_mirror_clause = 737;
+    public static readonly RULE_lost_write_protection = 738;
+    public static readonly RULE_cdb_fleet_clauses = 739;
+    public static readonly RULE_lead_cdb_clause = 740;
+    public static readonly RULE_lead_cdb_uri_clause = 741;
+    public static readonly RULE_property_clauses = 742;
+    public static readonly RULE_replay_upgrade_clauses = 743;
+    public static readonly RULE_alter_database_link = 744;
+    public static readonly RULE_password_value = 745;
+    public static readonly RULE_link_authentication = 746;
+    public static readonly RULE_create_schema = 747;
+    public static readonly RULE_create_database = 748;
+    public static readonly RULE_database_logging_clauses = 749;
+    public static readonly RULE_database_logging_sub_clause = 750;
+    public static readonly RULE_tablespace_clauses = 751;
+    public static readonly RULE_enable_pluggable_database = 752;
+    public static readonly RULE_file_name_convert = 753;
+    public static readonly RULE_filename_convert_sub_clause = 754;
+    public static readonly RULE_tablespace_datafile_clauses = 755;
+    public static readonly RULE_undo_mode_clause = 756;
+    public static readonly RULE_default_tablespace = 757;
+    public static readonly RULE_default_temp_tablespace = 758;
+    public static readonly RULE_undo_tablespace = 759;
+    public static readonly RULE_drop_database = 760;
+    public static readonly RULE_create_database_link = 761;
+    public static readonly RULE_drop_database_link = 762;
+    public static readonly RULE_alter_tablespace_set = 763;
+    public static readonly RULE_alter_tablespace_attrs = 764;
+    public static readonly RULE_alter_tablespace_encryption = 765;
+    public static readonly RULE_ts_file_name_convert = 766;
+    public static readonly RULE_alter_role = 767;
+    public static readonly RULE_role_identified_clause = 768;
+    public static readonly RULE_alter_table = 769;
+    public static readonly RULE_alter_table_body = 770;
+    public static readonly RULE_alter_table_action = 771;
+    public static readonly RULE_enable_disable_clauses = 772;
+    public static readonly RULE_memoptimize_read_write_clause = 773;
+    public static readonly RULE_alter_table_properties = 774;
+    public static readonly RULE_alter_table_partitioning = 775;
+    public static readonly RULE_add_table_partition = 776;
+    public static readonly RULE_drop_table_partition = 777;
+    public static readonly RULE_merge_table_partition = 778;
+    public static readonly RULE_modify_table_partition = 779;
+    public static readonly RULE_split_table_partition = 780;
+    public static readonly RULE_truncate_table_partition = 781;
+    public static readonly RULE_exchange_table_partition = 782;
+    public static readonly RULE_coalesce_table_partition = 783;
+    public static readonly RULE_alter_interval_partition = 784;
+    public static readonly RULE_move_table_partition = 785;
+    public static readonly RULE_filter_condition = 786;
+    public static readonly RULE_rename_table_partition = 787;
+    public static readonly RULE_partition_extended_names = 788;
+    public static readonly RULE_subpartition_extended_names = 789;
+    public static readonly RULE_alter_table_properties_1 = 790;
+    public static readonly RULE_alter_iot_clauses = 791;
+    public static readonly RULE_alter_mapping_table_clause = 792;
+    public static readonly RULE_alter_overflow_clause = 793;
+    public static readonly RULE_add_overflow_clause = 794;
+    public static readonly RULE_update_index_clauses = 795;
+    public static readonly RULE_update_global_index_clause = 796;
+    public static readonly RULE_update_all_indexes_clause = 797;
+    public static readonly RULE_update_all_indexes_index_clause = 798;
+    public static readonly RULE_update_index_partition = 799;
+    public static readonly RULE_update_index_subpartition = 800;
+    public static readonly RULE_enable_disable_clause = 801;
+    public static readonly RULE_using_index_clause = 802;
+    public static readonly RULE_index_attributes = 803;
+    public static readonly RULE_sort_or_nosort = 804;
+    public static readonly RULE_exceptions_clause = 805;
+    public static readonly RULE_move_table_clause = 806;
+    public static readonly RULE_modify_to_partitioned = 807;
+    public static readonly RULE_index_org_table_clause = 808;
+    public static readonly RULE_mapping_table_clause = 809;
+    public static readonly RULE_key_compression = 810;
+    public static readonly RULE_index_org_overflow_clause = 811;
+    public static readonly RULE_column_clauses = 812;
+    public static readonly RULE_modify_collection_retrieval = 813;
+    public static readonly RULE_collection_item = 814;
+    public static readonly RULE_rename_column_clause = 815;
+    public static readonly RULE_old_column_name = 816;
+    public static readonly RULE_new_column_name = 817;
+    public static readonly RULE_add_modify_drop_column_clauses = 818;
+    public static readonly RULE_drop_column_clause = 819;
+    public static readonly RULE_modify_column_clauses = 820;
+    public static readonly RULE_modify_col_properties = 821;
+    public static readonly RULE_modify_col_visibility = 822;
+    public static readonly RULE_modify_col_substitutable = 823;
+    public static readonly RULE_add_column_clause = 824;
+    public static readonly RULE_varray_col_properties = 825;
+    public static readonly RULE_varray_storage_clause = 826;
+    public static readonly RULE_lob_segname = 827;
+    public static readonly RULE_lob_item = 828;
+    public static readonly RULE_lob_storage_parameters = 829;
+    public static readonly RULE_lob_storage_clause = 830;
+    public static readonly RULE_modify_lob_storage_clause = 831;
+    public static readonly RULE_modify_lob_parameters = 832;
+    public static readonly RULE_lob_parameters = 833;
+    public static readonly RULE_lob_deduplicate_clause = 834;
+    public static readonly RULE_lob_compression_clause = 835;
+    public static readonly RULE_lob_retention_clause = 836;
+    public static readonly RULE_encryption_spec = 837;
+    public static readonly RULE_tablespace = 838;
+    public static readonly RULE_varray_item = 839;
+    public static readonly RULE_column_properties = 840;
+    public static readonly RULE_lob_partition_storage = 841;
+    public static readonly RULE_period_definition = 842;
+    public static readonly RULE_start_time_column = 843;
+    public static readonly RULE_end_time_column = 844;
+    public static readonly RULE_column_definition = 845;
+    public static readonly RULE_column_collation_name = 846;
+    public static readonly RULE_identity_clause = 847;
+    public static readonly RULE_identity_options_parentheses = 848;
+    public static readonly RULE_identity_options = 849;
+    public static readonly RULE_virtual_column_definition = 850;
+    public static readonly RULE_virtual_column_expression = 851;
+    public static readonly RULE_autogenerated_sequence_definition = 852;
+    public static readonly RULE_by_user_for_statistics_clause = 853;
+    public static readonly RULE_evaluation_edition_clause = 854;
+    public static readonly RULE_nested_table_col_properties = 855;
+    public static readonly RULE_nested_item = 856;
+    public static readonly RULE_substitutable_column_clause = 857;
+    public static readonly RULE_partition_name = 858;
+    public static readonly RULE_supplemental_logging_props = 859;
+    public static readonly RULE_object_type_col_properties = 860;
+    public static readonly RULE_constraint_clauses = 861;
+    public static readonly RULE_old_constraint_name = 862;
+    public static readonly RULE_new_constraint_name = 863;
+    public static readonly RULE_drop_constraint_clause = 864;
+    public static readonly RULE_check_constraint = 865;
+    public static readonly RULE_foreign_key_clause = 866;
+    public static readonly RULE_references_clause = 867;
+    public static readonly RULE_on_delete_clause = 868;
+    public static readonly RULE_anonymous_block = 869;
+    public static readonly RULE_invoker_rights_clause = 870;
+    public static readonly RULE_call_spec = 871;
+    public static readonly RULE_java_spec = 872;
+    public static readonly RULE_c_spec = 873;
+    public static readonly RULE_c_agent_in_clause = 874;
+    public static readonly RULE_c_parameters_clause = 875;
+    public static readonly RULE_c_external_parameter = 876;
+    public static readonly RULE_c_property = 877;
+    public static readonly RULE_parameter = 878;
+    public static readonly RULE_default_value_part = 879;
+    public static readonly RULE_seq_of_declare_specs = 880;
+    public static readonly RULE_declare_spec = 881;
+    public static readonly RULE_variable_declaration = 882;
+    public static readonly RULE_subtype_declaration = 883;
+    public static readonly RULE_cursor_declaration = 884;
+    public static readonly RULE_parameter_spec = 885;
+    public static readonly RULE_exception_declaration = 886;
+    public static readonly RULE_pragma_declaration = 887;
+    public static readonly RULE_record_type_def = 888;
+    public static readonly RULE_field_spec = 889;
+    public static readonly RULE_ref_cursor_type_def = 890;
+    public static readonly RULE_type_declaration = 891;
+    public static readonly RULE_table_type_def = 892;
+    public static readonly RULE_table_indexed_by_part = 893;
+    public static readonly RULE_varray_type_def = 894;
+    public static readonly RULE_seq_of_statements = 895;
+    public static readonly RULE_label_declaration = 896;
+    public static readonly RULE_statement = 897;
+    public static readonly RULE_assignment_statement = 898;
+    public static readonly RULE_continue_statement = 899;
+    public static readonly RULE_exit_statement = 900;
+    public static readonly RULE_goto_statement = 901;
+    public static readonly RULE_if_statement = 902;
+    public static readonly RULE_elsif_part = 903;
+    public static readonly RULE_else_part = 904;
+    public static readonly RULE_loop_statement = 905;
+    public static readonly RULE_cursor_loop_param = 906;
+    public static readonly RULE_forall_statement = 907;
+    public static readonly RULE_bounds_clause = 908;
+    public static readonly RULE_between_bound = 909;
+    public static readonly RULE_lower_bound = 910;
+    public static readonly RULE_upper_bound = 911;
+    public static readonly RULE_null_statement = 912;
+    public static readonly RULE_raise_statement = 913;
+    public static readonly RULE_return_statement = 914;
+    public static readonly RULE_call_statement = 915;
+    public static readonly RULE_pipe_row_statement = 916;
+    public static readonly RULE_selection_directive = 917;
+    public static readonly RULE_error_directive = 918;
+    public static readonly RULE_selection_directive_body = 919;
+    public static readonly RULE_body = 920;
+    public static readonly RULE_exception_handler = 921;
+    public static readonly RULE_trigger_block = 922;
+    public static readonly RULE_tps_block = 923;
+    public static readonly RULE_block = 924;
+    public static readonly RULE_sql_statement = 925;
+    public static readonly RULE_execute_immediate = 926;
+    public static readonly RULE_dynamic_returning_clause = 927;
+    public static readonly RULE_data_manipulation_language_statements = 928;
+    public static readonly RULE_cursor_manipulation_statements = 929;
+    public static readonly RULE_close_statement = 930;
+    public static readonly RULE_open_statement = 931;
+    public static readonly RULE_fetch_statement = 932;
+    public static readonly RULE_variable_or_collection = 933;
+    public static readonly RULE_open_for_statement = 934;
+    public static readonly RULE_transaction_control_statements = 935;
+    public static readonly RULE_set_transaction_command = 936;
+    public static readonly RULE_set_constraint_command = 937;
+    public static readonly RULE_commit_statement = 938;
+    public static readonly RULE_write_clause = 939;
+    public static readonly RULE_rollback_statement = 940;
+    public static readonly RULE_savepoint_statement = 941;
+    public static readonly RULE_collection_method_call = 942;
+    public static readonly RULE_explain_statement = 943;
+    public static readonly RULE_select_only_statement = 944;
+    public static readonly RULE_select_statement = 945;
+    public static readonly RULE_with_clause = 946;
+    public static readonly RULE_with_factoring_clause = 947;
+    public static readonly RULE_subquery_factoring_clause = 948;
+    public static readonly RULE_search_clause = 949;
+    public static readonly RULE_cycle_clause = 950;
+    public static readonly RULE_subav_factoring_clause = 951;
+    public static readonly RULE_subav_clause = 952;
+    public static readonly RULE_hierarchies_clause = 953;
+    public static readonly RULE_filter_clauses = 954;
+    public static readonly RULE_filter_clause = 955;
+    public static readonly RULE_add_calcs_clause = 956;
+    public static readonly RULE_add_calc_meas_clause = 957;
+    public static readonly RULE_subquery = 958;
+    public static readonly RULE_subquery_no_with = 959;
+    public static readonly RULE_subquery_basic_elements = 960;
+    public static readonly RULE_subquery_operation_part = 961;
+    public static readonly RULE_query_block = 962;
+    public static readonly RULE_selected_list = 963;
+    public static readonly RULE_from_clause = 964;
+    public static readonly RULE_select_list_elements = 965;
+    public static readonly RULE_table_ref_list = 966;
+    public static readonly RULE_table_ref = 967;
+    public static readonly RULE_table_ref_aux = 968;
+    public static readonly RULE_table_ref_aux_internal = 969;
+    public static readonly RULE_join_clause = 970;
+    public static readonly RULE_join_on_part = 971;
+    public static readonly RULE_join_using_part = 972;
+    public static readonly RULE_outer_join_type = 973;
+    public static readonly RULE_query_partition_clause = 974;
+    public static readonly RULE_flashback_query_clause = 975;
+    public static readonly RULE_pivot_clause = 976;
+    public static readonly RULE_pivot_element = 977;
+    public static readonly RULE_pivot_for_clause = 978;
+    public static readonly RULE_pivot_in_clause = 979;
+    public static readonly RULE_pivot_in_clause_element = 980;
+    public static readonly RULE_pivot_in_clause_elements = 981;
+    public static readonly RULE_unpivot_clause = 982;
+    public static readonly RULE_unpivot_in_clause = 983;
+    public static readonly RULE_unpivot_in_elements = 984;
+    public static readonly RULE_hierarchical_query_clause = 985;
+    public static readonly RULE_start_part = 986;
+    public static readonly RULE_group_by_clause = 987;
+    public static readonly RULE_group_by_elements = 988;
+    public static readonly RULE_rollup_cube_clause = 989;
+    public static readonly RULE_grouping_sets_clause = 990;
+    public static readonly RULE_grouping_sets_elements = 991;
+    public static readonly RULE_having_clause = 992;
+    public static readonly RULE_model_clause = 993;
+    public static readonly RULE_cell_reference_options = 994;
+    public static readonly RULE_return_rows_clause = 995;
+    public static readonly RULE_reference_model = 996;
+    public static readonly RULE_main_model = 997;
+    public static readonly RULE_model_column_clauses = 998;
+    public static readonly RULE_model_column_partition_part = 999;
+    public static readonly RULE_model_column_list = 1000;
+    public static readonly RULE_model_column = 1001;
+    public static readonly RULE_model_rules_clause = 1002;
+    public static readonly RULE_model_rules_part = 1003;
+    public static readonly RULE_model_rules_element = 1004;
+    public static readonly RULE_cell_assignment = 1005;
+    public static readonly RULE_model_iterate_clause = 1006;
+    public static readonly RULE_until_part = 1007;
+    public static readonly RULE_order_by_clause = 1008;
+    public static readonly RULE_order_by_elements = 1009;
+    public static readonly RULE_offset_clause = 1010;
+    public static readonly RULE_fetch_clause = 1011;
+    public static readonly RULE_for_update_clause = 1012;
+    public static readonly RULE_for_update_of_part = 1013;
+    public static readonly RULE_for_update_options = 1014;
+    public static readonly RULE_update_statement = 1015;
+    public static readonly RULE_update_set_clause = 1016;
+    public static readonly RULE_column_based_update_set_clause = 1017;
+    public static readonly RULE_delete_statement = 1018;
+    public static readonly RULE_insert_statement = 1019;
+    public static readonly RULE_single_table_insert = 1020;
+    public static readonly RULE_multi_table_insert = 1021;
+    public static readonly RULE_multi_table_element = 1022;
+    public static readonly RULE_conditional_insert_clause = 1023;
+    public static readonly RULE_conditional_insert_when_part = 1024;
+    public static readonly RULE_conditional_insert_else_part = 1025;
+    public static readonly RULE_insert_into_clause = 1026;
+    public static readonly RULE_values_clause = 1027;
+    public static readonly RULE_merge_statement = 1028;
+    public static readonly RULE_merge_update_clause = 1029;
+    public static readonly RULE_merge_element = 1030;
+    public static readonly RULE_merge_update_delete_part = 1031;
+    public static readonly RULE_merge_insert_clause = 1032;
+    public static readonly RULE_selected_tableview = 1033;
+    public static readonly RULE_lock_table_statement = 1034;
+    public static readonly RULE_wait_nowait_part = 1035;
+    public static readonly RULE_lock_table_element = 1036;
+    public static readonly RULE_lock_mode = 1037;
+    public static readonly RULE_general_table_ref = 1038;
+    public static readonly RULE_static_returning_clause = 1039;
+    public static readonly RULE_error_logging_clause = 1040;
+    public static readonly RULE_error_logging_into_part = 1041;
+    public static readonly RULE_error_logging_reject_part = 1042;
+    public static readonly RULE_dml_table_expression_clause = 1043;
+    public static readonly RULE_table_collection_expression = 1044;
+    public static readonly RULE_subquery_restriction_clause = 1045;
+    public static readonly RULE_sample_clause = 1046;
+    public static readonly RULE_seed_part = 1047;
+    public static readonly RULE_condition = 1048;
+    public static readonly RULE_expressions_ = 1049;
+    public static readonly RULE_expression = 1050;
+    public static readonly RULE_cursor_expression = 1051;
+    public static readonly RULE_logical_expression = 1052;
+    public static readonly RULE_unary_logical_expression = 1053;
+    public static readonly RULE_unary_logical_operation = 1054;
+    public static readonly RULE_logical_operation = 1055;
+    public static readonly RULE_multiset_expression = 1056;
+    public static readonly RULE_relational_expression = 1057;
+    public static readonly RULE_compound_expression = 1058;
+    public static readonly RULE_relational_operator = 1059;
+    public static readonly RULE_in_elements = 1060;
+    public static readonly RULE_between_elements = 1061;
+    public static readonly RULE_concatenation = 1062;
+    public static readonly RULE_interval_expression = 1063;
+    public static readonly RULE_model_expression = 1064;
+    public static readonly RULE_model_expression_element = 1065;
+    public static readonly RULE_single_column_for_loop = 1066;
+    public static readonly RULE_multi_column_for_loop = 1067;
+    public static readonly RULE_unary_expression = 1068;
+    public static readonly RULE_unary_expression_core = 1069;
+    public static readonly RULE_selection_directive_expression = 1070;
+    public static readonly RULE_implicit_cursor_expression = 1071;
+    public static readonly RULE_collection_expression = 1072;
+    public static readonly RULE_case_statement = 1073;
+    public static readonly RULE_simple_case_statement = 1074;
+    public static readonly RULE_searched_case_statement = 1075;
+    public static readonly RULE_case_when_part_statement = 1076;
+    public static readonly RULE_case_else_part_statement = 1077;
+    public static readonly RULE_case_expression = 1078;
+    public static readonly RULE_simple_case_expression = 1079;
+    public static readonly RULE_searched_case_expression = 1080;
+    public static readonly RULE_case_when_part_expression = 1081;
+    public static readonly RULE_case_else_part_expression = 1082;
+    public static readonly RULE_atom = 1083;
+    public static readonly RULE_quantified_expression = 1084;
+    public static readonly RULE_string_function = 1085;
+    public static readonly RULE_standard_function = 1086;
+    public static readonly RULE_json_function = 1087;
+    public static readonly RULE_json_object_content = 1088;
+    public static readonly RULE_json_object_entry = 1089;
+    public static readonly RULE_json_table_clause = 1090;
+    public static readonly RULE_json_array_element = 1091;
+    public static readonly RULE_json_on_null_clause = 1092;
+    public static readonly RULE_json_return_clause = 1093;
+    public static readonly RULE_json_transform_op = 1094;
+    public static readonly RULE_json_column_clause = 1095;
+    public static readonly RULE_json_column_definition = 1096;
+    public static readonly RULE_json_query_returning_clause = 1097;
+    public static readonly RULE_json_query_return_type = 1098;
+    public static readonly RULE_json_query_wrapper_clause = 1099;
+    public static readonly RULE_json_query_on_error_clause = 1100;
+    public static readonly RULE_json_query_on_empty_clause = 1101;
+    public static readonly RULE_json_value_return_clause = 1102;
+    public static readonly RULE_json_value_return_type = 1103;
+    public static readonly RULE_json_value_on_mismatch_clause = 1104;
+    public static readonly RULE_literal = 1105;
+    public static readonly RULE_numeric_function_wrapper = 1106;
+    public static readonly RULE_numeric_function = 1107;
+    public static readonly RULE_listagg_overflow_clause = 1108;
+    public static readonly RULE_other_function = 1109;
+    public static readonly RULE_over_clause_keyword = 1110;
+    public static readonly RULE_within_or_over_clause_keyword = 1111;
+    public static readonly RULE_standard_prediction_function_keyword = 1112;
+    public static readonly RULE_over_clause = 1113;
+    public static readonly RULE_windowing_clause = 1114;
+    public static readonly RULE_windowing_type = 1115;
+    public static readonly RULE_windowing_elements = 1116;
+    public static readonly RULE_using_clause = 1117;
+    public static readonly RULE_using_element = 1118;
+    public static readonly RULE_assignable_element = 1119;
+    public static readonly RULE_collect_order_by_part = 1120;
+    public static readonly RULE_within_or_over_part = 1121;
+    public static readonly RULE_string_delimiter = 1122;
+    public static readonly RULE_cost_matrix_clause = 1123;
+    public static readonly RULE_xml_passing_clause = 1124;
+    public static readonly RULE_xml_attributes_clause = 1125;
+    public static readonly RULE_xml_namespaces_clause = 1126;
+    public static readonly RULE_xml_table_column = 1127;
+    public static readonly RULE_xml_general_default_part = 1128;
+    public static readonly RULE_xml_multiuse_expression_element = 1129;
+    public static readonly RULE_xmlroot_param_version_part = 1130;
+    public static readonly RULE_xmlroot_param_standalone_part = 1131;
+    public static readonly RULE_xmlserialize_param_enconding_part = 1132;
+    public static readonly RULE_xmlserialize_param_version_part = 1133;
+    public static readonly RULE_xmlserialize_param_ident_part = 1134;
+    public static readonly RULE_annotations_clause = 1135;
+    public static readonly RULE_annotations_list = 1136;
+    public static readonly RULE_annotation = 1137;
+    public static readonly RULE_sql_plus_command = 1138;
+    public static readonly RULE_execute_command = 1139;
+    public static readonly RULE_start_command = 1140;
+    public static readonly RULE_sql_plus_filepath = 1141;
+    public static readonly RULE_whenever_command = 1142;
+    public static readonly RULE_set_command = 1143;
+    public static readonly RULE_timing_command = 1144;
+    public static readonly RULE_clear_command = 1145;
+    public static readonly RULE_partition_extension_clause = 1146;
+    public static readonly RULE_column_alias = 1147;
+    public static readonly RULE_table_alias = 1148;
+    public static readonly RULE_where_clause = 1149;
+    public static readonly RULE_into_clause = 1150;
+    public static readonly RULE_xml_column_name = 1151;
+    public static readonly RULE_cost_class_name = 1152;
+    public static readonly RULE_attribute_name = 1153;
+    public static readonly RULE_savepoint_name = 1154;
+    public static readonly RULE_rollback_segment_name = 1155;
+    public static readonly RULE_schema_name = 1156;
+    public static readonly RULE_routine_name = 1157;
+    public static readonly RULE_package_name = 1158;
+    public static readonly RULE_implementation_type_name = 1159;
+    public static readonly RULE_parameter_name = 1160;
+    public static readonly RULE_reference_model_name = 1161;
+    public static readonly RULE_main_model_name = 1162;
+    public static readonly RULE_container_tableview_name = 1163;
+    public static readonly RULE_aggregate_function_name = 1164;
+    public static readonly RULE_query_name = 1165;
+    public static readonly RULE_grantee_name = 1166;
+    public static readonly RULE_role_name = 1167;
+    public static readonly RULE_constraint_name = 1168;
+    public static readonly RULE_label_name = 1169;
+    public static readonly RULE_type_name = 1170;
+    public static readonly RULE_sequence_name = 1171;
+    public static readonly RULE_exception_name = 1172;
+    public static readonly RULE_function_name = 1173;
+    public static readonly RULE_procedure_name = 1174;
+    public static readonly RULE_trigger_name = 1175;
+    public static readonly RULE_variable_name = 1176;
+    public static readonly RULE_index_name = 1177;
+    public static readonly RULE_cursor_name = 1178;
+    public static readonly RULE_record_name = 1179;
+    public static readonly RULE_link_name = 1180;
+    public static readonly RULE_local_link_name = 1181;
+    public static readonly RULE_connection_qualifier = 1182;
+    public static readonly RULE_column_name = 1183;
+    public static readonly RULE_tableview_name = 1184;
+    public static readonly RULE_xmltable = 1185;
+    public static readonly RULE_char_set_name = 1186;
+    public static readonly RULE_synonym_name = 1187;
+    public static readonly RULE_schema_object_name = 1188;
+    public static readonly RULE_dir_object_name = 1189;
+    public static readonly RULE_user_object_name = 1190;
+    public static readonly RULE_grant_object_name = 1191;
+    public static readonly RULE_column_list = 1192;
+    public static readonly RULE_paren_column_list = 1193;
+    public static readonly RULE_keep_clause = 1194;
+    public static readonly RULE_function_argument = 1195;
+    public static readonly RULE_function_argument_analytic = 1196;
+    public static readonly RULE_function_argument_modeling = 1197;
+    public static readonly RULE_respect_or_ignore_nulls = 1198;
+    public static readonly RULE_argument = 1199;
+    public static readonly RULE_type_spec = 1200;
+    public static readonly RULE_datatype = 1201;
+    public static readonly RULE_precision_part = 1202;
+    public static readonly RULE_native_datatype_element = 1203;
+    public static readonly RULE_bind_variable = 1204;
+    public static readonly RULE_general_element = 1205;
+    public static readonly RULE_general_element_part = 1206;
+    public static readonly RULE_table_element = 1207;
+    public static readonly RULE_object_privilege = 1208;
+    public static readonly RULE_system_privilege = 1209;
+    public static readonly RULE_constant = 1210;
+    public static readonly RULE_numeric = 1211;
+    public static readonly RULE_numeric_negative = 1212;
+    public static readonly RULE_quoted_string = 1213;
+    public static readonly RULE_identifier = 1214;
+    public static readonly RULE_id_expression = 1215;
+    public static readonly RULE_inquiry_directive = 1216;
+    public static readonly RULE_outer_join_sign = 1217;
+    public static readonly RULE_regular_id = 1218;
+    public static readonly RULE_non_reserved_keywords_in_18c = 1219;
+    public static readonly RULE_non_reserved_keywords_in_12c = 1220;
+    public static readonly RULE_non_reserved_keywords_pre12c = 1221;
+
+    public static readonly literalNames = [
+        null, "'ABORT'", "'ABS'", "'ABSENT'", "'ACCESS'", "'ACCESSED'", 
+        "'ACCESSIBLE'", "'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'", "'ANNOTATIONS'", 
+        "'ANOMALY'", "'ANSI_REARCH'", "'ANTIJOIN'", "'ANY'", "'ANYSCHEMA'", 
+        "'APPEND'", "'APPENDCHILDXML'", "'APPEND_VALUES'", "'APPLICATION'", 
+        "'APPLY'", "'APPROX_COUNT_DISTINCT'", "'ARCHIVAL'", "'ARCHIVE'", 
+        "'ARCHIVED'", "'ARCHIVELOG'", "'ARE'", "'ARRAY'", "'AS'", "'ASC'", 
+        "'ASCII'", "'ASCIISTR'", "'ASIN'", "'ASIS'", "'ASSEMBLY'", "'ASSIGN'", 
+        "'ASSOCIATE'", "'ASYNC'", "'ASYNCHRONOUS'", "'ATAN2'", "'ATAN'", 
+        "'AT'", "'ATTRIBUTE'", "'ATTRIBUTES'", "'AUDIT'", "'AUTHENTICATED'", 
+        "'AUTHENTICATION'", "'AUTHID'", "'AUTHORIZATION'", "'AUTOALLOCATE'", 
+        "'AUTO'", "'AUTOBACKUP'", "'AUTOEXTEND'", "'AUTO_LOGIN'", "'AUTOMATIC'", 
+        "'AUTONOMOUS_TRANSACTION'", "'AUTO_REOPTIMIZE'", "'AVAILABILITY'", 
+        "'AVRO'", "'BACKGROUND'", "'BACKINGFILE'", "'BACKUP'", "'BACKUPS'", 
+        "'BACKUPSET'", "'BADFILE'", "'BASIC'", "'BASICFILE'", "'BATCH'", 
+        "'BATCHSIZE'", "'BATCH_TABLE_ACCESS_BY_ROWID'", "'BECOME'", "'BEFORE'", 
+        "'BEGIN'", "'BEGINNING'", "'BEGIN_OUTLINE_DATA'", "'BEHALF'", "'BEQUEATH'", 
+        "'BETWEEN'", "'BFILE'", "'BFILENAME'", "'BIG'", "'BIGFILE'", "'BIGINT'", 
+        "'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'", "'BLANKS'", "'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'", "'BYTES'", "'BYTEORDERMARK'", "'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'", 
+        "'CHANGETRACKING'", "'CHANGE_DUPKEY_ERROR_INDEX'", "'CHARACTER'", 
+        "'CHARACTERS'", "'CHARACTERSET'", "'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'", "'COLLECTION'", "'COLUMNAR'", "'COLUMN_AUTH_INDICATOR'", 
+        "'COLUMN'", "'COLUMNS'", "'COLUMN_STATS'", "'COLUMN_VALUE'", "'COMMENT'", 
+        "'COMMIT'", "'COMMITTED'", "'COMMON'", "'COMMON_DATA'", "'COMPACT'", 
+        "'COMPATIBLE'", "'COMPATIBILITY'", "'COMPILE'", "'COMPLETE'", "'COMPLIANCE'", 
+        "'COMPONENT'", "'COMPONENTS'", "'COMPOSE'", "'COMPOSITE'", "'COMPOSITE_LIMIT'", 
+        "'COMPOUND'", "'COMPRESS'", "'COMPRESSION'", "'COMPUTE'", "'COMPUTATION'", 
+        "'CONCAT'", "'CONCURRENT'", "'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'", 
+        "'COUNTED'", "'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'", "'CSV'", "'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'", 
+        "'DATAGUARDCONFIG'", "'DATAMOVEMENT'", "'DATAOBJNO'", "'DATAOBJ_TO_MAT_PARTITION'", 
+        "'DATAOBJ_TO_PARTITION'", "'DATAPUMP'", "'DATA_SECURITY_REWRITE_LIMIT'", 
+        "'DATE'", "'DATE_CACHE'", "'DATE_FORMAT'", "'DATE_MODE'", "'DAY'", 
+        "'DAYS'", "'DAY_TO_SECOND'", "'DBA'", "'DBA_RECYCLEBIN'", "'DBLINK'", 
+        "'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'", 
+        "'DEFAULTIF'", "'DEFAULTS'", "'DEFAULT_COLLATION'", "'DEFAULT_CREDENTIAL'", 
+        "'DEFERRABLE'", "'DEFERRED'", "'DEFINED'", "'DEFINE'", "'DEFINER'", 
+        "'DEGREE'", "'DELAY'", "'DELEGATE'", "'DELETE_ALL'", "'DELETE'", 
+        "'DELETEXML'", "'DELIMITED'", "'DEMAND'", "'DENSE_RANKM'", "'DEPENDENT'", 
+        "'DEPRECATE'", "'DEPTH'", "'DEQUEUE'", "'DEREF'", "'DEREF_NO_REWRITE'", 
+        "'DESC'", "'DESCRIPTION'", "'DESTROY'", "'DETACHED'", "'DETECTED'", 
+        "'DETERMINES'", "'DETERMINISTIC'", "'DICTIONARY'", "'DIMENSION'", 
+        "'DIMENSIONS'", "'DIRECTIO'", "'DIRECT_LOAD'", "'DIRECTORY'", "'DIRECT_PATH'", 
+        "'DISABLE_ALL'", "'DISABLE'", "'DISABLED'", "'DISABLE_DIRECTORY_LINK_CHECK'", 
+        "'DISABLE_PARALLEL_DML'", "'DISABLE_PRESET'", "'DISABLE_RPKE'", 
+        "'DISALLOW'", "'DISASSOCIATE'", "'DISCARD'", "'DISCARDFILE'", "'DISCONNECT'", 
+        "'DISK'", "'DISKGROUP'", "''+ DISKGROUP'", "'DISKS'", "'DISMOUNT'", 
+        "'DISTINCT'", "'DISTINGUISHED'", "'DISTRIBUTED'", "'DISTRIBUTE'", 
+        "'DML'", "'DML_UPDATE'", "'DNFS_DISABLE'", "'DNFS_ENABLE'", "'DNFS_READBUFFERS'", 
+        "'DOCFIDELITY'", "'DOCUMENT'", "'$ELSE'", "'$ELSIF'", "'$END'", 
+        "'$ERROR'", "'$IF'", "'$THEN'", "'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'", "'DUMPSET'", "'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'", "'EMBEDDED'", 
+        "'EMPTY_BLOB'", "'EMPTY_CLOB'", "'EMPTY'", "'ENABLE_ALL'", "'ENABLE'", 
+        "'ENABLED'", "'ENABLE_PARALLEL_DML'", "'ENABLE_PRESET'", "'ENCLOSED'", 
+        "'ENCODING'", "'ENCRYPT'", "'ENCRYPTION'", "'ENCRYPTPASSWORDISNULL'", 
+        "'END'", "'END_OUTLINE_DATA'", "'ENDIAN'", "'ENFORCED'", "'ENFORCE'", 
+        "'ENQUEUE'", "'ENTERPRISE'", "'ENTITYESCAPING'", "'ENTRY'", "'EQUIPART'", 
+        "'ERR'", "'ERROR_ARGUMENT'", "'ERROR'", "'ERROR_ON_OVERLAP_TIME'", 
+        "'ERRORS'", "'ERROR_INDEX'", "'ERROR_CODE'", "'ESCAPE'", "'ESCAPED'", 
+        "'ESTIMATE'", "'EVAL'", "'EVALNAME'", "'EVALUATE'", "'EVALUATION'", 
+        "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCEPTION'", "'EXCEPTION_INIT'", 
+        "'EXCEPTIONS'", "'EXCHANGE'", "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", 
+        "'EXEC'", "'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'", "'FIELD'", 
+        "'FIELDS'", "'FILE'", "'FILE_NAME_CONVERT'", "'FILEGROUP'", "'FILESTORE'", 
+        "'FILESYSTEM_LIKE_LOGGING'", "'FILTER'", "'FINAL'", "'FINE'", "'FINISH'", 
+        "'FIRST'", "'FIRSTM'", "'FIRST_ROWS'", "'FIRST_VALUE'", "'FIXED'", 
+        "'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'", "'HADOOP_TRAILERS'", "'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_CHARS_AFTER_EOR'", 
+        "'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'", "'INPUTFORMAT'", "'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'", "'INTERNAL'", "'INTO'", "'INVALIDATE'", "'INVALIDATION'", 
+        "'INVISIBLE'", "'IN_XQUERY'", "'IO_OPTIONS'", "'IS'", "'IS_LEAF'", 
+        "'ISOLATION'", "'ISOLATION_LEVEL'", "'ITEMS'", "'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'", "'LATEST'", "'LAX'", "'LAYER'", "'LDAP_REGISTRATION_ENABLED'", 
+        "'LDAP_REGISTRATION'", "'LDAP_REG_SYNC_INTERVAL'", "'LDRTRIM'", 
+        "'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'", "'LINES'", "'LINK'", "'LIST'", 
+        "'LITTLE'", "'LLS'", "'LN'", "'LNNVL'", "'LOAD'", "'LOB'", "'LOBFILE'", 
+        "'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'", "'LRTRIM'", 
+        "'LTRIM'", "'M'", "'MAIN'", "'MAKE_REF'", "'MANAGED'", "'MANAGE'", 
+        "'MANAGEMENT'", "'MANAGER'", "'MANDATORY'", "'MANUAL'", "'MAP'", 
+        "'MAPPING'", "'MASK'", "'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'", "'NEWLINE'", 
+        "'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'", "'NOBADFILE'", "'NO_AUTO_REOPTIMIZE'", 
+        "'NO_BASETABLE_MULTIMV_REWRITE'", "'NO_BATCH_TABLE_ACCESS_BY_ROWID'", 
+        "'NO_BIND_AWARE'", "'NO_BUFFER'", "'NOCACHE'", "'NOCHECK'", "'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'", "'NODIRECTIO'", "'NODISCARDFILE'", 
+        "'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'", "'NOEXTEND'", "'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'", "'NOLOG'", 
+        "'NOLOGFILE'", "'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'", "'NONPARTITIONED'", 
+        "'NONULLIF'", "'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'", "'NOSCALE'", "'NOSCHEMACHECK'", "'NOSEGMENT'", 
+        "'NO_SEMIJOIN'", "'NO_SEMI_TO_INNER'", "'NO_SET_TO_JOIN'", "'NOSHARD'", 
+        "'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'", "'NOTRIM'", "'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'", "'ONLINELOG'", "'ONLY'", "'ON'", 
+        "'OPAQUE'", "'OPAQUE_TRANSFORM'", "'OPAQUE_XCANONICAL'", "'OPCODE'", 
+        "'OPEN'", "'OPERATIONS'", "'OPERATOR'", "'OPT_ESTIMATE'", "'OPTIMAL'", 
+        "'OPTIMIZE'", "'OPTIMIZER_FEATURES_ENABLE'", "'OPTIMIZER_GOAL'", 
+        "'OPTION'", "'OPTIONALLY'", "'OPT_PARAM'", "'ORA_BRANCH'", "'ORA_CHECK_ACL'", 
+        "'ORA_CHECK_PRIVILEGE'", "'ORA_CLUSTERING'", "'ORADATA'", "'ORC'", 
+        "'ORACLE_DATE'", "'ORACLE_NUMBER'", "'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'", "'OUTPUTFORMAT'", "'OUT_OF_LINE'", 
+        "'OUT'", "'OVERFLOW_NOMOVE'", "'OVERFLOW'", "'OVERLAPS'", "'OVER'", 
+        "'OVERRIDE'", "'OVERRIDING'", "'OWNER'", "'OWNERSHIP'", "'OWN'", 
+        "'P'", "'PACKAGE'", "'PACKAGES'", "'PARALLEL_ENABLE'", "'PARALLEL_INDEX'", 
+        "'PARALLEL'", "'PARAMETERFILE'", "'PARAMETERS'", "'PARAM'", "'PARENT'", 
+        "'PARENT_LEVEL_NAME'", "'PARENT_UNIQUE_NAME'", "'PARITY'", "'PARQUET'", 
+        "'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'", null, 
+        null, null, "'PERCENT'", "'PERCENT_RANKM'", null, null, null, null, 
+        null, "'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'", 
+        "'POSITION'", "'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'", 
+        "'PREPROCESSOR'", "'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'", 
+        "'RCFILE'", "'RDBA'", "'READ'", "'READS'", "'READSIZE'", "'REALM'", 
+        "'REAL'", "'REBALANCE'", "'REBUILD'", "'RECORD'", "'RECORDS'", "'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'", "'SEQUENCEFILE'", "'SEQUENTIAL'", "'SEQ'", 
+        "'SERDE'", "'SERDEPROPERTIES'", "'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'", "'SHARD'", "'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'", 
+        "'SIZES'", "'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'", 
+        null, "'SQL_MACRO'", "'SQL_TRACE'", "'SQL_TRANSLATION_PROFILE'", 
+        "'SQRT'", "'STALE'", "'STANDALONE'", "'STANDARD'", "'STANDARD_HASH'", 
+        "'STANDBY_MAX_DATA_DELAY'", "'STANDBYS'", "'STANDBY'", "'STAR'", 
+        "'STAR_TRANSFORMATION'", "'START'", "'STARTOF'", "'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'", "'TEMPLATE_TABLE'", 
+        "'TEMPORARY'", "'TEMP_TABLE'", "'TERMINATED'", "'TEST'", "'TEXT'", 
+        "'TEXTFILE'", "'THAN'", "'THEN'", "'THE'", "'THESE'", "'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'", "'TINYINT'", "'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'", "'TRANSFORMS'", "'TRANSFORM_DISTINCT_AGG'", "'TRANSITIONAL'", 
+        "'TRANSITION'", "'TRANSLATE'", "'TRANSLATION'", "'TREAT'", "'TRIGGERS'", 
+        "'TRIGGER'", "'TRUE'", "'TRUNCATE'", "'TRUNC'", "'TRUSTED'", "'TRUST'", 
+        "'TUNING'", "'TX'", "'TYPES'", "'TYPE'", "'TZ_OFFSET'", "'UB2'", 
+        "'UBA'", "'UCS2'", "'UDF'", "'UID'", "'UNARCHIVED'", "'UNBOUNDED'", 
+        "'UNBOUND'", "'UNCONDITIONAL'", "'UNDER'", "'UNDO'", "'UNDROP'", 
+        "'UNIFORM'", "'UNION'", "'UNIONTYPE'", "'UNIQUE'", "'UNISTR'", "'UNLIMITED'", 
+        "'UNLOAD'", "'UNLOCK'", "'UNMATCHED'", "'UNNEST_INNERJ_DISTINCT_VIEW'", 
+        "'UNNEST_NOSEMIJ_NODISTINCTVIEW'", "'UNNEST_SEMIJ_VIEW'", "'UNNEST'", 
+        "'UNPACKED'", "'UNPIVOT'", "'UNPLUG'", "'UNPROTECTED'", "'UNQUIESCE'", 
+        "'UNRECOVERABLE'", "'UNRESTRICTED'", "'UNSIGNED'", "'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_NLS_COMP'", "'USING'", "'UTF16BE'", "'UTF16LE'", "'UTF32'", 
+        "'UTF8'", "'V1'", "'V2'", "'VALIDATE'", "'VALIDATE_CONVERSION'", 
+        "'VALIDATION'", "'VALID_TIME_END'", "'VALUES'", "'VALUE'", "'VARCHAR2'", 
+        "'VARCHAR'", "'VARCHARC'", "'VARIABLE'", "'VARRAW'", "'VARRAWC'", 
+        "'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'", "'WORKERID'", "'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'", "'XMLTAG'", "'XMLTRANSFORMBLOB'", 
+        "'XMLTRANSFORM'", "'XMLTYPE'", "'XML'", "'XPATHTABLE'", "'XS_SYS_CONTEXT'", 
+        "'XS'", "'XTRANSPORT'", "'YEARS'", "'YEAR'", "'YEAR_TO_MONTH'", 
+        "'YES'", "'YMINTERVAL_UNCONSTRAINED'", "'ZONEMAP'", "'ZONE'", "'ZONED'", 
+        "'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'", "'CHARSETID'", "'CHARSETFORM'", "'DURATION'", "'EXTEND'", 
+        "'MAXLEN'", "'PERSISTABLE'", "'POLYMORPHIC'", "'STRUCT'", "'TDO'", 
+        "'WM_CONCAT'", null, null, null, "'..'", "'.'", null, null, null, 
+        null, "'%'", "'&'", "'('", "')'", "'**'", "'*'", "'+'", "'-'", "','", 
+        "'/'", "'\\'", "'@'", "':='", "'#'", "'{'", "'}'", "'''", null, 
+        null, "'^'", "'~'", "'!'", "'>'", "'<'", "':'", "';'", "'|'", "'='", 
+        "'['", "']'", "'_'"
+    ];
+
+    public static readonly symbolicNames = [
+        null, "ABORT", "ABS", "ABSENT", "ACCESS", "ACCESSED", "ACCESSIBLE", 
+        "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", "ANNOTATIONS", "ANOMALY", "ANSI_REARCH", 
+        "ANTIJOIN", "ANY", "ANYSCHEMA", "APPEND", "APPENDCHILDXML", "APPEND_VALUES", 
+        "APPLICATION", "APPLY", "APPROX_COUNT_DISTINCT", "ARCHIVAL", "ARCHIVE", 
+        "ARCHIVED", "ARCHIVELOG", "ARE", "ARRAY", "AS", "ASC", "ASCII", 
+        "ASCIISTR", "ASIN", "ASIS", "ASSEMBLY", "ASSIGN", "ASSOCIATE", "ASYNC", 
+        "ASYNCHRONOUS", "ATAN2", "ATAN", "AT", "ATTRIBUTE", "ATTRIBUTES", 
+        "AUDIT", "AUTHENTICATED", "AUTHENTICATION", "AUTHID", "AUTHORIZATION", 
+        "AUTOALLOCATE", "AUTO", "AUTOBACKUP", "AUTOEXTEND", "AUTO_LOGIN", 
+        "AUTOMATIC", "AUTONOMOUS_TRANSACTION", "AUTO_REOPTIMIZE", "AVAILABILITY", 
+        "AVRO", "BACKGROUND", "BACKINGFILE", "BACKUP", "BACKUPS", "BACKUPSET", 
+        "BADFILE", "BASIC", "BASICFILE", "BATCH", "BATCHSIZE", "BATCH_TABLE_ACCESS_BY_ROWID", 
+        "BECOME", "BEFORE", "BEGIN", "BEGINNING", "BEGIN_OUTLINE_DATA", 
+        "BEHALF", "BEQUEATH", "BETWEEN", "BFILE", "BFILENAME", "BIG", "BIGFILE", 
+        "BIGINT", "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", "BLANKS", "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", "BYTES", "BYTEORDERMARK", "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", 
+        "CHANGETRACKING", "CHANGE_DUPKEY_ERROR_INDEX", "CHARACTER", "CHARACTERS", 
+        "CHARACTERSET", "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", "COLLECTION", "COLUMNAR", "COLUMN_AUTH_INDICATOR", 
+        "COLUMN", "COLUMNS", "COLUMN_STATS", "COLUMN_VALUE", "COMMENT", 
+        "COMMIT", "COMMITTED", "COMMON", "COMMON_DATA", "COMPACT", "COMPATIBLE", 
+        "COMPATIBILITY", "COMPILE", "COMPLETE", "COMPLIANCE", "COMPONENT", 
+        "COMPONENTS", "COMPOSE", "COMPOSITE", "COMPOSITE_LIMIT", "COMPOUND", 
+        "COMPRESS", "COMPRESSION", "COMPUTE", "COMPUTATION", "CONCAT", "CONCURRENT", 
+        "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", "COUNTED", "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", 
+        "CSV", "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", "DATAGUARDCONFIG", "DATAMOVEMENT", "DATAOBJNO", "DATAOBJ_TO_MAT_PARTITION", 
+        "DATAOBJ_TO_PARTITION", "DATAPUMP", "DATA_SECURITY_REWRITE_LIMIT", 
+        "DATE", "DATE_CACHE", "DATE_FORMAT", "DATE_MODE", "DAY", "DAYS", 
+        "DAY_TO_SECOND", "DBA", "DBA_RECYCLEBIN", "DBLINK", "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", "DEFAULTIF", "DEFAULTS", "DEFAULT_COLLATION", "DEFAULT_CREDENTIAL", 
+        "DEFERRABLE", "DEFERRED", "DEFINED", "DEFINE", "DEFINER", "DEGREE", 
+        "DELAY", "DELEGATE", "DELETE_ALL", "DELETE", "DELETEXML", "DELIMITED", 
+        "DEMAND", "DENSE_RANKM", "DEPENDENT", "DEPRECATE", "DEPTH", "DEQUEUE", 
+        "DEREF", "DEREF_NO_REWRITE", "DESC", "DESCRIPTION", "DESTROY", "DETACHED", 
+        "DETECTED", "DETERMINES", "DETERMINISTIC", "DICTIONARY", "DIMENSION", 
+        "DIMENSIONS", "DIRECTIO", "DIRECT_LOAD", "DIRECTORY", "DIRECT_PATH", 
+        "DISABLE_ALL", "DISABLE", "DISABLED", "DISABLE_DIRECTORY_LINK_CHECK", 
+        "DISABLE_PARALLEL_DML", "DISABLE_PRESET", "DISABLE_RPKE", "DISALLOW", 
+        "DISASSOCIATE", "DISCARD", "DISCARDFILE", "DISCONNECT", "DISK", 
+        "DISKGROUP", "DISKGROUP_PLUS", "DISKS", "DISMOUNT", "DISTINCT", 
+        "DISTINGUISHED", "DISTRIBUTED", "DISTRIBUTE", "DML", "DML_UPDATE", 
+        "DNFS_DISABLE", "DNFS_ENABLE", "DNFS_READBUFFERS", "DOCFIDELITY", 
+        "DOCUMENT", "DOLLAR_ELSE", "DOLLAR_ELSIF", "DOLLAR_END", "DOLLAR_ERROR", 
+        "DOLLAR_IF", "DOLLAR_THEN", "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", "DUMPSET", "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", 
+        "EMBEDDED", "EMPTY_BLOB", "EMPTY_CLOB", "EMPTY_", "ENABLE_ALL", 
+        "ENABLE", "ENABLED", "ENABLE_PARALLEL_DML", "ENABLE_PRESET", "ENCLOSED", 
+        "ENCODING", "ENCRYPT", "ENCRYPTION", "ENCRYPTPASSWORDISNULL", "END", 
+        "END_OUTLINE_DATA", "ENDIAN", "ENFORCED", "ENFORCE", "ENQUEUE", 
+        "ENTERPRISE", "ENTITYESCAPING", "ENTRY", "EQUIPART", "ERR", "ERROR_ARGUMENT", 
+        "ERROR", "ERROR_ON_OVERLAP_TIME", "ERRORS", "ERROR_INDEX", "ERROR_CODE", 
+        "ESCAPE", "ESCAPED", "ESTIMATE", "EVAL", "EVALNAME", "EVALUATE", 
+        "EVALUATION", "EVENTS", "EVERY", "EXCEPT", "EXCEPTION", "EXCEPTION_INIT", 
+        "EXCEPTIONS", "EXCHANGE", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXEC", 
+        "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", "FIELD", "FIELDS", "FILE", "FILE_NAME_CONVERT", 
+        "FILEGROUP", "FILESTORE", "FILESYSTEM_LIKE_LOGGING", "FILTER", "FINAL", 
+        "FINE", "FINISH", "FIRST", "FIRSTM", "FIRST_ROWS", "FIRST_VALUE", 
+        "FIXED", "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", "HADOOP_TRAILERS", 
+        "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_CHARS_AFTER_EOR", 
+        "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", "INPUTFORMAT", "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", "INTERNAL", "INTO", "INVALIDATE", 
+        "INVALIDATION", "INVISIBLE", "IN_XQUERY", "IO_OPTIONS", "IS", "IS_LEAF", 
+        "ISOLATION", "ISOLATION_LEVEL", "ITEMS", "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", "LATEST", "LAX", "LAYER", "LDAP_REGISTRATION_ENABLED", 
+        "LDAP_REGISTRATION", "LDAP_REG_SYNC_INTERVAL", "LDRTRIM", "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", "LINES", "LINK", "LIST", 
+        "LITTLE", "LLS", "LN", "LNNVL", "LOAD", "LOB", "LOBFILE", "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", "LRTRIM", "LTRIM", "M_LETTER", "MAIN", "MAKE_REF", "MANAGED", 
+        "MANAGE", "MANAGEMENT", "MANAGER", "MANDATORY", "MANUAL", "MAP", 
+        "MAPPING", "MASK", "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", "NEWLINE_", "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", "NOBADFILE", "NO_AUTO_REOPTIMIZE", "NO_BASETABLE_MULTIMV_REWRITE", 
+        "NO_BATCH_TABLE_ACCESS_BY_ROWID", "NO_BIND_AWARE", "NO_BUFFER", 
+        "NOCACHE", "NOCHECK", "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", 
+        "NODIRECTIO", "NODISCARDFILE", "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", 
+        "NOEXTEND", "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", 
+        "NOLOG", "NOLOGFILE", "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", "NONPARTITIONED", "NONULLIF", 
+        "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", "NOSCALE", "NOSCHEMACHECK", "NOSEGMENT", "NO_SEMIJOIN", 
+        "NO_SEMI_TO_INNER", "NO_SET_TO_JOIN", "NOSHARD", "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", "NOTRIM", "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", "ONLINELOG", "ONLY", "ON", 
+        "OPAQUE", "OPAQUE_TRANSFORM", "OPAQUE_XCANONICAL", "OPCODE", "OPEN", 
+        "OPERATIONS", "OPERATOR", "OPT_ESTIMATE", "OPTIMAL", "OPTIMIZE", 
+        "OPTIMIZER_FEATURES_ENABLE", "OPTIMIZER_GOAL", "OPTION", "OPTIONALLY", 
+        "OPT_PARAM", "ORA_BRANCH", "ORA_CHECK_ACL", "ORA_CHECK_PRIVILEGE", 
+        "ORA_CLUSTERING", "ORADATA", "ORC", "ORACLE_DATE", "ORACLE_NUMBER", 
+        "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", "OUTPUTFORMAT", 
+        "OUT_OF_LINE", "OUT", "OVERFLOW_NOMOVE", "OVERFLOW_", "OVERLAPS", 
+        "OVER", "OVERRIDE", "OVERRIDING", "OWNER", "OWNERSHIP", "OWN", "P_LETTER", 
+        "PACKAGE", "PACKAGES", "PARALLEL_ENABLE", "PARALLEL_INDEX", "PARALLEL", 
+        "PARAMETERFILE", "PARAMETERS", "PARAM", "PARENT", "PARENT_LEVEL_NAME", 
+        "PARENT_UNIQUE_NAME", "PARITY", "PARQUET", "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", "PERCENT_BULK_EXCEPTIONS", 
+        "PERCENT_BULK_ROWCOUNT", "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", "POSITION", "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", "PREPROCESSOR", "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", 
+        "RCFILE", "RDBA", "READ", "READS", "READSIZE", "REALM", "REAL", 
+        "REBALANCE", "REBUILD", "RECORD", "RECORDS", "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", "SEQUENCEFILE", "SEQUENTIAL", 
+        "SEQ", "SERDE", "SERDEPROPERTIES", "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", 
+        "SHARD", "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", "SIZES", 
+        "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", "FILE_EXT", "SQL_MACRO", "SQL_TRACE", "SQL_TRANSLATION_PROFILE", 
+        "SQRT", "STALE", "STANDALONE", "STANDARD", "STANDARD_HASH", "STANDBY_MAX_DATA_DELAY", 
+        "STANDBYS", "STANDBY", "STAR", "STAR_TRANSFORMATION", "START", "STARTOF", 
+        "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", "TEMPLATE_TABLE", "TEMPORARY", 
+        "TEMP_TABLE", "TERMINATED", "TEST", "TEXT", "TEXTFILE", "THAN", 
+        "THEN", "THE", "THESE", "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", "TINYINT", "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", "TRANSFORMS", 
+        "TRANSFORM_DISTINCT_AGG", "TRANSITIONAL", "TRANSITION", "TRANSLATE", 
+        "TRANSLATION", "TREAT", "TRIGGERS", "TRIGGER", "TRUE", "TRUNCATE", 
+        "TRUNC", "TRUSTED", "TRUST", "TUNING", "TX", "TYPES", "TYPE", "TZ_OFFSET", 
+        "UB2", "UBA", "UCS2", "UDF", "UID", "UNARCHIVED", "UNBOUNDED", "UNBOUND", 
+        "UNCONDITIONAL", "UNDER", "UNDO", "UNDROP", "UNIFORM", "UNION", 
+        "UNIONTYPE", "UNIQUE", "UNISTR", "UNLIMITED", "UNLOAD", "UNLOCK", 
+        "UNMATCHED", "UNNEST_INNERJ_DISTINCT_VIEW", "UNNEST_NOSEMIJ_NODISTINCTVIEW", 
+        "UNNEST_SEMIJ_VIEW", "UNNEST", "UNPACKED", "UNPIVOT", "UNPLUG", 
+        "UNPROTECTED", "UNQUIESCE", "UNRECOVERABLE", "UNRESTRICTED", "UNSIGNED", 
+        "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_NLS_COMP", "USING", "UTF16BE", "UTF16LE", 
+        "UTF32", "UTF8", "V1", "V2", "VALIDATE", "VALIDATE_CONVERSION", 
+        "VALIDATION", "VALID_TIME_END", "VALUES", "VALUE", "VARCHAR2", "VARCHAR", 
+        "VARCHARC", "VARIABLE", "VARRAW", "VARRAWC", "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", "WORKERID", "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", "XMLTAG", "XMLTRANSFORMBLOB", 
+        "XMLTRANSFORM", "XMLTYPE", "XML", "XPATHTABLE", "XS_SYS_CONTEXT", 
+        "XS", "XTRANSPORT", "YEARS", "YEAR", "YEAR_TO_MONTH", "YES", "YMINTERVAL_UNCONSTRAINED", 
+        "ZONEMAP", "ZONE", "ZONED", "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", "CHARSETID", 
+        "CHARSETFORM", "DURATION", "EXTEND", "MAXLEN", "PERSISTABLE", "POLYMORPHIC", 
+        "STRUCT", "TDO", "WM_CONCAT", "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", "RSOLIDUS", "AT_SIGN", 
+        "ASSIGN_OP", "HASH_OP", "LEFT_CURLY_PAREN", "RIGHT_CURLY_PAREN", 
+        "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", "REGULAR_ID", "INQUIRY_DIRECTIVE", "SPACES"
+    ];
+    public static readonly ruleNames = [
+        "sql_script", "script_unit", "terminator", "plsql_unit", "sql_unit", 
+        "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", "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", 
+        "accessible_by_clause", "default_collation_clause", "aggregate_clause", 
+        "pipelined_using_clause", "accessor", "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", "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", "alter_collection_clauses", 
+        "dependent_handling_clause", "dependent_exceptions_part", "create_type", 
+        "create_type_spec", "create_type_body", "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", 
+        "overriding_procedure_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", 
+        "system_actions", "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", "index_properties", "domain_index_clause", 
+        "local_domain_index_clause", "xmlindex_clause", "local_xmlindex_clause", 
+        "global_partitioned_index", "index_partitioning_clause", "index_partitioning_values_list", 
+        "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", "parallel_clause", "parallel_instances_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", 
+        "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", 
+        "query_rewrite_clause", "unusable_editions_clause", "drop_materialized_view", 
+        "drop_materialized_view_log", "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", "relational_table_properties", "relational_table_property", 
+        "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", 
+        "range_values_list", "list_values_clause", "table_partition_description", 
+        "partitioning_storage_clause", "lob_partitioning_storage", "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", "external_table_data_format", 
+        "external_table_transform", "external_table_field", "external_table_field_list", 
+        "external_table_fields_clause", "external_table_position_clause", 
+        "external_table_datatype_clause", "external_table_delimit_clause", 
+        "external_table_trim_clause", "external_table_date_format_clause", 
+        "external_table_init_clause", "external_table_condition_clause", 
+        "external_table_lls_clause", "external_table_records", "external_table_record_options_clause", 
+        "external_table_output_files", "external_table_fields", "external_table_datapump", 
+        "external_table_hive", "external_table_hive_parameter_map", "external_table_hive_parameter_map_entry", 
+        "external_table_directory", "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_schema", "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", "drop_database_link", 
+        "alter_tablespace_set", "alter_tablespace_attrs", "alter_tablespace_encryption", 
+        "ts_file_name_convert", "alter_role", "role_identified_clause", 
+        "alter_table", "alter_table_body", "alter_table_action", "enable_disable_clauses", 
+        "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", 
+        "move_table_partition", "filter_condition", "rename_table_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", "modify_to_partitioned", "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_properties", 
+        "modify_col_visibility", "modify_col_substitutable", "add_column_clause", 
+        "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", "virtual_column_expression", 
+        "autogenerated_sequence_definition", "by_user_for_statistics_clause", 
+        "evaluation_edition_clause", "nested_table_col_properties", "nested_item", 
+        "substitutable_column_clause", "partition_name", "supplemental_logging_props", 
+        "object_type_col_properties", "constraint_clauses", "old_constraint_name", 
+        "new_constraint_name", "drop_constraint_clause", "check_constraint", 
+        "foreign_key_clause", "references_clause", "on_delete_clause", "anonymous_block", 
+        "invoker_rights_clause", "call_spec", "java_spec", "c_spec", "c_agent_in_clause", 
+        "c_parameters_clause", "c_external_parameter", "c_property", "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", "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", "selection_directive", "error_directive", 
+        "selection_directive_body", "body", "exception_handler", "trigger_block", 
+        "tps_block", "block", "sql_statement", "execute_immediate", "dynamic_returning_clause", 
+        "data_manipulation_language_statements", "cursor_manipulation_statements", 
+        "close_statement", "open_statement", "fetch_statement", "variable_or_collection", 
+        "open_for_statement", "transaction_control_statements", "set_transaction_command", 
+        "set_constraint_command", "commit_statement", "write_clause", "rollback_statement", 
+        "savepoint_statement", "collection_method_call", "explain_statement", 
+        "select_only_statement", "select_statement", "with_clause", "with_factoring_clause", 
+        "subquery_factoring_clause", "search_clause", "cycle_clause", "subav_factoring_clause", 
+        "subav_clause", "hierarchies_clause", "filter_clauses", "filter_clause", 
+        "add_calcs_clause", "add_calc_meas_clause", "subquery", "subquery_no_with", 
+        "subquery_basic_elements", "subquery_operation_part", "query_block", 
+        "selected_list", "from_clause", "select_list_elements", "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", 
+        "expressions_", "expression", "cursor_expression", "logical_expression", 
+        "unary_logical_expression", "unary_logical_operation", "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", 
+        "unary_expression_core", "selection_directive_expression", "implicit_cursor_expression", 
+        "collection_expression", "case_statement", "simple_case_statement", 
+        "searched_case_statement", "case_when_part_statement", "case_else_part_statement", 
+        "case_expression", "simple_case_expression", "searched_case_expression", 
+        "case_when_part_expression", "case_else_part_expression", "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", 
+        "assignable_element", "collect_order_by_part", "within_or_over_part", 
+        "string_delimiter", "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", 
+        "annotations_clause", "annotations_list", "annotation", "sql_plus_command", 
+        "execute_command", "start_command", "sql_plus_filepath", "whenever_command", 
+        "set_command", "timing_command", "clear_command", "partition_extension_clause", 
+        "column_alias", "table_alias", "where_clause", "into_clause", "xml_column_name", 
+        "cost_class_name", "attribute_name", "savepoint_name", "rollback_segment_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", "link_name", "local_link_name", 
+        "connection_qualifier", "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", "numeric", "numeric_negative", 
+        "quoted_string", "identifier", "id_expression", "inquiry_directive", 
+        "outer_join_sign", "regular_id", "non_reserved_keywords_in_18c", 
+        "non_reserved_keywords_in_12c", "non_reserved_keywords_pre12c",
+    ];
+
+    public get grammarFileName(): string { return "PlSqlParser.g4"; }
+    public get literalNames(): (string | null)[] { return PlSqlParser.literalNames; }
+    public get symbolicNames(): (string | null)[] { return PlSqlParser.symbolicNames; }
+    public get ruleNames(): string[] { return PlSqlParser.ruleNames; }
+    public get serializedATN(): number[] { return PlSqlParser._serializedATN; }
+
+    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException {
+        return new antlr.FailedPredicateException(this, predicate, message);
+    }
+
+    public constructor(input: antlr.TokenStream) {
+        super(input);
+        this.interpreter = new antlr.ParserATNSimulator(this, PlSqlParser._ATN, PlSqlParser.decisionsToDFA, new antlr.PredictionContextCache());
+    }
+    public sql_script(): Sql_scriptContext {
+        let localContext = new Sql_scriptContext(this.context, this.state);
+        this.enterRule(localContext, 0, PlSqlParser.RULE_sql_script);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2450;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 2444;
+                    this.sql_plus_command();
+                    this.state = 2446;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 0, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 2445;
+                        this.match(PlSqlParser.SEMICOLON);
+                        }
+                        break;
+                    }
+                    }
+                    }
+                }
+                this.state = 2452;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1, this.context);
+            }
+            this.state = 2465;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) {
+            case 1:
+                {
+                this.state = 2453;
+                this.script_unit();
+                this.state = 2459;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2454;
+                        this.terminator();
+                        this.state = 2455;
+                        this.script_unit();
+                        }
+                        }
+                    }
+                    this.state = 2461;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2, this.context);
+                }
+                this.state = 2463;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2462;
+                    this.terminator();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 2467;
+            this.match(PlSqlParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public script_unit(): Script_unitContext {
+        let localContext = new Script_unitContext(this.context, this.state);
+        this.enterRule(localContext, 2, PlSqlParser.RULE_script_unit);
+        try {
+            this.state = 2478;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 2469;
+                this.plsql_unit();
+                this.setLastUnitPlsql();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 2472;
+                this.sql_unit();
+                this.setLastUnitSql();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 2475;
+                this.sql_plus_command();
+                this.setLastUnitSql();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public terminator(): TerminatorContext {
+        let localContext = new TerminatorContext(this.context, this.state);
+        this.enterRule(localContext, 4, PlSqlParser.RULE_terminator);
+        try {
+            this.state = 2486;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 6, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 2480;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 2481;
+                this.match(PlSqlParser.SEMICOLON);
+                this.state = 2482;
+                if (!(this.isSolidusSeparator())) {
+                    throw this.createFailedPredicateException("this.isSolidusSeparator()");
+                }
+                this.state = 2483;
+                this.match(PlSqlParser.SOLIDUS);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 2484;
+                if (!(this.isLastUnitSql() && this.isSolidusSeparator())) {
+                    throw this.createFailedPredicateException("this.isLastUnitSql() && this.isSolidusSeparator()");
+                }
+                this.state = 2485;
+                this.match(PlSqlParser.SOLIDUS);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public plsql_unit(): Plsql_unitContext {
+        let localContext = new Plsql_unitContext(this.context, this.state);
+        this.enterRule(localContext, 6, PlSqlParser.RULE_plsql_unit);
+        try {
+            this.state = 2495;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 7, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 2488;
+                this.anonymous_block();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 2489;
+                this.create_function_body();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 2490;
+                this.create_procedure_body();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 2491;
+                this.create_package();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 2492;
+                this.create_package_body();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 2493;
+                this.create_trigger();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 2494;
+                this.create_type_body();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_unit(): Sql_unitContext {
+        let localContext = new Sql_unitContext(this.context, this.state);
+        this.enterRule(localContext, 8, PlSqlParser.RULE_sql_unit);
+        try {
+            this.state = 2632;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 2497;
+                this.alter_analytic_view();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 2498;
+                this.alter_attribute_dimension();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 2499;
+                this.alter_audit_policy();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 2500;
+                this.alter_cluster();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 2501;
+                this.alter_database();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 2502;
+                this.alter_database_link();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 2503;
+                this.alter_dimension();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 2504;
+                this.alter_diskgroup();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 2505;
+                this.alter_flashback_archive();
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 2506;
+                this.alter_function();
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 2507;
+                this.alter_hierarchy();
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 2508;
+                this.alter_index();
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 2509;
+                this.alter_inmemory_join_group();
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 2510;
+                this.alter_java();
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 2511;
+                this.alter_library();
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 2512;
+                this.alter_lockdown_profile();
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 2513;
+                this.alter_materialized_view();
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 2514;
+                this.alter_materialized_view_log();
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 2515;
+                this.alter_materialized_zonemap();
+                }
+                break;
+            case 20:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 2516;
+                this.alter_operator();
+                }
+                break;
+            case 21:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 2517;
+                this.alter_outline();
+                }
+                break;
+            case 22:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 2518;
+                this.alter_package();
+                }
+                break;
+            case 23:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 2519;
+                this.alter_pmem_filestore();
+                }
+                break;
+            case 24:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 2520;
+                this.alter_procedure();
+                }
+                break;
+            case 25:
+                this.enterOuterAlt(localContext, 25);
+                {
+                this.state = 2521;
+                this.alter_resource_cost();
+                }
+                break;
+            case 26:
+                this.enterOuterAlt(localContext, 26);
+                {
+                this.state = 2522;
+                this.alter_role();
+                }
+                break;
+            case 27:
+                this.enterOuterAlt(localContext, 27);
+                {
+                this.state = 2523;
+                this.alter_rollback_segment();
+                }
+                break;
+            case 28:
+                this.enterOuterAlt(localContext, 28);
+                {
+                this.state = 2524;
+                this.alter_sequence();
+                }
+                break;
+            case 29:
+                this.enterOuterAlt(localContext, 29);
+                {
+                this.state = 2525;
+                this.alter_session();
+                }
+                break;
+            case 30:
+                this.enterOuterAlt(localContext, 30);
+                {
+                this.state = 2526;
+                this.alter_synonym();
+                }
+                break;
+            case 31:
+                this.enterOuterAlt(localContext, 31);
+                {
+                this.state = 2527;
+                this.alter_table();
+                }
+                break;
+            case 32:
+                this.enterOuterAlt(localContext, 32);
+                {
+                this.state = 2528;
+                this.alter_tablespace();
+                }
+                break;
+            case 33:
+                this.enterOuterAlt(localContext, 33);
+                {
+                this.state = 2529;
+                this.alter_tablespace_set();
+                }
+                break;
+            case 34:
+                this.enterOuterAlt(localContext, 34);
+                {
+                this.state = 2530;
+                this.alter_trigger();
+                }
+                break;
+            case 35:
+                this.enterOuterAlt(localContext, 35);
+                {
+                this.state = 2531;
+                this.alter_type();
+                }
+                break;
+            case 36:
+                this.enterOuterAlt(localContext, 36);
+                {
+                this.state = 2532;
+                this.alter_user();
+                }
+                break;
+            case 37:
+                this.enterOuterAlt(localContext, 37);
+                {
+                this.state = 2533;
+                this.alter_view();
+                }
+                break;
+            case 38:
+                this.enterOuterAlt(localContext, 38);
+                {
+                this.state = 2534;
+                this.call_statement();
+                }
+                break;
+            case 39:
+                this.enterOuterAlt(localContext, 39);
+                {
+                this.state = 2535;
+                this.create_analytic_view();
+                }
+                break;
+            case 40:
+                this.enterOuterAlt(localContext, 40);
+                {
+                this.state = 2536;
+                this.create_attribute_dimension();
+                }
+                break;
+            case 41:
+                this.enterOuterAlt(localContext, 41);
+                {
+                this.state = 2537;
+                this.create_audit_policy();
+                }
+                break;
+            case 42:
+                this.enterOuterAlt(localContext, 42);
+                {
+                this.state = 2538;
+                this.create_cluster();
+                }
+                break;
+            case 43:
+                this.enterOuterAlt(localContext, 43);
+                {
+                this.state = 2539;
+                this.create_context();
+                }
+                break;
+            case 44:
+                this.enterOuterAlt(localContext, 44);
+                {
+                this.state = 2540;
+                this.create_controlfile();
+                }
+                break;
+            case 45:
+                this.enterOuterAlt(localContext, 45);
+                {
+                this.state = 2541;
+                this.create_schema();
+                }
+                break;
+            case 46:
+                this.enterOuterAlt(localContext, 46);
+                {
+                this.state = 2542;
+                this.create_database();
+                }
+                break;
+            case 47:
+                this.enterOuterAlt(localContext, 47);
+                {
+                this.state = 2543;
+                this.create_database_link();
+                }
+                break;
+            case 48:
+                this.enterOuterAlt(localContext, 48);
+                {
+                this.state = 2544;
+                this.create_dimension();
+                }
+                break;
+            case 49:
+                this.enterOuterAlt(localContext, 49);
+                {
+                this.state = 2545;
+                this.create_directory();
+                }
+                break;
+            case 50:
+                this.enterOuterAlt(localContext, 50);
+                {
+                this.state = 2546;
+                this.create_diskgroup();
+                }
+                break;
+            case 51:
+                this.enterOuterAlt(localContext, 51);
+                {
+                this.state = 2547;
+                this.create_edition();
+                }
+                break;
+            case 52:
+                this.enterOuterAlt(localContext, 52);
+                {
+                this.state = 2548;
+                this.create_flashback_archive();
+                }
+                break;
+            case 53:
+                this.enterOuterAlt(localContext, 53);
+                {
+                this.state = 2549;
+                this.create_hierarchy();
+                }
+                break;
+            case 54:
+                this.enterOuterAlt(localContext, 54);
+                {
+                this.state = 2550;
+                this.create_index();
+                }
+                break;
+            case 55:
+                this.enterOuterAlt(localContext, 55);
+                {
+                this.state = 2551;
+                this.create_inmemory_join_group();
+                }
+                break;
+            case 56:
+                this.enterOuterAlt(localContext, 56);
+                {
+                this.state = 2552;
+                this.create_java();
+                }
+                break;
+            case 57:
+                this.enterOuterAlt(localContext, 57);
+                {
+                this.state = 2553;
+                this.create_library();
+                }
+                break;
+            case 58:
+                this.enterOuterAlt(localContext, 58);
+                {
+                this.state = 2554;
+                this.create_lockdown_profile();
+                }
+                break;
+            case 59:
+                this.enterOuterAlt(localContext, 59);
+                {
+                this.state = 2555;
+                this.create_materialized_view();
+                }
+                break;
+            case 60:
+                this.enterOuterAlt(localContext, 60);
+                {
+                this.state = 2556;
+                this.create_materialized_view_log();
+                }
+                break;
+            case 61:
+                this.enterOuterAlt(localContext, 61);
+                {
+                this.state = 2557;
+                this.create_materialized_zonemap();
+                }
+                break;
+            case 62:
+                this.enterOuterAlt(localContext, 62);
+                {
+                this.state = 2558;
+                this.create_operator();
+                }
+                break;
+            case 63:
+                this.enterOuterAlt(localContext, 63);
+                {
+                this.state = 2559;
+                this.create_outline();
+                }
+                break;
+            case 64:
+                this.enterOuterAlt(localContext, 64);
+                {
+                this.state = 2560;
+                this.create_pmem_filestore();
+                }
+                break;
+            case 65:
+                this.enterOuterAlt(localContext, 65);
+                {
+                this.state = 2561;
+                this.create_profile();
+                }
+                break;
+            case 66:
+                this.enterOuterAlt(localContext, 66);
+                {
+                this.state = 2562;
+                this.create_restore_point();
+                }
+                break;
+            case 67:
+                this.enterOuterAlt(localContext, 67);
+                {
+                this.state = 2563;
+                this.create_role();
+                }
+                break;
+            case 68:
+                this.enterOuterAlt(localContext, 68);
+                {
+                this.state = 2564;
+                this.create_rollback_segment();
+                }
+                break;
+            case 69:
+                this.enterOuterAlt(localContext, 69);
+                {
+                this.state = 2565;
+                this.create_sequence();
+                }
+                break;
+            case 70:
+                this.enterOuterAlt(localContext, 70);
+                {
+                this.state = 2566;
+                this.create_spfile();
+                }
+                break;
+            case 71:
+                this.enterOuterAlt(localContext, 71);
+                {
+                this.state = 2567;
+                this.create_synonym();
+                }
+                break;
+            case 72:
+                this.enterOuterAlt(localContext, 72);
+                {
+                this.state = 2568;
+                this.create_table();
+                }
+                break;
+            case 73:
+                this.enterOuterAlt(localContext, 73);
+                {
+                this.state = 2569;
+                this.create_tablespace();
+                }
+                break;
+            case 74:
+                this.enterOuterAlt(localContext, 74);
+                {
+                this.state = 2570;
+                this.create_tablespace_set();
+                }
+                break;
+            case 75:
+                this.enterOuterAlt(localContext, 75);
+                {
+                this.state = 2571;
+                this.create_type_spec();
+                }
+                break;
+            case 76:
+                this.enterOuterAlt(localContext, 76);
+                {
+                this.state = 2572;
+                this.create_user();
+                }
+                break;
+            case 77:
+                this.enterOuterAlt(localContext, 77);
+                {
+                this.state = 2573;
+                this.create_view();
+                }
+                break;
+            case 78:
+                this.enterOuterAlt(localContext, 78);
+                {
+                this.state = 2574;
+                this.drop_analytic_view();
+                }
+                break;
+            case 79:
+                this.enterOuterAlt(localContext, 79);
+                {
+                this.state = 2575;
+                this.drop_attribute_dimension();
+                }
+                break;
+            case 80:
+                this.enterOuterAlt(localContext, 80);
+                {
+                this.state = 2576;
+                this.drop_audit_policy();
+                }
+                break;
+            case 81:
+                this.enterOuterAlt(localContext, 81);
+                {
+                this.state = 2577;
+                this.drop_cluster();
+                }
+                break;
+            case 82:
+                this.enterOuterAlt(localContext, 82);
+                {
+                this.state = 2578;
+                this.drop_context();
+                }
+                break;
+            case 83:
+                this.enterOuterAlt(localContext, 83);
+                {
+                this.state = 2579;
+                this.drop_database();
+                }
+                break;
+            case 84:
+                this.enterOuterAlt(localContext, 84);
+                {
+                this.state = 2580;
+                this.drop_database_link();
+                }
+                break;
+            case 85:
+                this.enterOuterAlt(localContext, 85);
+                {
+                this.state = 2581;
+                this.drop_directory();
+                }
+                break;
+            case 86:
+                this.enterOuterAlt(localContext, 86);
+                {
+                this.state = 2582;
+                this.drop_diskgroup();
+                }
+                break;
+            case 87:
+                this.enterOuterAlt(localContext, 87);
+                {
+                this.state = 2583;
+                this.drop_edition();
+                }
+                break;
+            case 88:
+                this.enterOuterAlt(localContext, 88);
+                {
+                this.state = 2584;
+                this.drop_flashback_archive();
+                }
+                break;
+            case 89:
+                this.enterOuterAlt(localContext, 89);
+                {
+                this.state = 2585;
+                this.drop_function();
+                }
+                break;
+            case 90:
+                this.enterOuterAlt(localContext, 90);
+                {
+                this.state = 2586;
+                this.drop_hierarchy();
+                }
+                break;
+            case 91:
+                this.enterOuterAlt(localContext, 91);
+                {
+                this.state = 2587;
+                this.drop_index();
+                }
+                break;
+            case 92:
+                this.enterOuterAlt(localContext, 92);
+                {
+                this.state = 2588;
+                this.drop_indextype();
+                }
+                break;
+            case 93:
+                this.enterOuterAlt(localContext, 93);
+                {
+                this.state = 2589;
+                this.drop_inmemory_join_group();
+                }
+                break;
+            case 94:
+                this.enterOuterAlt(localContext, 94);
+                {
+                this.state = 2590;
+                this.drop_java();
+                }
+                break;
+            case 95:
+                this.enterOuterAlt(localContext, 95);
+                {
+                this.state = 2591;
+                this.drop_library();
+                }
+                break;
+            case 96:
+                this.enterOuterAlt(localContext, 96);
+                {
+                this.state = 2592;
+                this.drop_lockdown_profile();
+                }
+                break;
+            case 97:
+                this.enterOuterAlt(localContext, 97);
+                {
+                this.state = 2593;
+                this.drop_materialized_view();
+                }
+                break;
+            case 98:
+                this.enterOuterAlt(localContext, 98);
+                {
+                this.state = 2594;
+                this.drop_materialized_view_log();
+                }
+                break;
+            case 99:
+                this.enterOuterAlt(localContext, 99);
+                {
+                this.state = 2595;
+                this.drop_materialized_zonemap();
+                }
+                break;
+            case 100:
+                this.enterOuterAlt(localContext, 100);
+                {
+                this.state = 2596;
+                this.drop_operator();
+                }
+                break;
+            case 101:
+                this.enterOuterAlt(localContext, 101);
+                {
+                this.state = 2597;
+                this.drop_outline();
+                }
+                break;
+            case 102:
+                this.enterOuterAlt(localContext, 102);
+                {
+                this.state = 2598;
+                this.drop_package();
+                }
+                break;
+            case 103:
+                this.enterOuterAlt(localContext, 103);
+                {
+                this.state = 2599;
+                this.drop_pmem_filestore();
+                }
+                break;
+            case 104:
+                this.enterOuterAlt(localContext, 104);
+                {
+                this.state = 2600;
+                this.drop_procedure();
+                }
+                break;
+            case 105:
+                this.enterOuterAlt(localContext, 105);
+                {
+                this.state = 2601;
+                this.drop_restore_point();
+                }
+                break;
+            case 106:
+                this.enterOuterAlt(localContext, 106);
+                {
+                this.state = 2602;
+                this.drop_role();
+                }
+                break;
+            case 107:
+                this.enterOuterAlt(localContext, 107);
+                {
+                this.state = 2603;
+                this.drop_rollback_segment();
+                }
+                break;
+            case 108:
+                this.enterOuterAlt(localContext, 108);
+                {
+                this.state = 2604;
+                this.drop_sequence();
+                }
+                break;
+            case 109:
+                this.enterOuterAlt(localContext, 109);
+                {
+                this.state = 2605;
+                this.drop_synonym();
+                }
+                break;
+            case 110:
+                this.enterOuterAlt(localContext, 110);
+                {
+                this.state = 2606;
+                this.drop_table();
+                }
+                break;
+            case 111:
+                this.enterOuterAlt(localContext, 111);
+                {
+                this.state = 2607;
+                this.drop_tablespace();
+                }
+                break;
+            case 112:
+                this.enterOuterAlt(localContext, 112);
+                {
+                this.state = 2608;
+                this.drop_tablespace_set();
+                }
+                break;
+            case 113:
+                this.enterOuterAlt(localContext, 113);
+                {
+                this.state = 2609;
+                this.drop_trigger();
+                }
+                break;
+            case 114:
+                this.enterOuterAlt(localContext, 114);
+                {
+                this.state = 2610;
+                this.drop_type();
+                }
+                break;
+            case 115:
+                this.enterOuterAlt(localContext, 115);
+                {
+                this.state = 2611;
+                this.drop_user();
+                }
+                break;
+            case 116:
+                this.enterOuterAlt(localContext, 116);
+                {
+                this.state = 2612;
+                this.drop_view();
+                }
+                break;
+            case 117:
+                this.enterOuterAlt(localContext, 117);
+                {
+                this.state = 2613;
+                this.administer_key_management();
+                }
+                break;
+            case 118:
+                this.enterOuterAlt(localContext, 118);
+                {
+                this.state = 2614;
+                this.analyze();
+                }
+                break;
+            case 119:
+                this.enterOuterAlt(localContext, 119);
+                {
+                this.state = 2615;
+                this.associate_statistics();
+                }
+                break;
+            case 120:
+                this.enterOuterAlt(localContext, 120);
+                {
+                this.state = 2616;
+                this.audit_traditional();
+                }
+                break;
+            case 121:
+                this.enterOuterAlt(localContext, 121);
+                {
+                this.state = 2617;
+                this.comment_on_column();
+                }
+                break;
+            case 122:
+                this.enterOuterAlt(localContext, 122);
+                {
+                this.state = 2618;
+                this.comment_on_materialized();
+                }
+                break;
+            case 123:
+                this.enterOuterAlt(localContext, 123);
+                {
+                this.state = 2619;
+                this.comment_on_table();
+                }
+                break;
+            case 124:
+                this.enterOuterAlt(localContext, 124);
+                {
+                this.state = 2620;
+                this.data_manipulation_language_statements();
+                }
+                break;
+            case 125:
+                this.enterOuterAlt(localContext, 125);
+                {
+                this.state = 2621;
+                this.disassociate_statistics();
+                }
+                break;
+            case 126:
+                this.enterOuterAlt(localContext, 126);
+                {
+                this.state = 2622;
+                this.flashback_table();
+                }
+                break;
+            case 127:
+                this.enterOuterAlt(localContext, 127);
+                {
+                this.state = 2623;
+                this.grant_statement();
+                }
+                break;
+            case 128:
+                this.enterOuterAlt(localContext, 128);
+                {
+                this.state = 2624;
+                this.noaudit_statement();
+                }
+                break;
+            case 129:
+                this.enterOuterAlt(localContext, 129);
+                {
+                this.state = 2625;
+                this.purge_statement();
+                }
+                break;
+            case 130:
+                this.enterOuterAlt(localContext, 130);
+                {
+                this.state = 2626;
+                this.rename_object();
+                }
+                break;
+            case 131:
+                this.enterOuterAlt(localContext, 131);
+                {
+                this.state = 2627;
+                this.revoke_statement();
+                }
+                break;
+            case 132:
+                this.enterOuterAlt(localContext, 132);
+                {
+                this.state = 2628;
+                this.transaction_control_statements();
+                }
+                break;
+            case 133:
+                this.enterOuterAlt(localContext, 133);
+                {
+                this.state = 2629;
+                this.truncate_cluster();
+                }
+                break;
+            case 134:
+                this.enterOuterAlt(localContext, 134);
+                {
+                this.state = 2630;
+                this.truncate_table();
+                }
+                break;
+            case 135:
+                this.enterOuterAlt(localContext, 135);
+                {
+                this.state = 2631;
+                this.unified_auditing();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_diskgroup(): Alter_diskgroupContext {
+        let localContext = new Alter_diskgroupContext(this.context, this.state);
+        this.enterRule(localContext, 10, PlSqlParser.RULE_alter_diskgroup);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2634;
+            this.match(PlSqlParser.ALTER);
+            this.state = 2635;
+            this.match(PlSqlParser.DISKGROUP);
+            this.state = 2689;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context) ) {
+            case 1:
+                {
+                this.state = 2636;
+                this.id_expression();
+                this.state = 2671;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 14, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2644;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.ADD:
+                    case PlSqlParser.DROP:
+                        {
+                        this.state = 2639;
+                        this.errorHandler.sync(this);
+                        alternative = 1;
+                        do {
+                            switch (alternative) {
+                            case 1:
+                                {
+                                this.state = 2639;
+                                this.errorHandler.sync(this);
+                                switch (this.tokenStream.LA(1)) {
+                                case PlSqlParser.ADD:
+                                    {
+                                    this.state = 2637;
+                                    this.add_disk_clause();
+                                    }
+                                    break;
+                                case PlSqlParser.DROP:
+                                    {
+                                    this.state = 2638;
+                                    this.drop_disk_clause();
+                                    }
+                                    break;
+                                default:
+                                    throw new antlr.NoViableAltException(this);
+                                }
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                            }
+                            this.state = 2641;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 10, this.context);
+                        } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                        }
+                        break;
+                    case PlSqlParser.RESIZE:
+                        {
+                        this.state = 2643;
+                        this.resize_disk_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 2647;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 12, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 2646;
+                        this.rebalance_diskgroup_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 2669;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 13, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 2649;
+                        this.replace_disk_clause();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 2650;
+                        this.rename_disk_clause();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 2651;
+                        this.disk_online_clause();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 2652;
+                        this.disk_offline_clause();
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 2653;
+                        this.rebalance_diskgroup_clause();
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 2654;
+                        this.check_diskgroup_clause();
+                        }
+                        break;
+                    case 7:
+                        {
+                        this.state = 2655;
+                        this.diskgroup_template_clauses();
+                        }
+                        break;
+                    case 8:
+                        {
+                        this.state = 2656;
+                        this.diskgroup_directory_clauses();
+                        }
+                        break;
+                    case 9:
+                        {
+                        this.state = 2657;
+                        this.diskgroup_alias_clauses();
+                        }
+                        break;
+                    case 10:
+                        {
+                        this.state = 2658;
+                        this.diskgroup_volume_clauses();
+                        }
+                        break;
+                    case 11:
+                        {
+                        this.state = 2659;
+                        this.diskgroup_attributes();
+                        }
+                        break;
+                    case 12:
+                        {
+                        this.state = 2660;
+                        this.drop_diskgroup_file_clause();
+                        }
+                        break;
+                    case 13:
+                        {
+                        this.state = 2661;
+                        this.convert_redundancy_clause();
+                        }
+                        break;
+                    case 14:
+                        {
+                        this.state = 2662;
+                        this.usergroup_clauses();
+                        }
+                        break;
+                    case 15:
+                        {
+                        this.state = 2663;
+                        this.user_clauses();
+                        }
+                        break;
+                    case 16:
+                        {
+                        this.state = 2664;
+                        this.file_permissions_clause();
+                        }
+                        break;
+                    case 17:
+                        {
+                        this.state = 2665;
+                        this.file_owner_clause();
+                        }
+                        break;
+                    case 18:
+                        {
+                        this.state = 2666;
+                        this.scrub_clause();
+                        }
+                        break;
+                    case 19:
+                        {
+                        this.state = 2667;
+                        this.quotagroup_clauses();
+                        }
+                        break;
+                    case 20:
+                        {
+                        this.state = 2668;
+                        this.filegroup_clauses();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 2682;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 2673;
+                    this.id_expression();
+                    this.state = 2678;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 2674;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2675;
+                        this.id_expression();
+                        }
+                        }
+                        this.state = 2680;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                case PlSqlParser.ALL:
+                    {
+                    this.state = 2681;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 2687;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNDROP:
+                    {
+                    this.state = 2684;
+                    this.undrop_disk_clause();
+                    }
+                    break;
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.MOUNT:
+                    {
+                    this.state = 2685;
+                    this.diskgroup_availability();
+                    }
+                    break;
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.ENABLE:
+                    {
+                    this.state = 2686;
+                    this.enable_disable_volume();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_disk_clause(): Add_disk_clauseContext {
+        let localContext = new Add_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 12, PlSqlParser.RULE_add_disk_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2691;
+            this.match(PlSqlParser.ADD);
+            this.state = 2712;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 2694;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1690) {
+                        {
+                        this.state = 2692;
+                        this.match(PlSqlParser.SITE);
+                        this.state = 2693;
+                        localContext._sn = this.id_expression();
+                        }
+                    }
+
+                    this.state = 2697;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1491 || _la === 1550) {
+                        {
+                        this.state = 2696;
+                        this.quorum_regular();
+                        }
+                    }
+
+                    this.state = 2701;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 573) {
+                        {
+                        this.state = 2699;
+                        this.match(PlSqlParser.FAILGROUP);
+                        this.state = 2700;
+                        localContext._fgn = this.id_expression();
+                        }
+                    }
+
+                    this.state = 2703;
+                    this.match(PlSqlParser.DISK);
+                    this.state = 2704;
+                    this.qualified_disk_clause();
+                    this.state = 2709;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 22, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 2705;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 2706;
+                            this.qualified_disk_clause();
+                            }
+                            }
+                        }
+                        this.state = 2711;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 22, this.context);
+                    }
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 2714;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 23, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_disk_clause(): Drop_disk_clauseContext {
+        let localContext = new Drop_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 14, PlSqlParser.RULE_drop_disk_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2716;
+            this.match(PlSqlParser.DROP);
+            this.state = 2755;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DISK:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.REGULAR:
+                {
+                this.state = 2718;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1491 || _la === 1550) {
+                    {
+                    this.state = 2717;
+                    this.quorum_regular();
+                    }
+                }
+
+                this.state = 2720;
+                this.match(PlSqlParser.DISK);
+                this.state = 2721;
+                this.id_expression();
+                this.state = 2723;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 25, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2722;
+                    this.force_noforce();
+                    }
+                    break;
+                }
+                this.state = 2732;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 27, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2725;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2726;
+                        this.id_expression();
+                        this.state = 2728;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 26, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 2727;
+                            this.force_noforce();
+                            }
+                            break;
+                        }
+                        }
+                        }
+                    }
+                    this.state = 2734;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 27, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DISKS:
+                {
+                this.state = 2735;
+                this.match(PlSqlParser.DISKS);
+                this.state = 2736;
+                this.match(PlSqlParser.IN);
+                this.state = 2738;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1491 || _la === 1550) {
+                    {
+                    this.state = 2737;
+                    this.quorum_regular();
+                    }
+                }
+
+                this.state = 2740;
+                this.match(PlSqlParser.FAILGROUP);
+                this.state = 2741;
+                this.id_expression();
+                this.state = 2743;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 29, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2742;
+                    this.force_noforce();
+                    }
+                    break;
+                }
+                this.state = 2752;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 31, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2745;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2746;
+                        this.id_expression();
+                        this.state = 2748;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 30, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 2747;
+                            this.force_noforce();
+                            }
+                            break;
+                        }
+                        }
+                        }
+                    }
+                    this.state = 2754;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 31, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public resize_disk_clause(): Resize_disk_clauseContext {
+        let localContext = new Resize_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 16, PlSqlParser.RULE_resize_disk_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2757;
+            this.match(PlSqlParser.RESIZE);
+            this.state = 2758;
+            this.match(PlSqlParser.ALL);
+            this.state = 2761;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 33, this.context) ) {
+            case 1:
+                {
+                this.state = 2759;
+                this.match(PlSqlParser.SIZE);
+                this.state = 2760;
+                this.size_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public replace_disk_clause(): Replace_disk_clauseContext {
+        let localContext = new Replace_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 18, PlSqlParser.RULE_replace_disk_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2763;
+            this.match(PlSqlParser.REPLACE);
+            this.state = 2764;
+            this.match(PlSqlParser.DISK);
+            this.state = 2765;
+            this.id_expression();
+            this.state = 2766;
+            this.match(PlSqlParser.WITH);
+            this.state = 2767;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 2769;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 34, this.context) ) {
+            case 1:
+                {
+                this.state = 2768;
+                this.force_noforce();
+                }
+                break;
+            }
+            this.state = 2780;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 36, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 2771;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 2772;
+                    this.id_expression();
+                    this.state = 2773;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 2774;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 2776;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 35, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 2775;
+                        this.force_noforce();
+                        }
+                        break;
+                    }
+                    }
+                    }
+                }
+                this.state = 2782;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 36, this.context);
+            }
+            this.state = 2785;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 37, this.context) ) {
+            case 1:
+                {
+                this.state = 2783;
+                this.match(PlSqlParser.POWER);
+                this.state = 2784;
+                this.numeric();
+                }
+                break;
+            }
+            this.state = 2788;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 38, this.context) ) {
+            case 1:
+                {
+                this.state = 2787;
+                this.wait_nowait();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public wait_nowait(): Wait_nowaitContext {
+        let localContext = new Wait_nowaitContext(this.context, this.state);
+        this.enterRule(localContext, 20, PlSqlParser.RULE_wait_nowait);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2790;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1221 || _la === 2295)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rename_disk_clause(): Rename_disk_clauseContext {
+        let localContext = new Rename_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 22, PlSqlParser.RULE_rename_disk_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2792;
+            this.match(PlSqlParser.RENAME);
+            this.state = 2809;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DISK:
+                {
+                this.state = 2793;
+                this.match(PlSqlParser.DISK);
+                this.state = 2794;
+                this.id_expression();
+                this.state = 2795;
+                this.match(PlSqlParser.TO);
+                this.state = 2796;
+                this.id_expression();
+                this.state = 2804;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 39, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2797;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2798;
+                        this.id_expression();
+                        this.state = 2799;
+                        this.match(PlSqlParser.TO);
+                        this.state = 2800;
+                        this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 2806;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 39, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DISKS:
+                {
+                this.state = 2807;
+                this.match(PlSqlParser.DISKS);
+                this.state = 2808;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public disk_online_clause(): Disk_online_clauseContext {
+        let localContext = new Disk_online_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 24, PlSqlParser.RULE_disk_online_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2811;
+            this.match(PlSqlParser.ONLINE);
+            this.state = 2843;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.REGULAR:
+                {
+                this.state = 2838;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 2838;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.DISK:
+                        case PlSqlParser.QUORUM:
+                        case PlSqlParser.REGULAR:
+                            {
+                            this.state = 2813;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 1491 || _la === 1550) {
+                                {
+                                this.state = 2812;
+                                this.quorum_regular();
+                                }
+                            }
+
+                            this.state = 2815;
+                            this.match(PlSqlParser.DISK);
+                            this.state = 2816;
+                            this.id_expression();
+                            this.state = 2821;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 42, this.context);
+                            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                                if (alternative === 1) {
+                                    {
+                                    {
+                                    this.state = 2817;
+                                    this.match(PlSqlParser.COMMA);
+                                    this.state = 2818;
+                                    this.id_expression();
+                                    }
+                                    }
+                                }
+                                this.state = 2823;
+                                this.errorHandler.sync(this);
+                                alternative = this.interpreter.adaptivePredict(this.tokenStream, 42, this.context);
+                            }
+                            }
+                            break;
+                        case PlSqlParser.DISKS:
+                            {
+                            this.state = 2824;
+                            this.match(PlSqlParser.DISKS);
+                            this.state = 2825;
+                            this.match(PlSqlParser.IN);
+                            this.state = 2827;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 1491 || _la === 1550) {
+                                {
+                                this.state = 2826;
+                                this.quorum_regular();
+                                }
+                            }
+
+                            this.state = 2829;
+                            this.match(PlSqlParser.FAILGROUP);
+                            this.state = 2830;
+                            this.id_expression();
+                            this.state = 2835;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 44, this.context);
+                            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                                if (alternative === 1) {
+                                    {
+                                    {
+                                    this.state = 2831;
+                                    this.match(PlSqlParser.COMMA);
+                                    this.state = 2832;
+                                    this.id_expression();
+                                    }
+                                    }
+                                }
+                                this.state = 2837;
+                                this.errorHandler.sync(this);
+                                alternative = this.interpreter.adaptivePredict(this.tokenStream, 44, this.context);
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 2840;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 46, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 2842;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 2847;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 48, this.context) ) {
+            case 1:
+                {
+                this.state = 2845;
+                this.match(PlSqlParser.POWER);
+                this.state = 2846;
+                this.numeric();
+                }
+                break;
+            }
+            this.state = 2850;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 49, this.context) ) {
+            case 1:
+                {
+                this.state = 2849;
+                this.wait_nowait();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public disk_offline_clause(): Disk_offline_clauseContext {
+        let localContext = new Disk_offline_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 26, PlSqlParser.RULE_disk_offline_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2852;
+            this.match(PlSqlParser.OFFLINE);
+            this.state = 2879;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DISK:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.REGULAR:
+                {
+                this.state = 2854;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1491 || _la === 1550) {
+                    {
+                    this.state = 2853;
+                    this.quorum_regular();
+                    }
+                }
+
+                this.state = 2856;
+                this.match(PlSqlParser.DISK);
+                this.state = 2857;
+                this.id_expression();
+                this.state = 2862;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 51, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2858;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2859;
+                        this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 2864;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 51, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DISKS:
+                {
+                this.state = 2865;
+                this.match(PlSqlParser.DISKS);
+                this.state = 2866;
+                this.match(PlSqlParser.IN);
+                this.state = 2868;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1491 || _la === 1550) {
+                    {
+                    this.state = 2867;
+                    this.quorum_regular();
+                    }
+                }
+
+                this.state = 2870;
+                this.match(PlSqlParser.FAILGROUP);
+                this.state = 2871;
+                this.id_expression();
+                this.state = 2876;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 53, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2872;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2873;
+                        this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 2878;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 53, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 2882;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 55, this.context) ) {
+            case 1:
+                {
+                this.state = 2881;
+                this.timeout_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public timeout_clause(): Timeout_clauseContext {
+        let localContext = new Timeout_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 28, PlSqlParser.RULE_timeout_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2884;
+            this.match(PlSqlParser.DROP);
+            this.state = 2885;
+            this.match(PlSqlParser.AFTER);
+            this.state = 2886;
+            this.numeric();
+            this.state = 2887;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 685 || _la === 902)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rebalance_diskgroup_clause(): Rebalance_diskgroup_clauseContext {
+        let localContext = new Rebalance_diskgroup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 30, PlSqlParser.RULE_rebalance_diskgroup_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2889;
+            this.match(PlSqlParser.REBALANCE);
+            this.state = 2909;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.POWER:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH:
+                {
+                this.state = 2896;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2308 || _la === 2310) {
+                    {
+                    this.state = 2890;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2308 || _la === 2310)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 2892;
+                    this.errorHandler.sync(this);
+                    alternative = 1;
+                    do {
+                        switch (alternative) {
+                        case 1:
+                            {
+                            {
+                            this.state = 2891;
+                            this.phase();
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 2894;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 56, this.context);
+                    } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                    }
+                }
+
+                {
+                this.state = 2898;
+                this.match(PlSqlParser.POWER);
+                this.state = 2899;
+                this.numeric();
+                }
+                this.state = 2902;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 58, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2901;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1221 || _la === 2295)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                {
+                this.state = 2904;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 2905;
+                this.match(PlSqlParser.POWER);
+                this.state = 2907;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 59, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2906;
+                    this.numeric();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public phase(): PhaseContext {
+        let localContext = new PhaseContext(this.context, this.state);
+        this.enterRule(localContext, 32, PlSqlParser.RULE_phase);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2911;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public check_diskgroup_clause(): Check_diskgroup_clauseContext {
+        let localContext = new Check_diskgroup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 34, PlSqlParser.RULE_check_diskgroup_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2913;
+            this.match(PlSqlParser.CHECK);
+            this.state = 2915;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 61, this.context) ) {
+            case 1:
+                {
+                this.state = 2914;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            }
+            this.state = 2918;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 62, this.context) ) {
+            case 1:
+                {
+                this.state = 2917;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1173 || _la === 1562)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public diskgroup_template_clauses(): Diskgroup_template_clausesContext {
+        let localContext = new Diskgroup_template_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 36, PlSqlParser.RULE_diskgroup_template_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 2943;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 2920;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 21 || _la === 981)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 2921;
+                this.match(PlSqlParser.TEMPLATE);
+                this.state = 2922;
+                this.id_expression();
+                this.state = 2923;
+                this.qualified_template_clause();
+                this.state = 2930;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 63, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2924;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2925;
+                        this.id_expression();
+                        this.state = 2926;
+                        this.qualified_template_clause();
+                        }
+                        }
+                    }
+                    this.state = 2932;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 63, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 2933;
+                this.match(PlSqlParser.DROP);
+                this.state = 2934;
+                this.match(PlSqlParser.TEMPLATE);
+                this.state = 2935;
+                this.id_expression();
+                this.state = 2940;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 64, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2936;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2937;
+                        this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 2942;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 64, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public qualified_template_clause(): Qualified_template_clauseContext {
+        let localContext = new Qualified_template_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 38, PlSqlParser.RULE_qualified_template_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2945;
+            this.match(PlSqlParser.ATTRIBUTES);
+            this.state = 2946;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 2948;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 465 || _la === 676 || _la === 964 || _la === 1342 || _la === 2198) {
+                {
+                this.state = 2947;
+                this.redundancy_clause();
+                }
+            }
+
+            this.state = 2951;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 230 || _la === 597) {
+                {
+                this.state = 2950;
+                this.striping_clause();
+                }
+            }
+
+            this.state = 2953;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public redundancy_clause(): Redundancy_clauseContext {
+        let localContext = new Redundancy_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 40, PlSqlParser.RULE_redundancy_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2955;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 465 || _la === 676 || _la === 964 || _la === 1342 || _la === 2198)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public striping_clause(): Striping_clauseContext {
+        let localContext = new Striping_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 42, PlSqlParser.RULE_striping_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2957;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 230 || _la === 597)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public force_noforce(): Force_noforceContext {
+        let localContext = new Force_noforceContext(this.context, this.state);
+        this.enterRule(localContext, 44, PlSqlParser.RULE_force_noforce);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 2959;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 617 || _la === 1105)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public diskgroup_directory_clauses(): Diskgroup_directory_clausesContext {
+        let localContext = new Diskgroup_directory_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 46, PlSqlParser.RULE_diskgroup_directory_clauses);
+        try {
+            let alternative: number;
+            this.state = 3002;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 2961;
+                this.match(PlSqlParser.ADD);
+                this.state = 2962;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 2963;
+                this.filename();
+                this.state = 2968;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 68, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2964;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2965;
+                        this.filename();
+                        }
+                        }
+                    }
+                    this.state = 2970;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 68, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 2971;
+                this.match(PlSqlParser.DROP);
+                this.state = 2972;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 2973;
+                this.filename();
+                this.state = 2975;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) {
+                case 1:
+                    {
+                    this.state = 2974;
+                    this.force_noforce();
+                    }
+                    break;
+                }
+                this.state = 2984;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 71, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2977;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2978;
+                        this.filename();
+                        this.state = 2980;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 70, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 2979;
+                            this.force_noforce();
+                            }
+                            break;
+                        }
+                        }
+                        }
+                    }
+                    this.state = 2986;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 71, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 2987;
+                this.match(PlSqlParser.RENAME);
+                this.state = 2988;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 2989;
+                this.dir_name();
+                this.state = 2990;
+                this.match(PlSqlParser.TO);
+                this.state = 2991;
+                this.dir_name();
+                this.state = 2999;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 72, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 2992;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 2993;
+                        this.dir_name();
+                        this.state = 2994;
+                        this.match(PlSqlParser.TO);
+                        this.state = 2995;
+                        this.dir_name();
+                        }
+                        }
+                    }
+                    this.state = 3001;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 72, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dir_name(): Dir_nameContext {
+        let localContext = new Dir_nameContext(this.context, this.state);
+        this.enterRule(localContext, 48, PlSqlParser.RULE_dir_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3004;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public diskgroup_alias_clauses(): Diskgroup_alias_clausesContext {
+        let localContext = new Diskgroup_alias_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 50, PlSqlParser.RULE_diskgroup_alias_clauses);
+        try {
+            let alternative: number;
+            this.state = 3044;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3006;
+                this.match(PlSqlParser.ADD);
+                this.state = 3007;
+                this.match(PlSqlParser.ALIAS);
+                this.state = 3008;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3009;
+                this.match(PlSqlParser.FOR);
+                this.state = 3010;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3017;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 74, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3011;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3012;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        this.state = 3013;
+                        this.match(PlSqlParser.FOR);
+                        this.state = 3014;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3019;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 74, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3020;
+                this.match(PlSqlParser.DROP);
+                this.state = 3021;
+                this.match(PlSqlParser.ALIAS);
+                this.state = 3022;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3027;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 75, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3023;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3024;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3029;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 75, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3030;
+                this.match(PlSqlParser.RENAME);
+                this.state = 3031;
+                this.match(PlSqlParser.ALIAS);
+                this.state = 3032;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3033;
+                this.match(PlSqlParser.TO);
+                this.state = 3034;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3041;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 76, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3035;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3036;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        this.state = 3037;
+                        this.match(PlSqlParser.TO);
+                        this.state = 3038;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3043;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 76, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public diskgroup_volume_clauses(): Diskgroup_volume_clausesContext {
+        let localContext = new Diskgroup_volume_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 52, PlSqlParser.RULE_diskgroup_volume_clauses);
+        try {
+            this.state = 3057;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3046;
+                this.add_volume_clause();
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3047;
+                this.modify_volume_clause();
+                }
+                break;
+            case PlSqlParser.RESIZE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3048;
+                this.match(PlSqlParser.RESIZE);
+                this.state = 3049;
+                this.match(PlSqlParser.VOLUME);
+                this.state = 3050;
+                this.id_expression();
+                this.state = 3051;
+                this.match(PlSqlParser.SIZE);
+                this.state = 3052;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 3054;
+                this.match(PlSqlParser.DROP);
+                this.state = 3055;
+                this.match(PlSqlParser.VOLUME);
+                this.state = 3056;
+                this.id_expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_volume_clause(): Add_volume_clauseContext {
+        let localContext = new Add_volume_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 54, PlSqlParser.RULE_add_volume_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3059;
+            this.match(PlSqlParser.ADD);
+            this.state = 3060;
+            this.match(PlSqlParser.VOLUME);
+            this.state = 3061;
+            this.id_expression();
+            this.state = 3062;
+            this.match(PlSqlParser.SIZE);
+            this.state = 3063;
+            this.size_clause();
+            this.state = 3065;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 79, this.context) ) {
+            case 1:
+                {
+                this.state = 3064;
+                this.redundancy_clause();
+                }
+                break;
+            }
+            this.state = 3071;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 80, this.context) ) {
+            case 1:
+                {
+                this.state = 3067;
+                this.match(PlSqlParser.STRIPE_WIDTH);
+                this.state = 3068;
+                this.numeric();
+                this.state = 3069;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 813 || _la === 902)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 3075;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 81, this.context) ) {
+            case 1:
+                {
+                this.state = 3073;
+                this.match(PlSqlParser.STRIPE_COLUMNS);
+                this.state = 3074;
+                this.numeric();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_volume_clause(): Modify_volume_clauseContext {
+        let localContext = new Modify_volume_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 56, PlSqlParser.RULE_modify_volume_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3077;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 3078;
+            this.match(PlSqlParser.VOLUME);
+            this.state = 3079;
+            this.id_expression();
+            this.state = 3082;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 82, this.context) ) {
+            case 1:
+                {
+                this.state = 3080;
+                this.match(PlSqlParser.MOUNTPATH);
+                this.state = 3081;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            this.state = 3086;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 83, this.context) ) {
+            case 1:
+                {
+                this.state = 3084;
+                this.match(PlSqlParser.USAGE);
+                this.state = 3085;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public diskgroup_attributes(): Diskgroup_attributesContext {
+        let localContext = new Diskgroup_attributesContext(this.context, this.state);
+        this.enterRule(localContext, 58, PlSqlParser.RULE_diskgroup_attributes);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3088;
+            this.match(PlSqlParser.SET);
+            this.state = 3089;
+            this.match(PlSqlParser.ATTRIBUTE);
+            this.state = 3090;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3091;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 3092;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_diskgroup_file_clause(): Drop_diskgroup_file_clauseContext {
+        let localContext = new Drop_diskgroup_file_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 60, PlSqlParser.RULE_drop_diskgroup_file_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3094;
+            this.match(PlSqlParser.DROP);
+            this.state = 3095;
+            this.match(PlSqlParser.FILE);
+            this.state = 3096;
+            this.filename();
+            this.state = 3101;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 84, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 3097;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 3098;
+                    this.filename();
+                    }
+                    }
+                }
+                this.state = 3103;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 84, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public convert_redundancy_clause(): Convert_redundancy_clauseContext {
+        let localContext = new Convert_redundancy_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 62, PlSqlParser.RULE_convert_redundancy_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3104;
+            this.match(PlSqlParser.CONVERT);
+            this.state = 3105;
+            this.match(PlSqlParser.REDUNDANCY);
+            this.state = 3106;
+            this.match(PlSqlParser.TO);
+            this.state = 3107;
+            this.match(PlSqlParser.FLEX);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public usergroup_clauses(): Usergroup_clausesContext {
+        let localContext = new Usergroup_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 64, PlSqlParser.RULE_usergroup_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 3138;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3109;
+                this.match(PlSqlParser.ADD);
+                this.state = 3110;
+                this.match(PlSqlParser.USERGROUP);
+                this.state = 3111;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3112;
+                this.match(PlSqlParser.WITH);
+                this.state = 3113;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 3114;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3119;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 85, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3115;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3116;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3121;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 85, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3122;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 3123;
+                this.match(PlSqlParser.USERGROUP);
+                this.state = 3124;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3125;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 21 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3126;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 3127;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3132;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 86, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3128;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3129;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3134;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 86, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3135;
+                this.match(PlSqlParser.DROP);
+                this.state = 3136;
+                this.match(PlSqlParser.USERGROUP);
+                this.state = 3137;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public user_clauses(): User_clausesContext {
+        let localContext = new User_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 66, PlSqlParser.RULE_user_clauses);
+        try {
+            let alternative: number;
+            this.state = 3177;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3140;
+                this.match(PlSqlParser.ADD);
+                this.state = 3141;
+                this.match(PlSqlParser.USER);
+                this.state = 3142;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3147;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 88, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3143;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3144;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3149;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 88, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3150;
+                this.match(PlSqlParser.DROP);
+                this.state = 3151;
+                this.match(PlSqlParser.USER);
+                this.state = 3152;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3157;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 89, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3153;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3154;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3159;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 89, this.context);
+                }
+                this.state = 3161;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 90, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3160;
+                    this.match(PlSqlParser.CASCADE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.REPLACE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3163;
+                this.match(PlSqlParser.REPLACE);
+                this.state = 3164;
+                this.match(PlSqlParser.USER);
+                this.state = 3165;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3166;
+                this.match(PlSqlParser.WITH);
+                this.state = 3167;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3174;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 91, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3168;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3169;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        this.state = 3170;
+                        this.match(PlSqlParser.WITH);
+                        this.state = 3171;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 3176;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 91, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public file_permissions_clause(): File_permissions_clauseContext {
+        let localContext = new File_permissions_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 68, PlSqlParser.RULE_file_permissions_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3179;
+            this.match(PlSqlParser.SET);
+            this.state = 3180;
+            this.match(PlSqlParser.PERMISSION);
+            this.state = 3181;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 650 || _la === 1312 || _la === 1327)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3182;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 3186;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NONE:
+                {
+                this.state = 3183;
+                this.match(PlSqlParser.NONE);
+                }
+                break;
+            case PlSqlParser.READ:
+                {
+                this.state = 3184;
+                this.match(PlSqlParser.READ);
+                this.state = 3185;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1260 || _la === 2315)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 3198;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 3188;
+                this.match(PlSqlParser.COMMA);
+                this.state = 3189;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 650 || _la === 1312 || _la === 1327)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3190;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3194;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NONE:
+                    {
+                    this.state = 3191;
+                    this.match(PlSqlParser.NONE);
+                    }
+                    break;
+                case PlSqlParser.READ:
+                    {
+                    this.state = 3192;
+                    this.match(PlSqlParser.READ);
+                    this.state = 3193;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1260 || _la === 2315)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                }
+                this.state = 3200;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3201;
+            this.match(PlSqlParser.FOR);
+            this.state = 3202;
+            this.match(PlSqlParser.FILE);
+            this.state = 3203;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3208;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 96, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 3204;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 3205;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    }
+                }
+                this.state = 3210;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 96, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public file_owner_clause(): File_owner_clauseContext {
+        let localContext = new File_owner_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 70, PlSqlParser.RULE_file_owner_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3211;
+            this.match(PlSqlParser.SET);
+            this.state = 3212;
+            this.match(PlSqlParser.OWNERSHIP);
+            this.state = 3213;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 650 || _la === 1327)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3214;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 3215;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3222;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 3216;
+                this.match(PlSqlParser.COMMA);
+                this.state = 3217;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 650 || _la === 1327)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3218;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3219;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                }
+                this.state = 3224;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3225;
+            this.match(PlSqlParser.FOR);
+            this.state = 3226;
+            this.match(PlSqlParser.FILE);
+            this.state = 3227;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3232;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 98, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 3228;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 3229;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    }
+                }
+                this.state = 3234;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 98, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public scrub_clause(): Scrub_clauseContext {
+        let localContext = new Scrub_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 72, PlSqlParser.RULE_scrub_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3235;
+            this.match(PlSqlParser.SCRUB);
+            this.state = 3240;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 99, this.context) ) {
+            case 1:
+                {
+                this.state = 3236;
+                this.match(PlSqlParser.FILE);
+                this.state = 3237;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 2:
+                {
+                this.state = 3238;
+                this.match(PlSqlParser.DISK);
+                this.state = 3239;
+                this.id_expression();
+                }
+                break;
+            }
+            this.state = 3243;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 100, this.context) ) {
+            case 1:
+                {
+                this.state = 3242;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1173 || _la === 1562)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 3247;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 101, this.context) ) {
+            case 1:
+                {
+                this.state = 3245;
+                this.match(PlSqlParser.POWER);
+                this.state = 3246;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 91 || _la === 676 || _la === 898 || _la === 2408)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 3250;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 102, this.context) ) {
+            case 1:
+                {
+                this.state = 3249;
+                this.wait_nowait();
+                }
+                break;
+            }
+            this.state = 3253;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 103, this.context) ) {
+            case 1:
+                {
+                this.state = 3252;
+                this.force_noforce();
+                }
+                break;
+            }
+            this.state = 3256;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 104, this.context) ) {
+            case 1:
+                {
+                this.state = 3255;
+                this.match(PlSqlParser.STOP);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public quotagroup_clauses(): Quotagroup_clausesContext {
+        let localContext = new Quotagroup_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 74, PlSqlParser.RULE_quotagroup_clauses);
+        try {
+            this.state = 3285;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3258;
+                this.match(PlSqlParser.ADD);
+                this.state = 3259;
+                this.match(PlSqlParser.QUOTAGROUP);
+                this.state = 3260;
+                this.id_expression();
+                this.state = 3266;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 105, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3261;
+                    this.match(PlSqlParser.SET);
+                    this.state = 3262;
+                    this.property_name();
+                    this.state = 3263;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 3264;
+                    this.property_value();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3268;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 3269;
+                this.match(PlSqlParser.QUOTAGROUP);
+                this.state = 3270;
+                this.id_expression();
+                this.state = 3271;
+                this.match(PlSqlParser.SET);
+                this.state = 3272;
+                this.property_name();
+                this.state = 3273;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3274;
+                this.property_value();
+                }
+                break;
+            case PlSqlParser.MOVE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3276;
+                this.match(PlSqlParser.MOVE);
+                this.state = 3277;
+                this.match(PlSqlParser.QUOTAGROUP);
+                this.state = 3278;
+                this.id_expression();
+                this.state = 3279;
+                this.match(PlSqlParser.TO);
+                this.state = 3280;
+                this.id_expression();
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 3282;
+                this.match(PlSqlParser.DROP);
+                this.state = 3283;
+                this.match(PlSqlParser.QUOTAGROUP);
+                this.state = 3284;
+                this.id_expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public property_name(): Property_nameContext {
+        let localContext = new Property_nameContext(this.context, this.state);
+        this.enterRule(localContext, 76, PlSqlParser.RULE_property_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3287;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public property_value(): Property_valueContext {
+        let localContext = new Property_valueContext(this.context, this.state);
+        this.enterRule(localContext, 78, PlSqlParser.RULE_property_value);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3289;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filegroup_clauses(): Filegroup_clausesContext {
+        let localContext = new Filegroup_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 80, PlSqlParser.RULE_filegroup_clauses);
+        try {
+            this.state = 3295;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3291;
+                this.add_filegroup_clause();
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3292;
+                this.modify_filegroup_clause();
+                }
+                break;
+            case PlSqlParser.MOVE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3293;
+                this.move_to_filegroup_clause();
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 3294;
+                this.drop_filegroup_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_filegroup_clause(): Add_filegroup_clauseContext {
+        let localContext = new Add_filegroup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 82, PlSqlParser.RULE_add_filegroup_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3297;
+            this.match(PlSqlParser.ADD);
+            this.state = 3298;
+            this.match(PlSqlParser.FILEGROUP);
+            this.state = 3299;
+            this.id_expression();
+            this.state = 3303;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.VOLUME:
+                {
+                this.state = 3300;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 220 || _la === 350 || _la === 2293)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3301;
+                this.id_expression();
+                }
+                break;
+            case PlSqlParser.TEMPLATE:
+                {
+                this.state = 3302;
+                this.match(PlSqlParser.TEMPLATE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 3308;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 109, this.context) ) {
+            case 1:
+                {
+                this.state = 3305;
+                this.match(PlSqlParser.FROM);
+                this.state = 3306;
+                this.match(PlSqlParser.TEMPLATE);
+                this.state = 3307;
+                this.id_expression();
+                }
+                break;
+            }
+            this.state = 3314;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 110, this.context) ) {
+            case 1:
+                {
+                this.state = 3310;
+                this.match(PlSqlParser.SET);
+                this.state = 3311;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3312;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3313;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_filegroup_clause(): Modify_filegroup_clauseContext {
+        let localContext = new Modify_filegroup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 84, PlSqlParser.RULE_modify_filegroup_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3316;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 3317;
+            this.match(PlSqlParser.FILEGROUP);
+            this.state = 3318;
+            this.id_expression();
+            this.state = 3319;
+            this.match(PlSqlParser.SET);
+            this.state = 3320;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3321;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 3322;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public move_to_filegroup_clause(): Move_to_filegroup_clauseContext {
+        let localContext = new Move_to_filegroup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 86, PlSqlParser.RULE_move_to_filegroup_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3324;
+            this.match(PlSqlParser.MOVE);
+            this.state = 3325;
+            this.match(PlSqlParser.FILE);
+            this.state = 3326;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3327;
+            this.match(PlSqlParser.TO);
+            this.state = 3328;
+            this.match(PlSqlParser.FILEGROUP);
+            this.state = 3329;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_filegroup_clause(): Drop_filegroup_clauseContext {
+        let localContext = new Drop_filegroup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 88, PlSqlParser.RULE_drop_filegroup_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3331;
+            this.match(PlSqlParser.DROP);
+            this.state = 3332;
+            this.match(PlSqlParser.FILEGROUP);
+            this.state = 3333;
+            this.id_expression();
+            this.state = 3335;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 111, this.context) ) {
+            case 1:
+                {
+                this.state = 3334;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public quorum_regular(): Quorum_regularContext {
+        let localContext = new Quorum_regularContext(this.context, this.state);
+        this.enterRule(localContext, 90, PlSqlParser.RULE_quorum_regular);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3337;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1491 || _la === 1550)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public undrop_disk_clause(): Undrop_disk_clauseContext {
+        let localContext = new Undrop_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 92, PlSqlParser.RULE_undrop_disk_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3339;
+            this.match(PlSqlParser.UNDROP);
+            this.state = 3340;
+            this.match(PlSqlParser.DISKS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public diskgroup_availability(): Diskgroup_availabilityContext {
+        let localContext = new Diskgroup_availabilityContext(this.context, this.state);
+        this.enterRule(localContext, 94, PlSqlParser.RULE_diskgroup_availability);
+        let _la: number;
+        try {
+            this.state = 3353;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MOUNT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3342;
+                this.match(PlSqlParser.MOUNT);
+                this.state = 3344;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 112, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3343;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1180 || _la === 1578)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 3347;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 113, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3346;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 617 || _la === 1105)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.DISMOUNT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3349;
+                this.match(PlSqlParser.DISMOUNT);
+                this.state = 3351;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 114, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3350;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 617 || _la === 1105)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public enable_disable_volume(): Enable_disable_volumeContext {
+        let localContext = new Enable_disable_volumeContext(this.context, this.state);
+        this.enterRule(localContext, 96, PlSqlParser.RULE_enable_disable_volume);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3355;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 429 || _la === 499)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3356;
+            this.match(PlSqlParser.VOLUME);
+            this.state = 3366;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 3357;
+                this.id_expression();
+                this.state = 3362;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 116, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3358;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 3359;
+                        this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 3364;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 116, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 3365;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_function(): Drop_functionContext {
+        let localContext = new Drop_functionContext(this.context, this.state);
+        this.enterRule(localContext, 98, PlSqlParser.RULE_drop_function);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3368;
+            this.match(PlSqlParser.DROP);
+            this.state = 3369;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 3370;
+            this.function_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_flashback_archive(): Alter_flashback_archiveContext {
+        let localContext = new Alter_flashback_archiveContext(this.context, this.state);
+        this.enterRule(localContext, 100, PlSqlParser.RULE_alter_flashback_archive);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3372;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3373;
+            this.match(PlSqlParser.FLASHBACK);
+            this.state = 3374;
+            this.match(PlSqlParser.ARCHIVE);
+            this.state = 3375;
+            localContext._fa = this.id_expression();
+            this.state = 3405;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 122, this.context) ) {
+            case 1:
+                {
+                this.state = 3376;
+                this.match(PlSqlParser.SET);
+                this.state = 3377;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            case 2:
+                {
+                this.state = 3378;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 21 || _la === 981)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3379;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 3380;
+                localContext._ts = this.id_expression();
+                this.state = 3382;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 118, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3381;
+                    this.flashback_archive_quota();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 3384;
+                this.match(PlSqlParser.REMOVE);
+                this.state = 3385;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 3386;
+                localContext._rts = this.id_expression();
+                }
+                break;
+            case 4:
+                {
+                this.state = 3387;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 3388;
+                this.flashback_archive_retention();
+                }
+                break;
+            case 5:
+                {
+                this.state = 3389;
+                this.match(PlSqlParser.PURGE);
+                this.state = 3398;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ALL:
+                    {
+                    this.state = 3390;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                case PlSqlParser.BEFORE:
+                    {
+                    this.state = 3391;
+                    this.match(PlSqlParser.BEFORE);
+                    this.state = 3396;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.SCN:
+                        {
+                        this.state = 3392;
+                        this.match(PlSqlParser.SCN);
+                        this.state = 3393;
+                        this.expression();
+                        }
+                        break;
+                    case PlSqlParser.TIMESTAMP:
+                        {
+                        this.state = 3394;
+                        this.match(PlSqlParser.TIMESTAMP);
+                        this.state = 3395;
+                        this.expression();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 6:
+                {
+                this.state = 3401;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 3400;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 3403;
+                this.match(PlSqlParser.OPTIMIZE);
+                this.state = 3404;
+                this.match(PlSqlParser.DATA);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_hierarchy(): Alter_hierarchyContext {
+        let localContext = new Alter_hierarchyContext(this.context, this.state);
+        this.enterRule(localContext, 102, PlSqlParser.RULE_alter_hierarchy);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3407;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3408;
+            this.match(PlSqlParser.HIERARCHY);
+            this.state = 3412;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 123, this.context) ) {
+            case 1:
+                {
+                this.state = 3409;
+                this.schema_name();
+                this.state = 3410;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 3414;
+            localContext._hn = this.id_expression();
+            this.state = 3419;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RENAME:
+                {
+                this.state = 3415;
+                this.match(PlSqlParser.RENAME);
+                this.state = 3416;
+                this.match(PlSqlParser.TO);
+                this.state = 3417;
+                localContext._nhn = this.id_expression();
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 3418;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_function(): Alter_functionContext {
+        let localContext = new Alter_functionContext(this.context, this.state);
+        this.enterRule(localContext, 104, PlSqlParser.RULE_alter_function);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3421;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3422;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 3423;
+            this.function_name();
+            this.state = 3440;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.EDITIONABLE:
+                {
+                this.state = 3424;
+                this.match(PlSqlParser.EDITIONABLE);
+                }
+                break;
+            case PlSqlParser.NONEDITIONABLE:
+                {
+                this.state = 3425;
+                this.match(PlSqlParser.NONEDITIONABLE);
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 3426;
+                this.match(PlSqlParser.COMPILE);
+                this.state = 3428;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 125, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3427;
+                    this.match(PlSqlParser.DEBUG);
+                    }
+                    break;
+                }
+                this.state = 3433;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 126, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 3430;
+                        this.compiler_parameters_clause();
+                        }
+                        }
+                    }
+                    this.state = 3435;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 126, this.context);
+                }
+                this.state = 3438;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 127, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3436;
+                    this.match(PlSqlParser.REUSE);
+                    this.state = 3437;
+                    this.match(PlSqlParser.SETTINGS);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_java(): Alter_javaContext {
+        let localContext = new Alter_javaContext(this.context, this.state);
+        this.enterRule(localContext, 106, PlSqlParser.RULE_alter_java);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3442;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3443;
+            this.match(PlSqlParser.JAVA);
+            this.state = 3444;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 206 || _la === 1715)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3448;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 129, this.context) ) {
+            case 1:
+                {
+                this.state = 3445;
+                this.schema_name();
+                this.state = 3446;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 3450;
+            localContext._o = this.id_expression();
+            this.state = 3470;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1571) {
+                {
+                this.state = 3451;
+                this.match(PlSqlParser.RESOLVER);
+                this.state = 3452;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3464;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 3453;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 3454;
+                    this.match_string();
+                    this.state = 3456;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 3455;
+                        this.match(PlSqlParser.COMMA);
+                        }
+                    }
+
+                    this.state = 3460;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.ABORT:
+                    case PlSqlParser.ABS:
+                    case PlSqlParser.ABSENT:
+                    case PlSqlParser.ACCESS:
+                    case PlSqlParser.ACCESSED:
+                    case PlSqlParser.ACCESSIBLE:
+                    case PlSqlParser.ACCOUNT:
+                    case PlSqlParser.ACL:
+                    case PlSqlParser.ACOS:
+                    case PlSqlParser.ACROSS:
+                    case PlSqlParser.ACTION:
+                    case PlSqlParser.ACTIONS:
+                    case PlSqlParser.ACTIVATE:
+                    case PlSqlParser.ACTIVE:
+                    case PlSqlParser.ACTIVE_COMPONENT:
+                    case PlSqlParser.ACTIVE_DATA:
+                    case PlSqlParser.ACTIVE_FUNCTION:
+                    case PlSqlParser.ACTIVE_TAG:
+                    case PlSqlParser.ACTIVITY:
+                    case PlSqlParser.ADAPTIVE_PLAN:
+                    case PlSqlParser.ADD:
+                    case PlSqlParser.ADD_COLUMN:
+                    case PlSqlParser.ADD_GROUP:
+                    case PlSqlParser.ADD_MONTHS:
+                    case PlSqlParser.ADJ_DATE:
+                    case PlSqlParser.ADMIN:
+                    case PlSqlParser.ADMINISTER:
+                    case PlSqlParser.ADMINISTRATOR:
+                    case PlSqlParser.ADVANCED:
+                    case PlSqlParser.ADVISE:
+                    case PlSqlParser.ADVISOR:
+                    case PlSqlParser.AFD_DISKSTRING:
+                    case PlSqlParser.AFTER:
+                    case PlSqlParser.AGENT:
+                    case PlSqlParser.AGGREGATE:
+                    case PlSqlParser.A_LETTER:
+                    case PlSqlParser.ALIAS:
+                    case PlSqlParser.ALLOCATE:
+                    case PlSqlParser.ALLOW:
+                    case PlSqlParser.ALL_ROWS:
+                    case PlSqlParser.ALTERNATE:
+                    case PlSqlParser.ALWAYS:
+                    case PlSqlParser.ANALYTIC:
+                    case PlSqlParser.ANALYZE:
+                    case PlSqlParser.ANCESTOR:
+                    case PlSqlParser.ANCILLARY:
+                    case PlSqlParser.AND_EQUAL:
+                    case PlSqlParser.ANOMALY:
+                    case PlSqlParser.ANSI_REARCH:
+                    case PlSqlParser.ANTIJOIN:
+                    case PlSqlParser.ANYSCHEMA:
+                    case PlSqlParser.APPEND:
+                    case PlSqlParser.APPENDCHILDXML:
+                    case PlSqlParser.APPEND_VALUES:
+                    case PlSqlParser.APPLICATION:
+                    case PlSqlParser.APPLY:
+                    case PlSqlParser.APPROX_COUNT_DISTINCT:
+                    case PlSqlParser.ARCHIVAL:
+                    case PlSqlParser.ARCHIVE:
+                    case PlSqlParser.ARCHIVED:
+                    case PlSqlParser.ARCHIVELOG:
+                    case PlSqlParser.ARRAY:
+                    case PlSqlParser.ASCII:
+                    case PlSqlParser.ASCIISTR:
+                    case PlSqlParser.ASIN:
+                    case PlSqlParser.ASIS:
+                    case PlSqlParser.ASSEMBLY:
+                    case PlSqlParser.ASSIGN:
+                    case PlSqlParser.ASSOCIATE:
+                    case PlSqlParser.ASYNC:
+                    case PlSqlParser.ASYNCHRONOUS:
+                    case PlSqlParser.ATAN2:
+                    case PlSqlParser.ATAN:
+                    case PlSqlParser.AT:
+                    case PlSqlParser.ATTRIBUTE:
+                    case PlSqlParser.ATTRIBUTES:
+                    case PlSqlParser.AUDIT:
+                    case PlSqlParser.AUTHENTICATED:
+                    case PlSqlParser.AUTHENTICATION:
+                    case PlSqlParser.AUTHID:
+                    case PlSqlParser.AUTHORIZATION:
+                    case PlSqlParser.AUTOALLOCATE:
+                    case PlSqlParser.AUTO:
+                    case PlSqlParser.AUTOEXTEND:
+                    case PlSqlParser.AUTO_LOGIN:
+                    case PlSqlParser.AUTOMATIC:
+                    case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                    case PlSqlParser.AUTO_REOPTIMIZE:
+                    case PlSqlParser.AVAILABILITY:
+                    case PlSqlParser.AVRO:
+                    case PlSqlParser.BACKGROUND:
+                    case PlSqlParser.BACKINGFILE:
+                    case PlSqlParser.BACKUP:
+                    case PlSqlParser.BACKUPS:
+                    case PlSqlParser.BASIC:
+                    case PlSqlParser.BASICFILE:
+                    case PlSqlParser.BATCH:
+                    case PlSqlParser.BATCHSIZE:
+                    case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.BECOME:
+                    case PlSqlParser.BEFORE:
+                    case PlSqlParser.BEGIN:
+                    case PlSqlParser.BEGINNING:
+                    case PlSqlParser.BEGIN_OUTLINE_DATA:
+                    case PlSqlParser.BEHALF:
+                    case PlSqlParser.BEQUEATH:
+                    case PlSqlParser.BFILE:
+                    case PlSqlParser.BFILENAME:
+                    case PlSqlParser.BIGFILE:
+                    case PlSqlParser.BINARY:
+                    case PlSqlParser.BINARY_DOUBLE:
+                    case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                    case PlSqlParser.BINARY_DOUBLE_NAN:
+                    case PlSqlParser.BINARY_FLOAT:
+                    case PlSqlParser.BINARY_FLOAT_INFINITY:
+                    case PlSqlParser.BINARY_FLOAT_NAN:
+                    case PlSqlParser.BINARY_INTEGER:
+                    case PlSqlParser.BIND_AWARE:
+                    case PlSqlParser.BINDING:
+                    case PlSqlParser.BIN_TO_NUM:
+                    case PlSqlParser.BITAND:
+                    case PlSqlParser.BITMAP_AND:
+                    case PlSqlParser.BITMAP:
+                    case PlSqlParser.BITMAPS:
+                    case PlSqlParser.BITMAP_TREE:
+                    case PlSqlParser.BITS:
+                    case PlSqlParser.BLOB:
+                    case PlSqlParser.BLOCK:
+                    case PlSqlParser.BLOCK_RANGE:
+                    case PlSqlParser.BLOCKS:
+                    case PlSqlParser.BLOCKSIZE:
+                    case PlSqlParser.BODY:
+                    case PlSqlParser.BOOLEAN:
+                    case PlSqlParser.BOTH:
+                    case PlSqlParser.BOUND:
+                    case PlSqlParser.BRANCH:
+                    case PlSqlParser.BREADTH:
+                    case PlSqlParser.BROADCAST:
+                    case PlSqlParser.BSON:
+                    case PlSqlParser.BUFFER:
+                    case PlSqlParser.BUFFER_CACHE:
+                    case PlSqlParser.BUFFER_POOL:
+                    case PlSqlParser.BUILD:
+                    case PlSqlParser.BULK:
+                    case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                    case PlSqlParser.BYPASS_UJVC:
+                    case PlSqlParser.BYTE:
+                    case PlSqlParser.BYTES:
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.CACHE_CB:
+                    case PlSqlParser.CACHE_INSTANCES:
+                    case PlSqlParser.CACHE_TEMP_TABLE:
+                    case PlSqlParser.CACHING:
+                    case PlSqlParser.CALCULATED:
+                    case PlSqlParser.CALLBACK:
+                    case PlSqlParser.CALL:
+                    case PlSqlParser.CANCEL:
+                    case PlSqlParser.CAPACITY:
+                    case PlSqlParser.CAPTION:
+                    case PlSqlParser.CARDINALITY:
+                    case PlSqlParser.CASCADE:
+                    case PlSqlParser.CASE:
+                    case PlSqlParser.CAST:
+                    case PlSqlParser.CASESENSITIVE:
+                    case PlSqlParser.CATEGORY:
+                    case PlSqlParser.CDBDEFAULT:
+                    case PlSqlParser.CEIL:
+                    case PlSqlParser.CELL_FLASH_CACHE:
+                    case PlSqlParser.CERTIFICATE:
+                    case PlSqlParser.CFILE:
+                    case PlSqlParser.CHAINED:
+                    case PlSqlParser.CHANGE:
+                    case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                    case PlSqlParser.CHARACTER:
+                    case PlSqlParser.CHARACTERSET:
+                    case PlSqlParser.CHAR:
+                    case PlSqlParser.CHAR_CS:
+                    case PlSqlParser.CHARTOROWID:
+                    case PlSqlParser.CHECK_ACL_REWRITE:
+                    case PlSqlParser.CHECKPOINT:
+                    case PlSqlParser.CHILD:
+                    case PlSqlParser.CHOOSE:
+                    case PlSqlParser.CHR:
+                    case PlSqlParser.CHUNK:
+                    case PlSqlParser.CLASS:
+                    case PlSqlParser.CLASSIFICATION:
+                    case PlSqlParser.CLASSIFIER:
+                    case PlSqlParser.CLAUSE:
+                    case PlSqlParser.CLEAN:
+                    case PlSqlParser.CLEANUP:
+                    case PlSqlParser.CLEAR:
+                    case PlSqlParser.C_LETTER:
+                    case PlSqlParser.CLIENT:
+                    case PlSqlParser.CLOB:
+                    case PlSqlParser.CLONE:
+                    case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                    case PlSqlParser.CLOSE:
+                    case PlSqlParser.CLUSTER_BY_ROWID:
+                    case PlSqlParser.CLUSTER:
+                    case PlSqlParser.CLUSTER_DETAILS:
+                    case PlSqlParser.CLUSTER_DISTANCE:
+                    case PlSqlParser.CLUSTER_ID:
+                    case PlSqlParser.CLUSTERING:
+                    case PlSqlParser.CLUSTERING_FACTOR:
+                    case PlSqlParser.CLUSTER_PROBABILITY:
+                    case PlSqlParser.CLUSTER_SET:
+                    case PlSqlParser.COALESCE:
+                    case PlSqlParser.COALESCE_SQ:
+                    case PlSqlParser.COARSE:
+                    case PlSqlParser.CO_AUTH_IND:
+                    case PlSqlParser.COLD:
+                    case PlSqlParser.COLLECT:
+                    case PlSqlParser.COLUMNAR:
+                    case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                    case PlSqlParser.COLUMN:
+                    case PlSqlParser.COLUMNS:
+                    case PlSqlParser.COLUMN_STATS:
+                    case PlSqlParser.COLUMN_VALUE:
+                    case PlSqlParser.COMMENT:
+                    case PlSqlParser.COMMIT:
+                    case PlSqlParser.COMMITTED:
+                    case PlSqlParser.COMMON:
+                    case PlSqlParser.COMMON_DATA:
+                    case PlSqlParser.COMPACT:
+                    case PlSqlParser.COMPATIBILITY:
+                    case PlSqlParser.COMPILE:
+                    case PlSqlParser.COMPLETE:
+                    case PlSqlParser.COMPLIANCE:
+                    case PlSqlParser.COMPONENT:
+                    case PlSqlParser.COMPONENTS:
+                    case PlSqlParser.COMPOSE:
+                    case PlSqlParser.COMPOSITE:
+                    case PlSqlParser.COMPOSITE_LIMIT:
+                    case PlSqlParser.COMPOUND:
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.CONCAT:
+                    case PlSqlParser.CON_DBID_TO_ID:
+                    case PlSqlParser.CONDITIONAL:
+                    case PlSqlParser.CONDITION:
+                    case PlSqlParser.CONFIRM:
+                    case PlSqlParser.CONFORMING:
+                    case PlSqlParser.CON_GUID_TO_ID:
+                    case PlSqlParser.CON_ID:
+                    case PlSqlParser.CON_NAME_TO_ID:
+                    case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.CONNECT_BY_COST_BASED:
+                    case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.CONNECT_BY_FILTERING:
+                    case PlSqlParser.CONNECT_BY_ISCYCLE:
+                    case PlSqlParser.CONNECT_BY_ISLEAF:
+                    case PlSqlParser.CONNECT_BY_ROOT:
+                    case PlSqlParser.CONNECT_TIME:
+                    case PlSqlParser.CONSIDER:
+                    case PlSqlParser.CONSISTENT:
+                    case PlSqlParser.CONSTANT:
+                    case PlSqlParser.CONST:
+                    case PlSqlParser.CONSTRAINT:
+                    case PlSqlParser.CONSTRAINTS:
+                    case PlSqlParser.CONSTRUCTOR:
+                    case PlSqlParser.CONTAINER:
+                    case PlSqlParser.CONTAINERS:
+                    case PlSqlParser.CONTAINERS_DEFAULT:
+                    case PlSqlParser.CONTAINER_DATA:
+                    case PlSqlParser.CONTAINER_MAP:
+                    case PlSqlParser.CONTENT:
+                    case PlSqlParser.CONTENTS:
+                    case PlSqlParser.CONTEXT:
+                    case PlSqlParser.CONTINUE:
+                    case PlSqlParser.CONTROLFILE:
+                    case PlSqlParser.CON_UID_TO_ID:
+                    case PlSqlParser.CONVERT:
+                    case PlSqlParser.CONVERSION:
+                    case PlSqlParser.COOKIE:
+                    case PlSqlParser.COPY:
+                    case PlSqlParser.CORR_K:
+                    case PlSqlParser.CORR_S:
+                    case PlSqlParser.CORRUPTION:
+                    case PlSqlParser.CORRUPT_XID_ALL:
+                    case PlSqlParser.CORRUPT_XID:
+                    case PlSqlParser.COS:
+                    case PlSqlParser.COSH:
+                    case PlSqlParser.COST:
+                    case PlSqlParser.COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.COUNT:
+                    case PlSqlParser.COUNTED:
+                    case PlSqlParser.COVAR_POP:
+                    case PlSqlParser.COVAR_SAMP:
+                    case PlSqlParser.CPU_COSTING:
+                    case PlSqlParser.CPU_PER_CALL:
+                    case PlSqlParser.CPU_PER_SESSION:
+                    case PlSqlParser.CRASH:
+                    case PlSqlParser.CREATE_FILE_DEST:
+                    case PlSqlParser.CREATE_STORED_OUTLINES:
+                    case PlSqlParser.CREATION:
+                    case PlSqlParser.CREDENTIAL:
+                    case PlSqlParser.CRITICAL:
+                    case PlSqlParser.CROSS:
+                    case PlSqlParser.CROSSEDITION:
+                    case PlSqlParser.CSCONVERT:
+                    case PlSqlParser.CSV:
+                    case PlSqlParser.CUBE_AJ:
+                    case PlSqlParser.CUBE:
+                    case PlSqlParser.CUBE_GB:
+                    case PlSqlParser.CUBE_SJ:
+                    case PlSqlParser.CUME_DISTM:
+                    case PlSqlParser.CURRENT:
+                    case PlSqlParser.CURRENT_DATE:
+                    case PlSqlParser.CURRENT_SCHEMA:
+                    case PlSqlParser.CURRENT_TIME:
+                    case PlSqlParser.CURRENT_TIMESTAMP:
+                    case PlSqlParser.CURRENT_USER:
+                    case PlSqlParser.CURRENTV:
+                    case PlSqlParser.CURSOR:
+                    case PlSqlParser.CURSOR_SHARING_EXACT:
+                    case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                    case PlSqlParser.CUSTOMDATUM:
+                    case PlSqlParser.CV:
+                    case PlSqlParser.CYCLE:
+                    case PlSqlParser.DANGLING:
+                    case PlSqlParser.DATABASE:
+                    case PlSqlParser.DATA:
+                    case PlSqlParser.DATAFILE:
+                    case PlSqlParser.DATAFILES:
+                    case PlSqlParser.DATAMOVEMENT:
+                    case PlSqlParser.DATAOBJNO:
+                    case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                    case PlSqlParser.DATAOBJ_TO_PARTITION:
+                    case PlSqlParser.DATAPUMP:
+                    case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                    case PlSqlParser.DATE:
+                    case PlSqlParser.DATE_FORMAT:
+                    case PlSqlParser.DATE_MODE:
+                    case PlSqlParser.DAY:
+                    case PlSqlParser.DAYS:
+                    case PlSqlParser.DBA:
+                    case PlSqlParser.DBA_RECYCLEBIN:
+                    case PlSqlParser.DBLINK:
+                    case PlSqlParser.DBMS_STATS:
+                    case PlSqlParser.DB_ROLE_CHANGE:
+                    case PlSqlParser.DBTIMEZONE:
+                    case PlSqlParser.DB_UNIQUE_NAME:
+                    case PlSqlParser.DB_VERSION:
+                    case PlSqlParser.DDL:
+                    case PlSqlParser.DEALLOCATE:
+                    case PlSqlParser.DEBUG:
+                    case PlSqlParser.DEBUGGER:
+                    case PlSqlParser.DEC:
+                    case PlSqlParser.DECIMAL:
+                    case PlSqlParser.DECLARE:
+                    case PlSqlParser.DECOMPOSE:
+                    case PlSqlParser.DECORRELATE:
+                    case PlSqlParser.DECR:
+                    case PlSqlParser.DECREMENT:
+                    case PlSqlParser.DECRYPT:
+                    case PlSqlParser.DEDUPLICATE:
+                    case PlSqlParser.DEFAULTS:
+                    case PlSqlParser.DEFAULT_COLLATION:
+                    case PlSqlParser.DEFAULT_CREDENTIAL:
+                    case PlSqlParser.DEFERRABLE:
+                    case PlSqlParser.DEFERRED:
+                    case PlSqlParser.DEFINED:
+                    case PlSqlParser.DEFINE:
+                    case PlSqlParser.DEFINER:
+                    case PlSqlParser.DEGREE:
+                    case PlSqlParser.DELAY:
+                    case PlSqlParser.DELEGATE:
+                    case PlSqlParser.DELETE_ALL:
+                    case PlSqlParser.DELETE:
+                    case PlSqlParser.DELETEXML:
+                    case PlSqlParser.DEMAND:
+                    case PlSqlParser.DENSE_RANKM:
+                    case PlSqlParser.DEPENDENT:
+                    case PlSqlParser.DEPRECATE:
+                    case PlSqlParser.DEPTH:
+                    case PlSqlParser.DEQUEUE:
+                    case PlSqlParser.DEREF:
+                    case PlSqlParser.DEREF_NO_REWRITE:
+                    case PlSqlParser.DESCRIPTION:
+                    case PlSqlParser.DESTROY:
+                    case PlSqlParser.DETACHED:
+                    case PlSqlParser.DETECTED:
+                    case PlSqlParser.DETERMINES:
+                    case PlSqlParser.DETERMINISTIC:
+                    case PlSqlParser.DICTIONARY:
+                    case PlSqlParser.DIMENSION:
+                    case PlSqlParser.DIMENSIONS:
+                    case PlSqlParser.DIRECT_LOAD:
+                    case PlSqlParser.DIRECTORY:
+                    case PlSqlParser.DIRECT_PATH:
+                    case PlSqlParser.DISABLE_ALL:
+                    case PlSqlParser.DISABLE:
+                    case PlSqlParser.DISABLED:
+                    case PlSqlParser.DISABLE_PARALLEL_DML:
+                    case PlSqlParser.DISABLE_PRESET:
+                    case PlSqlParser.DISABLE_RPKE:
+                    case PlSqlParser.DISALLOW:
+                    case PlSqlParser.DISASSOCIATE:
+                    case PlSqlParser.DISCARD:
+                    case PlSqlParser.DISCONNECT:
+                    case PlSqlParser.DISK:
+                    case PlSqlParser.DISKGROUP:
+                    case PlSqlParser.DISKS:
+                    case PlSqlParser.DISMOUNT:
+                    case PlSqlParser.DISTINGUISHED:
+                    case PlSqlParser.DISTRIBUTED:
+                    case PlSqlParser.DISTRIBUTE:
+                    case PlSqlParser.DML:
+                    case PlSqlParser.DML_UPDATE:
+                    case PlSqlParser.DOCFIDELITY:
+                    case PlSqlParser.DOCUMENT:
+                    case PlSqlParser.DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                    case PlSqlParser.DOMAIN_INDEX_SORT:
+                    case PlSqlParser.DOUBLE:
+                    case PlSqlParser.DOWNGRADE:
+                    case PlSqlParser.DRIVING_SITE:
+                    case PlSqlParser.DROP_COLUMN:
+                    case PlSqlParser.DROP_GROUP:
+                    case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.DUMP:
+                    case PlSqlParser.DUPLICATE:
+                    case PlSqlParser.DV:
+                    case PlSqlParser.DYNAMIC:
+                    case PlSqlParser.DYNAMIC_SAMPLING:
+                    case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                    case PlSqlParser.E_LETTER:
+                    case PlSqlParser.EACH:
+                    case PlSqlParser.EDITIONABLE:
+                    case PlSqlParser.EDITION:
+                    case PlSqlParser.EDITIONING:
+                    case PlSqlParser.EDITIONS:
+                    case PlSqlParser.ELEMENT:
+                    case PlSqlParser.ELIM_GROUPBY:
+                    case PlSqlParser.ELIMINATE_JOIN:
+                    case PlSqlParser.ELIMINATE_OBY:
+                    case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.EM:
+                    case PlSqlParser.EMPTY_BLOB:
+                    case PlSqlParser.EMPTY_CLOB:
+                    case PlSqlParser.EMPTY_:
+                    case PlSqlParser.ENABLE_ALL:
+                    case PlSqlParser.ENABLE:
+                    case PlSqlParser.ENABLED:
+                    case PlSqlParser.ENABLE_PARALLEL_DML:
+                    case PlSqlParser.ENABLE_PRESET:
+                    case PlSqlParser.ENCLOSED:
+                    case PlSqlParser.ENCODING:
+                    case PlSqlParser.ENCRYPT:
+                    case PlSqlParser.ENCRYPTION:
+                    case PlSqlParser.END_OUTLINE_DATA:
+                    case PlSqlParser.ENFORCED:
+                    case PlSqlParser.ENFORCE:
+                    case PlSqlParser.ENQUEUE:
+                    case PlSqlParser.ENTERPRISE:
+                    case PlSqlParser.ENTITYESCAPING:
+                    case PlSqlParser.ENTRY:
+                    case PlSqlParser.EQUIPART:
+                    case PlSqlParser.ERR:
+                    case PlSqlParser.ERROR_ARGUMENT:
+                    case PlSqlParser.ERROR:
+                    case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                    case PlSqlParser.ERRORS:
+                    case PlSqlParser.ERROR_INDEX:
+                    case PlSqlParser.ERROR_CODE:
+                    case PlSqlParser.ESCAPE:
+                    case PlSqlParser.ESTIMATE:
+                    case PlSqlParser.EVAL:
+                    case PlSqlParser.EVALNAME:
+                    case PlSqlParser.EVALUATE:
+                    case PlSqlParser.EVALUATION:
+                    case PlSqlParser.EVENTS:
+                    case PlSqlParser.EVERY:
+                    case PlSqlParser.EXCEPT:
+                    case PlSqlParser.EXCEPTION:
+                    case PlSqlParser.EXCEPTION_INIT:
+                    case PlSqlParser.EXCEPTIONS:
+                    case PlSqlParser.EXCHANGE:
+                    case PlSqlParser.EXCLUDE:
+                    case PlSqlParser.EXCLUDING:
+                    case PlSqlParser.EXEC:
+                    case PlSqlParser.EXECUTE:
+                    case PlSqlParser.EXEMPT:
+                    case PlSqlParser.EXISTING:
+                    case PlSqlParser.EXISTS:
+                    case PlSqlParser.EXISTSNODE:
+                    case PlSqlParser.EXIT:
+                    case PlSqlParser.EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.EXPAND_TABLE:
+                    case PlSqlParser.EXP:
+                    case PlSqlParser.EXPIRE:
+                    case PlSqlParser.EXPLAIN:
+                    case PlSqlParser.EXPLOSION:
+                    case PlSqlParser.EXPORT:
+                    case PlSqlParser.EXPR_CORR_CHECK:
+                    case PlSqlParser.EXPRESS:
+                    case PlSqlParser.EXTENDS:
+                    case PlSqlParser.EXTENT:
+                    case PlSqlParser.EXTENTS:
+                    case PlSqlParser.EXTERNAL:
+                    case PlSqlParser.EXTERNALLY:
+                    case PlSqlParser.EXTRACTCLOBXML:
+                    case PlSqlParser.EXTRACT:
+                    case PlSqlParser.EXTRACTVALUE:
+                    case PlSqlParser.EXTRA:
+                    case PlSqlParser.FACILITY:
+                    case PlSqlParser.FACT:
+                    case PlSqlParser.FACTOR:
+                    case PlSqlParser.FACTORIZE_JOIN:
+                    case PlSqlParser.FAILED:
+                    case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                    case PlSqlParser.FAILGROUP:
+                    case PlSqlParser.FAILOVER:
+                    case PlSqlParser.FAILURE:
+                    case PlSqlParser.FALSE:
+                    case PlSqlParser.FAMILY:
+                    case PlSqlParser.FAR:
+                    case PlSqlParser.FAST:
+                    case PlSqlParser.FASTSTART:
+                    case PlSqlParser.FBTSCAN:
+                    case PlSqlParser.FEATURE:
+                    case PlSqlParser.FEATURE_DETAILS:
+                    case PlSqlParser.FEATURE_ID:
+                    case PlSqlParser.FEATURE_SET:
+                    case PlSqlParser.FEATURE_VALUE:
+                    case PlSqlParser.FETCH:
+                    case PlSqlParser.FIELD:
+                    case PlSqlParser.FIELDS:
+                    case PlSqlParser.FILE:
+                    case PlSqlParser.FILE_NAME_CONVERT:
+                    case PlSqlParser.FILEGROUP:
+                    case PlSqlParser.FILESTORE:
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.FILTER:
+                    case PlSqlParser.FINAL:
+                    case PlSqlParser.FINE:
+                    case PlSqlParser.FINISH:
+                    case PlSqlParser.FIRST:
+                    case PlSqlParser.FIRSTM:
+                    case PlSqlParser.FIRST_ROWS:
+                    case PlSqlParser.FIRST_VALUE:
+                    case PlSqlParser.FIXED_VIEW_DATA:
+                    case PlSqlParser.FLAGGER:
+                    case PlSqlParser.FLASHBACK:
+                    case PlSqlParser.FLASH_CACHE:
+                    case PlSqlParser.FLOAT:
+                    case PlSqlParser.FLOB:
+                    case PlSqlParser.FLEX:
+                    case PlSqlParser.FLOOR:
+                    case PlSqlParser.FLUSH:
+                    case PlSqlParser.FOLDER:
+                    case PlSqlParser.FOLLOWING:
+                    case PlSqlParser.FOLLOWS:
+                    case PlSqlParser.FORALL:
+                    case PlSqlParser.FORCE:
+                    case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                    case PlSqlParser.FOREIGN:
+                    case PlSqlParser.FOREVER:
+                    case PlSqlParser.FORMAT:
+                    case PlSqlParser.FORWARD:
+                    case PlSqlParser.FRAGMENT_NUMBER:
+                    case PlSqlParser.FREELIST:
+                    case PlSqlParser.FREELISTS:
+                    case PlSqlParser.FREEPOOLS:
+                    case PlSqlParser.FRESH:
+                    case PlSqlParser.FROM_TZ:
+                    case PlSqlParser.FULL:
+                    case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.FUNCTION:
+                    case PlSqlParser.FUNCTIONS:
+                    case PlSqlParser.FTP:
+                    case PlSqlParser.G_LETTER:
+                    case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.GATHER_PLAN_STATISTICS:
+                    case PlSqlParser.GBY_CONC_ROLLUP:
+                    case PlSqlParser.GBY_PUSHDOWN:
+                    case PlSqlParser.GENERATED:
+                    case PlSqlParser.GET:
+                    case PlSqlParser.GLOBAL:
+                    case PlSqlParser.GLOBALLY:
+                    case PlSqlParser.GLOBAL_NAME:
+                    case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                    case PlSqlParser.GROUP_BY:
+                    case PlSqlParser.GROUP_ID:
+                    case PlSqlParser.GROUPING:
+                    case PlSqlParser.GROUPING_ID:
+                    case PlSqlParser.GROUPS:
+                    case PlSqlParser.GUARANTEED:
+                    case PlSqlParser.GUARANTEE:
+                    case PlSqlParser.GUARD:
+                    case PlSqlParser.HALF_YEARS:
+                    case PlSqlParser.HASH_AJ:
+                    case PlSqlParser.HASH:
+                    case PlSqlParser.HASHKEYS:
+                    case PlSqlParser.HASH_SJ:
+                    case PlSqlParser.HEADER:
+                    case PlSqlParser.HEAP:
+                    case PlSqlParser.HELP:
+                    case PlSqlParser.HEXTORAW:
+                    case PlSqlParser.HEXTOREF:
+                    case PlSqlParser.HIDDEN_KEYWORD:
+                    case PlSqlParser.HIDE:
+                    case PlSqlParser.HIER_ORDER:
+                    case PlSqlParser.HIERARCHICAL:
+                    case PlSqlParser.HIERARCHY:
+                    case PlSqlParser.HIGH:
+                    case PlSqlParser.HINTSET_BEGIN:
+                    case PlSqlParser.HINTSET_END:
+                    case PlSqlParser.HOT:
+                    case PlSqlParser.HOUR:
+                    case PlSqlParser.HOURS:
+                    case PlSqlParser.HTTP:
+                    case PlSqlParser.HWM_BROKERED:
+                    case PlSqlParser.HYBRID:
+                    case PlSqlParser.H_LETTER:
+                    case PlSqlParser.IDENTIFIER:
+                    case PlSqlParser.IDENTITY:
+                    case PlSqlParser.IDGENERATORS:
+                    case PlSqlParser.ID:
+                    case PlSqlParser.IDLE_TIME:
+                    case PlSqlParser.IF:
+                    case PlSqlParser.IGNORE:
+                    case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                    case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                    case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                    case PlSqlParser.ILM:
+                    case PlSqlParser.IMMEDIATE:
+                    case PlSqlParser.IMPACT:
+                    case PlSqlParser.IMPORT:
+                    case PlSqlParser.INACTIVE:
+                    case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                    case PlSqlParser.INCLUDE:
+                    case PlSqlParser.INCLUDE_VERSION:
+                    case PlSqlParser.INCLUDING:
+                    case PlSqlParser.INCREMENTAL:
+                    case PlSqlParser.INCREMENT:
+                    case PlSqlParser.INCR:
+                    case PlSqlParser.INDENT:
+                    case PlSqlParser.INDEX_ASC:
+                    case PlSqlParser.INDEX_COMBINE:
+                    case PlSqlParser.INDEX_DESC:
+                    case PlSqlParser.INDEXED:
+                    case PlSqlParser.INDEXES:
+                    case PlSqlParser.INDEX_FFS:
+                    case PlSqlParser.INDEX_FILTER:
+                    case PlSqlParser.INDEXING:
+                    case PlSqlParser.INDEX_JOIN:
+                    case PlSqlParser.INDEX_ROWS:
+                    case PlSqlParser.INDEX_RRS:
+                    case PlSqlParser.INDEX_RS_ASC:
+                    case PlSqlParser.INDEX_RS_DESC:
+                    case PlSqlParser.INDEX_RS:
+                    case PlSqlParser.INDEX_SCAN:
+                    case PlSqlParser.INDEX_SKIP_SCAN:
+                    case PlSqlParser.INDEX_SS_ASC:
+                    case PlSqlParser.INDEX_SS_DESC:
+                    case PlSqlParser.INDEX_SS:
+                    case PlSqlParser.INDEX_STATS:
+                    case PlSqlParser.INDEXTYPE:
+                    case PlSqlParser.INDEXTYPES:
+                    case PlSqlParser.INDICATOR:
+                    case PlSqlParser.INDICES:
+                    case PlSqlParser.INFINITE:
+                    case PlSqlParser.INFORMATIONAL:
+                    case PlSqlParser.INHERIT:
+                    case PlSqlParser.INITCAP:
+                    case PlSqlParser.INITIAL:
+                    case PlSqlParser.INITIALIZED:
+                    case PlSqlParser.INITIALLY:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.INLINE:
+                    case PlSqlParser.INLINE_XMLTYPE_NT:
+                    case PlSqlParser.INMEMORY:
+                    case PlSqlParser.IN_MEMORY_METADATA:
+                    case PlSqlParser.INMEMORY_PRUNING:
+                    case PlSqlParser.INNER:
+                    case PlSqlParser.INOUT:
+                    case PlSqlParser.INPLACE:
+                    case PlSqlParser.INSERTCHILDXMLAFTER:
+                    case PlSqlParser.INSERTCHILDXMLBEFORE:
+                    case PlSqlParser.INSERTCHILDXML:
+                    case PlSqlParser.INSERTXMLAFTER:
+                    case PlSqlParser.INSERTXMLBEFORE:
+                    case PlSqlParser.INSTANCE:
+                    case PlSqlParser.INSTANCES:
+                    case PlSqlParser.INSTANTIABLE:
+                    case PlSqlParser.INSTANTLY:
+                    case PlSqlParser.INSTEAD:
+                    case PlSqlParser.INSTR2:
+                    case PlSqlParser.INSTR4:
+                    case PlSqlParser.INSTRB:
+                    case PlSqlParser.INSTRC:
+                    case PlSqlParser.INSTR:
+                    case PlSqlParser.INTEGER:
+                    case PlSqlParser.INTERLEAVED:
+                    case PlSqlParser.INTERMEDIATE:
+                    case PlSqlParser.INTERNAL_CONVERT:
+                    case PlSqlParser.INTERNAL_USE:
+                    case PlSqlParser.INTERPRETED:
+                    case PlSqlParser.INTERVAL:
+                    case PlSqlParser.INT:
+                    case PlSqlParser.INTERNAL:
+                    case PlSqlParser.INVALIDATE:
+                    case PlSqlParser.INVALIDATION:
+                    case PlSqlParser.INVISIBLE:
+                    case PlSqlParser.IN_XQUERY:
+                    case PlSqlParser.IS_LEAF:
+                    case PlSqlParser.ISOLATION:
+                    case PlSqlParser.ISOLATION_LEVEL:
+                    case PlSqlParser.ITEMS:
+                    case PlSqlParser.ITERATE:
+                    case PlSqlParser.ITERATION_NUMBER:
+                    case PlSqlParser.JAVA:
+                    case PlSqlParser.JOB:
+                    case PlSqlParser.JOIN:
+                    case PlSqlParser.JSON_ARRAYAGG:
+                    case PlSqlParser.JSON_ARRAY:
+                    case PlSqlParser.JSON_EQUAL:
+                    case PlSqlParser.JSON_EXISTS2:
+                    case PlSqlParser.JSON_EXISTS:
+                    case PlSqlParser.JSONGET:
+                    case PlSqlParser.JSON:
+                    case PlSqlParser.JSON_OBJECTAGG:
+                    case PlSqlParser.JSON_OBJECT:
+                    case PlSqlParser.JSONPARSE:
+                    case PlSqlParser.JSON_QUERY:
+                    case PlSqlParser.JSON_SERIALIZE:
+                    case PlSqlParser.JSON_TABLE:
+                    case PlSqlParser.JSON_TEXTCONTAINS2:
+                    case PlSqlParser.JSON_TEXTCONTAINS:
+                    case PlSqlParser.JSON_TRANSFORM:
+                    case PlSqlParser.JSON_VALUE:
+                    case PlSqlParser.K_LETTER:
+                    case PlSqlParser.KEEP_DUPLICATES:
+                    case PlSqlParser.KEEP:
+                    case PlSqlParser.KERBEROS:
+                    case PlSqlParser.KEY:
+                    case PlSqlParser.KEY_LENGTH:
+                    case PlSqlParser.KEYSIZE:
+                    case PlSqlParser.KEYS:
+                    case PlSqlParser.KEYSTORE:
+                    case PlSqlParser.KILL:
+                    case PlSqlParser.LABEL:
+                    case PlSqlParser.LANGUAGE:
+                    case PlSqlParser.LAST_DAY:
+                    case PlSqlParser.LAST:
+                    case PlSqlParser.LAST_VALUE:
+                    case PlSqlParser.LATERAL:
+                    case PlSqlParser.LAX:
+                    case PlSqlParser.LAYER:
+                    case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                    case PlSqlParser.LDAP_REGISTRATION:
+                    case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                    case PlSqlParser.LEAF:
+                    case PlSqlParser.LEAD_CDB:
+                    case PlSqlParser.LEAD_CDB_URI:
+                    case PlSqlParser.LEADING:
+                    case PlSqlParser.LEFT:
+                    case PlSqlParser.LENGTH2:
+                    case PlSqlParser.LENGTH4:
+                    case PlSqlParser.LENGTHB:
+                    case PlSqlParser.LENGTHC:
+                    case PlSqlParser.LENGTH:
+                    case PlSqlParser.LESS:
+                    case PlSqlParser.LEVEL:
+                    case PlSqlParser.LEVEL_NAME:
+                    case PlSqlParser.LEVELS:
+                    case PlSqlParser.LIBRARY:
+                    case PlSqlParser.LIFECYCLE:
+                    case PlSqlParser.LIFE:
+                    case PlSqlParser.LIFETIME:
+                    case PlSqlParser.LIKE2:
+                    case PlSqlParser.LIKE4:
+                    case PlSqlParser.LIKEC:
+                    case PlSqlParser.LIKE_EXPAND:
+                    case PlSqlParser.LIMIT:
+                    case PlSqlParser.LINEAR:
+                    case PlSqlParser.LINES:
+                    case PlSqlParser.LINK:
+                    case PlSqlParser.LIST:
+                    case PlSqlParser.LN:
+                    case PlSqlParser.LNNVL:
+                    case PlSqlParser.LOAD:
+                    case PlSqlParser.LOB:
+                    case PlSqlParser.LOBNVL:
+                    case PlSqlParser.LOBS:
+                    case PlSqlParser.LOCAL_INDEXES:
+                    case PlSqlParser.LOCAL:
+                    case PlSqlParser.LOCALTIME:
+                    case PlSqlParser.LOCALTIMESTAMP:
+                    case PlSqlParser.LOCATION:
+                    case PlSqlParser.LOCATOR:
+                    case PlSqlParser.LOCKDOWN:
+                    case PlSqlParser.LOCKED:
+                    case PlSqlParser.LOCKING:
+                    case PlSqlParser.LOGFILE:
+                    case PlSqlParser.LOGFILES:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.LOGICAL:
+                    case PlSqlParser.LOGICAL_READS_PER_CALL:
+                    case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                    case PlSqlParser.LOG:
+                    case PlSqlParser.LOGMINING:
+                    case PlSqlParser.LOGOFF:
+                    case PlSqlParser.LOGON:
+                    case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                    case PlSqlParser.LONG:
+                    case PlSqlParser.LOOP:
+                    case PlSqlParser.LOST:
+                    case PlSqlParser.LOWER:
+                    case PlSqlParser.LOW:
+                    case PlSqlParser.LPAD:
+                    case PlSqlParser.LTRIM:
+                    case PlSqlParser.M_LETTER:
+                    case PlSqlParser.MAIN:
+                    case PlSqlParser.MAKE_REF:
+                    case PlSqlParser.MANAGED:
+                    case PlSqlParser.MANAGE:
+                    case PlSqlParser.MANAGEMENT:
+                    case PlSqlParser.MANAGER:
+                    case PlSqlParser.MANDATORY:
+                    case PlSqlParser.MANUAL:
+                    case PlSqlParser.MAP:
+                    case PlSqlParser.MAPPING:
+                    case PlSqlParser.MASK:
+                    case PlSqlParser.MASTER:
+                    case PlSqlParser.MATCHED:
+                    case PlSqlParser.MATCHES:
+                    case PlSqlParser.MATCH:
+                    case PlSqlParser.MATCH_NUMBER:
+                    case PlSqlParser.MATCH_RECOGNIZE:
+                    case PlSqlParser.MATERIALIZED:
+                    case PlSqlParser.MATERIALIZE:
+                    case PlSqlParser.MAXARCHLOGS:
+                    case PlSqlParser.MAXDATAFILES:
+                    case PlSqlParser.MAXEXTENTS:
+                    case PlSqlParser.MAXIMIZE:
+                    case PlSqlParser.MAXINSTANCES:
+                    case PlSqlParser.MAXLOGFILES:
+                    case PlSqlParser.MAXLOGHISTORY:
+                    case PlSqlParser.MAXLOGMEMBERS:
+                    case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                    case PlSqlParser.MAXSIZE:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.MAXVALUE:
+                    case PlSqlParser.MEASURE:
+                    case PlSqlParser.MEASURES:
+                    case PlSqlParser.MEDIUM:
+                    case PlSqlParser.MEMBER:
+                    case PlSqlParser.MEMBER_CAPTION:
+                    case PlSqlParser.MEMBER_DESCRIPTION:
+                    case PlSqlParser.MEMBER_NAME:
+                    case PlSqlParser.MEMBER_UNIQUE_NAME:
+                    case PlSqlParser.MEMCOMPRESS:
+                    case PlSqlParser.MEMORY:
+                    case PlSqlParser.MERGEACTIONS:
+                    case PlSqlParser.MERGE_AJ:
+                    case PlSqlParser.MERGE_CONST_ON:
+                    case PlSqlParser.MERGE:
+                    case PlSqlParser.MERGE_SJ:
+                    case PlSqlParser.METADATA:
+                    case PlSqlParser.METHOD:
+                    case PlSqlParser.MIGRATE:
+                    case PlSqlParser.MIGRATION:
+                    case PlSqlParser.MINEXTENTS:
+                    case PlSqlParser.MINIMIZE:
+                    case PlSqlParser.MINIMUM:
+                    case PlSqlParser.MINING:
+                    case PlSqlParser.MINUS_NULL:
+                    case PlSqlParser.MINUTE:
+                    case PlSqlParser.MINUTES:
+                    case PlSqlParser.MINVALUE:
+                    case PlSqlParser.MIRRORCOLD:
+                    case PlSqlParser.MIRRORHOT:
+                    case PlSqlParser.MIRROR:
+                    case PlSqlParser.MISSING:
+                    case PlSqlParser.MISMATCH:
+                    case PlSqlParser.MLSLABEL:
+                    case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                    case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                    case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                    case PlSqlParser.MODEL_MIN_ANALYSIS:
+                    case PlSqlParser.MODEL:
+                    case PlSqlParser.MODEL_NB:
+                    case PlSqlParser.MODEL_NO_ANALYSIS:
+                    case PlSqlParser.MODEL_PBY:
+                    case PlSqlParser.MODEL_PUSH_REF:
+                    case PlSqlParser.MODEL_SV:
+                    case PlSqlParser.MODIFICATION:
+                    case PlSqlParser.MODIFY_COLUMN_TYPE:
+                    case PlSqlParser.MODIFY:
+                    case PlSqlParser.MOD:
+                    case PlSqlParser.MODULE:
+                    case PlSqlParser.MONITORING:
+                    case PlSqlParser.MONITOR:
+                    case PlSqlParser.MONTH:
+                    case PlSqlParser.MONTHS_BETWEEN:
+                    case PlSqlParser.MONTHS:
+                    case PlSqlParser.MOUNT:
+                    case PlSqlParser.MOUNTPATH:
+                    case PlSqlParser.MOUNTPOINT:
+                    case PlSqlParser.MOVEMENT:
+                    case PlSqlParser.MOVE:
+                    case PlSqlParser.MULTIDIMENSIONAL:
+                    case PlSqlParser.MULTISET:
+                    case PlSqlParser.MV_MERGE:
+                    case PlSqlParser.NAMED:
+                    case PlSqlParser.NAME:
+                    case PlSqlParser.NAMESPACE:
+                    case PlSqlParser.NAN_:
+                    case PlSqlParser.NANVL:
+                    case PlSqlParser.NATIONAL:
+                    case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NATIVE:
+                    case PlSqlParser.NATURAL:
+                    case PlSqlParser.NAV:
+                    case PlSqlParser.NCHAR_CS:
+                    case PlSqlParser.NCHAR:
+                    case PlSqlParser.NCHR:
+                    case PlSqlParser.NCLOB:
+                    case PlSqlParser.NEEDED:
+                    case PlSqlParser.NEG:
+                    case PlSqlParser.NESTED:
+                    case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                    case PlSqlParser.NESTED_TABLE_GET_REFS:
+                    case PlSqlParser.NESTED_TABLE_ID:
+                    case PlSqlParser.NESTED_TABLE_SET_REFS:
+                    case PlSqlParser.NESTED_TABLE_SET_SETID:
+                    case PlSqlParser.NETWORK:
+                    case PlSqlParser.NEVER:
+                    case PlSqlParser.NEW:
+                    case PlSqlParser.NEWLINE_:
+                    case PlSqlParser.NEW_TIME:
+                    case PlSqlParser.NEXT_DAY:
+                    case PlSqlParser.NEXT:
+                    case PlSqlParser.NL_AJ:
+                    case PlSqlParser.NLJ_BATCHING:
+                    case PlSqlParser.NLJ_INDEX_FILTER:
+                    case PlSqlParser.NLJ_INDEX_SCAN:
+                    case PlSqlParser.NLJ_PREFETCH:
+                    case PlSqlParser.NLS_CALENDAR:
+                    case PlSqlParser.NLS_CHARACTERSET:
+                    case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                    case PlSqlParser.NLS_CHARSET_ID:
+                    case PlSqlParser.NLS_CHARSET_NAME:
+                    case PlSqlParser.NLS_COMP:
+                    case PlSqlParser.NLS_CURRENCY:
+                    case PlSqlParser.NLS_DATE_FORMAT:
+                    case PlSqlParser.NLS_DATE_LANGUAGE:
+                    case PlSqlParser.NLS_INITCAP:
+                    case PlSqlParser.NLS_ISO_CURRENCY:
+                    case PlSqlParser.NL_SJ:
+                    case PlSqlParser.NLS_LANG:
+                    case PlSqlParser.NLS_LANGUAGE:
+                    case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                    case PlSqlParser.NLS_LOWER:
+                    case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                    case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                    case PlSqlParser.NLS_SORT:
+                    case PlSqlParser.NLSSORT:
+                    case PlSqlParser.NLS_SPECIAL_CHARS:
+                    case PlSqlParser.NLS_TERRITORY:
+                    case PlSqlParser.NLS_UPPER:
+                    case PlSqlParser.NO_ACCESS:
+                    case PlSqlParser.NO_ADAPTIVE_PLAN:
+                    case PlSqlParser.NO_ANSI_REARCH:
+                    case PlSqlParser.NOAPPEND:
+                    case PlSqlParser.NOARCHIVELOG:
+                    case PlSqlParser.NOAUDIT:
+                    case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                    case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.NO_BIND_AWARE:
+                    case PlSqlParser.NO_BUFFER:
+                    case PlSqlParser.NOCACHE:
+                    case PlSqlParser.NO_CARTESIAN:
+                    case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                    case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                    case PlSqlParser.NO_CLUSTERING:
+                    case PlSqlParser.NO_COALESCE_SQ:
+                    case PlSqlParser.NO_COMMON_DATA:
+                    case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                    case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                    case PlSqlParser.NOCOPY:
+                    case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_CPU_COSTING:
+                    case PlSqlParser.NOCPU_COSTING:
+                    case PlSqlParser.NOCYCLE:
+                    case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                    case PlSqlParser.NO_DECORRELATE:
+                    case PlSqlParser.NODELAY:
+                    case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.NO_ELIM_GROUPBY:
+                    case PlSqlParser.NO_ELIMINATE_JOIN:
+                    case PlSqlParser.NO_ELIMINATE_OBY:
+                    case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.NOENTITYESCAPING:
+                    case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.NO_EXPAND:
+                    case PlSqlParser.NO_EXPAND_TABLE:
+                    case PlSqlParser.NO_FACT:
+                    case PlSqlParser.NO_FACTORIZE_JOIN:
+                    case PlSqlParser.NO_FILTERING:
+                    case PlSqlParser.NOFORCE:
+                    case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.NO_GBY_PUSHDOWN:
+                    case PlSqlParser.NOGUARANTEE:
+                    case PlSqlParser.NO_INDEX_FFS:
+                    case PlSqlParser.NO_INDEX:
+                    case PlSqlParser.NO_INDEX_SS:
+                    case PlSqlParser.NO_INMEMORY:
+                    case PlSqlParser.NO_INMEMORY_PRUNING:
+                    case PlSqlParser.NOKEEP:
+                    case PlSqlParser.NO_LOAD:
+                    case PlSqlParser.NOLOCAL:
+                    case PlSqlParser.NOLOGGING:
+                    case PlSqlParser.NOMAPPING:
+                    case PlSqlParser.NOMAXVALUE:
+                    case PlSqlParser.NO_MERGE:
+                    case PlSqlParser.NOMINIMIZE:
+                    case PlSqlParser.NOMINVALUE:
+                    case PlSqlParser.NO_MODEL_PUSH_REF:
+                    case PlSqlParser.NO_MONITORING:
+                    case PlSqlParser.NOMONITORING:
+                    case PlSqlParser.NO_MONITOR:
+                    case PlSqlParser.NO_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NONBLOCKING:
+                    case PlSqlParser.NONEDITIONABLE:
+                    case PlSqlParser.NONE:
+                    case PlSqlParser.NONPARTITIONED:
+                    case PlSqlParser.NO_NLJ_BATCHING:
+                    case PlSqlParser.NO_NLJ_PREFETCH:
+                    case PlSqlParser.NO:
+                    case PlSqlParser.NONSCHEMA:
+                    case PlSqlParser.NO_OBJECT_LINK:
+                    case PlSqlParser.NOORDER:
+                    case PlSqlParser.NO_ORDER_ROLLUPS:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.NOOVERRIDE:
+                    case PlSqlParser.NO_PARALLEL_INDEX:
+                    case PlSqlParser.NOPARALLEL_INDEX:
+                    case PlSqlParser.NO_PARALLEL:
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.NO_PARTIAL_COMMIT:
+                    case PlSqlParser.NO_PARTIAL_JOIN:
+                    case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.NOPARTITION:
+                    case PlSqlParser.NO_PLACE_DISTINCT:
+                    case PlSqlParser.NO_PLACE_GROUP_BY:
+                    case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                    case PlSqlParser.NO_PQ_MAP:
+                    case PlSqlParser.NOPROMPT:
+                    case PlSqlParser.NO_PQ_REPLICATE:
+                    case PlSqlParser.NO_PQ_SKEW:
+                    case PlSqlParser.NO_PRUNE_GSETS:
+                    case PlSqlParser.NO_PULL_PRED:
+                    case PlSqlParser.NO_PUSH_PRED:
+                    case PlSqlParser.NO_PUSH_SUBQ:
+                    case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                    case PlSqlParser.NO_PX_JOIN_FILTER:
+                    case PlSqlParser.NO_QKN_BUFF:
+                    case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                    case PlSqlParser.NO_REF_CASCADE:
+                    case PlSqlParser.NORELOCATE:
+                    case PlSqlParser.NORELY:
+                    case PlSqlParser.NOREPAIR:
+                    case PlSqlParser.NOREPLAY:
+                    case PlSqlParser.NORESETLOGS:
+                    case PlSqlParser.NO_RESULT_CACHE:
+                    case PlSqlParser.NOREVERSE:
+                    case PlSqlParser.NO_REWRITE:
+                    case PlSqlParser.NOREWRITE:
+                    case PlSqlParser.NORMAL:
+                    case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                    case PlSqlParser.NOROWDEPENDENCIES:
+                    case PlSqlParser.NOSCHEMACHECK:
+                    case PlSqlParser.NOSEGMENT:
+                    case PlSqlParser.NO_SEMIJOIN:
+                    case PlSqlParser.NO_SEMI_TO_INNER:
+                    case PlSqlParser.NO_SET_TO_JOIN:
+                    case PlSqlParser.NOSORT:
+                    case PlSqlParser.NO_SQL_TRANSLATION:
+                    case PlSqlParser.NO_SQL_TUNE:
+                    case PlSqlParser.NO_STAR_TRANSFORMATION:
+                    case PlSqlParser.NO_STATEMENT_QUEUING:
+                    case PlSqlParser.NO_STATS_GSETS:
+                    case PlSqlParser.NOSTRICT:
+                    case PlSqlParser.NO_SUBQUERY_PRUNING:
+                    case PlSqlParser.NO_SUBSTRB_PAD:
+                    case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                    case PlSqlParser.NOSWITCH:
+                    case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.NO_TEMP_TABLE:
+                    case PlSqlParser.NOTHING:
+                    case PlSqlParser.NOTIFICATION:
+                    case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.NO_UNNEST:
+                    case PlSqlParser.NO_USE_CUBE:
+                    case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                    case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.NO_USE_HASH:
+                    case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.NO_USE_MERGE:
+                    case PlSqlParser.NO_USE_NL:
+                    case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.NOVALIDATE:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM:
+                    case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                    case PlSqlParser.NO_XML_DML_REWRITE:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE:
+                    case PlSqlParser.NO_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_ZONEMAP:
+                    case PlSqlParser.NTH_VALUE:
+                    case PlSqlParser.NULLIF:
+                    case PlSqlParser.NULLS:
+                    case PlSqlParser.NUMBER:
+                    case PlSqlParser.NUMERIC:
+                    case PlSqlParser.NUM_INDEX_KEYS:
+                    case PlSqlParser.NUMTODSINTERVAL:
+                    case PlSqlParser.NUMTOYMINTERVAL:
+                    case PlSqlParser.NVARCHAR2:
+                    case PlSqlParser.NVL2:
+                    case PlSqlParser.OBJECT2XML:
+                    case PlSqlParser.OBJECT:
+                    case PlSqlParser.OBJ_ID:
+                    case PlSqlParser.OBJNO:
+                    case PlSqlParser.OBJNO_REUSE:
+                    case PlSqlParser.OCCURENCES:
+                    case PlSqlParser.OFFLINE:
+                    case PlSqlParser.OFF:
+                    case PlSqlParser.OFFSET:
+                    case PlSqlParser.OIDINDEX:
+                    case PlSqlParser.OID:
+                    case PlSqlParser.OLAP:
+                    case PlSqlParser.OLD:
+                    case PlSqlParser.OLD_PUSH_PRED:
+                    case PlSqlParser.OLS:
+                    case PlSqlParser.OLTP:
+                    case PlSqlParser.OMIT:
+                    case PlSqlParser.ONE:
+                    case PlSqlParser.ONLINE:
+                    case PlSqlParser.ONLY:
+                    case PlSqlParser.OPAQUE:
+                    case PlSqlParser.OPAQUE_TRANSFORM:
+                    case PlSqlParser.OPAQUE_XCANONICAL:
+                    case PlSqlParser.OPCODE:
+                    case PlSqlParser.OPEN:
+                    case PlSqlParser.OPERATIONS:
+                    case PlSqlParser.OPERATOR:
+                    case PlSqlParser.OPT_ESTIMATE:
+                    case PlSqlParser.OPTIMAL:
+                    case PlSqlParser.OPTIMIZE:
+                    case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                    case PlSqlParser.OPTIMIZER_GOAL:
+                    case PlSqlParser.OPT_PARAM:
+                    case PlSqlParser.ORA_BRANCH:
+                    case PlSqlParser.ORA_CHECK_ACL:
+                    case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                    case PlSqlParser.ORA_CLUSTERING:
+                    case PlSqlParser.ORADATA:
+                    case PlSqlParser.ORC:
+                    case PlSqlParser.ORADEBUG:
+                    case PlSqlParser.ORA_DST_AFFECTED:
+                    case PlSqlParser.ORA_DST_CONVERT:
+                    case PlSqlParser.ORA_DST_ERROR:
+                    case PlSqlParser.ORA_GET_ACLIDS:
+                    case PlSqlParser.ORA_GET_PRIVILEGES:
+                    case PlSqlParser.ORA_HASH:
+                    case PlSqlParser.ORA_INVOKING_USERID:
+                    case PlSqlParser.ORA_INVOKING_USER:
+                    case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                    case PlSqlParser.ORA_INVOKING_XS_USER:
+                    case PlSqlParser.ORA_RAWCOMPARE:
+                    case PlSqlParser.ORA_RAWCONCAT:
+                    case PlSqlParser.ORA_ROWSCN:
+                    case PlSqlParser.ORA_ROWSCN_RAW:
+                    case PlSqlParser.ORA_ROWVERSION:
+                    case PlSqlParser.ORA_TABVERSION:
+                    case PlSqlParser.ORA_WRITE_TIME:
+                    case PlSqlParser.ORDERED:
+                    case PlSqlParser.ORDERED_PREDICATES:
+                    case PlSqlParser.ORDINALITY:
+                    case PlSqlParser.OR_EXPAND:
+                    case PlSqlParser.ORGANIZATION:
+                    case PlSqlParser.OR_PREDICATES:
+                    case PlSqlParser.OSERROR:
+                    case PlSqlParser.OTHER:
+                    case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.OUTER:
+                    case PlSqlParser.OUTLINE_LEAF:
+                    case PlSqlParser.OUTLINE:
+                    case PlSqlParser.OUT_OF_LINE:
+                    case PlSqlParser.OUT:
+                    case PlSqlParser.OVERFLOW_NOMOVE:
+                    case PlSqlParser.OVERFLOW_:
+                    case PlSqlParser.OVERLAPS:
+                    case PlSqlParser.OVER:
+                    case PlSqlParser.OVERRIDE:
+                    case PlSqlParser.OVERRIDING:
+                    case PlSqlParser.OWNER:
+                    case PlSqlParser.OWNERSHIP:
+                    case PlSqlParser.OWN:
+                    case PlSqlParser.P_LETTER:
+                    case PlSqlParser.PACKAGE:
+                    case PlSqlParser.PACKAGES:
+                    case PlSqlParser.PARALLEL_ENABLE:
+                    case PlSqlParser.PARALLEL_INDEX:
+                    case PlSqlParser.PARALLEL:
+                    case PlSqlParser.PARAMETERS:
+                    case PlSqlParser.PARAM:
+                    case PlSqlParser.PARENT:
+                    case PlSqlParser.PARENT_LEVEL_NAME:
+                    case PlSqlParser.PARENT_UNIQUE_NAME:
+                    case PlSqlParser.PARITY:
+                    case PlSqlParser.PARTIAL_JOIN:
+                    case PlSqlParser.PARTIALLY:
+                    case PlSqlParser.PARTIAL:
+                    case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.PARTITION_HASH:
+                    case PlSqlParser.PARTITION_LIST:
+                    case PlSqlParser.PARTITION:
+                    case PlSqlParser.PARTITION_RANGE:
+                    case PlSqlParser.PARTITIONS:
+                    case PlSqlParser.PARTNUMINST:
+                    case PlSqlParser.PASSING:
+                    case PlSqlParser.PASSWORD_GRACE_TIME:
+                    case PlSqlParser.PASSWORD_LIFE_TIME:
+                    case PlSqlParser.PASSWORD_LOCK_TIME:
+                    case PlSqlParser.PASSWORD:
+                    case PlSqlParser.PASSWORD_REUSE_MAX:
+                    case PlSqlParser.PASSWORD_REUSE_TIME:
+                    case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                    case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                    case PlSqlParser.PAST:
+                    case PlSqlParser.PATCH:
+                    case PlSqlParser.PATH:
+                    case PlSqlParser.PATH_PREFIX:
+                    case PlSqlParser.PATHS:
+                    case PlSqlParser.PATTERN:
+                    case PlSqlParser.PBL_HS_BEGIN:
+                    case PlSqlParser.PBL_HS_END:
+                    case PlSqlParser.PCTINCREASE:
+                    case PlSqlParser.PCTTHRESHOLD:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.PCTVERSION:
+                    case PlSqlParser.PENDING:
+                    case PlSqlParser.PERCENT_KEYWORD:
+                    case PlSqlParser.PERCENT_RANKM:
+                    case PlSqlParser.PERFORMANCE:
+                    case PlSqlParser.PERIOD_KEYWORD:
+                    case PlSqlParser.PERMANENT:
+                    case PlSqlParser.PERMISSION:
+                    case PlSqlParser.PERMUTE:
+                    case PlSqlParser.PER:
+                    case PlSqlParser.PFILE:
+                    case PlSqlParser.PHYSICAL:
+                    case PlSqlParser.PIKEY:
+                    case PlSqlParser.PIPELINED:
+                    case PlSqlParser.PIV_GB:
+                    case PlSqlParser.PIVOT:
+                    case PlSqlParser.PIV_SSF:
+                    case PlSqlParser.PLACE_DISTINCT:
+                    case PlSqlParser.PLACE_GROUP_BY:
+                    case PlSqlParser.PLAN:
+                    case PlSqlParser.PLSCOPE_SETTINGS:
+                    case PlSqlParser.PLS_INTEGER:
+                    case PlSqlParser.PLSQL_CCFLAGS:
+                    case PlSqlParser.PLSQL_CODE_TYPE:
+                    case PlSqlParser.PLSQL_DEBUG:
+                    case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                    case PlSqlParser.PLSQL_WARNINGS:
+                    case PlSqlParser.PLUGGABLE:
+                    case PlSqlParser.PMEM:
+                    case PlSqlParser.POINT:
+                    case PlSqlParser.POLICY:
+                    case PlSqlParser.POOL_16K:
+                    case PlSqlParser.POOL_2K:
+                    case PlSqlParser.POOL_32K:
+                    case PlSqlParser.POOL_4K:
+                    case PlSqlParser.POOL_8K:
+                    case PlSqlParser.POSITION:
+                    case PlSqlParser.POSITIVEN:
+                    case PlSqlParser.POSITIVE:
+                    case PlSqlParser.POST_TRANSACTION:
+                    case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                    case PlSqlParser.POWERMULTISET:
+                    case PlSqlParser.POWER:
+                    case PlSqlParser.PQ_CONCURRENT_UNION:
+                    case PlSqlParser.PQ_DISTRIBUTE:
+                    case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                    case PlSqlParser.PQ_FILTER:
+                    case PlSqlParser.PQ_MAP:
+                    case PlSqlParser.PQ_NOMAP:
+                    case PlSqlParser.PQ_REPLICATE:
+                    case PlSqlParser.PQ_SKEW:
+                    case PlSqlParser.PRAGMA:
+                    case PlSqlParser.PREBUILT:
+                    case PlSqlParser.PRECEDES:
+                    case PlSqlParser.PRECEDING:
+                    case PlSqlParser.PRECISION:
+                    case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                    case PlSqlParser.PREDICATE_REORDERS:
+                    case PlSqlParser.PRELOAD:
+                    case PlSqlParser.PREPARE:
+                    case PlSqlParser.PRESENTNNV:
+                    case PlSqlParser.PRESENT:
+                    case PlSqlParser.PRESENTV:
+                    case PlSqlParser.PRESERVE_OID:
+                    case PlSqlParser.PRESERVE:
+                    case PlSqlParser.PRETTY:
+                    case PlSqlParser.PREVIOUS:
+                    case PlSqlParser.PREV:
+                    case PlSqlParser.PRIMARY:
+                    case PlSqlParser.PRINTBLOBTOCLOB:
+                    case PlSqlParser.PRIORITY:
+                    case PlSqlParser.PRIVATE:
+                    case PlSqlParser.PRIVATE_SGA:
+                    case PlSqlParser.PRIVILEGED:
+                    case PlSqlParser.PRIVILEGE:
+                    case PlSqlParser.PRIVILEGES:
+                    case PlSqlParser.PROCEDURAL:
+                    case PlSqlParser.PROCEDURE:
+                    case PlSqlParser.PROCESS:
+                    case PlSqlParser.PROFILE:
+                    case PlSqlParser.PROGRAM:
+                    case PlSqlParser.PROJECT:
+                    case PlSqlParser.PROPAGATE:
+                    case PlSqlParser.PROPERTY:
+                    case PlSqlParser.PROTECTED:
+                    case PlSqlParser.PROTECTION:
+                    case PlSqlParser.PROTOCOL:
+                    case PlSqlParser.PROXY:
+                    case PlSqlParser.PRUNING:
+                    case PlSqlParser.PUBLIC:
+                    case PlSqlParser.PULL_PRED:
+                    case PlSqlParser.PURGE:
+                    case PlSqlParser.PUSH_PRED:
+                    case PlSqlParser.PUSH_SUBQ:
+                    case PlSqlParser.PX_FAULT_TOLERANCE:
+                    case PlSqlParser.PX_GRANULE:
+                    case PlSqlParser.PX_JOIN_FILTER:
+                    case PlSqlParser.QB_NAME:
+                    case PlSqlParser.QUARTERS:
+                    case PlSqlParser.QUERY_BLOCK:
+                    case PlSqlParser.QUERY:
+                    case PlSqlParser.QUEUE_CURR:
+                    case PlSqlParser.QUEUE:
+                    case PlSqlParser.QUEUE_ROWP:
+                    case PlSqlParser.QUIESCE:
+                    case PlSqlParser.QUORUM:
+                    case PlSqlParser.QUOTA:
+                    case PlSqlParser.QUOTAGROUP:
+                    case PlSqlParser.RAISE:
+                    case PlSqlParser.RANDOM_LOCAL:
+                    case PlSqlParser.RANDOM:
+                    case PlSqlParser.RANGE:
+                    case PlSqlParser.RANKM:
+                    case PlSqlParser.RAPIDLY:
+                    case PlSqlParser.RAW:
+                    case PlSqlParser.RAWTOHEX:
+                    case PlSqlParser.RAWTONHEX:
+                    case PlSqlParser.RBA:
+                    case PlSqlParser.RBO_OUTLINE:
+                    case PlSqlParser.RDBA:
+                    case PlSqlParser.READ:
+                    case PlSqlParser.READS:
+                    case PlSqlParser.REALM:
+                    case PlSqlParser.REAL:
+                    case PlSqlParser.REBALANCE:
+                    case PlSqlParser.REBUILD:
+                    case PlSqlParser.RECORD:
+                    case PlSqlParser.RECORDS:
+                    case PlSqlParser.RECORDS_PER_BLOCK:
+                    case PlSqlParser.RECOVERABLE:
+                    case PlSqlParser.RECOVER:
+                    case PlSqlParser.RECOVERY:
+                    case PlSqlParser.RECYCLEBIN:
+                    case PlSqlParser.RECYCLE:
+                    case PlSqlParser.REDACTION:
+                    case PlSqlParser.REDEFINE:
+                    case PlSqlParser.REDO:
+                    case PlSqlParser.REDUCED:
+                    case PlSqlParser.REDUNDANCY:
+                    case PlSqlParser.REF_CASCADE_CURSOR:
+                    case PlSqlParser.REFERENCED:
+                    case PlSqlParser.REFERENCE:
+                    case PlSqlParser.REFERENCES:
+                    case PlSqlParser.REFERENCING:
+                    case PlSqlParser.REF:
+                    case PlSqlParser.REFRESH:
+                    case PlSqlParser.REFTOHEX:
+                    case PlSqlParser.REGEXP_COUNT:
+                    case PlSqlParser.REGEXP_INSTR:
+                    case PlSqlParser.REGEXP_LIKE:
+                    case PlSqlParser.REGEXP_REPLACE:
+                    case PlSqlParser.REGEXP_SUBSTR:
+                    case PlSqlParser.REGISTER:
+                    case PlSqlParser.REGR_AVGX:
+                    case PlSqlParser.REGR_AVGY:
+                    case PlSqlParser.REGR_COUNT:
+                    case PlSqlParser.REGR_INTERCEPT:
+                    case PlSqlParser.REGR_R2:
+                    case PlSqlParser.REGR_SLOPE:
+                    case PlSqlParser.REGR_SXX:
+                    case PlSqlParser.REGR_SXY:
+                    case PlSqlParser.REGR_SYY:
+                    case PlSqlParser.REGULAR:
+                    case PlSqlParser.REJECT:
+                    case PlSqlParser.REKEY:
+                    case PlSqlParser.RELATIONAL:
+                    case PlSqlParser.RELOCATE:
+                    case PlSqlParser.RELY:
+                    case PlSqlParser.REMAINDER:
+                    case PlSqlParser.REMOTE:
+                    case PlSqlParser.REMOTE_MAPPED:
+                    case PlSqlParser.REMOVE:
+                    case PlSqlParser.RENAME:
+                    case PlSqlParser.REPAIR:
+                    case PlSqlParser.REPEAT:
+                    case PlSqlParser.REPLACE:
+                    case PlSqlParser.REPLICATION:
+                    case PlSqlParser.REQUIRED:
+                    case PlSqlParser.RESETLOGS:
+                    case PlSqlParser.RESET:
+                    case PlSqlParser.RESIZE:
+                    case PlSqlParser.RESOLVE:
+                    case PlSqlParser.RESOLVER:
+                    case PlSqlParser.RESPECT:
+                    case PlSqlParser.RESTART:
+                    case PlSqlParser.RESTORE_AS_INTERVALS:
+                    case PlSqlParser.RESTORE:
+                    case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                    case PlSqlParser.RESTRICTED:
+                    case PlSqlParser.RESTRICT_REFERENCES:
+                    case PlSqlParser.RESTRICT:
+                    case PlSqlParser.RESULT_CACHE:
+                    case PlSqlParser.RESULT:
+                    case PlSqlParser.RESUMABLE:
+                    case PlSqlParser.RESUME:
+                    case PlSqlParser.RETENTION:
+                    case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                    case PlSqlParser.RETURNING:
+                    case PlSqlParser.RETURN:
+                    case PlSqlParser.REUSE:
+                    case PlSqlParser.REVERSE:
+                    case PlSqlParser.REWRITE_OR_ERROR:
+                    case PlSqlParser.REWRITE:
+                    case PlSqlParser.RIGHT:
+                    case PlSqlParser.ROLE:
+                    case PlSqlParser.ROLESET:
+                    case PlSqlParser.ROLES:
+                    case PlSqlParser.ROLLBACK:
+                    case PlSqlParser.ROLLING:
+                    case PlSqlParser.ROLLUP:
+                    case PlSqlParser.ROWDEPENDENCIES:
+                    case PlSqlParser.ROWID_MAPPING_TABLE:
+                    case PlSqlParser.ROWID:
+                    case PlSqlParser.ROWIDTOCHAR:
+                    case PlSqlParser.ROWIDTONCHAR:
+                    case PlSqlParser.ROW_LENGTH:
+                    case PlSqlParser.ROWNUM:
+                    case PlSqlParser.ROW:
+                    case PlSqlParser.ROWS:
+                    case PlSqlParser.RPAD:
+                    case PlSqlParser.RTRIM:
+                    case PlSqlParser.RULE:
+                    case PlSqlParser.RULES:
+                    case PlSqlParser.RUNNING:
+                    case PlSqlParser.SALT:
+                    case PlSqlParser.SAMPLE:
+                    case PlSqlParser.SAVE_AS_INTERVALS:
+                    case PlSqlParser.SAVEPOINT:
+                    case PlSqlParser.SAVE:
+                    case PlSqlParser.SB4:
+                    case PlSqlParser.SCALE_ROWS:
+                    case PlSqlParser.SCALE:
+                    case PlSqlParser.SCAN_INSTANCES:
+                    case PlSqlParser.SCAN:
+                    case PlSqlParser.SCHEDULER:
+                    case PlSqlParser.SCHEMACHECK:
+                    case PlSqlParser.SCHEMA:
+                    case PlSqlParser.SCN_ASCENDING:
+                    case PlSqlParser.SCN:
+                    case PlSqlParser.SCOPE:
+                    case PlSqlParser.SCRUB:
+                    case PlSqlParser.SD_ALL:
+                    case PlSqlParser.SD_INHIBIT:
+                    case PlSqlParser.SDO_GEOM_MBR:
+                    case PlSqlParser.SDO_GEOMETRY:
+                    case PlSqlParser.SD_SHOW:
+                    case PlSqlParser.SEARCH:
+                    case PlSqlParser.SECOND:
+                    case PlSqlParser.SECONDS:
+                    case PlSqlParser.SECRET:
+                    case PlSqlParser.SECUREFILE_DBA:
+                    case PlSqlParser.SECUREFILE:
+                    case PlSqlParser.SECURITY:
+                    case PlSqlParser.SEED:
+                    case PlSqlParser.SEG_BLOCK:
+                    case PlSqlParser.SEG_FILE:
+                    case PlSqlParser.SEGMENT:
+                    case PlSqlParser.SELECTIVITY:
+                    case PlSqlParser.SELF:
+                    case PlSqlParser.SEMIJOIN_DRIVER:
+                    case PlSqlParser.SEMIJOIN:
+                    case PlSqlParser.SEMI_TO_INNER:
+                    case PlSqlParser.SEQUENCED:
+                    case PlSqlParser.SEQUENCE:
+                    case PlSqlParser.SEQUENTIAL:
+                    case PlSqlParser.SEQ:
+                    case PlSqlParser.SERIALIZABLE:
+                    case PlSqlParser.SERIALLY_REUSABLE:
+                    case PlSqlParser.SERIAL:
+                    case PlSqlParser.SERVERERROR:
+                    case PlSqlParser.SERVICE_NAME_CONVERT:
+                    case PlSqlParser.SERVICE:
+                    case PlSqlParser.SERVICES:
+                    case PlSqlParser.SESSION_CACHED_CURSORS:
+                    case PlSqlParser.SESSION:
+                    case PlSqlParser.SESSIONS_PER_USER:
+                    case PlSqlParser.SESSIONTIMEZONE:
+                    case PlSqlParser.SESSIONTZNAME:
+                    case PlSqlParser.SET:
+                    case PlSqlParser.SETS:
+                    case PlSqlParser.SETTINGS:
+                    case PlSqlParser.SET_TO_JOIN:
+                    case PlSqlParser.SEVERE:
+                    case PlSqlParser.SHARDSPACE:
+                    case PlSqlParser.SHARED_POOL:
+                    case PlSqlParser.SHARED:
+                    case PlSqlParser.SHARING:
+                    case PlSqlParser.SHELFLIFE:
+                    case PlSqlParser.SHOW:
+                    case PlSqlParser.SHRINK:
+                    case PlSqlParser.SHUTDOWN:
+                    case PlSqlParser.SIBLINGS:
+                    case PlSqlParser.SID:
+                    case PlSqlParser.SITE:
+                    case PlSqlParser.SIGNAL_COMPONENT:
+                    case PlSqlParser.SIGNAL_FUNCTION:
+                    case PlSqlParser.SIGN:
+                    case PlSqlParser.SIGNTYPE:
+                    case PlSqlParser.SIMPLE_INTEGER:
+                    case PlSqlParser.SIMPLE:
+                    case PlSqlParser.SINGLE:
+                    case PlSqlParser.SINGLETASK:
+                    case PlSqlParser.SINH:
+                    case PlSqlParser.SIN:
+                    case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                    case PlSqlParser.SKIP_:
+                    case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                    case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                    case PlSqlParser.SMALLFILE:
+                    case PlSqlParser.SMALLINT:
+                    case PlSqlParser.SNAPSHOT:
+                    case PlSqlParser.SOME:
+                    case PlSqlParser.SORT:
+                    case PlSqlParser.SOUNDEX:
+                    case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                    case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                    case PlSqlParser.SOURCE:
+                    case PlSqlParser.SPACE_KEYWORD:
+                    case PlSqlParser.SPECIFICATION:
+                    case PlSqlParser.SPFILE:
+                    case PlSqlParser.SPLIT:
+                    case PlSqlParser.SPREADSHEET:
+                    case PlSqlParser.SQLDATA:
+                    case PlSqlParser.SQLERROR:
+                    case PlSqlParser.SQLLDR:
+                    case PlSqlParser.SQL:
+                    case PlSqlParser.FILE_EXT:
+                    case PlSqlParser.SQL_MACRO:
+                    case PlSqlParser.SQL_TRACE:
+                    case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                    case PlSqlParser.SQRT:
+                    case PlSqlParser.STALE:
+                    case PlSqlParser.STANDALONE:
+                    case PlSqlParser.STANDARD:
+                    case PlSqlParser.STANDARD_HASH:
+                    case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                    case PlSqlParser.STANDBYS:
+                    case PlSqlParser.STANDBY:
+                    case PlSqlParser.STAR:
+                    case PlSqlParser.STAR_TRANSFORMATION:
+                    case PlSqlParser.STARTUP:
+                    case PlSqlParser.STATEMENT_ID:
+                    case PlSqlParser.STATEMENT_QUEUING:
+                    case PlSqlParser.STATEMENTS:
+                    case PlSqlParser.STATEMENT:
+                    case PlSqlParser.STATE:
+                    case PlSqlParser.STATIC:
+                    case PlSqlParser.STATISTICS:
+                    case PlSqlParser.STATS_BINOMIAL_TEST:
+                    case PlSqlParser.STATS_CROSSTAB:
+                    case PlSqlParser.STATS_F_TEST:
+                    case PlSqlParser.STATS_KS_TEST:
+                    case PlSqlParser.STATS_MODE:
+                    case PlSqlParser.STATS_MW_TEST:
+                    case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                    case PlSqlParser.STATS_T_TEST_INDEP:
+                    case PlSqlParser.STATS_T_TEST_INDEPU:
+                    case PlSqlParser.STATS_T_TEST_ONE:
+                    case PlSqlParser.STATS_T_TEST_PAIRED:
+                    case PlSqlParser.STATS_WSR_TEST:
+                    case PlSqlParser.STDDEV_POP:
+                    case PlSqlParser.STDDEV_SAMP:
+                    case PlSqlParser.STOP:
+                    case PlSqlParser.STORAGE:
+                    case PlSqlParser.STORE:
+                    case PlSqlParser.STREAMS:
+                    case PlSqlParser.STREAM:
+                    case PlSqlParser.STRICT:
+                    case PlSqlParser.STRING:
+                    case PlSqlParser.STRIPE_COLUMNS:
+                    case PlSqlParser.STRIPE_WIDTH:
+                    case PlSqlParser.STRIP:
+                    case PlSqlParser.STRUCTURE:
+                    case PlSqlParser.SUBMULTISET:
+                    case PlSqlParser.SUBPARTITION_REL:
+                    case PlSqlParser.SUBPARTITIONS:
+                    case PlSqlParser.SUBPARTITION:
+                    case PlSqlParser.SUBQUERIES:
+                    case PlSqlParser.SUBQUERY_PRUNING:
+                    case PlSqlParser.SUBSCRIBE:
+                    case PlSqlParser.SUBSET:
+                    case PlSqlParser.SUBSTITUTABLE:
+                    case PlSqlParser.SUBSTR2:
+                    case PlSqlParser.SUBSTR4:
+                    case PlSqlParser.SUBSTRB:
+                    case PlSqlParser.SUBSTRC:
+                    case PlSqlParser.SUBTYPE:
+                    case PlSqlParser.SUCCESSFUL:
+                    case PlSqlParser.SUCCESS:
+                    case PlSqlParser.SUMMARY:
+                    case PlSqlParser.SUPPLEMENTAL:
+                    case PlSqlParser.SUSPEND:
+                    case PlSqlParser.SWAP_JOIN_INPUTS:
+                    case PlSqlParser.SWITCHOVER:
+                    case PlSqlParser.SWITCH:
+                    case PlSqlParser.SYNCHRONOUS:
+                    case PlSqlParser.SYNC:
+                    case PlSqlParser.SYS:
+                    case PlSqlParser.SYSASM:
+                    case PlSqlParser.SYS_AUDIT:
+                    case PlSqlParser.SYSAUX:
+                    case PlSqlParser.SYSBACKUP:
+                    case PlSqlParser.SYS_CHECKACL:
+                    case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                    case PlSqlParser.SYS_CONNECT_BY_PATH:
+                    case PlSqlParser.SYS_CONTEXT:
+                    case PlSqlParser.SYSDATE:
+                    case PlSqlParser.SYSDBA:
+                    case PlSqlParser.SYS_DBURIGEN:
+                    case PlSqlParser.SYSDG:
+                    case PlSqlParser.SYS_DL_CURSOR:
+                    case PlSqlParser.SYS_DM_RXFORM_CHR:
+                    case PlSqlParser.SYS_DM_RXFORM_NUM:
+                    case PlSqlParser.SYS_DOM_COMPARE:
+                    case PlSqlParser.SYS_DST_PRIM2SEC:
+                    case PlSqlParser.SYS_DST_SEC2PRIM:
+                    case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                    case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                    case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                    case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                    case PlSqlParser.SYS_EXTPDTXT:
+                    case PlSqlParser.SYS_EXTRACT_UTC:
+                    case PlSqlParser.SYS_FBT_INSDEL:
+                    case PlSqlParser.SYS_FILTER_ACLS:
+                    case PlSqlParser.SYS_FNMATCHES:
+                    case PlSqlParser.SYS_FNREPLACE:
+                    case PlSqlParser.SYS_GET_ACLIDS:
+                    case PlSqlParser.SYS_GET_COL_ACLIDS:
+                    case PlSqlParser.SYS_GET_PRIVILEGES:
+                    case PlSqlParser.SYS_GETTOKENID:
+                    case PlSqlParser.SYS_GETXTIVAL:
+                    case PlSqlParser.SYS_GUID:
+                    case PlSqlParser.SYSGUID:
+                    case PlSqlParser.SYSKM:
+                    case PlSqlParser.SYS_MAKE_XMLNODEID:
+                    case PlSqlParser.SYS_MAKEXML:
+                    case PlSqlParser.SYS_MKXMLATTR:
+                    case PlSqlParser.SYS_MKXTI:
+                    case PlSqlParser.SYSOBJ:
+                    case PlSqlParser.SYS_OP_ADT2BIN:
+                    case PlSqlParser.SYS_OP_ADTCONS:
+                    case PlSqlParser.SYS_OP_ALSCRVAL:
+                    case PlSqlParser.SYS_OP_ATG:
+                    case PlSqlParser.SYS_OP_BIN2ADT:
+                    case PlSqlParser.SYS_OP_BITVEC:
+                    case PlSqlParser.SYS_OP_BL2R:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                    case PlSqlParser.SYS_OP_C2C:
+                    case PlSqlParser.SYS_OP_CAST:
+                    case PlSqlParser.SYS_OP_CEG:
+                    case PlSqlParser.SYS_OP_CL2C:
+                    case PlSqlParser.SYS_OP_COMBINED_HASH:
+                    case PlSqlParser.SYS_OP_COMP:
+                    case PlSqlParser.SYS_OP_CONVERT:
+                    case PlSqlParser.SYS_OP_COUNTCHG:
+                    case PlSqlParser.SYS_OP_CSCONV:
+                    case PlSqlParser.SYS_OP_CSCONVTEST:
+                    case PlSqlParser.SYS_OP_CSR:
+                    case PlSqlParser.SYS_OP_CSX_PATCH:
+                    case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                    case PlSqlParser.SYS_OP_DECOMP:
+                    case PlSqlParser.SYS_OP_DESCEND:
+                    case PlSqlParser.SYS_OP_DISTINCT:
+                    case PlSqlParser.SYS_OP_DRA:
+                    case PlSqlParser.SYS_OP_DUMP:
+                    case PlSqlParser.SYS_OP_DV_CHECK:
+                    case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                    case PlSqlParser.SYSOPER:
+                    case PlSqlParser.SYS_OP_EXTRACT:
+                    case PlSqlParser.SYS_OP_GROUPING:
+                    case PlSqlParser.SYS_OP_GUID:
+                    case PlSqlParser.SYS_OP_HASH:
+                    case PlSqlParser.SYS_OP_IIX:
+                    case PlSqlParser.SYS_OP_ITR:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                    case PlSqlParser.SYS_OP_LBID:
+                    case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2ID:
+                    case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                    case PlSqlParser.SYS_OP_LSVI:
+                    case PlSqlParser.SYS_OP_LVL:
+                    case PlSqlParser.SYS_OP_MAKEOID:
+                    case PlSqlParser.SYS_OP_MAP_NONNULL:
+                    case PlSqlParser.SYS_OP_MSR:
+                    case PlSqlParser.SYS_OP_NICOMBINE:
+                    case PlSqlParser.SYS_OP_NIEXTRACT:
+                    case PlSqlParser.SYS_OP_NII:
+                    case PlSqlParser.SYS_OP_NIX:
+                    case PlSqlParser.SYS_OP_NOEXPAND:
+                    case PlSqlParser.SYS_OP_NTCIMG:
+                    case PlSqlParser.SYS_OP_NUMTORAW:
+                    case PlSqlParser.SYS_OP_OIDVALUE:
+                    case PlSqlParser.SYS_OP_OPNSIZE:
+                    case PlSqlParser.SYS_OP_PAR_1:
+                    case PlSqlParser.SYS_OP_PARGID_1:
+                    case PlSqlParser.SYS_OP_PARGID:
+                    case PlSqlParser.SYS_OP_PAR:
+                    case PlSqlParser.SYS_OP_PART_ID:
+                    case PlSqlParser.SYS_OP_PIVOT:
+                    case PlSqlParser.SYS_OP_R2O:
+                    case PlSqlParser.SYS_OP_RAWTONUM:
+                    case PlSqlParser.SYS_OP_RDTM:
+                    case PlSqlParser.SYS_OP_REF:
+                    case PlSqlParser.SYS_OP_RMTD:
+                    case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                    case PlSqlParser.SYS_OP_RPB:
+                    case PlSqlParser.SYS_OPTLOBPRBSC:
+                    case PlSqlParser.SYS_OP_TOSETID:
+                    case PlSqlParser.SYS_OP_TPR:
+                    case PlSqlParser.SYS_OP_TRTB:
+                    case PlSqlParser.SYS_OPTXICMP:
+                    case PlSqlParser.SYS_OPTXQCASTASNQ:
+                    case PlSqlParser.SYS_OP_UNDESCEND:
+                    case PlSqlParser.SYS_OP_VECAND:
+                    case PlSqlParser.SYS_OP_VECBIT:
+                    case PlSqlParser.SYS_OP_VECOR:
+                    case PlSqlParser.SYS_OP_VECXOR:
+                    case PlSqlParser.SYS_OP_VERSION:
+                    case PlSqlParser.SYS_OP_VREF:
+                    case PlSqlParser.SYS_OP_VVD:
+                    case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                    case PlSqlParser.SYS_OP_XPTHATG:
+                    case PlSqlParser.SYS_OP_XPTHIDX:
+                    case PlSqlParser.SYS_OP_XPTHOP:
+                    case PlSqlParser.SYS_OP_XTXT2SQLT:
+                    case PlSqlParser.SYS_OP_ZONE_ID:
+                    case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                    case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                    case PlSqlParser.SYS_ORDERKEY_PARENT:
+                    case PlSqlParser.SYS_PARALLEL_TXN:
+                    case PlSqlParser.SYS_PATHID_IS_ATTR:
+                    case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                    case PlSqlParser.SYS_PATHID_LASTNAME:
+                    case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                    case PlSqlParser.SYS_PATH_REVERSE:
+                    case PlSqlParser.SYS_PXQEXTRACT:
+                    case PlSqlParser.SYS_RAW_TO_XSID:
+                    case PlSqlParser.SYS_RID_ORDER:
+                    case PlSqlParser.SYS_ROW_DELTA:
+                    case PlSqlParser.SYS_SC_2_XMLT:
+                    case PlSqlParser.SYS_SYNRCIREDO:
+                    case PlSqlParser.SYSTEM_DEFINED:
+                    case PlSqlParser.SYSTEM:
+                    case PlSqlParser.SYSTIMESTAMP:
+                    case PlSqlParser.SYS_TYPEID:
+                    case PlSqlParser.SYS_UMAKEXML:
+                    case PlSqlParser.SYS_XMLANALYZE:
+                    case PlSqlParser.SYS_XMLCONTAINS:
+                    case PlSqlParser.SYS_XMLCONV:
+                    case PlSqlParser.SYS_XMLEXNSURI:
+                    case PlSqlParser.SYS_XMLGEN:
+                    case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                    case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                    case PlSqlParser.SYS_XMLINSTR:
+                    case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETCID:
+                    case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                    case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                    case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                    case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETTID:
+                    case PlSqlParser.SYS_XMLNODEID:
+                    case PlSqlParser.SYS_XMLT_2_SC:
+                    case PlSqlParser.SYS_XMLTRANSLATE:
+                    case PlSqlParser.SYS_XMLTYPE2SQL:
+                    case PlSqlParser.SYS_XQ_ASQLCNV:
+                    case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                    case PlSqlParser.SYS_XQBASEURI:
+                    case PlSqlParser.SYS_XQCASTABLEERRH:
+                    case PlSqlParser.SYS_XQCODEP2STR:
+                    case PlSqlParser.SYS_XQCODEPEQ:
+                    case PlSqlParser.SYS_XQCON2SEQ:
+                    case PlSqlParser.SYS_XQCONCAT:
+                    case PlSqlParser.SYS_XQDELETE:
+                    case PlSqlParser.SYS_XQDFLTCOLATION:
+                    case PlSqlParser.SYS_XQDOC:
+                    case PlSqlParser.SYS_XQDOCURI:
+                    case PlSqlParser.SYS_XQDURDIV:
+                    case PlSqlParser.SYS_XQED4URI:
+                    case PlSqlParser.SYS_XQENDSWITH:
+                    case PlSqlParser.SYS_XQERRH:
+                    case PlSqlParser.SYS_XQERR:
+                    case PlSqlParser.SYS_XQESHTMLURI:
+                    case PlSqlParser.SYS_XQEXLOBVAL:
+                    case PlSqlParser.SYS_XQEXSTWRP:
+                    case PlSqlParser.SYS_XQEXTRACT:
+                    case PlSqlParser.SYS_XQEXTRREF:
+                    case PlSqlParser.SYS_XQEXVAL:
+                    case PlSqlParser.SYS_XQFB2STR:
+                    case PlSqlParser.SYS_XQFNBOOL:
+                    case PlSqlParser.SYS_XQFNCMP:
+                    case PlSqlParser.SYS_XQFNDATIM:
+                    case PlSqlParser.SYS_XQFNLNAME:
+                    case PlSqlParser.SYS_XQFNNM:
+                    case PlSqlParser.SYS_XQFNNSURI:
+                    case PlSqlParser.SYS_XQFNPREDTRUTH:
+                    case PlSqlParser.SYS_XQFNQNM:
+                    case PlSqlParser.SYS_XQFNROOT:
+                    case PlSqlParser.SYS_XQFORMATNUM:
+                    case PlSqlParser.SYS_XQFTCONTAIN:
+                    case PlSqlParser.SYS_XQFUNCR:
+                    case PlSqlParser.SYS_XQGETCONTENT:
+                    case PlSqlParser.SYS_XQINDXOF:
+                    case PlSqlParser.SYS_XQINSERT:
+                    case PlSqlParser.SYS_XQINSPFX:
+                    case PlSqlParser.SYS_XQIRI2URI:
+                    case PlSqlParser.SYS_XQLANG:
+                    case PlSqlParser.SYS_XQLLNMFRMQNM:
+                    case PlSqlParser.SYS_XQMKNODEREF:
+                    case PlSqlParser.SYS_XQNILLED:
+                    case PlSqlParser.SYS_XQNODENAME:
+                    case PlSqlParser.SYS_XQNORMSPACE:
+                    case PlSqlParser.SYS_XQNORMUCODE:
+                    case PlSqlParser.SYS_XQ_NRNG:
+                    case PlSqlParser.SYS_XQNSP4PFX:
+                    case PlSqlParser.SYS_XQNSPFRMQNM:
+                    case PlSqlParser.SYS_XQPFXFRMQNM:
+                    case PlSqlParser.SYS_XQ_PKSQL2XML:
+                    case PlSqlParser.SYS_XQPOLYABS:
+                    case PlSqlParser.SYS_XQPOLYADD:
+                    case PlSqlParser.SYS_XQPOLYCEL:
+                    case PlSqlParser.SYS_XQPOLYCSTBL:
+                    case PlSqlParser.SYS_XQPOLYCST:
+                    case PlSqlParser.SYS_XQPOLYDIV:
+                    case PlSqlParser.SYS_XQPOLYFLR:
+                    case PlSqlParser.SYS_XQPOLYMOD:
+                    case PlSqlParser.SYS_XQPOLYMUL:
+                    case PlSqlParser.SYS_XQPOLYRND:
+                    case PlSqlParser.SYS_XQPOLYSQRT:
+                    case PlSqlParser.SYS_XQPOLYSUB:
+                    case PlSqlParser.SYS_XQPOLYUMUS:
+                    case PlSqlParser.SYS_XQPOLYUPLS:
+                    case PlSqlParser.SYS_XQPOLYVEQ:
+                    case PlSqlParser.SYS_XQPOLYVGE:
+                    case PlSqlParser.SYS_XQPOLYVGT:
+                    case PlSqlParser.SYS_XQPOLYVLE:
+                    case PlSqlParser.SYS_XQPOLYVLT:
+                    case PlSqlParser.SYS_XQPOLYVNE:
+                    case PlSqlParser.SYS_XQREF2VAL:
+                    case PlSqlParser.SYS_XQRENAME:
+                    case PlSqlParser.SYS_XQREPLACE:
+                    case PlSqlParser.SYS_XQRESVURI:
+                    case PlSqlParser.SYS_XQRNDHALF2EVN:
+                    case PlSqlParser.SYS_XQRSLVQNM:
+                    case PlSqlParser.SYS_XQRYENVPGET:
+                    case PlSqlParser.SYS_XQRYVARGET:
+                    case PlSqlParser.SYS_XQRYWRP:
+                    case PlSqlParser.SYS_XQSEQ2CON4XC:
+                    case PlSqlParser.SYS_XQSEQ2CON:
+                    case PlSqlParser.SYS_XQSEQDEEPEQ:
+                    case PlSqlParser.SYS_XQSEQINSB:
+                    case PlSqlParser.SYS_XQSEQRM:
+                    case PlSqlParser.SYS_XQSEQRVS:
+                    case PlSqlParser.SYS_XQSEQSUB:
+                    case PlSqlParser.SYS_XQSEQTYPMATCH:
+                    case PlSqlParser.SYS_XQSTARTSWITH:
+                    case PlSqlParser.SYS_XQSTATBURI:
+                    case PlSqlParser.SYS_XQSTR2CODEP:
+                    case PlSqlParser.SYS_XQSTRJOIN:
+                    case PlSqlParser.SYS_XQSUBSTRAFT:
+                    case PlSqlParser.SYS_XQSUBSTRBEF:
+                    case PlSqlParser.SYS_XQTOKENIZE:
+                    case PlSqlParser.SYS_XQTREATAS:
+                    case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                    case PlSqlParser.SYS_XQXFORM:
+                    case PlSqlParser.SYS_XSID_TO_RAW:
+                    case PlSqlParser.SYS_ZMAP_FILTER:
+                    case PlSqlParser.SYS_ZMAP_REFRESH:
+                    case PlSqlParser.T_LETTER:
+                    case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.TABLESPACE_NO:
+                    case PlSqlParser.TABLESPACE:
+                    case PlSqlParser.TABLES:
+                    case PlSqlParser.TABLE_STATS:
+                    case PlSqlParser.TABLE:
+                    case PlSqlParser.TABNO:
+                    case PlSqlParser.TAG:
+                    case PlSqlParser.TANH:
+                    case PlSqlParser.TAN:
+                    case PlSqlParser.TBLORIDXPARTNUM:
+                    case PlSqlParser.TEMPFILE:
+                    case PlSqlParser.TEMPLATE:
+                    case PlSqlParser.TEMPLATE_TABLE:
+                    case PlSqlParser.TEMPORARY:
+                    case PlSqlParser.TEMP_TABLE:
+                    case PlSqlParser.TEST:
+                    case PlSqlParser.TEXT:
+                    case PlSqlParser.THAN:
+                    case PlSqlParser.THEN:
+                    case PlSqlParser.THE:
+                    case PlSqlParser.THREAD:
+                    case PlSqlParser.THROUGH:
+                    case PlSqlParser.TIER:
+                    case PlSqlParser.TIES:
+                    case PlSqlParser.TIMEOUT:
+                    case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP:
+                    case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                    case PlSqlParser.TIMES:
+                    case PlSqlParser.TIME:
+                    case PlSqlParser.TIMEZONE:
+                    case PlSqlParser.TIMEZONE_ABBR:
+                    case PlSqlParser.TIMEZONE_HOUR:
+                    case PlSqlParser.TIMEZONE_MINUTE:
+                    case PlSqlParser.TIMEZONE_OFFSET:
+                    case PlSqlParser.TIMEZONE_REGION:
+                    case PlSqlParser.TIME_ZONE:
+                    case PlSqlParser.TIMING:
+                    case PlSqlParser.TIV_GB:
+                    case PlSqlParser.TIV_SSF:
+                    case PlSqlParser.TO_ACLID:
+                    case PlSqlParser.TO_BINARY_DOUBLE:
+                    case PlSqlParser.TO_BINARY_FLOAT:
+                    case PlSqlParser.TO_BLOB:
+                    case PlSqlParser.TO_CLOB:
+                    case PlSqlParser.TO_DSINTERVAL:
+                    case PlSqlParser.TO_LOB:
+                    case PlSqlParser.TO_MULTI_BYTE:
+                    case PlSqlParser.TO_NCHAR:
+                    case PlSqlParser.TO_NCLOB:
+                    case PlSqlParser.TO_NUMBER:
+                    case PlSqlParser.TOPLEVEL:
+                    case PlSqlParser.TO_SINGLE_BYTE:
+                    case PlSqlParser.TO_TIMESTAMP:
+                    case PlSqlParser.TO_TIMESTAMP_TZ:
+                    case PlSqlParser.TO_TIME:
+                    case PlSqlParser.TO_TIME_TZ:
+                    case PlSqlParser.TO_YMINTERVAL:
+                    case PlSqlParser.TRACE:
+                    case PlSqlParser.TRACING:
+                    case PlSqlParser.TRACKING:
+                    case PlSqlParser.TRAILING:
+                    case PlSqlParser.TRANSACTION:
+                    case PlSqlParser.TRANSFORM:
+                    case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.TRANSITIONAL:
+                    case PlSqlParser.TRANSITION:
+                    case PlSqlParser.TRANSLATE:
+                    case PlSqlParser.TRANSLATION:
+                    case PlSqlParser.TREAT:
+                    case PlSqlParser.TRIGGERS:
+                    case PlSqlParser.TRIGGER:
+                    case PlSqlParser.TRUE:
+                    case PlSqlParser.TRUNCATE:
+                    case PlSqlParser.TRUNC:
+                    case PlSqlParser.TRUSTED:
+                    case PlSqlParser.TRUST:
+                    case PlSqlParser.TUNING:
+                    case PlSqlParser.TX:
+                    case PlSqlParser.TYPES:
+                    case PlSqlParser.TYPE:
+                    case PlSqlParser.TZ_OFFSET:
+                    case PlSqlParser.UB2:
+                    case PlSqlParser.UBA:
+                    case PlSqlParser.UCS2:
+                    case PlSqlParser.UDF:
+                    case PlSqlParser.UID:
+                    case PlSqlParser.UNARCHIVED:
+                    case PlSqlParser.UNBOUNDED:
+                    case PlSqlParser.UNBOUND:
+                    case PlSqlParser.UNCONDITIONAL:
+                    case PlSqlParser.UNDER:
+                    case PlSqlParser.UNDO:
+                    case PlSqlParser.UNDROP:
+                    case PlSqlParser.UNIFORM:
+                    case PlSqlParser.UNISTR:
+                    case PlSqlParser.UNLIMITED:
+                    case PlSqlParser.UNLOAD:
+                    case PlSqlParser.UNLOCK:
+                    case PlSqlParser.UNMATCHED:
+                    case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                    case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                    case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                    case PlSqlParser.UNNEST:
+                    case PlSqlParser.UNPACKED:
+                    case PlSqlParser.UNPIVOT:
+                    case PlSqlParser.UNPLUG:
+                    case PlSqlParser.UNPROTECTED:
+                    case PlSqlParser.UNQUIESCE:
+                    case PlSqlParser.UNRECOVERABLE:
+                    case PlSqlParser.UNRESTRICTED:
+                    case PlSqlParser.UNSUBSCRIBE:
+                    case PlSqlParser.UNTIL:
+                    case PlSqlParser.UNUSABLE:
+                    case PlSqlParser.UNUSED:
+                    case PlSqlParser.UPDATABLE:
+                    case PlSqlParser.UPDATED:
+                    case PlSqlParser.UPDATEXML:
+                    case PlSqlParser.UPD_INDEXES:
+                    case PlSqlParser.UPD_JOININDEX:
+                    case PlSqlParser.UPGRADE:
+                    case PlSqlParser.UPPER:
+                    case PlSqlParser.UPSERT:
+                    case PlSqlParser.UROWID:
+                    case PlSqlParser.USABLE:
+                    case PlSqlParser.USAGE:
+                    case PlSqlParser.USE_ANTI:
+                    case PlSqlParser.USE_CONCAT:
+                    case PlSqlParser.USE_CUBE:
+                    case PlSqlParser.USE_HASH_AGGREGATION:
+                    case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.USE_HASH:
+                    case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                    case PlSqlParser.USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.USE_MERGE_CARTESIAN:
+                    case PlSqlParser.USE_MERGE:
+                    case PlSqlParser.USE_NL:
+                    case PlSqlParser.USE_NL_WITH_INDEX:
+                    case PlSqlParser.USE_PRIVATE_OUTLINES:
+                    case PlSqlParser.USER_DATA:
+                    case PlSqlParser.USER_DEFINED:
+                    case PlSqlParser.USERENV:
+                    case PlSqlParser.USERGROUP:
+                    case PlSqlParser.USER_RECYCLEBIN:
+                    case PlSqlParser.USERS:
+                    case PlSqlParser.USER_TABLESPACES:
+                    case PlSqlParser.USER:
+                    case PlSqlParser.USE_SEMI:
+                    case PlSqlParser.USE_STORED_OUTLINES:
+                    case PlSqlParser.USE_TTT_FOR_GSETS:
+                    case PlSqlParser.USE:
+                    case PlSqlParser.USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.USE_WEAK_NAME_RESL:
+                    case PlSqlParser.USING_NO_EXPAND:
+                    case PlSqlParser.USING_NLS_COMP:
+                    case PlSqlParser.USING:
+                    case PlSqlParser.UTF16BE:
+                    case PlSqlParser.UTF16LE:
+                    case PlSqlParser.UTF32:
+                    case PlSqlParser.UTF8:
+                    case PlSqlParser.V1:
+                    case PlSqlParser.V2:
+                    case PlSqlParser.VALIDATE:
+                    case PlSqlParser.VALIDATE_CONVERSION:
+                    case PlSqlParser.VALIDATION:
+                    case PlSqlParser.VALID_TIME_END:
+                    case PlSqlParser.VALUE:
+                    case PlSqlParser.VARCHAR2:
+                    case PlSqlParser.VARCHAR:
+                    case PlSqlParser.VARIABLE:
+                    case PlSqlParser.VAR_POP:
+                    case PlSqlParser.VARRAYS:
+                    case PlSqlParser.VARRAY:
+                    case PlSqlParser.VAR_SAMP:
+                    case PlSqlParser.VARYING:
+                    case PlSqlParser.VECTOR_READ_TRACE:
+                    case PlSqlParser.VECTOR_READ:
+                    case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.VECTOR_TRANSFORM:
+                    case PlSqlParser.VERIFIER:
+                    case PlSqlParser.VERIFY:
+                    case PlSqlParser.VERSIONING:
+                    case PlSqlParser.VERSIONS_ENDSCN:
+                    case PlSqlParser.VERSIONS_ENDTIME:
+                    case PlSqlParser.VERSIONS_OPERATION:
+                    case PlSqlParser.VERSIONS_STARTSCN:
+                    case PlSqlParser.VERSIONS_STARTTIME:
+                    case PlSqlParser.VERSIONS:
+                    case PlSqlParser.VERSIONS_XID:
+                    case PlSqlParser.VERSION:
+                    case PlSqlParser.VIOLATION:
+                    case PlSqlParser.VIRTUAL:
+                    case PlSqlParser.VISIBILITY:
+                    case PlSqlParser.VISIBLE:
+                    case PlSqlParser.VOLUME:
+                    case PlSqlParser.VSIZE:
+                    case PlSqlParser.WAIT:
+                    case PlSqlParser.WALLET:
+                    case PlSqlParser.WARNING:
+                    case PlSqlParser.WEEKS:
+                    case PlSqlParser.WEEK:
+                    case PlSqlParser.WELLFORMED:
+                    case PlSqlParser.WHENEVER:
+                    case PlSqlParser.WHEN:
+                    case PlSqlParser.WHILE:
+                    case PlSqlParser.WHITESPACE:
+                    case PlSqlParser.WIDTH_BUCKET:
+                    case PlSqlParser.WITHIN:
+                    case PlSqlParser.WITHOUT:
+                    case PlSqlParser.WITH_PLSQL:
+                    case PlSqlParser.WORK:
+                    case PlSqlParser.WRAPPED:
+                    case PlSqlParser.WRAPPER:
+                    case PlSqlParser.WRITE:
+                    case PlSqlParser.XDB_FASTPATH_INSERT:
+                    case PlSqlParser.X_DYN_PRUNE:
+                    case PlSqlParser.XID:
+                    case PlSqlParser.XML2OBJECT:
+                    case PlSqlParser.XMLAGG:
+                    case PlSqlParser.XMLATTRIBUTES:
+                    case PlSqlParser.XMLCAST:
+                    case PlSqlParser.XMLCDATA:
+                    case PlSqlParser.XMLCOLATTVAL:
+                    case PlSqlParser.XMLCOMMENT:
+                    case PlSqlParser.XMLCONCAT:
+                    case PlSqlParser.XMLDIFF:
+                    case PlSqlParser.XML_DML_RWT_STMT:
+                    case PlSqlParser.XMLELEMENT:
+                    case PlSqlParser.XMLEXISTS2:
+                    case PlSqlParser.XMLEXISTS:
+                    case PlSqlParser.XMLFOREST:
+                    case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.XMLINDEX_REWRITE:
+                    case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                    case PlSqlParser.XMLISNODE:
+                    case PlSqlParser.XMLISVALID:
+                    case PlSqlParser.XMLNAMESPACES:
+                    case PlSqlParser.XMLPARSE:
+                    case PlSqlParser.XMLPATCH:
+                    case PlSqlParser.XMLPI:
+                    case PlSqlParser.XMLQUERYVAL:
+                    case PlSqlParser.XMLQUERY:
+                    case PlSqlParser.XMLROOT:
+                    case PlSqlParser.XMLSCHEMA:
+                    case PlSqlParser.XMLSERIALIZE:
+                    case PlSqlParser.XMLTABLE:
+                    case PlSqlParser.XMLTRANSFORMBLOB:
+                    case PlSqlParser.XMLTRANSFORM:
+                    case PlSqlParser.XMLTYPE:
+                    case PlSqlParser.XML:
+                    case PlSqlParser.XPATHTABLE:
+                    case PlSqlParser.XS_SYS_CONTEXT:
+                    case PlSqlParser.XS:
+                    case PlSqlParser.YEARS:
+                    case PlSqlParser.YEAR:
+                    case PlSqlParser.YES:
+                    case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.ZONEMAP:
+                    case PlSqlParser.ZONE:
+                    case PlSqlParser.PREDICTION:
+                    case PlSqlParser.PREDICTION_BOUNDS:
+                    case PlSqlParser.PREDICTION_COST:
+                    case PlSqlParser.PREDICTION_DETAILS:
+                    case PlSqlParser.PREDICTION_PROBABILITY:
+                    case PlSqlParser.PREDICTION_SET:
+                    case PlSqlParser.BLOCKCHAIN:
+                    case PlSqlParser.COLLATE:
+                    case PlSqlParser.COLLATION:
+                    case PlSqlParser.DEFINITION:
+                    case PlSqlParser.DUPLICATED:
+                    case PlSqlParser.EXTENDED:
+                    case PlSqlParser.HASHING:
+                    case PlSqlParser.IDLE:
+                    case PlSqlParser.IMMUTABLE:
+                    case PlSqlParser.ORACLE_DATAPUMP:
+                    case PlSqlParser.ORACLE_HDFS:
+                    case PlSqlParser.ORACLE_HIVE:
+                    case PlSqlParser.ORACLE_LOADER:
+                    case PlSqlParser.SHARDED:
+                    case PlSqlParser.ISOLATE:
+                    case PlSqlParser.ROOT:
+                    case PlSqlParser.UNITE:
+                    case PlSqlParser.ALGORITHM:
+                    case PlSqlParser.CUME_DIST:
+                    case PlSqlParser.DENSE_RANK:
+                    case PlSqlParser.LISTAGG:
+                    case PlSqlParser.PERCENT_RANK:
+                    case PlSqlParser.PERCENTILE_CONT:
+                    case PlSqlParser.PERCENTILE_DISC:
+                    case PlSqlParser.RANK:
+                    case PlSqlParser.AVG:
+                    case PlSqlParser.CORR:
+                    case PlSqlParser.COVAR_:
+                    case PlSqlParser.LAG:
+                    case PlSqlParser.LEAD:
+                    case PlSqlParser.MAX:
+                    case PlSqlParser.MEDIAN:
+                    case PlSqlParser.MEMOPTIMIZE:
+                    case PlSqlParser.MIN:
+                    case PlSqlParser.NTILE:
+                    case PlSqlParser.NVL:
+                    case PlSqlParser.RATIO_TO_REPORT:
+                    case PlSqlParser.REGR_:
+                    case PlSqlParser.ROUND:
+                    case PlSqlParser.ROW_NUMBER:
+                    case PlSqlParser.SUBSTR:
+                    case PlSqlParser.TO_CHAR:
+                    case PlSqlParser.TRIM:
+                    case PlSqlParser.SUM:
+                    case PlSqlParser.STDDEV:
+                    case PlSqlParser.VAR_:
+                    case PlSqlParser.VARIANCE:
+                    case PlSqlParser.LEAST:
+                    case PlSqlParser.GREATEST:
+                    case PlSqlParser.TO_DATE:
+                    case PlSqlParser.CHARSETID:
+                    case PlSqlParser.CHARSETFORM:
+                    case PlSqlParser.DURATION:
+                    case PlSqlParser.EXTEND:
+                    case PlSqlParser.MAXLEN:
+                    case PlSqlParser.PERSISTABLE:
+                    case PlSqlParser.POLYMORPHIC:
+                    case PlSqlParser.STRUCT:
+                    case PlSqlParser.TDO:
+                    case PlSqlParser.WM_CONCAT:
+                    case PlSqlParser.PERIOD:
+                    case PlSqlParser.DELIMITED_ID:
+                    case PlSqlParser.INTRODUCER:
+                    case PlSqlParser.REGULAR_ID:
+                        {
+                        this.state = 3458;
+                        this.schema_name();
+                        }
+                        break;
+                    case PlSqlParser.MINUS_SIGN:
+                        {
+                        this.state = 3459;
+                        this.match(PlSqlParser.MINUS_SIGN);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 3462;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    }
+                    this.state = 3466;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 2449);
+                this.state = 3468;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 3475;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 3472;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            case PlSqlParser.RESOLVE:
+                {
+                this.state = 3473;
+                this.match(PlSqlParser.RESOLVE);
+                }
+                break;
+            case PlSqlParser.AUTHID:
+                {
+                this.state = 3474;
+                this.invoker_rights_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public match_string(): Match_stringContext {
+        let localContext = new Match_stringContext(this.context, this.state);
+        this.enterRule(localContext, 108, PlSqlParser.RULE_match_string);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3477;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 2446 || _la === 2452)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_function_body(): Create_function_bodyContext {
+        let localContext = new Create_function_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 110, PlSqlParser.RULE_create_function_body);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3479;
+            this.match(PlSqlParser.CREATE);
+            this.state = 3482;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 3480;
+                this.match(PlSqlParser.OR);
+                this.state = 3481;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 3485;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 3484;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 3487;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 3488;
+            this.function_name();
+            this.state = 3500;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 3489;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3490;
+                this.parameter();
+                this.state = 3495;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 3491;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 3492;
+                    this.parameter();
+                    }
+                    }
+                    this.state = 3497;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 3498;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 3502;
+            this.match(PlSqlParser.RETURN);
+            this.state = 3503;
+            this.type_spec();
+            this.state = 3507;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1683) {
+                {
+                this.state = 3504;
+                this.match(PlSqlParser.SHARING);
+                this.state = 3505;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3506;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 3518;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 141, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 3516;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.AUTHID:
+                        {
+                        this.state = 3509;
+                        this.invoker_rights_clause();
+                        }
+                        break;
+                    case PlSqlParser.ACCESSIBLE:
+                        {
+                        this.state = 3510;
+                        this.accessible_by_clause();
+                        }
+                        break;
+                    case PlSqlParser.DEFAULT:
+                        {
+                        this.state = 3511;
+                        this.default_collation_clause();
+                        }
+                        break;
+                    case PlSqlParser.PARALLEL_ENABLE:
+                        {
+                        this.state = 3512;
+                        this.parallel_enable_clause();
+                        }
+                        break;
+                    case PlSqlParser.RESULT_CACHE:
+                        {
+                        this.state = 3513;
+                        this.result_cache_clause();
+                        }
+                        break;
+                    case PlSqlParser.PIPELINED:
+                        {
+                        this.state = 3514;
+                        this.match(PlSqlParser.PIPELINED);
+                        }
+                        break;
+                    case PlSqlParser.DETERMINISTIC:
+                        {
+                        this.state = 3515;
+                        this.match(PlSqlParser.DETERMINISTIC);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 3520;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 141, this.context);
+            }
+            this.state = 3535;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.AS:
+            case PlSqlParser.IS:
+                {
+                {
+                this.state = 3521;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 69 || _la === 786)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3530;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 144, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3523;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 142, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 3522;
+                        this.match(PlSqlParser.DECLARE);
+                        }
+                        break;
+                    }
+                    this.state = 3526;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 143, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 3525;
+                        this.seq_of_declare_specs();
+                        }
+                        break;
+                    }
+                    this.state = 3528;
+                    this.body();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 3529;
+                    this.call_spec();
+                    }
+                    break;
+                }
+                }
+                }
+                break;
+            case PlSqlParser.AGGREGATE:
+                {
+                this.state = 3532;
+                this.aggregate_clause();
+                }
+                break;
+            case PlSqlParser.PIPELINED:
+                {
+                this.state = 3533;
+                this.pipelined_using_clause();
+                }
+                break;
+            case PlSqlParser.SQL_MACRO:
+                {
+                this.state = 3534;
+                this.sql_macro_body();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_macro_body(): Sql_macro_bodyContext {
+        let localContext = new Sql_macro_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 112, PlSqlParser.RULE_sql_macro_body);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3537;
+            this.match(PlSqlParser.SQL_MACRO);
+            this.state = 3538;
+            this.match(PlSqlParser.IS);
+            this.state = 3539;
+            this.match(PlSqlParser.BEGIN);
+            this.state = 3540;
+            this.match(PlSqlParser.RETURN);
+            this.state = 3541;
+            this.quoted_string();
+            this.state = 3542;
+            this.match(PlSqlParser.SEMICOLON);
+            this.state = 3543;
+            this.match(PlSqlParser.END);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parallel_enable_clause(): Parallel_enable_clauseContext {
+        let localContext = new Parallel_enable_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 114, PlSqlParser.RULE_parallel_enable_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3545;
+            this.match(PlSqlParser.PARALLEL_ENABLE);
+            this.state = 3547;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 3546;
+                this.partition_by_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_by_clause(): Partition_by_clauseContext {
+        let localContext = new Partition_by_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 116, PlSqlParser.RULE_partition_by_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3549;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 3550;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 3551;
+            this.expression();
+            this.state = 3552;
+            this.match(PlSqlParser.BY);
+            this.state = 3556;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ANY:
+                {
+                this.state = 3553;
+                this.match(PlSqlParser.ANY);
+                }
+                break;
+            case PlSqlParser.HASH:
+            case PlSqlParser.LIST:
+            case PlSqlParser.RANGE:
+                {
+                this.state = 3554;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 661 || _la === 863 || _la === 1497)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3555;
+                this.paren_column_list();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 3559;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 220 || _la === 1305) {
+                {
+                this.state = 3558;
+                this.streaming_clause();
+                }
+            }
+
+            this.state = 3561;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public result_cache_clause(): Result_cache_clauseContext {
+        let localContext = new Result_cache_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 118, PlSqlParser.RULE_result_cache_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3563;
+            this.match(PlSqlParser.RESULT_CACHE);
+            this.state = 3565;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 149, this.context) ) {
+            case 1:
+                {
+                this.state = 3564;
+                this.relies_on_part();
+                }
+                break;
+            }
+            this.state = 3571;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 150, this.context) ) {
+            case 1:
+                {
+                this.state = 3567;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3568;
+                this.match(PlSqlParser.MODE);
+                this.state = 3569;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 389 || _la === 617)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3570;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public accessible_by_clause(): Accessible_by_clauseContext {
+        let localContext = new Accessible_by_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 120, PlSqlParser.RULE_accessible_by_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3573;
+            this.match(PlSqlParser.ACCESSIBLE);
+            this.state = 3574;
+            this.match(PlSqlParser.BY);
+            this.state = 3575;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 3576;
+            this.accessor();
+            this.state = 3581;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 3577;
+                this.match(PlSqlParser.COMMA);
+                this.state = 3578;
+                this.accessor();
+                }
+                }
+                this.state = 3583;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3584;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_collation_clause(): Default_collation_clauseContext {
+        let localContext = new Default_collation_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 122, PlSqlParser.RULE_default_collation_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3586;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 3587;
+            this.match(PlSqlParser.COLLATION);
+            this.state = 3588;
+            this.match(PlSqlParser.USING_NLS_COMP);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public aggregate_clause(): Aggregate_clauseContext {
+        let localContext = new Aggregate_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 124, PlSqlParser.RULE_aggregate_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3590;
+            this.match(PlSqlParser.AGGREGATE);
+            this.state = 3591;
+            this.match(PlSqlParser.USING);
+            this.state = 3592;
+            this.implementation_type_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pipelined_using_clause(): Pipelined_using_clauseContext {
+        let localContext = new Pipelined_using_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 126, PlSqlParser.RULE_pipelined_using_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3594;
+            this.match(PlSqlParser.PIPELINED);
+            this.state = 3597;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1608 || _la === 2085) {
+                {
+                this.state = 3595;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1608 || _la === 2085)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3596;
+                this.match(PlSqlParser.POLYMORPHIC);
+                }
+            }
+
+            this.state = 3599;
+            this.match(PlSqlParser.USING);
+            this.state = 3600;
+            this.implementation_type_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public accessor(): AccessorContext {
+        let localContext = new AccessorContext(this.context, this.state);
+        this.enterRule(localContext, 128, PlSqlParser.RULE_accessor);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3602;
+            localContext._unitKind = this.tokenStream.LT(1);
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 633 || _la === 1331 || _la === 1463 || _la === 2159 || _la === 2168)) {
+                localContext._unitKind = this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3603;
+            this.function_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public relies_on_part(): Relies_on_partContext {
+        let localContext = new Relies_on_partContext(this.context, this.state);
+        this.enterRule(localContext, 130, PlSqlParser.RULE_relies_on_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3605;
+            this.match(PlSqlParser.RELIES_ON);
+            this.state = 3606;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 3607;
+            this.tableview_name();
+            this.state = 3612;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 3608;
+                this.match(PlSqlParser.COMMA);
+                this.state = 3609;
+                this.tableview_name();
+                }
+                }
+                this.state = 3614;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3615;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public streaming_clause(): Streaming_clauseContext {
+        let localContext = new Streaming_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 132, PlSqlParser.RULE_streaming_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3617;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 220 || _la === 1305)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3618;
+            this.expression();
+            this.state = 3619;
+            this.match(PlSqlParser.BY);
+            this.state = 3620;
+            this.paren_column_list();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_outline(): Alter_outlineContext {
+        let localContext = new Alter_outlineContext(this.context, this.state);
+        this.enterRule(localContext, 134, PlSqlParser.RULE_alter_outline);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3622;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3623;
+            this.match(PlSqlParser.OUTLINE);
+            this.state = 3625;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 154, this.context) ) {
+            case 1:
+                {
+                this.state = 3624;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1457 || _la === 1475)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 3627;
+            localContext._o = this.id_expression();
+            this.state = 3629;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 3628;
+                    this.outline_options();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 3631;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 155, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public outline_options(): Outline_optionsContext {
+        let localContext = new Outline_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 136, PlSqlParser.RULE_outline_options);
+        try {
+            this.state = 3643;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.REBUILD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3633;
+                this.match(PlSqlParser.REBUILD);
+                }
+                break;
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3634;
+                this.match(PlSqlParser.RENAME);
+                this.state = 3635;
+                this.match(PlSqlParser.TO);
+                this.state = 3636;
+                localContext._non = this.id_expression();
+                }
+                break;
+            case PlSqlParser.CHANGE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3637;
+                this.match(PlSqlParser.CHANGE);
+                this.state = 3638;
+                this.match(PlSqlParser.CATEGORY);
+                this.state = 3639;
+                this.match(PlSqlParser.TO);
+                this.state = 3640;
+                localContext._ncn = this.id_expression();
+                }
+                break;
+            case PlSqlParser.ENABLE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 3641;
+                this.match(PlSqlParser.ENABLE);
+                }
+                break;
+            case PlSqlParser.DISABLE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 3642;
+                this.match(PlSqlParser.DISABLE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_lockdown_profile(): Alter_lockdown_profileContext {
+        let localContext = new Alter_lockdown_profileContext(this.context, this.state);
+        this.enterRule(localContext, 138, PlSqlParser.RULE_alter_lockdown_profile);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3645;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3646;
+            this.match(PlSqlParser.LOCKDOWN);
+            this.state = 3647;
+            this.match(PlSqlParser.PROFILE);
+            this.state = 3648;
+            this.id_expression();
+            this.state = 3652;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 157, this.context) ) {
+            case 1:
+                {
+                this.state = 3649;
+                this.lockdown_feature();
+                }
+                break;
+            case 2:
+                {
+                this.state = 3650;
+                this.lockdown_options();
+                }
+                break;
+            case 3:
+                {
+                this.state = 3651;
+                this.lockdown_statements();
+                }
+                break;
+            }
+            this.state = 3657;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 158, this.context) ) {
+            case 1:
+                {
+                this.state = 3654;
+                this.match(PlSqlParser.USERS);
+                this.state = 3655;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3656;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 38 || _la === 244 || _la === 874)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lockdown_feature(): Lockdown_featureContext {
+        let localContext = new Lockdown_featureContext(this.context, this.state);
+        this.enterRule(localContext, 140, PlSqlParser.RULE_lockdown_feature);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3659;
+            this.disable_enable();
+            this.state = 3660;
+            this.match(PlSqlParser.FEATURE);
+            this.state = 3675;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.EQUALS_OP:
+                {
+                this.state = 3661;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3662;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3663;
+                this.string_list();
+                this.state = 3664;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 3666;
+                this.match(PlSqlParser.ALL);
+                this.state = 3673;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 159, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3667;
+                    this.match(PlSqlParser.EXCEPT);
+                    this.state = 3668;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 3669;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 3670;
+                    this.string_list();
+                    this.state = 3671;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lockdown_options(): Lockdown_optionsContext {
+        let localContext = new Lockdown_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 142, PlSqlParser.RULE_lockdown_options);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3677;
+            this.disable_enable();
+            this.state = 3678;
+            this.match(PlSqlParser.OPTION);
+            this.state = 3693;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.EQUALS_OP:
+                {
+                this.state = 3679;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3680;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3681;
+                this.string_list();
+                this.state = 3682;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 3684;
+                this.match(PlSqlParser.ALL);
+                this.state = 3691;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 161, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3685;
+                    this.match(PlSqlParser.EXCEPT);
+                    this.state = 3686;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 3687;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 3688;
+                    this.string_list();
+                    this.state = 3689;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lockdown_statements(): Lockdown_statementsContext {
+        let localContext = new Lockdown_statementsContext(this.context, this.state);
+        this.enterRule(localContext, 144, PlSqlParser.RULE_lockdown_statements);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3695;
+            this.disable_enable();
+            this.state = 3696;
+            this.match(PlSqlParser.STATEMENT);
+            this.state = 3716;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 164, this.context) ) {
+            case 1:
+                {
+                this.state = 3697;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3698;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3699;
+                this.string_list();
+                this.state = 3700;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 3702;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3703;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3704;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3705;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 3706;
+                this.statement_clauses();
+                }
+                break;
+            case 3:
+                {
+                this.state = 3707;
+                this.match(PlSqlParser.ALL);
+                this.state = 3714;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 163, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3708;
+                    this.match(PlSqlParser.EXCEPT);
+                    this.state = 3709;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 3710;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 3711;
+                    this.string_list();
+                    this.state = 3712;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public statement_clauses(): Statement_clausesContext {
+        let localContext = new Statement_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 146, PlSqlParser.RULE_statement_clauses);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3718;
+            this.match(PlSqlParser.CLAUSE);
+            this.state = 3738;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 166, this.context) ) {
+            case 1:
+                {
+                this.state = 3719;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3720;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3721;
+                this.string_list();
+                this.state = 3722;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 3724;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3725;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3726;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3727;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 3728;
+                this.clause_options();
+                }
+                break;
+            case 3:
+                {
+                this.state = 3729;
+                this.match(PlSqlParser.ALL);
+                this.state = 3736;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 165, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3730;
+                    this.match(PlSqlParser.EXCEPT);
+                    this.state = 3731;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 3732;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 3733;
+                    this.string_list();
+                    this.state = 3734;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public clause_options(): Clause_optionsContext {
+        let localContext = new Clause_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 148, PlSqlParser.RULE_clause_options);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3740;
+            this.match(PlSqlParser.OPTION);
+            this.state = 3764;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 169, this.context) ) {
+            case 1:
+                {
+                this.state = 3741;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3742;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3743;
+                this.string_list();
+                this.state = 3744;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 3746;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3747;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3748;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 3749;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 3751;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 3750;
+                        this.option_values();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 3753;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 167, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 3:
+                {
+                this.state = 3755;
+                this.match(PlSqlParser.ALL);
+                this.state = 3762;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 168, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3756;
+                    this.match(PlSqlParser.EXCEPT);
+                    this.state = 3757;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 3758;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 3759;
+                    this.string_list();
+                    this.state = 3760;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public option_values(): Option_valuesContext {
+        let localContext = new Option_valuesContext(this.context, this.state);
+        this.enterRule(localContext, 150, PlSqlParser.RULE_option_values);
+        let _la: number;
+        try {
+            this.state = 3775;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VALUE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3766;
+                this.match(PlSqlParser.VALUE);
+                this.state = 3767;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3768;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3769;
+                this.string_list();
+                this.state = 3770;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MINVALUE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3772;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 933 || _la === 961)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 3773;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 3774;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public string_list(): String_listContext {
+        let localContext = new String_listContext(this.context, this.state);
+        this.enterRule(localContext, 152, PlSqlParser.RULE_string_list);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3777;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 3782;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 3778;
+                this.match(PlSqlParser.COMMA);
+                this.state = 3779;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                }
+                this.state = 3784;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public disable_enable(): Disable_enableContext {
+        let localContext = new Disable_enableContext(this.context, this.state);
+        this.enterRule(localContext, 154, PlSqlParser.RULE_disable_enable);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3785;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 429 || _la === 499)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_lockdown_profile(): Drop_lockdown_profileContext {
+        let localContext = new Drop_lockdown_profileContext(this.context, this.state);
+        this.enterRule(localContext, 156, PlSqlParser.RULE_drop_lockdown_profile);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3787;
+            this.match(PlSqlParser.DROP);
+            this.state = 3788;
+            this.match(PlSqlParser.LOCKDOWN);
+            this.state = 3789;
+            this.match(PlSqlParser.PROFILE);
+            this.state = 3790;
+            localContext._p = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_package(): Drop_packageContext {
+        let localContext = new Drop_packageContext(this.context, this.state);
+        this.enterRule(localContext, 158, PlSqlParser.RULE_drop_package);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3792;
+            this.match(PlSqlParser.DROP);
+            this.state = 3793;
+            this.match(PlSqlParser.PACKAGE);
+            this.state = 3795;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 172, this.context) ) {
+            case 1:
+                {
+                this.state = 3794;
+                this.match(PlSqlParser.BODY);
+                }
+                break;
+            }
+            this.state = 3800;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 173, this.context) ) {
+            case 1:
+                {
+                this.state = 3797;
+                this.schema_object_name();
+                this.state = 3798;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 3802;
+            this.package_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_package(): Alter_packageContext {
+        let localContext = new Alter_packageContext(this.context, this.state);
+        this.enterRule(localContext, 160, PlSqlParser.RULE_alter_package);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3804;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3805;
+            this.match(PlSqlParser.PACKAGE);
+            this.state = 3806;
+            this.package_name();
+            this.state = 3807;
+            this.match(PlSqlParser.COMPILE);
+            this.state = 3809;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 174, this.context) ) {
+            case 1:
+                {
+                this.state = 3808;
+                this.match(PlSqlParser.DEBUG);
+                }
+                break;
+            }
+            this.state = 3812;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 175, this.context) ) {
+            case 1:
+                {
+                this.state = 3811;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 147 || _la === 1331 || _la === 1717)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 3817;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 176, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 3814;
+                    this.compiler_parameters_clause();
+                    }
+                    }
+                }
+                this.state = 3819;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 176, this.context);
+            }
+            this.state = 3822;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 177, this.context) ) {
+            case 1:
+                {
+                this.state = 3820;
+                this.match(PlSqlParser.REUSE);
+                this.state = 3821;
+                this.match(PlSqlParser.SETTINGS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_package(): Create_packageContext {
+        let localContext = new Create_packageContext(this.context, this.state);
+        this.enterRule(localContext, 162, PlSqlParser.RULE_create_package);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3824;
+            this.match(PlSqlParser.CREATE);
+            this.state = 3827;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 3825;
+                this.match(PlSqlParser.OR);
+                this.state = 3826;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 3830;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 3829;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 3832;
+            this.match(PlSqlParser.PACKAGE);
+            this.state = 3836;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 180, this.context) ) {
+            case 1:
+                {
+                this.state = 3833;
+                this.schema_object_name();
+                this.state = 3834;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 3838;
+            this.package_name();
+            this.state = 3840;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 88) {
+                {
+                this.state = 3839;
+                this.invoker_rights_clause();
+                }
+            }
+
+            this.state = 3842;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3846;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                {
+                this.state = 3843;
+                this.package_obj_spec();
+                }
+                }
+                this.state = 3848;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3849;
+            this.match(PlSqlParser.END);
+            this.state = 3851;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 183, this.context) ) {
+            case 1:
+                {
+                this.state = 3850;
+                this.package_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_package_body(): Create_package_bodyContext {
+        let localContext = new Create_package_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 164, PlSqlParser.RULE_create_package_body);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3853;
+            this.match(PlSqlParser.CREATE);
+            this.state = 3856;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 3854;
+                this.match(PlSqlParser.OR);
+                this.state = 3855;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 3859;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 3858;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 3861;
+            this.match(PlSqlParser.PACKAGE);
+            this.state = 3862;
+            this.match(PlSqlParser.BODY);
+            this.state = 3866;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 186, this.context) ) {
+            case 1:
+                {
+                this.state = 3863;
+                this.schema_object_name();
+                this.state = 3864;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 3868;
+            this.package_name();
+            this.state = 3869;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 3873;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 187, this.context);
+            while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1 + 1) {
+                    {
+                    {
+                    this.state = 3870;
+                    this.package_obj_body();
+                    }
+                    }
+                }
+                this.state = 3875;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 187, this.context);
+            }
+            this.state = 3886;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 113) {
+                {
+                this.state = 3876;
+                this.match(PlSqlParser.BEGIN);
+                this.state = 3877;
+                this.seq_of_statements();
+                this.state = 3884;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 535) {
+                    {
+                    this.state = 3878;
+                    this.match(PlSqlParser.EXCEPTION);
+                    this.state = 3880;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    do {
+                        {
+                        {
+                        this.state = 3879;
+                        this.exception_handler();
+                        }
+                        }
+                        this.state = 3882;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    } while (_la === 2302);
+                    }
+                }
+
+                }
+            }
+
+            this.state = 3888;
+            this.match(PlSqlParser.END);
+            this.state = 3890;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 191, this.context) ) {
+            case 1:
+                {
+                this.state = 3889;
+                this.package_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public package_obj_spec(): Package_obj_specContext {
+        let localContext = new Package_obj_specContext(this.context, this.state);
+        this.enterRule(localContext, 166, PlSqlParser.RULE_package_obj_spec);
+        try {
+            this.state = 3900;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 192, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3892;
+                this.pragma_declaration();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3893;
+                this.exception_declaration();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3894;
+                this.procedure_spec();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 3895;
+                this.function_spec();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 3896;
+                this.variable_declaration();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 3897;
+                this.subtype_declaration();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 3898;
+                this.cursor_declaration();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 3899;
+                this.type_declaration();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public procedure_spec(): Procedure_specContext {
+        let localContext = new Procedure_specContext(this.context, this.state);
+        this.enterRule(localContext, 168, PlSqlParser.RULE_procedure_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3902;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 3903;
+            this.identifier();
+            this.state = 3915;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 3904;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3905;
+                this.parameter();
+                this.state = 3910;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 3906;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 3907;
+                    this.parameter();
+                    }
+                    }
+                    this.state = 3912;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 3913;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 3922;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 6 || _la === 420 || _la === 1333) {
+                {
+                this.state = 3920;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ACCESSIBLE:
+                    {
+                    this.state = 3917;
+                    this.accessible_by_clause();
+                    }
+                    break;
+                case PlSqlParser.PARALLEL_ENABLE:
+                    {
+                    this.state = 3918;
+                    this.match(PlSqlParser.PARALLEL_ENABLE);
+                    }
+                    break;
+                case PlSqlParser.DETERMINISTIC:
+                    {
+                    this.state = 3919;
+                    this.match(PlSqlParser.DETERMINISTIC);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 3924;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3927;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 69) {
+                {
+                this.state = 3925;
+                this.match(PlSqlParser.AS);
+                this.state = 3926;
+                this.call_spec();
+                }
+            }
+
+            this.state = 3929;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_spec(): Function_specContext {
+        let localContext = new Function_specContext(this.context, this.state);
+        this.enterRule(localContext, 170, PlSqlParser.RULE_function_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3931;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 3932;
+            this.identifier();
+            this.state = 3944;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 3933;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 3934;
+                this.parameter();
+                this.state = 3939;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 3935;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 3936;
+                    this.parameter();
+                    }
+                    }
+                    this.state = 3941;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 3942;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 3946;
+            this.match(PlSqlParser.RETURN);
+            this.state = 3947;
+            this.type_spec();
+            this.state = 3955;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 220 || _la === 420 || _la === 1305 || _la === 1333 || _la === 1396 || _la === 1581) {
+                {
+                this.state = 3953;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DETERMINISTIC:
+                    {
+                    this.state = 3948;
+                    this.match(PlSqlParser.DETERMINISTIC);
+                    }
+                    break;
+                case PlSqlParser.PIPELINED:
+                    {
+                    this.state = 3949;
+                    this.match(PlSqlParser.PIPELINED);
+                    }
+                    break;
+                case PlSqlParser.PARALLEL_ENABLE:
+                    {
+                    this.state = 3950;
+                    this.parallel_enable_clause();
+                    }
+                    break;
+                case PlSqlParser.RESULT_CACHE:
+                    {
+                    this.state = 3951;
+                    this.match(PlSqlParser.RESULT_CACHE);
+                    }
+                    break;
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.ORDER:
+                    {
+                    this.state = 3952;
+                    this.streaming_clause();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 3957;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 3960;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 69) {
+                {
+                this.state = 3958;
+                this.match(PlSqlParser.AS);
+                this.state = 3959;
+                this.call_spec();
+                }
+            }
+
+            this.state = 3962;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public package_obj_body(): Package_obj_bodyContext {
+        let localContext = new Package_obj_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 172, PlSqlParser.RULE_package_obj_body);
+        try {
+            this.state = 3975;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 203, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 3964;
+                this.pragma_declaration();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 3965;
+                this.exception_declaration();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 3966;
+                this.procedure_spec();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 3967;
+                this.function_spec();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 3968;
+                this.subtype_declaration();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 3969;
+                this.cursor_declaration();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 3970;
+                this.variable_declaration();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 3971;
+                this.type_declaration();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 3972;
+                this.procedure_body();
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 3973;
+                this.function_body();
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 3974;
+                this.selection_directive();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_pmem_filestore(): Alter_pmem_filestoreContext {
+        let localContext = new Alter_pmem_filestoreContext(this.context, this.state);
+        this.enterRule(localContext, 174, PlSqlParser.RULE_alter_pmem_filestore);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3977;
+            this.match(PlSqlParser.ALTER);
+            this.state = 3978;
+            this.match(PlSqlParser.PMEM);
+            this.state = 3979;
+            this.match(PlSqlParser.FILESTORE);
+            this.state = 3980;
+            localContext._fsn = this.id_expression();
+            this.state = 3997;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RESIZE:
+                {
+                this.state = 3981;
+                this.match(PlSqlParser.RESIZE);
+                this.state = 3982;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.AUTOEXTEND:
+                {
+                this.state = 3983;
+                this.autoextend_clause();
+                }
+                break;
+            case PlSqlParser.MOUNT:
+                {
+                this.state = 3984;
+                this.match(PlSqlParser.MOUNT);
+                this.state = 3987;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 204, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3985;
+                    this.match(PlSqlParser.MOUNTPOINT);
+                    this.state = 3986;
+                    this.file_path();
+                    }
+                    break;
+                }
+                this.state = 3991;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 205, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3989;
+                    this.match(PlSqlParser.BACKINGFILE);
+                    this.state = 3990;
+                    this.filename();
+                    }
+                    break;
+                }
+                this.state = 3994;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 206, this.context) ) {
+                case 1:
+                    {
+                    this.state = 3993;
+                    this.match(PlSqlParser.FORCE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.DISMOUNT:
+                {
+                this.state = 3996;
+                this.match(PlSqlParser.DISMOUNT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_pmem_filestore(): Drop_pmem_filestoreContext {
+        let localContext = new Drop_pmem_filestoreContext(this.context, this.state);
+        this.enterRule(localContext, 176, PlSqlParser.RULE_drop_pmem_filestore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 3999;
+            this.match(PlSqlParser.DROP);
+            this.state = 4000;
+            this.match(PlSqlParser.PMEM);
+            this.state = 4001;
+            this.match(PlSqlParser.FILESTORE);
+            this.state = 4002;
+            localContext._fsn = this.id_expression();
+            this.state = 4011;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 210, this.context) ) {
+            case 1:
+                {
+                this.state = 4008;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.FORCE:
+                case PlSqlParser.INCLUDING:
+                    {
+                    this.state = 4004;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 617) {
+                        {
+                        this.state = 4003;
+                        this.match(PlSqlParser.FORCE);
+                        }
+                    }
+
+                    this.state = 4006;
+                    this.match(PlSqlParser.INCLUDING);
+                    }
+                    break;
+                case PlSqlParser.EXCLUDING:
+                    {
+                    this.state = 4007;
+                    this.match(PlSqlParser.EXCLUDING);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 4010;
+                this.match(PlSqlParser.CONTENTS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_procedure(): Drop_procedureContext {
+        let localContext = new Drop_procedureContext(this.context, this.state);
+        this.enterRule(localContext, 178, PlSqlParser.RULE_drop_procedure);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4013;
+            this.match(PlSqlParser.DROP);
+            this.state = 4014;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4015;
+            this.procedure_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_procedure(): Alter_procedureContext {
+        let localContext = new Alter_procedureContext(this.context, this.state);
+        this.enterRule(localContext, 180, PlSqlParser.RULE_alter_procedure);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4017;
+            this.match(PlSqlParser.ALTER);
+            this.state = 4018;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4019;
+            this.procedure_name();
+            this.state = 4020;
+            this.match(PlSqlParser.COMPILE);
+            this.state = 4022;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) {
+            case 1:
+                {
+                this.state = 4021;
+                this.match(PlSqlParser.DEBUG);
+                }
+                break;
+            }
+            this.state = 4027;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 212, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 4024;
+                    this.compiler_parameters_clause();
+                    }
+                    }
+                }
+                this.state = 4029;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 212, this.context);
+            }
+            this.state = 4032;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 213, this.context) ) {
+            case 1:
+                {
+                this.state = 4030;
+                this.match(PlSqlParser.REUSE);
+                this.state = 4031;
+                this.match(PlSqlParser.SETTINGS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_body(): Function_bodyContext {
+        let localContext = new Function_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 182, PlSqlParser.RULE_function_body);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4034;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 4035;
+            this.identifier();
+            this.state = 4047;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4036;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4037;
+                this.parameter();
+                this.state = 4042;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4038;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4039;
+                    this.parameter();
+                    }
+                    }
+                    this.state = 4044;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4045;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4049;
+            this.match(PlSqlParser.RETURN);
+            this.state = 4050;
+            this.type_spec();
+            this.state = 4059;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 217, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 4057;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.PIPELINED:
+                        {
+                        this.state = 4051;
+                        this.match(PlSqlParser.PIPELINED);
+                        }
+                        break;
+                    case PlSqlParser.DETERMINISTIC:
+                        {
+                        this.state = 4052;
+                        this.match(PlSqlParser.DETERMINISTIC);
+                        }
+                        break;
+                    case PlSqlParser.AUTHID:
+                        {
+                        this.state = 4053;
+                        this.invoker_rights_clause();
+                        }
+                        break;
+                    case PlSqlParser.PARALLEL_ENABLE:
+                        {
+                        this.state = 4054;
+                        this.parallel_enable_clause();
+                        }
+                        break;
+                    case PlSqlParser.RESULT_CACHE:
+                        {
+                        this.state = 4055;
+                        this.result_cache_clause();
+                        }
+                        break;
+                    case PlSqlParser.CLUSTER:
+                    case PlSqlParser.ORDER:
+                        {
+                        this.state = 4056;
+                        this.streaming_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 4061;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 217, this.context);
+            }
+            this.state = 4076;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.AS:
+            case PlSqlParser.IS:
+                {
+                {
+                this.state = 4062;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 69 || _la === 786)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 4071;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 220, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4064;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 218, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 4063;
+                        this.match(PlSqlParser.DECLARE);
+                        }
+                        break;
+                    }
+                    this.state = 4067;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 219, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 4066;
+                        this.seq_of_declare_specs();
+                        }
+                        break;
+                    }
+                    this.state = 4069;
+                    this.body();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 4070;
+                    this.call_spec();
+                    }
+                    break;
+                }
+                }
+                }
+                break;
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.PIPELINED:
+                {
+                this.state = 4073;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 35 || _la === 1396)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 4074;
+                this.match(PlSqlParser.USING);
+                this.state = 4075;
+                this.implementation_type_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 4078;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public procedure_body(): Procedure_bodyContext {
+        let localContext = new Procedure_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 184, PlSqlParser.RULE_procedure_body);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4080;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4081;
+            this.identifier();
+            this.state = 4093;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4082;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4083;
+                this.parameter();
+                this.state = 4088;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4084;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4085;
+                    this.parameter();
+                    }
+                    }
+                    this.state = 4090;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4091;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4100;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 6 || _la === 420 || _la === 1333) {
+                {
+                this.state = 4098;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ACCESSIBLE:
+                    {
+                    this.state = 4095;
+                    this.accessible_by_clause();
+                    }
+                    break;
+                case PlSqlParser.PARALLEL_ENABLE:
+                    {
+                    this.state = 4096;
+                    this.match(PlSqlParser.PARALLEL_ENABLE);
+                    }
+                    break;
+                case PlSqlParser.DETERMINISTIC:
+                    {
+                    this.state = 4097;
+                    this.match(PlSqlParser.DETERMINISTIC);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 4102;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 4103;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4113;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 228, this.context) ) {
+            case 1:
+                {
+                this.state = 4105;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 226, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4104;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4108;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 227, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4107;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4110;
+                this.body();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4111;
+                this.call_spec();
+                }
+                break;
+            case 3:
+                {
+                this.state = 4112;
+                this.match(PlSqlParser.EXTERNAL);
+                }
+                break;
+            }
+            this.state = 4115;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_procedure_body(): Create_procedure_bodyContext {
+        let localContext = new Create_procedure_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 186, PlSqlParser.RULE_create_procedure_body);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4117;
+            this.match(PlSqlParser.CREATE);
+            this.state = 4120;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 4118;
+                this.match(PlSqlParser.OR);
+                this.state = 4119;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 4123;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 4122;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 4125;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4126;
+            this.procedure_name();
+            this.state = 4138;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4127;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4128;
+                this.parameter();
+                this.state = 4133;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4129;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4130;
+                    this.parameter();
+                    }
+                    }
+                    this.state = 4135;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4136;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4141;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 88) {
+                {
+                this.state = 4140;
+                this.invoker_rights_clause();
+                }
+            }
+
+            this.state = 4146;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 420 || _la === 1333) {
+                {
+                {
+                this.state = 4143;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 420 || _la === 1333)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                }
+                this.state = 4148;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 4149;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4159;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 237, this.context) ) {
+            case 1:
+                {
+                this.state = 4151;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 235, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4150;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4154;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 236, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4153;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4156;
+                this.body();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4157;
+                this.call_spec();
+                }
+                break;
+            case 3:
+                {
+                this.state = 4158;
+                this.match(PlSqlParser.EXTERNAL);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_resource_cost(): Alter_resource_costContext {
+        let localContext = new Alter_resource_costContext(this.context, this.state);
+        this.enterRule(localContext, 188, PlSqlParser.RULE_alter_resource_cost);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4161;
+            this.match(PlSqlParser.ALTER);
+            this.state = 4162;
+            this.match(PlSqlParser.RESOURCE);
+            this.state = 4163;
+            this.match(PlSqlParser.COST);
+            this.state = 4166;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 4164;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 281 || _la === 319 || _la === 888 || _la === 1458)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 4165;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 4168;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 238, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_outline(): Drop_outlineContext {
+        let localContext = new Drop_outlineContext(this.context, this.state);
+        this.enterRule(localContext, 190, PlSqlParser.RULE_drop_outline);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4170;
+            this.match(PlSqlParser.DROP);
+            this.state = 4171;
+            this.match(PlSqlParser.OUTLINE);
+            this.state = 4172;
+            localContext._o = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_rollback_segment(): Alter_rollback_segmentContext {
+        let localContext = new Alter_rollback_segmentContext(this.context, this.state);
+        this.enterRule(localContext, 192, PlSqlParser.RULE_alter_rollback_segment);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4174;
+            this.match(PlSqlParser.ALTER);
+            this.state = 4175;
+            this.match(PlSqlParser.ROLLBACK);
+            this.state = 4176;
+            this.match(PlSqlParser.SEGMENT);
+            this.state = 4177;
+            this.rollback_segment_name();
+            this.state = 4186;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ONLINE:
+                {
+                this.state = 4178;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            case PlSqlParser.OFFLINE:
+                {
+                this.state = 4179;
+                this.match(PlSqlParser.OFFLINE);
+                }
+                break;
+            case PlSqlParser.STORAGE:
+                {
+                this.state = 4180;
+                this.storage_clause();
+                }
+                break;
+            case PlSqlParser.SHRINK:
+                {
+                this.state = 4181;
+                this.match(PlSqlParser.SHRINK);
+                this.state = 4184;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 239, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4182;
+                    this.match(PlSqlParser.TO);
+                    this.state = 4183;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_restore_point(): Drop_restore_pointContext {
+        let localContext = new Drop_restore_pointContext(this.context, this.state);
+        this.enterRule(localContext, 194, PlSqlParser.RULE_drop_restore_point);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4188;
+            this.match(PlSqlParser.DROP);
+            this.state = 4189;
+            this.match(PlSqlParser.RESTORE);
+            this.state = 4190;
+            this.match(PlSqlParser.POINT);
+            this.state = 4191;
+            localContext._rp = this.id_expression();
+            this.state = 4196;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) {
+            case 1:
+                {
+                this.state = 4192;
+                this.match(PlSqlParser.FOR);
+                this.state = 4193;
+                this.match(PlSqlParser.PLUGGABLE);
+                this.state = 4194;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 4195;
+                localContext._pdb = this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_rollback_segment(): Drop_rollback_segmentContext {
+        let localContext = new Drop_rollback_segmentContext(this.context, this.state);
+        this.enterRule(localContext, 196, PlSqlParser.RULE_drop_rollback_segment);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4198;
+            this.match(PlSqlParser.DROP);
+            this.state = 4199;
+            this.match(PlSqlParser.ROLLBACK);
+            this.state = 4200;
+            this.match(PlSqlParser.SEGMENT);
+            this.state = 4201;
+            this.rollback_segment_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_role(): Drop_roleContext {
+        let localContext = new Drop_roleContext(this.context, this.state);
+        this.enterRule(localContext, 198, PlSqlParser.RULE_drop_role);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4203;
+            this.match(PlSqlParser.DROP);
+            this.state = 4204;
+            this.match(PlSqlParser.ROLE);
+            this.state = 4205;
+            this.role_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_pmem_filestore(): Create_pmem_filestoreContext {
+        let localContext = new Create_pmem_filestoreContext(this.context, this.state);
+        this.enterRule(localContext, 200, PlSqlParser.RULE_create_pmem_filestore);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4207;
+            this.match(PlSqlParser.CREATE);
+            this.state = 4208;
+            this.match(PlSqlParser.PMEM);
+            this.state = 4209;
+            this.match(PlSqlParser.FILESTORE);
+            this.state = 4210;
+            localContext._fsn = this.id_expression();
+            this.state = 4212;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 4211;
+                    this.pmem_filestore_options();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 4214;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 242, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pmem_filestore_options(): Pmem_filestore_optionsContext {
+        let localContext = new Pmem_filestore_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 202, PlSqlParser.RULE_pmem_filestore_options);
+        let _la: number;
+        try {
+            this.state = 4226;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MOUNTPOINT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4216;
+                this.match(PlSqlParser.MOUNTPOINT);
+                this.state = 4217;
+                this.file_path();
+                }
+                break;
+            case PlSqlParser.BACKINGFILE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4218;
+                this.match(PlSqlParser.BACKINGFILE);
+                this.state = 4219;
+                this.filename();
+                this.state = 4221;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 243, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4220;
+                    this.match(PlSqlParser.REUSE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.SIZE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 4223;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 146 || _la === 1701)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 4224;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.AUTOEXTEND:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 4225;
+                this.autoextend_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public file_path(): File_pathContext {
+        let localContext = new File_pathContext(this.context, this.state);
+        this.enterRule(localContext, 204, PlSqlParser.RULE_file_path);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4228;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_rollback_segment(): Create_rollback_segmentContext {
+        let localContext = new Create_rollback_segmentContext(this.context, this.state);
+        this.enterRule(localContext, 206, PlSqlParser.RULE_create_rollback_segment);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4230;
+            this.match(PlSqlParser.CREATE);
+            this.state = 4232;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1475) {
+                {
+                this.state = 4231;
+                this.match(PlSqlParser.PUBLIC);
+                }
+            }
+
+            this.state = 4234;
+            this.match(PlSqlParser.ROLLBACK);
+            this.state = 4235;
+            this.match(PlSqlParser.SEGMENT);
+            this.state = 4236;
+            this.rollback_segment_name();
+            this.state = 4242;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 247, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 4240;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.TABLESPACE:
+                        {
+                        this.state = 4237;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 4238;
+                        this.tablespace();
+                        }
+                        break;
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 4239;
+                        this.storage_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 4244;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 247, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_trigger(): Drop_triggerContext {
+        let localContext = new Drop_triggerContext(this.context, this.state);
+        this.enterRule(localContext, 208, PlSqlParser.RULE_drop_trigger);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4245;
+            this.match(PlSqlParser.DROP);
+            this.state = 4246;
+            this.match(PlSqlParser.TRIGGER);
+            this.state = 4247;
+            this.trigger_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_trigger(): Alter_triggerContext {
+        let localContext = new Alter_triggerContext(this.context, this.state);
+        this.enterRule(localContext, 210, PlSqlParser.RULE_alter_trigger);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4249;
+            this.match(PlSqlParser.ALTER);
+            this.state = 4250;
+            this.match(PlSqlParser.TRIGGER);
+            this.state = 4251;
+            localContext._alter_trigger_name = this.trigger_name();
+            this.state = 4270;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+                {
+                this.state = 4252;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.RENAME:
+                {
+                this.state = 4253;
+                this.match(PlSqlParser.RENAME);
+                this.state = 4254;
+                this.match(PlSqlParser.TO);
+                this.state = 4255;
+                localContext._rename_trigger_name = this.trigger_name();
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 4256;
+                this.match(PlSqlParser.COMPILE);
+                this.state = 4258;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 248, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4257;
+                    this.match(PlSqlParser.DEBUG);
+                    }
+                    break;
+                }
+                this.state = 4263;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 249, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 4260;
+                        this.compiler_parameters_clause();
+                        }
+                        }
+                    }
+                    this.state = 4265;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 249, this.context);
+                }
+                this.state = 4268;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 250, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4266;
+                    this.match(PlSqlParser.REUSE);
+                    this.state = 4267;
+                    this.match(PlSqlParser.SETTINGS);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_trigger(): Create_triggerContext {
+        let localContext = new Create_triggerContext(this.context, this.state);
+        this.enterRule(localContext, 212, PlSqlParser.RULE_create_trigger);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4272;
+            this.match(PlSqlParser.CREATE);
+            this.state = 4275;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 4273;
+                this.match(PlSqlParser.OR);
+                this.state = 4274;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 4278;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 4277;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 4280;
+            this.match(PlSqlParser.TRIGGER);
+            this.state = 4281;
+            this.trigger_name();
+            this.state = 4285;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 254, this.context) ) {
+            case 1:
+                {
+                this.state = 4282;
+                this.simple_dml_trigger();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4283;
+                this.compound_dml_trigger();
+                }
+                break;
+            case 3:
+                {
+                this.state = 4284;
+                this.non_dml_trigger();
+                }
+                break;
+            }
+            this.state = 4288;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 615) {
+                {
+                this.state = 4287;
+                this.trigger_follows_clause();
+                }
+            }
+
+            this.state = 4291;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 429 || _la === 499) {
+                {
+                this.state = 4290;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 4294;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2302) {
+                {
+                this.state = 4293;
+                this.trigger_when_clause();
+                }
+            }
+
+            this.state = 4296;
+            this.trigger_body();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public trigger_follows_clause(): Trigger_follows_clauseContext {
+        let localContext = new Trigger_follows_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 214, PlSqlParser.RULE_trigger_follows_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4298;
+            this.match(PlSqlParser.FOLLOWS);
+            this.state = 4299;
+            this.trigger_name();
+            this.state = 4304;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 4300;
+                this.match(PlSqlParser.COMMA);
+                this.state = 4301;
+                this.trigger_name();
+                }
+                }
+                this.state = 4306;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public trigger_when_clause(): Trigger_when_clauseContext {
+        let localContext = new Trigger_when_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 216, PlSqlParser.RULE_trigger_when_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4307;
+            this.match(PlSqlParser.WHEN);
+            this.state = 4308;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 4309;
+            this.condition();
+            this.state = 4310;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public simple_dml_trigger(): Simple_dml_triggerContext {
+        let localContext = new Simple_dml_triggerContext(this.context, this.state);
+        this.enterRule(localContext, 218, PlSqlParser.RULE_simple_dml_trigger);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4316;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.BEFORE:
+                {
+                this.state = 4312;
+                this.match(PlSqlParser.BEFORE);
+                }
+                break;
+            case PlSqlParser.AFTER:
+                {
+                this.state = 4313;
+                this.match(PlSqlParser.AFTER);
+                }
+                break;
+            case PlSqlParser.INSTEAD:
+                {
+                this.state = 4314;
+                this.match(PlSqlParser.INSTEAD);
+                this.state = 4315;
+                this.match(PlSqlParser.OF);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 4318;
+            this.dml_event_clause();
+            this.state = 4320;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1530 || _la === 1531) {
+                {
+                this.state = 4319;
+                this.referencing_clause();
+                }
+            }
+
+            this.state = 4323;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 621) {
+                {
+                this.state = 4322;
+                this.for_each_row();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public for_each_row(): For_each_rowContext {
+        let localContext = new For_each_rowContext(this.context, this.state);
+        this.enterRule(localContext, 220, PlSqlParser.RULE_for_each_row);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4325;
+            this.match(PlSqlParser.FOR);
+            this.state = 4326;
+            this.match(PlSqlParser.EACH);
+            this.state = 4327;
+            this.match(PlSqlParser.ROW);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public compound_dml_trigger(): Compound_dml_triggerContext {
+        let localContext = new Compound_dml_triggerContext(this.context, this.state);
+        this.enterRule(localContext, 222, PlSqlParser.RULE_compound_dml_trigger);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4329;
+            this.match(PlSqlParser.FOR);
+            this.state = 4330;
+            this.dml_event_clause();
+            this.state = 4332;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1530 || _la === 1531) {
+                {
+                this.state = 4331;
+                this.referencing_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public non_dml_trigger(): Non_dml_triggerContext {
+        let localContext = new Non_dml_triggerContext(this.context, this.state);
+        this.enterRule(localContext, 224, PlSqlParser.RULE_non_dml_trigger);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4334;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 33 || _la === 112)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4335;
+            this.non_dml_event();
+            this.state = 4340;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 1309) {
+                {
+                {
+                this.state = 4336;
+                this.match(PlSqlParser.OR);
+                this.state = 4337;
+                this.non_dml_event();
+                }
+                }
+                this.state = 4342;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 4343;
+            this.match(PlSqlParser.ON);
+            this.state = 4351;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) {
+            case 1:
+                {
+                this.state = 4344;
+                this.match(PlSqlParser.DATABASE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 4348;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 264, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4345;
+                    this.schema_name();
+                    this.state = 4346;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 4350;
+                this.match(PlSqlParser.SCHEMA);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public trigger_body(): Trigger_bodyContext {
+        let localContext = new Trigger_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 226, PlSqlParser.RULE_trigger_body);
+        try {
+            this.state = 4357;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPOUND:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4353;
+                this.compound_trigger_block();
+                }
+                break;
+            case PlSqlParser.CALL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4354;
+                this.match(PlSqlParser.CALL);
+                this.state = 4355;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.DECLARE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 4356;
+                this.trigger_block();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public compound_trigger_block(): Compound_trigger_blockContext {
+        let localContext = new Compound_trigger_blockContext(this.context, this.state);
+        this.enterRule(localContext, 228, PlSqlParser.RULE_compound_trigger_block);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4359;
+            this.match(PlSqlParser.COMPOUND);
+            this.state = 4360;
+            this.match(PlSqlParser.TRIGGER);
+            this.state = 4362;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 267, this.context) ) {
+            case 1:
+                {
+                this.state = 4361;
+                this.seq_of_declare_specs();
+                }
+                break;
+            }
+            this.state = 4365;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 4364;
+                this.timing_point_section();
+                }
+                }
+                this.state = 4367;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 33 || _la === 112);
+            this.state = 4369;
+            this.match(PlSqlParser.END);
+            this.state = 4371;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 269, this.context) ) {
+            case 1:
+                {
+                this.state = 4370;
+                this.trigger_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public timing_point_section(): Timing_point_sectionContext {
+        let localContext = new Timing_point_sectionContext(this.context, this.state);
+        this.enterRule(localContext, 230, PlSqlParser.RULE_timing_point_section);
+        try {
+            this.state = 4409;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 270, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4373;
+                localContext._bk = this.match(PlSqlParser.BEFORE);
+                this.state = 4374;
+                this.match(PlSqlParser.STATEMENT);
+                this.state = 4375;
+                this.match(PlSqlParser.IS);
+                this.state = 4376;
+                this.tps_block();
+                this.state = 4377;
+                this.match(PlSqlParser.BEFORE);
+                this.state = 4378;
+                this.match(PlSqlParser.STATEMENT);
+                this.state = 4379;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4381;
+                localContext._bk = this.match(PlSqlParser.BEFORE);
+                this.state = 4382;
+                this.match(PlSqlParser.EACH);
+                this.state = 4383;
+                this.match(PlSqlParser.ROW);
+                this.state = 4384;
+                this.match(PlSqlParser.IS);
+                this.state = 4385;
+                this.tps_block();
+                this.state = 4386;
+                this.match(PlSqlParser.BEFORE);
+                this.state = 4387;
+                this.match(PlSqlParser.EACH);
+                this.state = 4388;
+                this.match(PlSqlParser.ROW);
+                this.state = 4389;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 4391;
+                localContext._ak = this.match(PlSqlParser.AFTER);
+                this.state = 4392;
+                this.match(PlSqlParser.STATEMENT);
+                this.state = 4393;
+                this.match(PlSqlParser.IS);
+                this.state = 4394;
+                this.tps_block();
+                this.state = 4395;
+                this.match(PlSqlParser.AFTER);
+                this.state = 4396;
+                this.match(PlSqlParser.STATEMENT);
+                this.state = 4397;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 4399;
+                localContext._ak = this.match(PlSqlParser.AFTER);
+                this.state = 4400;
+                this.match(PlSqlParser.EACH);
+                this.state = 4401;
+                this.match(PlSqlParser.ROW);
+                this.state = 4402;
+                this.match(PlSqlParser.IS);
+                this.state = 4403;
+                this.tps_block();
+                this.state = 4404;
+                this.match(PlSqlParser.AFTER);
+                this.state = 4405;
+                this.match(PlSqlParser.EACH);
+                this.state = 4406;
+                this.match(PlSqlParser.ROW);
+                this.state = 4407;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public non_dml_event(): Non_dml_eventContext {
+        let localContext = new Non_dml_eventContext(this.context, this.state);
+        this.enterRule(localContext, 232, PlSqlParser.RULE_non_dml_event);
+        try {
+            this.state = 4437;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALTER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4411;
+                this.match(PlSqlParser.ALTER);
+                }
+                break;
+            case PlSqlParser.ANALYZE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4412;
+                this.match(PlSqlParser.ANALYZE);
+                }
+                break;
+            case PlSqlParser.ASSOCIATE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 4413;
+                this.match(PlSqlParser.ASSOCIATE);
+                this.state = 4414;
+                this.match(PlSqlParser.STATISTICS);
+                }
+                break;
+            case PlSqlParser.AUDIT:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 4415;
+                this.match(PlSqlParser.AUDIT);
+                }
+                break;
+            case PlSqlParser.COMMENT:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 4416;
+                this.match(PlSqlParser.COMMENT);
+                }
+                break;
+            case PlSqlParser.CREATE:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 4417;
+                this.match(PlSqlParser.CREATE);
+                }
+                break;
+            case PlSqlParser.DISASSOCIATE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 4418;
+                this.match(PlSqlParser.DISASSOCIATE);
+                this.state = 4419;
+                this.match(PlSqlParser.STATISTICS);
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 4420;
+                this.match(PlSqlParser.DROP);
+                }
+                break;
+            case PlSqlParser.GRANT:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 4421;
+                this.match(PlSqlParser.GRANT);
+                }
+                break;
+            case PlSqlParser.NOAUDIT:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 4422;
+                this.match(PlSqlParser.NOAUDIT);
+                }
+                break;
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 4423;
+                this.match(PlSqlParser.RENAME);
+                }
+                break;
+            case PlSqlParser.REVOKE:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 4424;
+                this.match(PlSqlParser.REVOKE);
+                }
+                break;
+            case PlSqlParser.TRUNCATE:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 4425;
+                this.match(PlSqlParser.TRUNCATE);
+                }
+                break;
+            case PlSqlParser.DDL:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 4426;
+                this.match(PlSqlParser.DDL);
+                }
+                break;
+            case PlSqlParser.STARTUP:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 4427;
+                this.match(PlSqlParser.STARTUP);
+                }
+                break;
+            case PlSqlParser.SHUTDOWN:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 4428;
+                this.match(PlSqlParser.SHUTDOWN);
+                }
+                break;
+            case PlSqlParser.DB_ROLE_CHANGE:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 4429;
+                this.match(PlSqlParser.DB_ROLE_CHANGE);
+                }
+                break;
+            case PlSqlParser.LOGON:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 4430;
+                this.match(PlSqlParser.LOGON);
+                }
+                break;
+            case PlSqlParser.LOGOFF:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 4431;
+                this.match(PlSqlParser.LOGOFF);
+                }
+                break;
+            case PlSqlParser.SERVERERROR:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 4432;
+                this.match(PlSqlParser.SERVERERROR);
+                }
+                break;
+            case PlSqlParser.SUSPEND:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 4433;
+                this.match(PlSqlParser.SUSPEND);
+                }
+                break;
+            case PlSqlParser.DATABASE:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 4434;
+                this.match(PlSqlParser.DATABASE);
+                }
+                break;
+            case PlSqlParser.SCHEMA:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 4435;
+                this.match(PlSqlParser.SCHEMA);
+                }
+                break;
+            case PlSqlParser.FOLLOWS:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 4436;
+                this.match(PlSqlParser.FOLLOWS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dml_event_clause(): Dml_event_clauseContext {
+        let localContext = new Dml_event_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 234, PlSqlParser.RULE_dml_event_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4439;
+            this.dml_event_element();
+            this.state = 4444;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 1309) {
+                {
+                {
+                this.state = 4440;
+                this.match(PlSqlParser.OR);
+                this.state = 4441;
+                this.dml_event_element();
+                }
+                }
+                this.state = 4446;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 4447;
+            this.match(PlSqlParser.ON);
+            this.state = 4449;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 273, this.context) ) {
+            case 1:
+                {
+                this.state = 4448;
+                this.dml_event_nested_clause();
+                }
+                break;
+            }
+            this.state = 4451;
+            this.tableview_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dml_event_element(): Dml_event_elementContext {
+        let localContext = new Dml_event_elementContext(this.context, this.state);
+        this.enterRule(localContext, 236, PlSqlParser.RULE_dml_event_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4453;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 403 || _la === 757 || _la === 2209)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4456;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1248) {
+                {
+                this.state = 4454;
+                this.match(PlSqlParser.OF);
+                this.state = 4455;
+                this.column_list();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dml_event_nested_clause(): Dml_event_nested_clauseContext {
+        let localContext = new Dml_event_nested_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 238, PlSqlParser.RULE_dml_event_nested_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4458;
+            this.match(PlSqlParser.NESTED);
+            this.state = 4459;
+            this.match(PlSqlParser.TABLE);
+            this.state = 4460;
+            this.tableview_name();
+            this.state = 4461;
+            this.match(PlSqlParser.OF);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public referencing_clause(): Referencing_clauseContext {
+        let localContext = new Referencing_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 240, PlSqlParser.RULE_referencing_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4466;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.REFERENCING:
+                {
+                this.state = 4463;
+                this.match(PlSqlParser.REFERENCING);
+                this.state = 4464;
+                this.referencing_element();
+                }
+                break;
+            case PlSqlParser.REFERENCES:
+                {
+                this.state = 4465;
+                this.match(PlSqlParser.REFERENCES);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 4471;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 1022 || _la === 1252 || _la === 1339) {
+                {
+                {
+                this.state = 4468;
+                this.referencing_element();
+                }
+                }
+                this.state = 4473;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public referencing_element(): Referencing_elementContext {
+        let localContext = new Referencing_elementContext(this.context, this.state);
+        this.enterRule(localContext, 242, PlSqlParser.RULE_referencing_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4474;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1022 || _la === 1252 || _la === 1339)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4475;
+            this.column_alias();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_type(): Drop_typeContext {
+        let localContext = new Drop_typeContext(this.context, this.state);
+        this.enterRule(localContext, 244, PlSqlParser.RULE_drop_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4477;
+            this.match(PlSqlParser.DROP);
+            this.state = 4478;
+            this.match(PlSqlParser.TYPE);
+            this.state = 4480;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 277, this.context) ) {
+            case 1:
+                {
+                this.state = 4479;
+                this.match(PlSqlParser.BODY);
+                }
+                break;
+            }
+            this.state = 4482;
+            this.type_name();
+            this.state = 4484;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 278, this.context) ) {
+            case 1:
+                {
+                this.state = 4483;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 617 || _la === 2255)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_type(): Alter_typeContext {
+        let localContext = new Alter_typeContext(this.context, this.state);
+        this.enterRule(localContext, 246, PlSqlParser.RULE_alter_type);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4486;
+            this.match(PlSqlParser.ALTER);
+            this.state = 4487;
+            this.match(PlSqlParser.TYPE);
+            this.state = 4488;
+            this.type_name();
+            this.state = 4496;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 279, this.context) ) {
+            case 1:
+                {
+                this.state = 4489;
+                this.compile_type_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4490;
+                this.replace_type_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 4491;
+                this.alter_method_spec();
+                }
+                break;
+            case 4:
+                {
+                this.state = 4492;
+                this.alter_attribute_definition();
+                }
+                break;
+            case 5:
+                {
+                this.state = 4493;
+                this.alter_collection_clauses();
+                }
+                break;
+            case 6:
+                {
+                this.state = 4494;
+                this.modifier_clause();
+                }
+                break;
+            case 7:
+                {
+                this.state = 4495;
+                this.overriding_subprogram_spec();
+                }
+                break;
+            }
+            this.state = 4499;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 280, this.context) ) {
+            case 1:
+                {
+                this.state = 4498;
+                this.dependent_handling_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public compile_type_clause(): Compile_type_clauseContext {
+        let localContext = new Compile_type_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 248, PlSqlParser.RULE_compile_type_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4501;
+            this.match(PlSqlParser.COMPILE);
+            this.state = 4503;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 281, this.context) ) {
+            case 1:
+                {
+                this.state = 4502;
+                this.match(PlSqlParser.DEBUG);
+                }
+                break;
+            }
+            this.state = 4506;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 282, this.context) ) {
+            case 1:
+                {
+                this.state = 4505;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 147 || _la === 1717)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 4511;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 283, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 4508;
+                    this.compiler_parameters_clause();
+                    }
+                    }
+                }
+                this.state = 4513;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 283, this.context);
+            }
+            this.state = 4516;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 284, this.context) ) {
+            case 1:
+                {
+                this.state = 4514;
+                this.match(PlSqlParser.REUSE);
+                this.state = 4515;
+                this.match(PlSqlParser.SETTINGS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public replace_type_clause(): Replace_type_clauseContext {
+        let localContext = new Replace_type_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 250, PlSqlParser.RULE_replace_type_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4518;
+            this.match(PlSqlParser.REPLACE);
+            this.state = 4520;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 88) {
+                {
+                this.state = 4519;
+                this.invoker_rights_clause();
+                }
+            }
+
+            this.state = 4522;
+            this.match(PlSqlParser.AS);
+            this.state = 4523;
+            this.match(PlSqlParser.OBJECT);
+            this.state = 4524;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 4525;
+            this.object_member_spec();
+            this.state = 4530;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 4526;
+                this.match(PlSqlParser.COMMA);
+                this.state = 4527;
+                this.object_member_spec();
+                }
+                }
+                this.state = 4532;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 4533;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_method_spec(): Alter_method_specContext {
+        let localContext = new Alter_method_specContext(this.context, this.state);
+        this.enterRule(localContext, 252, PlSqlParser.RULE_alter_method_spec);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4535;
+            this.alter_method_element();
+            this.state = 4540;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 287, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 4536;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4537;
+                    this.alter_method_element();
+                    }
+                    }
+                }
+                this.state = 4542;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 287, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_method_element(): Alter_method_elementContext {
+        let localContext = new Alter_method_elementContext(this.context, this.state);
+        this.enterRule(localContext, 254, PlSqlParser.RULE_alter_method_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4543;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 21 || _la === 469)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4546;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MAP:
+            case PlSqlParser.ORDER:
+                {
+                this.state = 4544;
+                this.map_order_function_spec();
+                }
+                break;
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.STATIC:
+                {
+                this.state = 4545;
+                this.subprogram_spec();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_attribute_definition(): Alter_attribute_definitionContext {
+        let localContext = new Alter_attribute_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 256, PlSqlParser.RULE_alter_attribute_definition);
+        let _la: number;
+        try {
+            this.state = 4586;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4548;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 21 || _la === 981)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 4549;
+                this.match(PlSqlParser.ATTRIBUTE);
+                this.state = 4568;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.INTRODUCER:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 4550;
+                    this.identifier();
+                    this.state = 4552;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 289, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 4551;
+                        this.type_spec();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 4554;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 4555;
+                    this.identifier();
+                    this.state = 4556;
+                    this.type_spec();
+                    this.state = 4563;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 4557;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 4558;
+                        this.identifier();
+                        this.state = 4559;
+                        this.type_spec();
+                        }
+                        }
+                        this.state = 4565;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 4566;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4570;
+                this.match(PlSqlParser.DROP);
+                this.state = 4571;
+                this.match(PlSqlParser.ATTRIBUTE);
+                this.state = 4584;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.INTRODUCER:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 4572;
+                    this.identifier();
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 4573;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 4574;
+                    this.identifier();
+                    this.state = 4579;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 4575;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 4576;
+                        this.identifier();
+                        }
+                        }
+                        this.state = 4581;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 4582;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_collection_clauses(): Alter_collection_clausesContext {
+        let localContext = new Alter_collection_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 258, PlSqlParser.RULE_alter_collection_clauses);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4588;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 4594;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LIMIT:
+                {
+                this.state = 4589;
+                this.match(PlSqlParser.LIMIT);
+                this.state = 4590;
+                this.expression();
+                }
+                break;
+            case PlSqlParser.ELEMENT:
+                {
+                this.state = 4591;
+                this.match(PlSqlParser.ELEMENT);
+                this.state = 4592;
+                this.match(PlSqlParser.TYPE);
+                this.state = 4593;
+                this.type_spec();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dependent_handling_clause(): Dependent_handling_clauseContext {
+        let localContext = new Dependent_handling_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 260, PlSqlParser.RULE_dependent_handling_clause);
+        let _la: number;
+        try {
+            this.state = 4612;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INVALIDATE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4596;
+                this.match(PlSqlParser.INVALIDATE);
+                }
+                break;
+            case PlSqlParser.CASCADE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4597;
+                this.match(PlSqlParser.CASCADE);
+                this.state = 4607;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 297, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4598;
+                    this.match(PlSqlParser.CONVERT);
+                    this.state = 4599;
+                    this.match(PlSqlParser.TO);
+                    this.state = 4600;
+                    this.match(PlSqlParser.SUBSTITUTABLE);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 4602;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1206) {
+                        {
+                        this.state = 4601;
+                        this.match(PlSqlParser.NOT);
+                        }
+                    }
+
+                    this.state = 4604;
+                    this.match(PlSqlParser.INCLUDING);
+                    this.state = 4605;
+                    this.match(PlSqlParser.TABLE);
+                    this.state = 4606;
+                    this.match(PlSqlParser.DATA);
+                    }
+                    break;
+                }
+                this.state = 4610;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 298, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4609;
+                    this.dependent_exceptions_part();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dependent_exceptions_part(): Dependent_exceptions_partContext {
+        let localContext = new Dependent_exceptions_partContext(this.context, this.state);
+        this.enterRule(localContext, 262, PlSqlParser.RULE_dependent_exceptions_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4615;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 4614;
+                this.match(PlSqlParser.FORCE);
+                }
+            }
+
+            this.state = 4617;
+            this.match(PlSqlParser.EXCEPTIONS);
+            this.state = 4618;
+            this.match(PlSqlParser.INTO);
+            this.state = 4619;
+            this.tableview_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_type(): Create_typeContext {
+        let localContext = new Create_typeContext(this.context, this.state);
+        this.enterRule(localContext, 264, PlSqlParser.RULE_create_type);
+        try {
+            this.state = 4623;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 301, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4621;
+                this.create_type_spec();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4622;
+                this.create_type_body();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_type_spec(): Create_type_specContext {
+        let localContext = new Create_type_specContext(this.context, this.state);
+        this.enterRule(localContext, 266, PlSqlParser.RULE_create_type_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4625;
+            this.match(PlSqlParser.CREATE);
+            this.state = 4628;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 4626;
+                this.match(PlSqlParser.OR);
+                this.state = 4627;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 4631;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 4630;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 4633;
+            this.match(PlSqlParser.TYPE);
+            this.state = 4634;
+            this.type_definition();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_type_body(): Create_type_bodyContext {
+        let localContext = new Create_type_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 268, PlSqlParser.RULE_create_type_body);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4636;
+            this.match(PlSqlParser.CREATE);
+            this.state = 4639;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 4637;
+                this.match(PlSqlParser.OR);
+                this.state = 4638;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 4642;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 4641;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 4644;
+            this.match(PlSqlParser.TYPE);
+            this.state = 4645;
+            this.type_body();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_definition(): Type_definitionContext {
+        let localContext = new Type_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 270, PlSqlParser.RULE_type_definition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4647;
+            this.type_name();
+            this.state = 4650;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 306, this.context) ) {
+            case 1:
+                {
+                this.state = 4648;
+                this.match(PlSqlParser.OID);
+                this.state = 4649;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            this.state = 4653;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 307, this.context) ) {
+            case 1:
+                {
+                this.state = 4652;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            this.state = 4656;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 308, this.context) ) {
+            case 1:
+                {
+                this.state = 4655;
+                this.object_type_def();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_type_def(): Object_type_defContext {
+        let localContext = new Object_type_defContext(this.context, this.state);
+        this.enterRule(localContext, 272, PlSqlParser.RULE_object_type_def);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4659;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 88) {
+                {
+                this.state = 4658;
+                this.invoker_rights_clause();
+                }
+            }
+
+            this.state = 4663;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.AS:
+            case PlSqlParser.IS:
+                {
+                this.state = 4661;
+                this.object_as_part();
+                }
+                break;
+            case PlSqlParser.UNDER:
+                {
+                this.state = 4662;
+                this.object_under_part();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 4666;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 311, this.context) ) {
+            case 1:
+                {
+                this.state = 4665;
+                this.sqlj_object_type();
+                }
+                break;
+            }
+            this.state = 4679;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 313, this.context) ) {
+            case 1:
+                {
+                this.state = 4668;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4669;
+                this.object_member_spec();
+                this.state = 4674;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4670;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4671;
+                    this.object_member_spec();
+                    }
+                    }
+                    this.state = 4676;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4677;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 4684;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 314, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 4681;
+                    this.modifier_clause();
+                    }
+                    }
+                }
+                this.state = 4686;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 314, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_as_part(): Object_as_partContext {
+        let localContext = new Object_as_partContext(this.context, this.state);
+        this.enterRule(localContext, 274, PlSqlParser.RULE_object_as_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4687;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4691;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.OBJECT:
+                {
+                this.state = 4688;
+                this.match(PlSqlParser.OBJECT);
+                }
+                break;
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VARYING:
+                {
+                this.state = 4689;
+                this.varray_type_def();
+                }
+                break;
+            case PlSqlParser.TABLE:
+                {
+                this.state = 4690;
+                this.nested_table_type_def();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_under_part(): Object_under_partContext {
+        let localContext = new Object_under_partContext(this.context, this.state);
+        this.enterRule(localContext, 276, PlSqlParser.RULE_object_under_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4693;
+            this.match(PlSqlParser.UNDER);
+            this.state = 4694;
+            this.type_spec();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public nested_table_type_def(): Nested_table_type_defContext {
+        let localContext = new Nested_table_type_defContext(this.context, this.state);
+        this.enterRule(localContext, 278, PlSqlParser.RULE_nested_table_type_def);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4696;
+            this.match(PlSqlParser.TABLE);
+            this.state = 4697;
+            this.match(PlSqlParser.OF);
+            this.state = 4698;
+            this.type_spec();
+            this.state = 4701;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 316, this.context) ) {
+            case 1:
+                {
+                this.state = 4699;
+                this.match(PlSqlParser.NOT);
+                this.state = 4700;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sqlj_object_type(): Sqlj_object_typeContext {
+        let localContext = new Sqlj_object_typeContext(this.context, this.state);
+        this.enterRule(localContext, 280, PlSqlParser.RULE_sqlj_object_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4703;
+            this.match(PlSqlParser.EXTERNAL);
+            this.state = 4704;
+            this.match(PlSqlParser.NAME);
+            this.state = 4705;
+            this.expression();
+            this.state = 4706;
+            this.match(PlSqlParser.LANGUAGE);
+            this.state = 4707;
+            this.match(PlSqlParser.JAVA);
+            this.state = 4708;
+            this.match(PlSqlParser.USING);
+            this.state = 4709;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 346 || _la === 1281 || _la === 1721)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_body(): Type_bodyContext {
+        let localContext = new Type_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 282, PlSqlParser.RULE_type_body);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4711;
+            this.match(PlSqlParser.BODY);
+            this.state = 4712;
+            this.type_name();
+            this.state = 4713;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4715;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 4714;
+                this.type_body_elements();
+                }
+                }
+                this.state = 4717;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 288 || _la === 596 || _la === 633 || _la === 762 || _la === 911 || _la === 937 || _la === 1305 || _la === 1326 || _la === 1463 || _la === 1747);
+            this.state = 4719;
+            this.match(PlSqlParser.END);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_body_elements(): Type_body_elementsContext {
+        let localContext = new Type_body_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 284, PlSqlParser.RULE_type_body_elements);
+        try {
+            this.state = 4724;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MAP:
+            case PlSqlParser.ORDER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4721;
+                this.map_order_func_declaration();
+                }
+                break;
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.STATIC:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4722;
+                this.subprog_decl_in_type();
+                }
+                break;
+            case PlSqlParser.OVERRIDING:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 4723;
+                this.overriding_subprogram_spec();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public map_order_func_declaration(): Map_order_func_declarationContext {
+        let localContext = new Map_order_func_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 286, PlSqlParser.RULE_map_order_func_declaration);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4726;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 911 || _la === 1305)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4727;
+            this.match(PlSqlParser.MEMBER);
+            this.state = 4728;
+            this.func_decl_in_type();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subprog_decl_in_type(): Subprog_decl_in_typeContext {
+        let localContext = new Subprog_decl_in_typeContext(this.context, this.state);
+        this.enterRule(localContext, 288, PlSqlParser.RULE_subprog_decl_in_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4731;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 937 || _la === 1747) {
+                {
+                this.state = 4730;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 937 || _la === 1747)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 4736;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PROCEDURE:
+                {
+                this.state = 4733;
+                this.proc_decl_in_type();
+                }
+                break;
+            case PlSqlParser.FUNCTION:
+                {
+                this.state = 4734;
+                this.func_decl_in_type();
+                }
+                break;
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.INSTANTIABLE:
+                {
+                this.state = 4735;
+                this.constructor_declaration();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public proc_decl_in_type(): Proc_decl_in_typeContext {
+        let localContext = new Proc_decl_in_typeContext(this.context, this.state);
+        this.enterRule(localContext, 290, PlSqlParser.RULE_proc_decl_in_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4738;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4739;
+            this.procedure_name();
+            this.state = 4751;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4740;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4741;
+                this.type_elements_parameter();
+                this.state = 4746;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4742;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4743;
+                    this.type_elements_parameter();
+                    }
+                    }
+                    this.state = 4748;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4749;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4753;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4764;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 325, this.context) ) {
+            case 1:
+                {
+                this.state = 4754;
+                this.call_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4756;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 323, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4755;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4759;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 324, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4758;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4761;
+                this.body();
+                this.state = 4762;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public func_decl_in_type(): Func_decl_in_typeContext {
+        let localContext = new Func_decl_in_typeContext(this.context, this.state);
+        this.enterRule(localContext, 292, PlSqlParser.RULE_func_decl_in_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4766;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 4767;
+            this.function_name();
+            this.state = 4779;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4768;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4769;
+                this.type_elements_parameter();
+                this.state = 4774;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4770;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4771;
+                    this.type_elements_parameter();
+                    }
+                    }
+                    this.state = 4776;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4777;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4781;
+            this.match(PlSqlParser.RETURN);
+            this.state = 4782;
+            this.type_spec();
+            this.state = 4783;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4794;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 330, this.context) ) {
+            case 1:
+                {
+                this.state = 4784;
+                this.call_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4786;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 328, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4785;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4789;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 329, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4788;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4791;
+                this.body();
+                this.state = 4792;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public constructor_declaration(): Constructor_declarationContext {
+        let localContext = new Constructor_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 294, PlSqlParser.RULE_constructor_declaration);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4797;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 596) {
+                {
+                this.state = 4796;
+                this.match(PlSqlParser.FINAL);
+                }
+            }
+
+            this.state = 4800;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 762) {
+                {
+                this.state = 4799;
+                this.match(PlSqlParser.INSTANTIABLE);
+                }
+            }
+
+            this.state = 4802;
+            this.match(PlSqlParser.CONSTRUCTOR);
+            this.state = 4803;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 4804;
+            this.function_name();
+            this.state = 4825;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4805;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4812;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 333, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4806;
+                    this.match(PlSqlParser.SELF);
+                    this.state = 4807;
+                    this.match(PlSqlParser.IN);
+                    this.state = 4808;
+                    this.match(PlSqlParser.OUT);
+                    this.state = 4809;
+                    this.type_spec();
+                    this.state = 4810;
+                    this.match(PlSqlParser.COMMA);
+                    }
+                    break;
+                }
+                this.state = 4822;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2477 || _la === 2482) {
+                    {
+                    this.state = 4814;
+                    this.type_elements_parameter();
+                    this.state = 4819;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 4815;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 4816;
+                        this.type_elements_parameter();
+                        }
+                        }
+                        this.state = 4821;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                }
+
+                this.state = 4824;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4827;
+            this.match(PlSqlParser.RETURN);
+            this.state = 4828;
+            this.match(PlSqlParser.SELF);
+            this.state = 4829;
+            this.match(PlSqlParser.AS);
+            this.state = 4830;
+            this.match(PlSqlParser.RESULT);
+            this.state = 4831;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4842;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 339, this.context) ) {
+            case 1:
+                {
+                this.state = 4832;
+                this.call_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4834;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 337, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4833;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4837;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 338, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4836;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4839;
+                this.body();
+                this.state = 4840;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modifier_clause(): Modifier_clauseContext {
+        let localContext = new Modifier_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 296, PlSqlParser.RULE_modifier_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4845;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 4844;
+                this.match(PlSqlParser.NOT);
+                }
+            }
+
+            this.state = 4847;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 596 || _la === 762 || _la === 1326)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_member_spec(): Object_member_specContext {
+        let localContext = new Object_member_specContext(this.context, this.state);
+        this.enterRule(localContext, 298, PlSqlParser.RULE_object_member_spec);
+        let _la: number;
+        try {
+            this.state = 4855;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 342, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4849;
+                this.identifier();
+                this.state = 4850;
+                this.type_spec();
+                this.state = 4852;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 561) {
+                    {
+                    this.state = 4851;
+                    this.sqlj_object_type_attr();
+                    }
+                }
+
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4854;
+                this.element_spec();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sqlj_object_type_attr(): Sqlj_object_type_attrContext {
+        let localContext = new Sqlj_object_type_attrContext(this.context, this.state);
+        this.enterRule(localContext, 300, PlSqlParser.RULE_sqlj_object_type_attr);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4857;
+            this.match(PlSqlParser.EXTERNAL);
+            this.state = 4858;
+            this.match(PlSqlParser.NAME);
+            this.state = 4859;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public element_spec(): Element_specContext {
+        let localContext = new Element_specContext(this.context, this.state);
+        this.enterRule(localContext, 302, PlSqlParser.RULE_element_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4862;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 343, this.context) ) {
+            case 1:
+                {
+                this.state = 4861;
+                this.modifier_clause();
+                }
+                break;
+            }
+            this.state = 4865;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 4864;
+                this.element_spec_options();
+                }
+                }
+                this.state = 4867;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 288 || _la === 596 || _la === 762 || _la === 911 || _la === 937 || _la === 1305 || _la === 1747);
+            this.state = 4871;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 345, this.context) ) {
+            case 1:
+                {
+                this.state = 4869;
+                this.match(PlSqlParser.COMMA);
+                this.state = 4870;
+                this.pragma_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public element_spec_options(): Element_spec_optionsContext {
+        let localContext = new Element_spec_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 304, PlSqlParser.RULE_element_spec_options);
+        try {
+            this.state = 4876;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.STATIC:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4873;
+                this.subprogram_spec();
+                }
+                break;
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.INSTANTIABLE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4874;
+                this.constructor_spec();
+                }
+                break;
+            case PlSqlParser.MAP:
+            case PlSqlParser.ORDER:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 4875;
+                this.map_order_function_spec();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subprogram_spec(): Subprogram_specContext {
+        let localContext = new Subprogram_specContext(this.context, this.state);
+        this.enterRule(localContext, 306, PlSqlParser.RULE_subprogram_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4878;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 937 || _la === 1747)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4881;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PROCEDURE:
+                {
+                this.state = 4879;
+                this.type_procedure_spec();
+                }
+                break;
+            case PlSqlParser.FUNCTION:
+                {
+                this.state = 4880;
+                this.type_function_spec();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public overriding_subprogram_spec(): Overriding_subprogram_specContext {
+        let localContext = new Overriding_subprogram_specContext(this.context, this.state);
+        this.enterRule(localContext, 308, PlSqlParser.RULE_overriding_subprogram_spec);
+        try {
+            this.state = 4889;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 348, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 4883;
+                this.match(PlSqlParser.OVERRIDING);
+                this.state = 4884;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 4885;
+                this.overriding_function_spec();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 4886;
+                this.match(PlSqlParser.OVERRIDING);
+                this.state = 4887;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 4888;
+                this.overriding_procedure_spec();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public overriding_function_spec(): Overriding_function_specContext {
+        let localContext = new Overriding_function_specContext(this.context, this.state);
+        this.enterRule(localContext, 310, PlSqlParser.RULE_overriding_function_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4891;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 4892;
+            this.function_name();
+            this.state = 4904;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4893;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4894;
+                this.type_elements_parameter();
+                this.state = 4899;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4895;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4896;
+                    this.type_elements_parameter();
+                    }
+                    }
+                    this.state = 4901;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4902;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4906;
+            this.match(PlSqlParser.RETURN);
+            this.state = 4911;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 351, this.context) ) {
+            case 1:
+                {
+                this.state = 4907;
+                this.type_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4908;
+                this.match(PlSqlParser.SELF);
+                this.state = 4909;
+                this.match(PlSqlParser.AS);
+                this.state = 4910;
+                this.match(PlSqlParser.RESULT);
+                }
+                break;
+            }
+            this.state = 4924;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 355, this.context) ) {
+            case 1:
+                {
+                this.state = 4914;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1396) {
+                    {
+                    this.state = 4913;
+                    this.match(PlSqlParser.PIPELINED);
+                    }
+                }
+
+                this.state = 4916;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 69 || _la === 786)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                {
+                this.state = 4918;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 353, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4917;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4921;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 354, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4920;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4923;
+                this.body();
+                }
+                }
+                break;
+            }
+            this.state = 4927;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 356, this.context) ) {
+            case 1:
+                {
+                this.state = 4926;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public overriding_procedure_spec(): Overriding_procedure_specContext {
+        let localContext = new Overriding_procedure_specContext(this.context, this.state);
+        this.enterRule(localContext, 312, PlSqlParser.RULE_overriding_procedure_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4929;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4930;
+            this.procedure_name();
+            this.state = 4942;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4931;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4932;
+                this.type_elements_parameter();
+                this.state = 4937;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4933;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4934;
+                    this.type_elements_parameter();
+                    }
+                    }
+                    this.state = 4939;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4940;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4944;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 4955;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 361, this.context) ) {
+            case 1:
+                {
+                this.state = 4945;
+                this.call_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4947;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 359, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4946;
+                    this.match(PlSqlParser.DECLARE);
+                    }
+                    break;
+                }
+                this.state = 4950;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 360, this.context) ) {
+                case 1:
+                    {
+                    this.state = 4949;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                this.state = 4952;
+                this.body();
+                this.state = 4953;
+                this.match(PlSqlParser.SEMICOLON);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_procedure_spec(): Type_procedure_specContext {
+        let localContext = new Type_procedure_specContext(this.context, this.state);
+        this.enterRule(localContext, 314, PlSqlParser.RULE_type_procedure_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4957;
+            this.match(PlSqlParser.PROCEDURE);
+            this.state = 4958;
+            this.procedure_name();
+            this.state = 4970;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 363, this.context) ) {
+            case 1:
+                {
+                this.state = 4959;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4960;
+                this.type_elements_parameter();
+                this.state = 4965;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4961;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4962;
+                    this.type_elements_parameter();
+                    }
+                    }
+                    this.state = 4967;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4968;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 4974;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 364, this.context) ) {
+            case 1:
+                {
+                this.state = 4972;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 69 || _la === 786)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 4973;
+                this.call_spec();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_function_spec(): Type_function_specContext {
+        let localContext = new Type_function_specContext(this.context, this.state);
+        this.enterRule(localContext, 316, PlSqlParser.RULE_type_function_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 4976;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 4977;
+            this.function_name();
+            this.state = 4989;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 4978;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 4979;
+                this.type_elements_parameter();
+                this.state = 4984;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 4980;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 4981;
+                    this.type_elements_parameter();
+                    }
+                    }
+                    this.state = 4986;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 4987;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 4991;
+            this.match(PlSqlParser.RETURN);
+            this.state = 4996;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 367, this.context) ) {
+            case 1:
+                {
+                this.state = 4992;
+                this.type_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 4993;
+                this.match(PlSqlParser.SELF);
+                this.state = 4994;
+                this.match(PlSqlParser.AS);
+                this.state = 4995;
+                this.match(PlSqlParser.RESULT);
+                }
+                break;
+            }
+            this.state = 5006;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 369, this.context) ) {
+            case 1:
+                {
+                this.state = 4998;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 69 || _la === 786)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 4999;
+                this.call_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 5000;
+                this.match(PlSqlParser.EXTERNAL);
+                this.state = 5002;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2264) {
+                    {
+                    this.state = 5001;
+                    this.match(PlSqlParser.VARIABLE);
+                    }
+                }
+
+                this.state = 5004;
+                this.match(PlSqlParser.NAME);
+                this.state = 5005;
+                this.expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public constructor_spec(): Constructor_specContext {
+        let localContext = new Constructor_specContext(this.context, this.state);
+        this.enterRule(localContext, 318, PlSqlParser.RULE_constructor_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5009;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 596) {
+                {
+                this.state = 5008;
+                this.match(PlSqlParser.FINAL);
+                }
+            }
+
+            this.state = 5012;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 762) {
+                {
+                this.state = 5011;
+                this.match(PlSqlParser.INSTANTIABLE);
+                }
+            }
+
+            this.state = 5014;
+            this.match(PlSqlParser.CONSTRUCTOR);
+            this.state = 5015;
+            this.match(PlSqlParser.FUNCTION);
+            this.state = 5016;
+            this.type_spec();
+            this.state = 5037;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 5017;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 5024;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 372, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5018;
+                    this.match(PlSqlParser.SELF);
+                    this.state = 5019;
+                    this.match(PlSqlParser.IN);
+                    this.state = 5020;
+                    this.match(PlSqlParser.OUT);
+                    this.state = 5021;
+                    this.type_spec();
+                    this.state = 5022;
+                    this.match(PlSqlParser.COMMA);
+                    }
+                    break;
+                }
+                this.state = 5034;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2477 || _la === 2482) {
+                    {
+                    this.state = 5026;
+                    this.type_elements_parameter();
+                    this.state = 5031;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 5027;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5028;
+                        this.type_elements_parameter();
+                        }
+                        }
+                        this.state = 5033;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                }
+
+                this.state = 5036;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 5039;
+            this.match(PlSqlParser.RETURN);
+            this.state = 5040;
+            this.match(PlSqlParser.SELF);
+            this.state = 5041;
+            this.match(PlSqlParser.AS);
+            this.state = 5042;
+            this.match(PlSqlParser.RESULT);
+            this.state = 5045;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 69 || _la === 786) {
+                {
+                this.state = 5043;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 69 || _la === 786)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 5044;
+                this.call_spec();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public map_order_function_spec(): Map_order_function_specContext {
+        let localContext = new Map_order_function_specContext(this.context, this.state);
+        this.enterRule(localContext, 320, PlSqlParser.RULE_map_order_function_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5047;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 911 || _la === 1305)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 5048;
+            this.match(PlSqlParser.MEMBER);
+            this.state = 5049;
+            this.type_function_spec();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pragma_clause(): Pragma_clauseContext {
+        let localContext = new Pragma_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 322, PlSqlParser.RULE_pragma_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5051;
+            this.match(PlSqlParser.PRAGMA);
+            this.state = 5052;
+            this.match(PlSqlParser.RESTRICT_REFERENCES);
+            this.state = 5053;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5054;
+            this.pragma_elements();
+            this.state = 5059;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5055;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5056;
+                this.pragma_elements();
+                }
+                }
+                this.state = 5061;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5062;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pragma_elements(): Pragma_elementsContext {
+        let localContext = new Pragma_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 324, PlSqlParser.RULE_pragma_elements);
+        try {
+            this.state = 5066;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5064;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.DEFAULT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5065;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_elements_parameter(): Type_elements_parameterContext {
+        let localContext = new Type_elements_parameterContext(this.context, this.state);
+        this.enterRule(localContext, 326, PlSqlParser.RULE_type_elements_parameter);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5068;
+            this.parameter_name();
+            this.state = 5078;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 379, this.context) ) {
+            case 1:
+                {
+                this.state = 5069;
+                this.match(PlSqlParser.IN);
+                this.state = 5070;
+                this.match(PlSqlParser.OUT);
+                this.state = 5071;
+                this.match(PlSqlParser.NOCOPY);
+                }
+                break;
+            case 2:
+                {
+                this.state = 5072;
+                this.match(PlSqlParser.IN);
+                this.state = 5073;
+                this.match(PlSqlParser.OUT);
+                }
+                break;
+            case 3:
+                {
+                this.state = 5074;
+                this.match(PlSqlParser.OUT);
+                this.state = 5075;
+                this.match(PlSqlParser.NOCOPY);
+                }
+                break;
+            case 4:
+                {
+                this.state = 5076;
+                this.match(PlSqlParser.OUT);
+                }
+                break;
+            case 5:
+                {
+                this.state = 5077;
+                this.match(PlSqlParser.IN);
+                }
+                break;
+            }
+            this.state = 5080;
+            this.type_spec();
+            this.state = 5083;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2459) {
+                {
+                this.state = 5081;
+                this.match(PlSqlParser.ASSIGN_OP);
+                this.state = 5082;
+                this.constant();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_sequence(): Drop_sequenceContext {
+        let localContext = new Drop_sequenceContext(this.context, this.state);
+        this.enterRule(localContext, 328, PlSqlParser.RULE_drop_sequence);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5085;
+            this.match(PlSqlParser.DROP);
+            this.state = 5086;
+            this.match(PlSqlParser.SEQUENCE);
+            this.state = 5087;
+            this.sequence_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_sequence(): Alter_sequenceContext {
+        let localContext = new Alter_sequenceContext(this.context, this.state);
+        this.enterRule(localContext, 330, PlSqlParser.RULE_alter_sequence);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5089;
+            this.match(PlSqlParser.ALTER);
+            this.state = 5090;
+            this.match(PlSqlParser.SEQUENCE);
+            this.state = 5091;
+            this.sequence_name();
+            this.state = 5093;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 5092;
+                    this.sequence_spec();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 5095;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 381, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_session(): Alter_sessionContext {
+        let localContext = new Alter_sessionContext(this.context, this.state);
+        this.enterRule(localContext, 332, PlSqlParser.RULE_alter_session);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5097;
+            this.match(PlSqlParser.ALTER);
+            this.state = 5098;
+            this.match(PlSqlParser.SESSION);
+            this.state = 5128;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 385, this.context) ) {
+            case 1:
+                {
+                this.state = 5099;
+                this.match(PlSqlParser.ADVISE);
+                this.state = 5100;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 242 || _la === 1203 || _la === 1598)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 5101;
+                this.match(PlSqlParser.CLOSE);
+                this.state = 5102;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 5103;
+                this.match(PlSqlParser.LINK);
+                this.state = 5104;
+                this.parameter_name();
+                }
+                break;
+            case 3:
+                {
+                this.state = 5105;
+                this.enable_or_disable();
+                this.state = 5106;
+                this.match(PlSqlParser.COMMIT);
+                this.state = 5107;
+                this.match(PlSqlParser.IN);
+                this.state = 5108;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 4:
+                {
+                this.state = 5110;
+                this.enable_or_disable();
+                this.state = 5111;
+                this.match(PlSqlParser.GUARD);
+                }
+                break;
+            case 5:
+                {
+                this.state = 5115;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.ENABLE:
+                    {
+                    this.state = 5113;
+                    this.enable_or_disable();
+                    }
+                    break;
+                case PlSqlParser.FORCE:
+                    {
+                    this.state = 5114;
+                    this.match(PlSqlParser.FORCE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 5117;
+                this.match(PlSqlParser.PARALLEL);
+                this.state = 5118;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 376 || _la === 449 || _la === 1486)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 5124;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 384, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5119;
+                    this.match(PlSqlParser.PARALLEL);
+                    this.state = 5122;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 383, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5120;
+                        this.literal();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 5121;
+                        this.parameter_name();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case 6:
+                {
+                this.state = 5126;
+                this.match(PlSqlParser.SET);
+                this.state = 5127;
+                this.alter_session_set_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_session_set_clause(): Alter_session_set_clauseContext {
+        let localContext = new Alter_session_set_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 334, PlSqlParser.RULE_alter_session_set_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 5160;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 389, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5134;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 5130;
+                        this.parameter_name();
+                        this.state = 5131;
+                        this.match(PlSqlParser.EQUALS_OP);
+                        this.state = 5132;
+                        this.parameter_value();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 5136;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 386, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5138;
+                this.match(PlSqlParser.EDITION);
+                this.state = 5139;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5140;
+                localContext._en = this.id_expression();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 5141;
+                this.match(PlSqlParser.CONTAINER);
+                this.state = 5142;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5143;
+                localContext._cn = this.id_expression();
+                this.state = 5147;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 387, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5144;
+                    this.match(PlSqlParser.SERVICE);
+                    this.state = 5145;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 5146;
+                    localContext._sn = this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 5149;
+                this.match(PlSqlParser.ROW);
+                this.state = 5150;
+                this.match(PlSqlParser.ARCHIVAL);
+                this.state = 5151;
+                this.match(PlSqlParser.VISIBILITY);
+                this.state = 5152;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5153;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 14 || _la === 38)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 5154;
+                this.match(PlSqlParser.DEFAULT_COLLATION);
+                this.state = 5155;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5158;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 388, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5156;
+                    localContext._c = this.id_expression();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 5157;
+                    this.match(PlSqlParser.NONE);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_sequence(): Create_sequenceContext {
+        let localContext = new Create_sequenceContext(this.context, this.state);
+        this.enterRule(localContext, 336, PlSqlParser.RULE_create_sequence);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5162;
+            this.match(PlSqlParser.CREATE);
+            this.state = 5163;
+            this.match(PlSqlParser.SEQUENCE);
+            this.state = 5167;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 390, this.context) ) {
+            case 1:
+                {
+                this.state = 5164;
+                this.match(PlSqlParser.IF);
+                this.state = 5165;
+                this.match(PlSqlParser.NOT);
+                this.state = 5166;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 5169;
+            this.sequence_name();
+            this.state = 5173;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 391, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5170;
+                    this.sequence_spec();
+                    }
+                    }
+                }
+                this.state = 5175;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 391, this.context);
+            }
+            this.state = 5179;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 392, this.context) ) {
+            case 1:
+                {
+                this.state = 5176;
+                this.match(PlSqlParser.SHARING);
+                this.state = 5177;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5178;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 351 || _la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sequence_spec(): Sequence_specContext {
+        let localContext = new Sequence_specContext(this.context, this.state);
+        this.enterRule(localContext, 338, PlSqlParser.RULE_sequence_spec);
+        let _la: number;
+        try {
+            this.state = 5212;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INCREMENT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5181;
+                this.match(PlSqlParser.INCREMENT);
+                this.state = 5182;
+                this.match(PlSqlParser.BY);
+                this.state = 5183;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.START:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5184;
+                this.sequence_start_clause();
+                }
+                break;
+            case PlSqlParser.MAXVALUE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 5185;
+                this.match(PlSqlParser.MAXVALUE);
+                this.state = 5186;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.NOMAXVALUE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 5187;
+                this.match(PlSqlParser.NOMAXVALUE);
+                }
+                break;
+            case PlSqlParser.MINVALUE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 5188;
+                this.match(PlSqlParser.MINVALUE);
+                this.state = 5189;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.NOMINVALUE:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 5190;
+                this.match(PlSqlParser.NOMINVALUE);
+                }
+                break;
+            case PlSqlParser.CYCLE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 5191;
+                this.match(PlSqlParser.CYCLE);
+                }
+                break;
+            case PlSqlParser.NOCYCLE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 5192;
+                this.match(PlSqlParser.NOCYCLE);
+                }
+                break;
+            case PlSqlParser.CACHE:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 5193;
+                this.match(PlSqlParser.CACHE);
+                this.state = 5194;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.NOCACHE:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 5195;
+                this.match(PlSqlParser.NOCACHE);
+                }
+                break;
+            case PlSqlParser.ORDER:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 5196;
+                this.match(PlSqlParser.ORDER);
+                }
+                break;
+            case PlSqlParser.NOORDER:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 5197;
+                this.match(PlSqlParser.NOORDER);
+                }
+                break;
+            case PlSqlParser.KEEP:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 5198;
+                this.match(PlSqlParser.KEEP);
+                }
+                break;
+            case PlSqlParser.NOKEEP:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 5199;
+                this.match(PlSqlParser.NOKEEP);
+                }
+                break;
+            case PlSqlParser.SCALE:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 5200;
+                this.match(PlSqlParser.SCALE);
+                this.state = 5202;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 393, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5201;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1101 || _la === 2431)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.NOSCALE:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 5204;
+                this.match(PlSqlParser.NOSCALE);
+                }
+                break;
+            case PlSqlParser.SHARD:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 5205;
+                this.match(PlSqlParser.SHARD);
+                this.state = 5207;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 394, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5206;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1101 || _la === 2431)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.NOSHARD:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 5209;
+                this.match(PlSqlParser.NOSHARD);
+                }
+                break;
+            case PlSqlParser.SESSION:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 5210;
+                this.match(PlSqlParser.SESSION);
+                }
+                break;
+            case PlSqlParser.GLOBAL:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 5211;
+                this.match(PlSqlParser.GLOBAL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sequence_start_clause(): Sequence_start_clauseContext {
+        let localContext = new Sequence_start_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 340, PlSqlParser.RULE_sequence_start_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5214;
+            this.match(PlSqlParser.START);
+            this.state = 5215;
+            this.match(PlSqlParser.WITH);
+            this.state = 5216;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 2443 || _la === 2444)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_analytic_view(): Create_analytic_viewContext {
+        let localContext = new Create_analytic_viewContext(this.context, this.state);
+        this.enterRule(localContext, 342, PlSqlParser.RULE_create_analytic_view);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5218;
+            this.match(PlSqlParser.CREATE);
+            this.state = 5221;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 5219;
+                this.match(PlSqlParser.OR);
+                this.state = 5220;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 5224;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617 || _la === 1105) {
+                {
+                this.state = 5223;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 617 || _la === 1105)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 5226;
+            this.match(PlSqlParser.ANALYTIC);
+            this.state = 5227;
+            this.match(PlSqlParser.VIEW);
+            this.state = 5228;
+            localContext._av = this.id_expression();
+            this.state = 5232;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 398, this.context) ) {
+            case 1:
+                {
+                this.state = 5229;
+                this.match(PlSqlParser.SHARING);
+                this.state = 5230;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5231;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 5237;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 399, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5234;
+                    this.classification_clause();
+                    }
+                    }
+                }
+                this.state = 5239;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 399, this.context);
+            }
+            this.state = 5241;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 400, this.context) ) {
+            case 1:
+                {
+                this.state = 5240;
+                this.cav_using_clause();
+                }
+                break;
+            }
+            this.state = 5244;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 401, this.context) ) {
+            case 1:
+                {
+                this.state = 5243;
+                this.dim_by_clause();
+                }
+                break;
+            }
+            this.state = 5247;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 402, this.context) ) {
+            case 1:
+                {
+                this.state = 5246;
+                this.measures_clause();
+                }
+                break;
+            }
+            this.state = 5250;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 403, this.context) ) {
+            case 1:
+                {
+                this.state = 5249;
+                this.default_measure_clause();
+                }
+                break;
+            }
+            this.state = 5253;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 404, this.context) ) {
+            case 1:
+                {
+                this.state = 5252;
+                this.default_aggregate_clause();
+                }
+                break;
+            }
+            this.state = 5256;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 405, this.context) ) {
+            case 1:
+                {
+                this.state = 5255;
+                this.cache_clause();
+                }
+                break;
+            }
+            this.state = 5259;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 406, this.context) ) {
+            case 1:
+                {
+                this.state = 5258;
+                this.fact_columns_clause();
+                }
+                break;
+            }
+            this.state = 5262;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 407, this.context) ) {
+            case 1:
+                {
+                this.state = 5261;
+                this.qry_transform_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public classification_clause(): Classification_clauseContext {
+        let localContext = new Classification_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 344, PlSqlParser.RULE_classification_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 5291;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 415, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5272;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 410, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5264;
+                    this.caption_clause();
+                    this.state = 5266;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 408, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5265;
+                        this.description_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 5269;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 177) {
+                        {
+                        this.state = 5268;
+                        this.caption_clause();
+                        }
+                    }
+
+                    this.state = 5271;
+                    this.description_clause();
+                    }
+                    break;
+                }
+                this.state = 5277;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 411, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5274;
+                        this.classification_item();
+                        }
+                        }
+                    }
+                    this.state = 5279;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 411, this.context);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5281;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 177) {
+                    {
+                    this.state = 5280;
+                    this.caption_clause();
+                    }
+                }
+
+                this.state = 5284;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 415) {
+                    {
+                    this.state = 5283;
+                    this.description_clause();
+                    }
+                }
+
+                this.state = 5287;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 5286;
+                        this.classification_item();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 5289;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 414, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public caption_clause(): Caption_clauseContext {
+        let localContext = new Caption_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 346, PlSqlParser.RULE_caption_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5293;
+            this.match(PlSqlParser.CAPTION);
+            this.state = 5294;
+            localContext._c = this.quoted_string();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public description_clause(): Description_clauseContext {
+        let localContext = new Description_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 348, PlSqlParser.RULE_description_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5296;
+            this.match(PlSqlParser.DESCRIPTION);
+            this.state = 5297;
+            localContext._d = this.quoted_string();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public classification_item(): Classification_itemContext {
+        let localContext = new Classification_itemContext(this.context, this.state);
+        this.enterRule(localContext, 350, PlSqlParser.RULE_classification_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5299;
+            this.match(PlSqlParser.CLASSIFICATION);
+            this.state = 5300;
+            localContext._cn = this.id_expression();
+            this.state = 5303;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 416, this.context) ) {
+            case 1:
+                {
+                this.state = 5301;
+                this.match(PlSqlParser.VALUE);
+                this.state = 5302;
+                localContext._cv = this.quoted_string();
+                }
+                break;
+            }
+            this.state = 5307;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 417, this.context) ) {
+            case 1:
+                {
+                this.state = 5305;
+                this.match(PlSqlParser.LANGUAGE);
+                this.state = 5306;
+                this.language();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public language(): LanguageContext {
+        let localContext = new LanguageContext(this.context, this.state);
+        this.enterRule(localContext, 352, PlSqlParser.RULE_language);
+        try {
+            this.state = 5311;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NULL_:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5309;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5310;
+                localContext._nls = this.id_expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cav_using_clause(): Cav_using_clauseContext {
+        let localContext = new Cav_using_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 354, PlSqlParser.RULE_cav_using_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5313;
+            this.match(PlSqlParser.USING);
+            this.state = 5317;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 419, this.context) ) {
+            case 1:
+                {
+                this.state = 5314;
+                this.schema_name();
+                this.state = 5315;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5319;
+            localContext._t = this.id_expression();
+            this.state = 5321;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 420, this.context) ) {
+            case 1:
+                {
+                this.state = 5320;
+                this.match(PlSqlParser.REMOTE);
+                }
+                break;
+            }
+            this.state = 5327;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 422, this.context) ) {
+            case 1:
+                {
+                this.state = 5324;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 5323;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 5326;
+                localContext._ta = this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dim_by_clause(): Dim_by_clauseContext {
+        let localContext = new Dim_by_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 356, PlSqlParser.RULE_dim_by_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5329;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 5330;
+            this.match(PlSqlParser.BY);
+            this.state = 5331;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5332;
+            this.dim_key();
+            this.state = 5337;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5333;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5334;
+                this.dim_key();
+                }
+                }
+                this.state = 5339;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5340;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dim_key(): Dim_keyContext {
+        let localContext = new Dim_keyContext(this.context, this.state);
+        this.enterRule(localContext, 358, PlSqlParser.RULE_dim_key);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5342;
+            this.dim_ref();
+            this.state = 5346;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 177 || _la === 207 || _la === 415) {
+                {
+                {
+                this.state = 5343;
+                this.classification_clause();
+                }
+                }
+                this.state = 5348;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5349;
+            this.match(PlSqlParser.KEY);
+            this.state = 5377;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 5350;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 5354;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 425, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5351;
+                    localContext._id_expression = this.id_expression();
+                    localContext._a.push(localContext._id_expression!);
+                    this.state = 5352;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 5356;
+                localContext._column_name = this.column_name();
+                localContext._f.push(localContext._column_name!);
+                this.state = 5366;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 5357;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5361;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 426, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5358;
+                        localContext._id_expression = this.id_expression();
+                        localContext._a.push(localContext._id_expression!);
+                        this.state = 5359;
+                        this.match(PlSqlParser.PERIOD);
+                        }
+                        break;
+                    }
+                    this.state = 5363;
+                    localContext._column_name = this.column_name();
+                    localContext._f.push(localContext._column_name!);
+                    }
+                    }
+                    this.state = 5368;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 5369;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 5374;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 428, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5371;
+                    localContext._id_expression = this.id_expression();
+                    localContext._a.push(localContext._id_expression!);
+                    this.state = 5372;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 5376;
+                localContext._column_name = this.column_name();
+                localContext._f.push(localContext._column_name!);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 5379;
+            this.match(PlSqlParser.REFERENCES);
+            this.state = 5381;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 445) {
+                {
+                this.state = 5380;
+                this.match(PlSqlParser.DISTINCT);
+                }
+            }
+
+            this.state = 5395;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 5383;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 5384;
+                this.attribute_name();
+                this.state = 5389;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 5385;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5386;
+                    this.attribute_name();
+                    }
+                    }
+                    this.state = 5391;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 5392;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 5394;
+                this.attribute_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 5397;
+            this.match(PlSqlParser.HIERARCHIES);
+            this.state = 5398;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5399;
+            this.hier_ref();
+            this.state = 5404;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5400;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5401;
+                this.hier_ref();
+                }
+                }
+                this.state = 5406;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5407;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dim_ref(): Dim_refContext {
+        let localContext = new Dim_refContext(this.context, this.state);
+        this.enterRule(localContext, 360, PlSqlParser.RULE_dim_ref);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5412;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 434, this.context) ) {
+            case 1:
+                {
+                this.state = 5409;
+                this.schema_name();
+                this.state = 5410;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5414;
+            localContext._ad = this.id_expression();
+            this.state = 5419;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 436, this.context) ) {
+            case 1:
+                {
+                this.state = 5416;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 5415;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 5418;
+                localContext._da = this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hier_ref(): Hier_refContext {
+        let localContext = new Hier_refContext(this.context, this.state);
+        this.enterRule(localContext, 362, PlSqlParser.RULE_hier_ref);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5424;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 437, this.context) ) {
+            case 1:
+                {
+                this.state = 5421;
+                this.schema_name();
+                this.state = 5422;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5426;
+            localContext._h = this.id_expression();
+            this.state = 5431;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 5428;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 5427;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 5430;
+                localContext._ha = this.id_expression();
+                }
+            }
+
+            this.state = 5434;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389) {
+                {
+                this.state = 5433;
+                this.match(PlSqlParser.DEFAULT);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public measures_clause(): Measures_clauseContext {
+        let localContext = new Measures_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 364, PlSqlParser.RULE_measures_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5436;
+            this.match(PlSqlParser.MEASURES);
+            this.state = 5437;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5438;
+            this.av_measure();
+            this.state = 5443;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5439;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5440;
+                this.av_measure();
+                }
+                }
+                this.state = 5445;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5446;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public av_measure(): Av_measureContext {
+        let localContext = new Av_measureContext(this.context, this.state);
+        this.enterRule(localContext, 366, PlSqlParser.RULE_av_measure);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5448;
+            localContext._mn = this.id_expression();
+            this.state = 5451;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.FACT:
+                {
+                this.state = 5449;
+                this.base_meas_clause();
+                }
+                break;
+            case PlSqlParser.AS:
+                {
+                this.state = 5450;
+                this.calc_meas_clause();
+                }
+                break;
+            case PlSqlParser.RIGHT_PAREN:
+            case PlSqlParser.COMMA:
+                break;
+            default:
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public base_meas_clause(): Base_meas_clauseContext {
+        let localContext = new Base_meas_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 368, PlSqlParser.RULE_base_meas_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5453;
+            this.match(PlSqlParser.FACT);
+            this.state = 5454;
+            localContext._bm = this.id_expression();
+            this.state = 5456;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 35) {
+                {
+                this.state = 5455;
+                this.meas_aggregate_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public meas_aggregate_clause(): Meas_aggregate_clauseContext {
+        let localContext = new Meas_aggregate_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 370, PlSqlParser.RULE_meas_aggregate_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5458;
+            this.match(PlSqlParser.AGGREGATE);
+            this.state = 5459;
+            this.match(PlSqlParser.BY);
+            this.state = 5460;
+            this.aggregate_function_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public calc_meas_clause(): Calc_meas_clauseContext {
+        let localContext = new Calc_meas_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 372, PlSqlParser.RULE_calc_meas_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5462;
+            this.match(PlSqlParser.AS);
+            this.state = 5463;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5464;
+            this.expression();
+            this.state = 5465;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_measure_clause(): Default_measure_clauseContext {
+        let localContext = new Default_measure_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 374, PlSqlParser.RULE_default_measure_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5467;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 5468;
+            this.match(PlSqlParser.MEASURE);
+            this.state = 5469;
+            localContext._m = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_aggregate_clause(): Default_aggregate_clauseContext {
+        let localContext = new Default_aggregate_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 376, PlSqlParser.RULE_default_aggregate_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5471;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 5472;
+            this.match(PlSqlParser.AGGREGATE);
+            this.state = 5473;
+            this.match(PlSqlParser.BY);
+            this.state = 5474;
+            this.aggregate_function_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cache_clause(): Cache_clauseContext {
+        let localContext = new Cache_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 378, PlSqlParser.RULE_cache_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5476;
+            this.match(PlSqlParser.CACHE);
+            this.state = 5477;
+            this.cache_specification();
+            this.state = 5482;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 444, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5478;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5479;
+                    this.cache_specification();
+                    }
+                    }
+                }
+                this.state = 5484;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 444, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cache_specification(): Cache_specificationContext {
+        let localContext = new Cache_specificationContext(this.context, this.state);
+        this.enterRule(localContext, 380, PlSqlParser.RULE_cache_specification);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5485;
+            this.match(PlSqlParser.MEASURE);
+            this.state = 5486;
+            this.match(PlSqlParser.GROUP);
+            this.state = 5506;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALL:
+                {
+                this.state = 5487;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 5488;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 5489;
+                this.id_expression();
+                this.state = 5494;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 5490;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5491;
+                    this.id_expression();
+                    }
+                    }
+                    this.state = 5496;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 5497;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 5498;
+                this.levels_clause();
+                this.state = 5503;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 446, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5499;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5500;
+                        this.levels_clause();
+                        }
+                        }
+                    }
+                    this.state = 5505;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 446, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public levels_clause(): Levels_clauseContext {
+        let localContext = new Levels_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 382, PlSqlParser.RULE_levels_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5508;
+            this.match(PlSqlParser.LEVELS);
+            this.state = 5509;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5510;
+            this.level_specification();
+            this.state = 5515;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5511;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5512;
+                this.level_specification();
+                }
+                }
+                this.state = 5517;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5518;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 5519;
+            this.level_group_type();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public level_specification(): Level_specificationContext {
+        let localContext = new Level_specificationContext(this.context, this.state);
+        this.enterRule(localContext, 384, PlSqlParser.RULE_level_specification);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5521;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5530;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 450, this.context) ) {
+            case 1:
+                {
+                this.state = 5525;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 449, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5522;
+                    localContext._d = this.id_expression();
+                    this.state = 5523;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 5527;
+                localContext._h = this.id_expression();
+                this.state = 5528;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5532;
+            localContext._l = this.id_expression();
+            this.state = 5533;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public level_group_type(): Level_group_typeContext {
+        let localContext = new Level_group_typeContext(this.context, this.state);
+        this.enterRule(localContext, 386, PlSqlParser.RULE_level_group_type);
+        try {
+            this.state = 5546;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DYNAMIC:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5535;
+                this.match(PlSqlParser.DYNAMIC);
+                }
+                break;
+            case PlSqlParser.MATERIALIZED:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5536;
+                this.match(PlSqlParser.MATERIALIZED);
+                this.state = 5544;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 452, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5537;
+                    this.match(PlSqlParser.USING);
+                    this.state = 5541;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 451, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5538;
+                        this.schema_name();
+                        this.state = 5539;
+                        this.match(PlSqlParser.PERIOD);
+                        }
+                        break;
+                    }
+                    this.state = 5543;
+                    localContext._t = this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public fact_columns_clause(): Fact_columns_clauseContext {
+        let localContext = new Fact_columns_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 388, PlSqlParser.RULE_fact_columns_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5548;
+            this.match(PlSqlParser.FACT);
+            this.state = 5549;
+            this.match(PlSqlParser.COLUMN);
+            this.state = 5550;
+            localContext._f = this.column_name();
+            this.state = 5565;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 457, this.context) ) {
+            case 1:
+                {
+                this.state = 5552;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 5551;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 5554;
+                localContext._fa = this.id_expression();
+                this.state = 5562;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 456, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5555;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5557;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 69) {
+                            {
+                            this.state = 5556;
+                            this.match(PlSqlParser.AS);
+                            }
+                        }
+
+                        this.state = 5559;
+                        localContext._fa = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 5564;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 456, this.context);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public qry_transform_clause(): Qry_transform_clauseContext {
+        let localContext = new Qry_transform_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 390, PlSqlParser.RULE_qry_transform_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5567;
+            this.match(PlSqlParser.ENABLE);
+            this.state = 5568;
+            this.match(PlSqlParser.QUERY);
+            this.state = 5569;
+            this.match(PlSqlParser.TRANSFORM);
+            this.state = 5571;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 458, this.context) ) {
+            case 1:
+                {
+                this.state = 5570;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1172 || _la === 1556)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_attribute_dimension(): Create_attribute_dimensionContext {
+        let localContext = new Create_attribute_dimensionContext(this.context, this.state);
+        this.enterRule(localContext, 392, PlSqlParser.RULE_create_attribute_dimension);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5573;
+            this.match(PlSqlParser.CREATE);
+            this.state = 5576;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 5574;
+                this.match(PlSqlParser.OR);
+                this.state = 5575;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 5579;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617 || _la === 1105) {
+                {
+                this.state = 5578;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 617 || _la === 1105)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 5581;
+            this.match(PlSqlParser.ATTRIBUTE);
+            this.state = 5582;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 5586;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 461, this.context) ) {
+            case 1:
+                {
+                this.state = 5583;
+                this.schema_name();
+                this.state = 5584;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5588;
+            localContext._ad = this.id_expression();
+            this.state = 5592;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1683) {
+                {
+                this.state = 5589;
+                this.match(PlSqlParser.SHARING);
+                this.state = 5590;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 5591;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 5597;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 177 || _la === 207 || _la === 415) {
+                {
+                {
+                this.state = 5594;
+                this.classification_clause();
+                }
+                }
+                this.state = 5599;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5603;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 422) {
+                {
+                this.state = 5600;
+                this.match(PlSqlParser.DIMENSION);
+                this.state = 5601;
+                this.match(PlSqlParser.TYPE);
+                this.state = 5602;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1732 || _la === 2114)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 5605;
+            this.ad_using_clause();
+            this.state = 5606;
+            this.attributes_clause();
+            this.state = 5608;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 5607;
+                    this.ad_level_clause();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 5610;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 465, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            this.state = 5613;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 466, this.context) ) {
+            case 1:
+                {
+                this.state = 5612;
+                this.all_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ad_using_clause(): Ad_using_clauseContext {
+        let localContext = new Ad_using_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 394, PlSqlParser.RULE_ad_using_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5615;
+            this.match(PlSqlParser.USING);
+            this.state = 5616;
+            this.source_clause();
+            this.state = 5621;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5617;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5618;
+                this.source_clause();
+                }
+                }
+                this.state = 5623;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5627;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 795) {
+                {
+                {
+                this.state = 5624;
+                this.join_path_clause();
+                }
+                }
+                this.state = 5629;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public source_clause(): Source_clauseContext {
+        let localContext = new Source_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 396, PlSqlParser.RULE_source_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5633;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 469, this.context) ) {
+            case 1:
+                {
+                this.state = 5630;
+                this.schema_name();
+                this.state = 5631;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5635;
+            localContext._ftov = this.id_expression();
+            this.state = 5637;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 470, this.context) ) {
+            case 1:
+                {
+                this.state = 5636;
+                this.match(PlSqlParser.REMOTE);
+                }
+                break;
+            }
+            this.state = 5643;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 472, this.context) ) {
+            case 1:
+                {
+                this.state = 5640;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 5639;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 5642;
+                localContext._a = this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public join_path_clause(): Join_path_clauseContext {
+        let localContext = new Join_path_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 398, PlSqlParser.RULE_join_path_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5645;
+            this.match(PlSqlParser.JOIN);
+            this.state = 5646;
+            this.match(PlSqlParser.PATH);
+            this.state = 5647;
+            localContext._jpn = this.id_expression();
+            this.state = 5648;
+            this.match(PlSqlParser.ON);
+            this.state = 5649;
+            this.join_condition();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public join_condition(): Join_conditionContext {
+        let localContext = new Join_conditionContext(this.context, this.state);
+        this.enterRule(localContext, 400, PlSqlParser.RULE_join_condition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5651;
+            this.join_condition_item();
+            this.state = 5656;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 49) {
+                {
+                {
+                this.state = 5652;
+                this.match(PlSqlParser.AND);
+                this.state = 5653;
+                this.join_condition_item();
+                }
+                }
+                this.state = 5658;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public join_condition_item(): Join_condition_itemContext {
+        let localContext = new Join_condition_itemContext(this.context, this.state);
+        this.enterRule(localContext, 402, PlSqlParser.RULE_join_condition_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5662;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 474, this.context) ) {
+            case 1:
+                {
+                this.state = 5659;
+                localContext._a = this.id_expression();
+                this.state = 5660;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5664;
+            this.column_name();
+            this.state = 5665;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 5669;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 475, this.context) ) {
+            case 1:
+                {
+                this.state = 5666;
+                localContext._b = this.id_expression();
+                this.state = 5667;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5671;
+            this.column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public attributes_clause(): Attributes_clauseContext {
+        let localContext = new Attributes_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 404, PlSqlParser.RULE_attributes_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5673;
+            this.match(PlSqlParser.ATTRIBUTES);
+            this.state = 5674;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 5675;
+            this.ad_attributes_clause();
+            this.state = 5680;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 5676;
+                this.match(PlSqlParser.COMMA);
+                this.state = 5677;
+                this.ad_attributes_clause();
+                }
+                }
+                this.state = 5682;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5683;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ad_attributes_clause(): Ad_attributes_clauseContext {
+        let localContext = new Ad_attributes_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 406, PlSqlParser.RULE_ad_attributes_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5688;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 477, this.context) ) {
+            case 1:
+                {
+                this.state = 5685;
+                localContext._a = this.id_expression();
+                this.state = 5686;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 5690;
+            this.column_name();
+            this.state = 5695;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 479, this.context) ) {
+            case 1:
+                {
+                this.state = 5692;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 5691;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 5694;
+                localContext._an = this.id_expression();
+                }
+                break;
+            }
+            this.state = 5700;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 177 || _la === 207 || _la === 415) {
+                {
+                {
+                this.state = 5697;
+                this.classification_clause();
+                }
+                }
+                this.state = 5702;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ad_level_clause(): Ad_level_clauseContext {
+        let localContext = new Ad_level_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 408, PlSqlParser.RULE_ad_level_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5703;
+            this.match(PlSqlParser.LEVEL);
+            this.state = 5704;
+            localContext._l = this.id_expression();
+            this.state = 5710;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOT:
+                {
+                this.state = 5705;
+                this.match(PlSqlParser.NOT);
+                this.state = 5706;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.SKIP_:
+                {
+                this.state = 5707;
+                this.match(PlSqlParser.SKIP_);
+                this.state = 5708;
+                this.match(PlSqlParser.WHEN);
+                this.state = 5709;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.KEY:
+            case PlSqlParser.LEVEL:
+                break;
+            default:
+                break;
+            }
+            this.state = 5715;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 847) {
+                {
+                this.state = 5712;
+                this.match(PlSqlParser.LEVEL);
+                this.state = 5713;
+                this.match(PlSqlParser.TYPE);
+                this.state = 5714;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 366 || _la === 659 || _la === 681 || _la === 960 || _la === 988 || _la === 1484 || _la === 1639 || _la === 1732 || _la === 2298 || _la === 2359)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 5720;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 177 || _la === 207 || _la === 415) {
+                {
+                {
+                this.state = 5717;
+                this.classification_clause();
+                }
+                }
+                this.state = 5722;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 5723;
+            this.key_clause();
+            this.state = 5725;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 484, this.context) ) {
+            case 1:
+                {
+                this.state = 5724;
+                this.alternate_key_clause();
+                }
+                break;
+            }
+            this.state = 5730;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 485, this.context) ) {
+            case 1:
+                {
+                this.state = 5727;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 5728;
+                this.match(PlSqlParser.NAME);
+                this.state = 5729;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 5735;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 486, this.context) ) {
+            case 1:
+                {
+                this.state = 5732;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 5733;
+                this.match(PlSqlParser.CAPTION);
+                this.state = 5734;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 5740;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 487, this.context) ) {
+            case 1:
+                {
+                this.state = 5737;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 5738;
+                this.match(PlSqlParser.DESCRIPTION);
+                this.state = 5739;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 5758;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 491, this.context) ) {
+            case 1:
+                {
+                this.state = 5742;
+                this.match(PlSqlParser.ORDER);
+                this.state = 5743;
+                this.match(PlSqlParser.BY);
+                this.state = 5745;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 488, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5744;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2408 || _la === 2411)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 5747;
+                this.dim_order_clause();
+                this.state = 5755;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 490, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5748;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5750;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 489, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 5749;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 2408 || _la === 2411)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        }
+                        this.state = 5752;
+                        this.dim_order_clause();
+                        }
+                        }
+                    }
+                    this.state = 5757;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 490, this.context);
+                }
+                }
+                break;
+            }
+            this.state = 5772;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 493, this.context) ) {
+            case 1:
+                {
+                this.state = 5760;
+                this.match(PlSqlParser.DETERMINES);
+                this.state = 5761;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 5762;
+                this.id_expression();
+                this.state = 5767;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 5763;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5764;
+                    this.id_expression();
+                    }
+                    }
+                    this.state = 5769;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 5770;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public key_clause(): Key_clauseContext {
+        let localContext = new Key_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 410, PlSqlParser.RULE_key_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5774;
+            this.match(PlSqlParser.KEY);
+            this.state = 5787;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 5775;
+                localContext._a = this.id_expression();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 5776;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 5777;
+                this.id_expression();
+                this.state = 5782;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 5778;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5779;
+                    this.id_expression();
+                    }
+                    }
+                    this.state = 5784;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 5785;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alternate_key_clause(): Alternate_key_clauseContext {
+        let localContext = new Alternate_key_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 412, PlSqlParser.RULE_alternate_key_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5789;
+            this.match(PlSqlParser.ALTERNATE);
+            this.state = 5790;
+            this.key_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dim_order_clause(): Dim_order_clauseContext {
+        let localContext = new Dim_order_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 414, PlSqlParser.RULE_dim_order_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5792;
+            localContext._a = this.id_expression();
+            this.state = 5794;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 496, this.context) ) {
+            case 1:
+                {
+                this.state = 5793;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 70 || _la === 414)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 5798;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 497, this.context) ) {
+            case 1:
+                {
+                this.state = 5796;
+                this.match(PlSqlParser.NULLS);
+                this.state = 5797;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 599 || _la === 826)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public all_clause(): All_clauseContext {
+        let localContext = new All_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 416, PlSqlParser.RULE_all_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5800;
+            this.match(PlSqlParser.ALL);
+            this.state = 5801;
+            this.match(PlSqlParser.MEMBER);
+            this.state = 5818;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NAME:
+                {
+                this.state = 5802;
+                this.match(PlSqlParser.NAME);
+                this.state = 5803;
+                this.expression();
+                this.state = 5807;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 498, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5804;
+                    this.match(PlSqlParser.MEMBER);
+                    this.state = 5805;
+                    this.match(PlSqlParser.CAPTION);
+                    this.state = 5806;
+                    this.expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.CAPTION:
+                {
+                this.state = 5809;
+                this.match(PlSqlParser.CAPTION);
+                this.state = 5810;
+                this.expression();
+                this.state = 5814;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 499, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5811;
+                    this.match(PlSqlParser.MEMBER);
+                    this.state = 5812;
+                    this.match(PlSqlParser.DESCRIPTION);
+                    this.state = 5813;
+                    this.expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.DESCRIPTION:
+                {
+                this.state = 5816;
+                this.match(PlSqlParser.DESCRIPTION);
+                this.state = 5817;
+                this.expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_audit_policy(): Create_audit_policyContext {
+        let localContext = new Create_audit_policyContext(this.context, this.state);
+        this.enterRule(localContext, 418, PlSqlParser.RULE_create_audit_policy);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5820;
+            this.match(PlSqlParser.CREATE);
+            this.state = 5821;
+            this.match(PlSqlParser.AUDIT);
+            this.state = 5822;
+            this.match(PlSqlParser.POLICY);
+            this.state = 5823;
+            localContext._p = this.id_expression();
+            this.state = 5825;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 501, this.context) ) {
+            case 1:
+                {
+                this.state = 5824;
+                this.privilege_audit_clause();
+                }
+                break;
+            }
+            this.state = 5828;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 502, this.context) ) {
+            case 1:
+                {
+                this.state = 5827;
+                this.action_audit_clause();
+                }
+                break;
+            }
+            this.state = 5831;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 503, this.context) ) {
+            case 1:
+                {
+                this.state = 5830;
+                this.role_audit_clause();
+                }
+                break;
+            }
+            this.state = 5839;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 504, this.context) ) {
+            case 1:
+                {
+                this.state = 5833;
+                this.match(PlSqlParser.WHEN);
+                this.state = 5834;
+                this.quoted_string();
+                this.state = 5835;
+                this.match(PlSqlParser.EVALUATE);
+                this.state = 5836;
+                this.match(PlSqlParser.PER);
+                this.state = 5837;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 760 || _la === 1669 || _la === 1745)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 5843;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 505, this.context) ) {
+            case 1:
+                {
+                this.state = 5841;
+                this.match(PlSqlParser.ONLY);
+                this.state = 5842;
+                this.match(PlSqlParser.TOPLEVEL);
+                }
+                break;
+            }
+            this.state = 5846;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 506, this.context) ) {
+            case 1:
+                {
+                this.state = 5845;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public privilege_audit_clause(): Privilege_audit_clauseContext {
+        let localContext = new Privilege_audit_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 420, PlSqlParser.RULE_privilege_audit_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5848;
+            this.match(PlSqlParser.PRIVILEGES);
+            this.state = 5849;
+            this.system_privilege();
+            this.state = 5854;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 507, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5850;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5851;
+                    this.system_privilege();
+                    }
+                    }
+                }
+                this.state = 5856;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 507, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public action_audit_clause(): Action_audit_clauseContext {
+        let localContext = new Action_audit_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 422, PlSqlParser.RULE_action_audit_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5860;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 5860;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 508, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5857;
+                        this.standard_actions();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 5858;
+                        this.component_actions();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 5859;
+                        this.system_actions();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 5862;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 509, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public system_actions(): System_actionsContext {
+        let localContext = new System_actionsContext(this.context, this.state);
+        this.enterRule(localContext, 424, PlSqlParser.RULE_system_actions);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5864;
+            this.match(PlSqlParser.ACTIONS);
+            this.state = 5865;
+            this.system_privilege();
+            this.state = 5870;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 510, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5866;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5867;
+                    this.system_privilege();
+                    }
+                    }
+                }
+                this.state = 5872;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 510, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public standard_actions(): Standard_actionsContext {
+        let localContext = new Standard_actionsContext(this.context, this.state);
+        this.enterRule(localContext, 426, PlSqlParser.RULE_standard_actions);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5873;
+            this.match(PlSqlParser.ACTIONS);
+            this.state = 5874;
+            this.actions_clause();
+            this.state = 5879;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 511, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5875;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5876;
+                    this.actions_clause();
+                    }
+                    }
+                }
+                this.state = 5881;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 511, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public actions_clause(): Actions_clauseContext {
+        let localContext = new Actions_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 428, PlSqlParser.RULE_actions_clause);
+        try {
+            this.state = 5905;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 517, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5884;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ALTER:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.GRANT:
+                case PlSqlParser.INDEX:
+                case PlSqlParser.INSERT:
+                case PlSqlParser.LOCK:
+                case PlSqlParser.READ:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.SELECT:
+                case PlSqlParser.UPDATE:
+                    {
+                    this.state = 5882;
+                    this.object_action();
+                    }
+                    break;
+                case PlSqlParser.ALL:
+                    {
+                    this.state = 5883;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 5886;
+                this.match(PlSqlParser.ON);
+                this.state = 5899;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 515, this.context) ) {
+                case 1:
+                    {
+                    this.state = 5887;
+                    this.match(PlSqlParser.DIRECTORY);
+                    this.state = 5888;
+                    this.directory_name();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 5891;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 513, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5889;
+                        this.match(PlSqlParser.MINING);
+                        this.state = 5890;
+                        this.match(PlSqlParser.MODEL);
+                        }
+                        break;
+                    }
+                    this.state = 5896;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 514, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 5893;
+                        this.schema_name();
+                        this.state = 5894;
+                        this.match(PlSqlParser.PERIOD);
+                        }
+                        break;
+                    }
+                    this.state = 5898;
+                    this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5903;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTER:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOCK:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 5901;
+                    this.system_action();
+                    }
+                    break;
+                case PlSqlParser.ALL:
+                    {
+                    this.state = 5902;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_action(): Object_actionContext {
+        let localContext = new Object_actionContext(this.context, this.state);
+        this.enterRule(localContext, 430, PlSqlParser.RULE_object_action);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5907;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 42 || _la === 85 || _la === 241 || _la === 403 || _la === 543 || _la === 606 || _la === 648 || _la === 718 || _la === 757 || _la === 882 || _la === 1507 || _la === 1561 || _la === 1649 || _la === 2209)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public system_action(): System_actionContext {
+        let localContext = new System_actionContext(this.context, this.state);
+        this.enterRule(localContext, 432, PlSqlParser.RULE_system_action);
+        let _la: number;
+        try {
+            this.state = 5916;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 518, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5909;
+                this.id_expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5910;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 5911;
+                this.match(PlSqlParser.JAVA);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 5912;
+                this.match(PlSqlParser.LOCK);
+                this.state = 5913;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 5914;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 543 || _la === 1507 || _la === 2315)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 5915;
+                this.match(PlSqlParser.DIRECTORY);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public component_actions(): Component_actionsContext {
+        let localContext = new Component_actionsContext(this.context, this.state);
+        this.enterRule(localContext, 434, PlSqlParser.RULE_component_actions);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5918;
+            this.match(PlSqlParser.ACTIONS);
+            this.state = 5919;
+            this.match(PlSqlParser.COMPONENT);
+            this.state = 5920;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 5946;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.OLS:
+            case PlSqlParser.XS:
+                {
+                this.state = 5921;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 359 || _la === 425 || _la === 1254 || _la === 2357)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 5922;
+                this.component_action();
+                this.state = 5927;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 519, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5923;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5924;
+                        this.component_action();
+                        }
+                        }
+                    }
+                    this.state = 5929;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 519, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DV:
+                {
+                this.state = 5930;
+                this.match(PlSqlParser.DV);
+                this.state = 5931;
+                this.component_action();
+                this.state = 5932;
+                this.match(PlSqlParser.ON);
+                this.state = 5933;
+                this.id_expression();
+                this.state = 5941;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 520, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5934;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5935;
+                        this.component_action();
+                        this.state = 5936;
+                        this.match(PlSqlParser.ON);
+                        this.state = 5937;
+                        this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 5943;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 520, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.PROTOCOL:
+                {
+                this.state = 5944;
+                this.match(PlSqlParser.PROTOCOL);
+                this.state = 5945;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 87 || _la === 635 || _la === 682)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public component_action(): Component_actionContext {
+        let localContext = new Component_actionContext(this.context, this.state);
+        this.enterRule(localContext, 436, PlSqlParser.RULE_component_action);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5948;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public role_audit_clause(): Role_audit_clauseContext {
+        let localContext = new Role_audit_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 438, PlSqlParser.RULE_role_audit_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5950;
+            this.match(PlSqlParser.ROLES);
+            this.state = 5951;
+            this.role_name();
+            this.state = 5956;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 522, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5952;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 5953;
+                    this.role_name();
+                    }
+                    }
+                }
+                this.state = 5958;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 522, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_controlfile(): Create_controlfileContext {
+        let localContext = new Create_controlfileContext(this.context, this.state);
+        this.enterRule(localContext, 440, PlSqlParser.RULE_create_controlfile);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 5959;
+            this.match(PlSqlParser.CREATE);
+            this.state = 5960;
+            this.match(PlSqlParser.CONTROLFILE);
+            this.state = 5962;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1589) {
+                {
+                this.state = 5961;
+                this.match(PlSqlParser.REUSE);
+                }
+            }
+
+            this.state = 5965;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1673) {
+                {
+                this.state = 5964;
+                this.match(PlSqlParser.SET);
+                }
+            }
+
+            this.state = 5967;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 5968;
+            localContext._d = this.id_expression();
+            this.state = 5970;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 883) {
+                {
+                this.state = 5969;
+                this.logfile_clause();
+                }
+            }
+
+            this.state = 5972;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1175 || _la === 1567)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 5982;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 527, this.context) ) {
+            case 1:
+                {
+                this.state = 5973;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 5974;
+                this.file_specification();
+                this.state = 5979;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 526, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 5975;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 5976;
+                        this.file_specification();
+                        }
+                        }
+                    }
+                    this.state = 5981;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 526, this.context);
+                }
+                }
+                break;
+            }
+            this.state = 5987;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 528, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 5984;
+                    this.controlfile_options();
+                    }
+                    }
+                }
+                this.state = 5989;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 528, this.context);
+            }
+            this.state = 5991;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 529, this.context) ) {
+            case 1:
+                {
+                this.state = 5990;
+                this.character_set_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public controlfile_options(): Controlfile_optionsContext {
+        let localContext = new Controlfile_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 442, PlSqlParser.RULE_controlfile_options);
+        try {
+            this.state = 6017;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MAXLOGFILES:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 5993;
+                this.match(PlSqlParser.MAXLOGFILES);
+                this.state = 5994;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.MAXLOGMEMBERS:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 5995;
+                this.match(PlSqlParser.MAXLOGMEMBERS);
+                this.state = 5996;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.MAXLOGHISTORY:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 5997;
+                this.match(PlSqlParser.MAXLOGHISTORY);
+                this.state = 5998;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.MAXDATAFILES:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 5999;
+                this.match(PlSqlParser.MAXDATAFILES);
+                this.state = 6000;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.MAXINSTANCES:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 6001;
+                this.match(PlSqlParser.MAXINSTANCES);
+                this.state = 6002;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.ARCHIVELOG:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 6003;
+                this.match(PlSqlParser.ARCHIVELOG);
+                }
+                break;
+            case PlSqlParser.NOARCHIVELOG:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 6004;
+                this.match(PlSqlParser.NOARCHIVELOG);
+                }
+                break;
+            case PlSqlParser.FORCE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 6005;
+                this.match(PlSqlParser.FORCE);
+                this.state = 6006;
+                this.match(PlSqlParser.LOGGING);
+                }
+                break;
+            case PlSqlParser.SET:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 6007;
+                this.match(PlSqlParser.SET);
+                this.state = 6008;
+                this.match(PlSqlParser.STANDBY);
+                this.state = 6009;
+                this.match(PlSqlParser.NOLOGGING);
+                this.state = 6010;
+                this.match(PlSqlParser.FOR);
+                this.state = 6015;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DATA:
+                    {
+                    this.state = 6011;
+                    this.match(PlSqlParser.DATA);
+                    this.state = 6012;
+                    this.match(PlSqlParser.AVAILABILITY);
+                    }
+                    break;
+                case PlSqlParser.LOAD:
+                    {
+                    this.state = 6013;
+                    this.match(PlSqlParser.LOAD);
+                    this.state = 6014;
+                    this.match(PlSqlParser.PERFORMANCE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public logfile_clause(): Logfile_clauseContext {
+        let localContext = new Logfile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 444, PlSqlParser.RULE_logfile_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6019;
+            this.match(PlSqlParser.LOGFILE);
+            this.state = 6024;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 650 || _la === 2443 || _la === 2444) {
+                {
+                this.state = 6021;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 650) {
+                    {
+                    this.state = 6020;
+                    this.match(PlSqlParser.GROUP);
+                    }
+                }
+
+                this.state = 6023;
+                this.numeric();
+                }
+            }
+
+            this.state = 6026;
+            this.file_specification();
+            this.state = 6037;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6027;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6032;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 650 || _la === 2443 || _la === 2444) {
+                    {
+                    this.state = 6029;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 650) {
+                        {
+                        this.state = 6028;
+                        this.match(PlSqlParser.GROUP);
+                        }
+                    }
+
+                    this.state = 6031;
+                    this.numeric();
+                    }
+                }
+
+                this.state = 6034;
+                this.file_specification();
+                }
+                }
+                this.state = 6039;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public character_set_clause(): Character_set_clauseContext {
+        let localContext = new Character_set_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 446, PlSqlParser.RULE_character_set_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6040;
+            this.match(PlSqlParser.CHARACTER);
+            this.state = 6041;
+            this.match(PlSqlParser.SET);
+            this.state = 6042;
+            localContext._cs = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public file_specification(): File_specificationContext {
+        let localContext = new File_specificationContext(this.context, this.state);
+        this.enterRule(localContext, 448, PlSqlParser.RULE_file_specification);
+        try {
+            this.state = 6046;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 537, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6044;
+                this.datafile_tempfile_spec();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6045;
+                this.redo_log_file_spec();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_diskgroup(): Create_diskgroupContext {
+        let localContext = new Create_diskgroupContext(this.context, this.state);
+        this.enterRule(localContext, 450, PlSqlParser.RULE_create_diskgroup);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6048;
+            this.match(PlSqlParser.CREATE);
+            this.state = 6049;
+            this.match(PlSqlParser.DISKGROUP);
+            this.state = 6050;
+            this.id_expression();
+            this.state = 6063;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 561 || _la === 610 || _la === 676 || _la === 1180 || _la === 2378) {
+                {
+                this.state = 6060;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.HIGH:
+                    {
+                    this.state = 6051;
+                    this.match(PlSqlParser.HIGH);
+                    }
+                    break;
+                case PlSqlParser.NORMAL:
+                    {
+                    this.state = 6052;
+                    this.match(PlSqlParser.NORMAL);
+                    }
+                    break;
+                case PlSqlParser.FLEX:
+                    {
+                    this.state = 6053;
+                    this.match(PlSqlParser.FLEX);
+                    }
+                    break;
+                case PlSqlParser.EXTENDED:
+                    {
+                    this.state = 6054;
+                    this.match(PlSqlParser.EXTENDED);
+                    this.state = 6057;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1690) {
+                        {
+                        this.state = 6055;
+                        this.match(PlSqlParser.SITE);
+                        this.state = 6056;
+                        localContext._sn = this.id_expression();
+                        }
+                    }
+
+                    }
+                    break;
+                case PlSqlParser.EXTERNAL:
+                    {
+                    this.state = 6059;
+                    this.match(PlSqlParser.EXTERNAL);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 6062;
+                this.match(PlSqlParser.REDUNDANCY);
+                }
+            }
+
+            this.state = 6081;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 6066;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1491 || _la === 1550) {
+                        {
+                        this.state = 6065;
+                        this.quorum_regular();
+                        }
+                    }
+
+                    this.state = 6070;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 573) {
+                        {
+                        this.state = 6068;
+                        this.match(PlSqlParser.FAILGROUP);
+                        this.state = 6069;
+                        localContext._fg = this.id_expression();
+                        }
+                    }
+
+                    this.state = 6072;
+                    this.match(PlSqlParser.DISK);
+                    this.state = 6073;
+                    this.qualified_disk_clause();
+                    this.state = 6078;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 543, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 6074;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 6075;
+                            this.qualified_disk_clause();
+                            }
+                            }
+                        }
+                        this.state = 6080;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 543, this.context);
+                    }
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 6083;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 544, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            this.state = 6098;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 546, this.context) ) {
+            case 1:
+                {
+                this.state = 6085;
+                this.match(PlSqlParser.ATTRIBUTE);
+                this.state = 6086;
+                localContext._an = this.match(PlSqlParser.CHAR_STRING);
+                this.state = 6087;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 6088;
+                localContext._av = this.match(PlSqlParser.CHAR_STRING);
+                this.state = 6095;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 545, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 6089;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 6090;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        this.state = 6091;
+                        this.match(PlSqlParser.EQUALS_OP);
+                        this.state = 6092;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        }
+                    }
+                    this.state = 6097;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 545, this.context);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public qualified_disk_clause(): Qualified_disk_clauseContext {
+        let localContext = new Qualified_disk_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 452, PlSqlParser.RULE_qualified_disk_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6100;
+            localContext._ss = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 6103;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 547, this.context) ) {
+            case 1:
+                {
+                this.state = 6101;
+                this.match(PlSqlParser.NAME);
+                this.state = 6102;
+                localContext._dn = this.id_expression();
+                }
+                break;
+            }
+            this.state = 6107;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 548, this.context) ) {
+            case 1:
+                {
+                this.state = 6105;
+                this.match(PlSqlParser.SIZE);
+                this.state = 6106;
+                this.size_clause();
+                }
+                break;
+            }
+            this.state = 6110;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 549, this.context) ) {
+            case 1:
+                {
+                this.state = 6109;
+                this.force_noforce();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_edition(): Create_editionContext {
+        let localContext = new Create_editionContext(this.context, this.state);
+        this.enterRule(localContext, 454, PlSqlParser.RULE_create_edition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6112;
+            this.match(PlSqlParser.CREATE);
+            this.state = 6113;
+            this.match(PlSqlParser.EDITION);
+            this.state = 6114;
+            localContext._e = this.id_expression();
+            this.state = 6119;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 550, this.context) ) {
+            case 1:
+                {
+                this.state = 6115;
+                this.match(PlSqlParser.AS);
+                this.state = 6116;
+                this.match(PlSqlParser.CHILD);
+                this.state = 6117;
+                this.match(PlSqlParser.OF);
+                this.state = 6118;
+                localContext._pe = this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_flashback_archive(): Create_flashback_archiveContext {
+        let localContext = new Create_flashback_archiveContext(this.context, this.state);
+        this.enterRule(localContext, 456, PlSqlParser.RULE_create_flashback_archive);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6121;
+            this.match(PlSqlParser.CREATE);
+            this.state = 6122;
+            this.match(PlSqlParser.FLASHBACK);
+            this.state = 6123;
+            this.match(PlSqlParser.ARCHIVE);
+            this.state = 6125;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389) {
+                {
+                this.state = 6124;
+                this.match(PlSqlParser.DEFAULT);
+                }
+            }
+
+            this.state = 6127;
+            localContext._fa = this.id_expression();
+            this.state = 6128;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 6129;
+            localContext._ts = this.id_expression();
+            this.state = 6131;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1492) {
+                {
+                this.state = 6130;
+                this.flashback_archive_quota();
+                }
+            }
+
+            this.state = 6138;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1139 || _la === 1271) {
+                {
+                this.state = 6134;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 6133;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 6136;
+                this.match(PlSqlParser.OPTIMIZE);
+                this.state = 6137;
+                this.match(PlSqlParser.DATA);
+                }
+            }
+
+            this.state = 6140;
+            this.flashback_archive_retention();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public flashback_archive_quota(): Flashback_archive_quotaContext {
+        let localContext = new Flashback_archive_quotaContext(this.context, this.state);
+        this.enterRule(localContext, 458, PlSqlParser.RULE_flashback_archive_quota);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6142;
+            this.match(PlSqlParser.QUOTA);
+            this.state = 6143;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            this.state = 6144;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 480 || _la === 636 || _la === 902 || _la === 1330 || _la === 2079)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public flashback_archive_retention(): Flashback_archive_retentionContext {
+        let localContext = new Flashback_archive_retentionContext(this.context, this.state);
+        this.enterRule(localContext, 460, PlSqlParser.RULE_flashback_archive_retention);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6146;
+            this.match(PlSqlParser.RETENTION);
+            this.state = 6147;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            this.state = 6148;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 365 || _la === 986 || _la === 2360)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_hierarchy(): Create_hierarchyContext {
+        let localContext = new Create_hierarchyContext(this.context, this.state);
+        this.enterRule(localContext, 462, PlSqlParser.RULE_create_hierarchy);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6150;
+            this.match(PlSqlParser.CREATE);
+            this.state = 6153;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 6151;
+                this.match(PlSqlParser.OR);
+                this.state = 6152;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 6159;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617 || _la === 1139) {
+                {
+                this.state = 6156;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 6155;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 6158;
+                this.match(PlSqlParser.FORCE);
+                }
+            }
+
+            this.state = 6161;
+            this.match(PlSqlParser.HIERARCHY);
+            this.state = 6165;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 558, this.context) ) {
+            case 1:
+                {
+                this.state = 6162;
+                this.schema_name();
+                this.state = 6163;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 6167;
+            localContext._h = this.id_expression();
+            this.state = 6171;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1683) {
+                {
+                this.state = 6168;
+                this.match(PlSqlParser.SHARING);
+                this.state = 6169;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 6170;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 6176;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 177 || _la === 207 || _la === 415) {
+                {
+                {
+                this.state = 6173;
+                this.classification_clause();
+                }
+                }
+                this.state = 6178;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6179;
+            this.hier_using_clause();
+            this.state = 6180;
+            this.level_hier_clause();
+            this.state = 6182;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 561, this.context) ) {
+            case 1:
+                {
+                this.state = 6181;
+                this.hier_attrs_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hier_using_clause(): Hier_using_clauseContext {
+        let localContext = new Hier_using_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 464, PlSqlParser.RULE_hier_using_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6184;
+            this.match(PlSqlParser.USING);
+            this.state = 6188;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 562, this.context) ) {
+            case 1:
+                {
+                this.state = 6185;
+                this.schema_name();
+                this.state = 6186;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 6190;
+            localContext._ad = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public level_hier_clause(): Level_hier_clauseContext {
+        let localContext = new Level_hier_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 466, PlSqlParser.RULE_level_hier_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6192;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6198;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 6193;
+                localContext._l = this.id_expression();
+                this.state = 6196;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 563, this.context) ) {
+                case 1:
+                    {
+                    this.state = 6194;
+                    this.match(PlSqlParser.CHILD);
+                    this.state = 6195;
+                    this.match(PlSqlParser.OF);
+                    }
+                    break;
+                }
+                }
+                }
+                this.state = 6200;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482);
+            this.state = 6202;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hier_attrs_clause(): Hier_attrs_clauseContext {
+        let localContext = new Hier_attrs_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 468, PlSqlParser.RULE_hier_attrs_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6204;
+            this.match(PlSqlParser.HIERARCHICAL);
+            this.state = 6205;
+            this.match(PlSqlParser.ATTRIBUTES);
+            this.state = 6206;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6207;
+            this.hier_attr_clause();
+            this.state = 6208;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hier_attr_clause(): Hier_attr_clauseContext {
+        let localContext = new Hier_attr_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 470, PlSqlParser.RULE_hier_attr_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6210;
+            this.hier_attr_name();
+            this.state = 6214;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 177 || _la === 207 || _la === 415) {
+                {
+                {
+                this.state = 6211;
+                this.classification_clause();
+                }
+                }
+                this.state = 6216;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hier_attr_name(): Hier_attr_nameContext {
+        let localContext = new Hier_attr_nameContext(this.context, this.state);
+        this.enterRule(localContext, 472, PlSqlParser.RULE_hier_attr_name);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6217;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 410 || _la === 672 || _la === 787 || _la === 848 || ((((_la - 938)) & ~0x1F) === 0 && ((1 << (_la - 938)) & 15) !== 0) || _la === 1340 || _la === 1341)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_index(): Create_indexContext {
+        let localContext = new Create_indexContext(this.context, this.state);
+        this.enterRule(localContext, 474, PlSqlParser.RULE_create_index);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6219;
+            this.match(PlSqlParser.CREATE);
+            this.state = 6221;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 137 || _la === 2185) {
+                {
+                this.state = 6220;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 137 || _la === 2185)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 6223;
+            this.match(PlSqlParser.INDEX);
+            this.state = 6224;
+            this.index_name();
+            this.state = 6228;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 692) {
+                {
+                this.state = 6225;
+                this.match(PlSqlParser.IF);
+                this.state = 6226;
+                this.match(PlSqlParser.NOT);
+                this.state = 6227;
+                this.match(PlSqlParser.EXISTS);
+                }
+            }
+
+            this.state = 6230;
+            this.match(PlSqlParser.ON);
+            this.state = 6234;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 568, this.context) ) {
+            case 1:
+                {
+                this.state = 6231;
+                this.cluster_index_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 6232;
+                this.table_index_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 6233;
+                this.bitmap_join_index_clause();
+                }
+                break;
+            }
+            this.state = 6237;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 569, this.context) ) {
+            case 1:
+                {
+                this.state = 6236;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2205 || _la === 2217)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 6241;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 570, this.context) ) {
+            case 1:
+                {
+                this.state = 6239;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 395 || _la === 699)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 6240;
+                this.match(PlSqlParser.INVALIDATION);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cluster_index_clause(): Cluster_index_clauseContext {
+        let localContext = new Cluster_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 476, PlSqlParser.RULE_cluster_index_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6243;
+            this.match(PlSqlParser.CLUSTER);
+            this.state = 6244;
+            this.cluster_name();
+            this.state = 6246;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 571, this.context) ) {
+            case 1:
+                {
+                this.state = 6245;
+                this.index_attributes();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cluster_name(): Cluster_nameContext {
+        let localContext = new Cluster_nameContext(this.context, this.state);
+        this.enterRule(localContext, 478, PlSqlParser.RULE_cluster_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6251;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 572, this.context) ) {
+            case 1:
+                {
+                this.state = 6248;
+                this.id_expression();
+                this.state = 6249;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 6253;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_index_clause(): Table_index_clauseContext {
+        let localContext = new Table_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 480, PlSqlParser.RULE_table_index_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6255;
+            this.tableview_name();
+            this.state = 6257;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                this.state = 6256;
+                this.table_alias();
+                }
+            }
+
+            this.state = 6259;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6260;
+            this.index_expr();
+            this.state = 6262;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 70 || _la === 414) {
+                {
+                this.state = 6261;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 70 || _la === 414)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 6271;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6264;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6265;
+                this.index_expr();
+                this.state = 6267;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 70 || _la === 414) {
+                    {
+                    this.state = 6266;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 70 || _la === 414)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                }
+                }
+                this.state = 6273;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6274;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 6276;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 577, this.context) ) {
+            case 1:
+                {
+                this.state = 6275;
+                this.index_properties();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public bitmap_join_index_clause(): Bitmap_join_index_clauseContext {
+        let localContext = new Bitmap_join_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 482, PlSqlParser.RULE_bitmap_join_index_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6278;
+            this.tableview_name();
+            this.state = 6279;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6282;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 578, this.context) ) {
+            case 1:
+                {
+                this.state = 6280;
+                this.tableview_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 6281;
+                this.table_alias();
+                }
+                break;
+            }
+            this.state = 6284;
+            this.column_name();
+            this.state = 6286;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 70 || _la === 414) {
+                {
+                this.state = 6285;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 70 || _la === 414)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 6299;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6288;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6291;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 580, this.context) ) {
+                case 1:
+                    {
+                    this.state = 6289;
+                    this.tableview_name();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 6290;
+                    this.table_alias();
+                    }
+                    break;
+                }
+                this.state = 6293;
+                this.column_name();
+                this.state = 6295;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 70 || _la === 414) {
+                    {
+                    this.state = 6294;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 70 || _la === 414)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                }
+                }
+                this.state = 6301;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6302;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 6303;
+            this.match(PlSqlParser.FROM);
+            this.state = 6304;
+            this.tableview_name();
+            this.state = 6305;
+            this.table_alias();
+            this.state = 6312;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6306;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6307;
+                this.tableview_name();
+                this.state = 6308;
+                this.table_alias();
+                }
+                }
+                this.state = 6314;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6315;
+            this.where_clause();
+            this.state = 6317;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 584, this.context) ) {
+            case 1:
+                {
+                this.state = 6316;
+                this.local_partitioned_index();
+                }
+                break;
+            }
+            this.state = 6320;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 585, this.context) ) {
+            case 1:
+                {
+                this.state = 6319;
+                this.index_attributes();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_expr(): Index_exprContext {
+        let localContext = new Index_exprContext(this.context, this.state);
+        this.enterRule(localContext, 484, PlSqlParser.RULE_index_expr);
+        try {
+            this.state = 6324;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 586, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6322;
+                this.column_name();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6323;
+                this.expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_properties(): Index_propertiesContext {
+        let localContext = new Index_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 486, PlSqlParser.RULE_index_properties);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6339;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 590, this.context) ) {
+            case 1:
+                {
+                this.state = 6329;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 6329;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.GLOBAL:
+                            {
+                            this.state = 6326;
+                            this.global_partitioned_index();
+                            }
+                            break;
+                        case PlSqlParser.LOCAL:
+                            {
+                            this.state = 6327;
+                            this.local_partitioned_index();
+                            }
+                            break;
+                        case PlSqlParser.COMPRESS:
+                        case PlSqlParser.COMPUTE:
+                        case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                        case PlSqlParser.INITRANS:
+                        case PlSqlParser.INVISIBLE:
+                        case PlSqlParser.LOGGING:
+                        case PlSqlParser.MAXTRANS:
+                        case PlSqlParser.NOCOMPRESS:
+                        case PlSqlParser.NOLOGGING:
+                        case PlSqlParser.NOPARALLEL:
+                        case PlSqlParser.NOSORT:
+                        case PlSqlParser.ONLINE:
+                        case PlSqlParser.PARALLEL:
+                        case PlSqlParser.PCTFREE:
+                        case PlSqlParser.PCTUSED:
+                        case PlSqlParser.REVERSE:
+                        case PlSqlParser.SORT:
+                        case PlSqlParser.STORAGE:
+                        case PlSqlParser.TABLESPACE:
+                        case PlSqlParser.VISIBLE:
+                            {
+                            this.state = 6328;
+                            this.index_attributes();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 6331;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 588, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 2:
+                {
+                this.state = 6333;
+                this.match(PlSqlParser.INDEXTYPE);
+                this.state = 6334;
+                this.match(PlSqlParser.IS);
+                this.state = 6337;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 6335;
+                    this.domain_index_clause();
+                    }
+                    break;
+                case PlSqlParser.XDB:
+                case PlSqlParser.XMLINDEX:
+                    {
+                    this.state = 6336;
+                    this.xmlindex_clause();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public domain_index_clause(): Domain_index_clauseContext {
+        let localContext = new Domain_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 488, PlSqlParser.RULE_domain_index_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6341;
+            this.indextype();
+            this.state = 6343;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 591, this.context) ) {
+            case 1:
+                {
+                this.state = 6342;
+                this.local_domain_index_clause();
+                }
+                break;
+            }
+            this.state = 6346;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 592, this.context) ) {
+            case 1:
+                {
+                this.state = 6345;
+                this.parallel_clause();
+                }
+                break;
+            }
+            this.state = 6353;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 593, this.context) ) {
+            case 1:
+                {
+                this.state = 6348;
+                this.match(PlSqlParser.PARAMETERS);
+                this.state = 6349;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6350;
+                this.odci_parameters();
+                this.state = 6351;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public local_domain_index_clause(): Local_domain_index_clauseContext {
+        let localContext = new Local_domain_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 490, PlSqlParser.RULE_local_domain_index_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6355;
+            this.match(PlSqlParser.LOCAL);
+            this.state = 6383;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 597, this.context) ) {
+            case 1:
+                {
+                this.state = 6356;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6357;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 6358;
+                this.partition_name();
+                this.state = 6364;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1337) {
+                    {
+                    this.state = 6359;
+                    this.match(PlSqlParser.PARAMETERS);
+                    this.state = 6360;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 6361;
+                    this.odci_parameters();
+                    this.state = 6362;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                this.state = 6378;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6366;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6367;
+                    this.match(PlSqlParser.PARTITION);
+                    this.state = 6368;
+                    this.partition_name();
+                    this.state = 6374;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1337) {
+                        {
+                        this.state = 6369;
+                        this.match(PlSqlParser.PARAMETERS);
+                        this.state = 6370;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 6371;
+                        this.odci_parameters();
+                        this.state = 6372;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                    }
+
+                    }
+                    }
+                    this.state = 6380;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6381;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlindex_clause(): Xmlindex_clauseContext {
+        let localContext = new Xmlindex_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 492, PlSqlParser.RULE_xmlindex_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6387;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2317) {
+                {
+                this.state = 6385;
+                this.match(PlSqlParser.XDB);
+                this.state = 6386;
+                this.match(PlSqlParser.PERIOD);
+                }
+            }
+
+            this.state = 6389;
+            this.match(PlSqlParser.XMLINDEX);
+            this.state = 6391;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 599, this.context) ) {
+            case 1:
+                {
+                this.state = 6390;
+                this.local_xmlindex_clause();
+                }
+                break;
+            }
+            this.state = 6394;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 600, this.context) ) {
+            case 1:
+                {
+                this.state = 6393;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public local_xmlindex_clause(): Local_xmlindex_clauseContext {
+        let localContext = new Local_xmlindex_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 494, PlSqlParser.RULE_local_xmlindex_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6396;
+            this.match(PlSqlParser.LOCAL);
+            this.state = 6410;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 602, this.context) ) {
+            case 1:
+                {
+                this.state = 6397;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6398;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 6399;
+                this.partition_name();
+                this.state = 6405;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6400;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6401;
+                    this.match(PlSqlParser.PARTITION);
+                    this.state = 6402;
+                    this.partition_name();
+                    }
+                    }
+                    this.state = 6407;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6408;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public global_partitioned_index(): Global_partitioned_indexContext {
+        let localContext = new Global_partitioned_indexContext(this.context, this.state);
+        this.enterRule(localContext, 496, PlSqlParser.RULE_global_partitioned_index);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6412;
+            this.match(PlSqlParser.GLOBAL);
+            this.state = 6413;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6414;
+            this.match(PlSqlParser.BY);
+            this.state = 6452;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RANGE:
+                {
+                this.state = 6415;
+                this.match(PlSqlParser.RANGE);
+                this.state = 6416;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6417;
+                this.column_name();
+                this.state = 6422;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6418;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6419;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 6424;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6425;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 6426;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6427;
+                this.index_partitioning_clause();
+                this.state = 6432;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6428;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6429;
+                    this.index_partitioning_clause();
+                    }
+                    }
+                    this.state = 6434;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6435;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.HASH:
+                {
+                this.state = 6437;
+                this.match(PlSqlParser.HASH);
+                this.state = 6438;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6439;
+                this.column_name();
+                this.state = 6444;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6440;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6441;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 6446;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6447;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 6450;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 6448;
+                    this.individual_hash_partitions();
+                    }
+                    break;
+                case PlSqlParser.PARTITIONS:
+                    {
+                    this.state = 6449;
+                    this.hash_partitions_by_quantity();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_partitioning_clause(): Index_partitioning_clauseContext {
+        let localContext = new Index_partitioning_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 498, PlSqlParser.RULE_index_partitioning_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6454;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6456;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 6455;
+                this.partition_name();
+                }
+            }
+
+            this.state = 6458;
+            this.match(PlSqlParser.VALUES);
+            this.state = 6459;
+            this.match(PlSqlParser.LESS);
+            this.state = 6460;
+            this.match(PlSqlParser.THAN);
+            this.state = 6461;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6462;
+            this.index_partitioning_values_list();
+            this.state = 6463;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 6465;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 10485761) !== 0) || _la === 594 || _la === 744 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1764 || _la === 2082) {
+                {
+                this.state = 6464;
+                this.segment_attributes_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_partitioning_values_list(): Index_partitioning_values_listContext {
+        let localContext = new Index_partitioning_values_listContext(this.context, this.state);
+        this.enterRule(localContext, 500, PlSqlParser.RULE_index_partitioning_values_list);
+        let _la: number;
+        try {
+            this.state = 6485;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHR:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.DECODE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.MINUS_SIGN:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6467;
+                this.literal();
+                this.state = 6472;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6468;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6469;
+                    this.literal();
+                    }
+                    }
+                    this.state = 6474;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6475;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 6476;
+                this.literal();
+                this.state = 6482;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6477;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6478;
+                    this.match(PlSqlParser.TIMESTAMP);
+                    this.state = 6479;
+                    this.literal();
+                    }
+                    }
+                    this.state = 6484;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public local_partitioned_index(): Local_partitioned_indexContext {
+        let localContext = new Local_partitioned_indexContext(this.context, this.state);
+        this.enterRule(localContext, 502, PlSqlParser.RULE_local_partitioned_index);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6487;
+            this.match(PlSqlParser.LOCAL);
+            this.state = 6492;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 613, this.context) ) {
+            case 1:
+                {
+                this.state = 6488;
+                this.on_range_partitioned_table();
+                }
+                break;
+            case 2:
+                {
+                this.state = 6489;
+                this.on_list_partitioned_table();
+                }
+                break;
+            case 3:
+                {
+                this.state = 6490;
+                this.on_hash_partitioned_table();
+                }
+                break;
+            case 4:
+                {
+                this.state = 6491;
+                this.on_comp_partitioned_table();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_range_partitioned_table(): On_range_partitioned_tableContext {
+        let localContext = new On_range_partitioned_tableContext(this.context, this.state);
+        this.enterRule(localContext, 504, PlSqlParser.RULE_on_range_partitioned_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6494;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6495;
+            this.partitioned_table();
+            this.state = 6500;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6496;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6497;
+                this.partitioned_table();
+                }
+                }
+                this.state = 6502;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6503;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_list_partitioned_table(): On_list_partitioned_tableContext {
+        let localContext = new On_list_partitioned_tableContext(this.context, this.state);
+        this.enterRule(localContext, 506, PlSqlParser.RULE_on_list_partitioned_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6505;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6506;
+            this.partitioned_table();
+            this.state = 6511;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6507;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6508;
+                this.partitioned_table();
+                }
+                }
+                this.state = 6513;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6514;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partitioned_table(): Partitioned_tableContext {
+        let localContext = new Partitioned_tableContext(this.context, this.state);
+        this.enterRule(localContext, 508, PlSqlParser.RULE_partitioned_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6516;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6518;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 616, this.context) ) {
+            case 1:
+                {
+                this.state = 6517;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 6524;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 10485761) !== 0) || _la === 594 || _la === 744 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1764 || _la === 2082) {
+                {
+                this.state = 6522;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 617, this.context) ) {
+                case 1:
+                    {
+                    this.state = 6520;
+                    this.segment_attributes_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 6521;
+                    this.key_compression();
+                    }
+                    break;
+                }
+                }
+                this.state = 6526;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6528;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2205) {
+                {
+                this.state = 6527;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_hash_partitioned_table(): On_hash_partitioned_tableContext {
+        let localContext = new On_hash_partitioned_tableContext(this.context, this.state);
+        this.enterRule(localContext, 510, PlSqlParser.RULE_on_hash_partitioned_table);
+        let _la: number;
+        try {
+            this.state = 6554;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.STORE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6530;
+                this.match(PlSqlParser.STORE);
+                this.state = 6531;
+                this.match(PlSqlParser.IN);
+                this.state = 6532;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6533;
+                this.tablespace();
+                this.state = 6538;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6534;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6535;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 6540;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6541;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6543;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6544;
+                this.on_hash_partitioned_clause();
+                this.state = 6549;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6545;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6546;
+                    this.on_hash_partitioned_clause();
+                    }
+                    }
+                    this.state = 6551;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6552;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_hash_partitioned_clause(): On_hash_partitioned_clauseContext {
+        let localContext = new On_hash_partitioned_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 512, PlSqlParser.RULE_on_hash_partitioned_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6556;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6558;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 623, this.context) ) {
+            case 1:
+                {
+                this.state = 6557;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 6562;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2082) {
+                {
+                this.state = 6560;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 6561;
+                this.tablespace();
+                }
+            }
+
+            this.state = 6565;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 258 || _la === 1075) {
+                {
+                this.state = 6564;
+                this.key_compression();
+                }
+            }
+
+            this.state = 6568;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2205) {
+                {
+                this.state = 6567;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_comp_partitioned_table(): On_comp_partitioned_tableContext {
+        let localContext = new On_comp_partitioned_tableContext(this.context, this.state);
+        this.enterRule(localContext, 514, PlSqlParser.RULE_on_comp_partitioned_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6583;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1765) {
+                {
+                this.state = 6570;
+                this.match(PlSqlParser.STORE);
+                this.state = 6571;
+                this.match(PlSqlParser.IN);
+                this.state = 6572;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6573;
+                this.tablespace();
+                this.state = 6578;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6574;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6575;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 6580;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6581;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 6585;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6586;
+            this.on_comp_partitioned_clause();
+            this.state = 6591;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6587;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6588;
+                this.on_comp_partitioned_clause();
+                }
+                }
+                this.state = 6593;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6594;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_comp_partitioned_clause(): On_comp_partitioned_clauseContext {
+        let localContext = new On_comp_partitioned_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 516, PlSqlParser.RULE_on_comp_partitioned_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6596;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6598;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 630, this.context) ) {
+            case 1:
+                {
+                this.state = 6597;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 6604;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 10485761) !== 0) || _la === 594 || _la === 744 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1764 || _la === 2082) {
+                {
+                this.state = 6602;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 631, this.context) ) {
+                case 1:
+                    {
+                    this.state = 6600;
+                    this.segment_attributes_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 6601;
+                    this.key_compression();
+                    }
+                    break;
+                }
+                }
+                this.state = 6606;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6608;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2205) {
+                {
+                this.state = 6607;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+            }
+
+            this.state = 6611;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1765 || _la === 2449) {
+                {
+                this.state = 6610;
+                this.index_subpartition_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_subpartition_clause(): Index_subpartition_clauseContext {
+        let localContext = new Index_subpartition_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 518, PlSqlParser.RULE_index_subpartition_clause);
+        let _la: number;
+        try {
+            this.state = 6637;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.STORE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6613;
+                this.match(PlSqlParser.STORE);
+                this.state = 6614;
+                this.match(PlSqlParser.IN);
+                this.state = 6615;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6616;
+                this.tablespace();
+                this.state = 6621;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6617;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6618;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 6623;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6624;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6626;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6627;
+                this.index_subpartition_subclause();
+                this.state = 6632;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6628;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6629;
+                    this.index_subpartition_subclause();
+                    }
+                    }
+                    this.state = 6634;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6635;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_subpartition_subclause(): Index_subpartition_subclauseContext {
+        let localContext = new Index_subpartition_subclauseContext(this.context, this.state);
+        this.enterRule(localContext, 520, PlSqlParser.RULE_index_subpartition_subclause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6639;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 6641;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 638, this.context) ) {
+            case 1:
+                {
+                this.state = 6640;
+                this.subpartition_name();
+                }
+                break;
+            }
+            this.state = 6645;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2082) {
+                {
+                this.state = 6643;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 6644;
+                this.tablespace();
+                }
+            }
+
+            this.state = 6648;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 258 || _la === 1075) {
+                {
+                this.state = 6647;
+                this.key_compression();
+                }
+            }
+
+            this.state = 6651;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2205) {
+                {
+                this.state = 6650;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public odci_parameters(): Odci_parametersContext {
+        let localContext = new Odci_parametersContext(this.context, this.state);
+        this.enterRule(localContext, 522, PlSqlParser.RULE_odci_parameters);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6653;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public indextype(): IndextypeContext {
+        let localContext = new IndextypeContext(this.context, this.state);
+        this.enterRule(localContext, 524, PlSqlParser.RULE_indextype);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6658;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 642, this.context) ) {
+            case 1:
+                {
+                this.state = 6655;
+                this.id_expression();
+                this.state = 6656;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 6660;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_index(): Alter_indexContext {
+        let localContext = new Alter_indexContext(this.context, this.state);
+        this.enterRule(localContext, 526, PlSqlParser.RULE_alter_index);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6662;
+            this.match(PlSqlParser.ALTER);
+            this.state = 6663;
+            this.match(PlSqlParser.INDEX);
+            this.state = 6664;
+            this.index_name();
+            this.state = 6667;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.STORAGE:
+                {
+                this.state = 6665;
+                this.alter_index_ops_set1();
+                }
+                break;
+            case PlSqlParser.ADD:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DROP:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UPDATE:
+            case PlSqlParser.VISIBLE:
+                {
+                this.state = 6666;
+                this.alter_index_ops_set2();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_index_ops_set1(): Alter_index_ops_set1Context {
+        let localContext = new Alter_index_ops_set1Context(this.context, this.state);
+        this.enterRule(localContext, 528, PlSqlParser.RULE_alter_index_ops_set1);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6675;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 6675;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.DEALLOCATE:
+                        {
+                        this.state = 6669;
+                        this.deallocate_unused_clause();
+                        }
+                        break;
+                    case PlSqlParser.ALLOCATE:
+                        {
+                        this.state = 6670;
+                        this.allocate_extent_clause();
+                        }
+                        break;
+                    case PlSqlParser.SHRINK:
+                        {
+                        this.state = 6671;
+                        this.shrink_clause();
+                        }
+                        break;
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.PARALLEL:
+                        {
+                        this.state = 6672;
+                        this.parallel_clause();
+                        }
+                        break;
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.PCTFREE:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 6673;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.NOLOGGING:
+                        {
+                        this.state = 6674;
+                        this.logging_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 6677;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 645, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_index_ops_set2(): Alter_index_ops_set2Context {
+        let localContext = new Alter_index_ops_set2Context(this.context, this.state);
+        this.enterRule(localContext, 530, PlSqlParser.RULE_alter_index_ops_set2);
+        try {
+            this.state = 6700;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 646, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6679;
+                this.rebuild_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6680;
+                this.match(PlSqlParser.PARAMETERS);
+                this.state = 6681;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6682;
+                this.odci_parameters();
+                this.state = 6683;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 6685;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 6686;
+                this.enable_or_disable();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 6687;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 6688;
+                this.visible_or_invisible();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 6689;
+                this.match(PlSqlParser.RENAME);
+                this.state = 6690;
+                this.match(PlSqlParser.TO);
+                this.state = 6691;
+                this.new_index_name();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 6692;
+                this.match(PlSqlParser.COALESCE);
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 6693;
+                this.monitoring_nomonitoring();
+                this.state = 6694;
+                this.match(PlSqlParser.USAGE);
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 6696;
+                this.match(PlSqlParser.UPDATE);
+                this.state = 6697;
+                this.match(PlSqlParser.BLOCK);
+                this.state = 6698;
+                this.match(PlSqlParser.REFERENCES);
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 6699;
+                this.alter_index_partitioning();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public visible_or_invisible(): Visible_or_invisibleContext {
+        let localContext = new Visible_or_invisibleContext(this.context, this.state);
+        this.enterRule(localContext, 532, PlSqlParser.RULE_visible_or_invisible);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6702;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 783 || _la === 2292)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public monitoring_nomonitoring(): Monitoring_nomonitoringContext {
+        let localContext = new Monitoring_nomonitoringContext(this.context, this.state);
+        this.enterRule(localContext, 534, PlSqlParser.RULE_monitoring_nomonitoring);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6704;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 984 || _la === 1128)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rebuild_clause(): Rebuild_clauseContext {
+        let localContext = new Rebuild_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 536, PlSqlParser.RULE_rebuild_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6706;
+            this.match(PlSqlParser.REBUILD);
+            this.state = 6713;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 647, this.context) ) {
+            case 1:
+                {
+                this.state = 6707;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 6708;
+                this.partition_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 6709;
+                this.match(PlSqlParser.SUBPARTITION);
+                this.state = 6710;
+                this.subpartition_name();
+                }
+                break;
+            case 3:
+                {
+                this.state = 6711;
+                this.match(PlSqlParser.REVERSE);
+                }
+                break;
+            case 4:
+                {
+                this.state = 6712;
+                this.match(PlSqlParser.NOREVERSE);
+                }
+                break;
+            }
+            this.state = 6729;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 649, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 6727;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.PARALLEL:
+                        {
+                        this.state = 6715;
+                        this.parallel_clause();
+                        }
+                        break;
+                    case PlSqlParser.TABLESPACE:
+                        {
+                        this.state = 6716;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 6717;
+                        this.tablespace();
+                        }
+                        break;
+                    case PlSqlParser.PARAMETERS:
+                        {
+                        this.state = 6718;
+                        this.match(PlSqlParser.PARAMETERS);
+                        this.state = 6719;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 6720;
+                        this.odci_parameters();
+                        this.state = 6721;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    case PlSqlParser.ONLINE:
+                        {
+                        this.state = 6723;
+                        this.match(PlSqlParser.ONLINE);
+                        }
+                        break;
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.PCTFREE:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 6724;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case PlSqlParser.COMPRESS:
+                    case PlSqlParser.NOCOMPRESS:
+                        {
+                        this.state = 6725;
+                        this.key_compression();
+                        }
+                        break;
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.NOLOGGING:
+                        {
+                        this.state = 6726;
+                        this.logging_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 6731;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 649, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_index_partitioning(): Alter_index_partitioningContext {
+        let localContext = new Alter_index_partitioningContext(this.context, this.state);
+        this.enterRule(localContext, 538, PlSqlParser.RULE_alter_index_partitioning);
+        try {
+            this.state = 6740;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 650, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6732;
+                this.modify_index_default_attrs();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6733;
+                this.add_hash_index_partition();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 6734;
+                this.modify_index_partition();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 6735;
+                this.rename_index_partition();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 6736;
+                this.drop_index_partition();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 6737;
+                this.split_index_partition();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 6738;
+                this.coalesce_index_partition();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 6739;
+                this.modify_index_subpartition();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_index_default_attrs(): Modify_index_default_attrsContext {
+        let localContext = new Modify_index_default_attrsContext(this.context, this.state);
+        this.enterRule(localContext, 540, PlSqlParser.RULE_modify_index_default_attrs);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6742;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 6743;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 6744;
+            this.match(PlSqlParser.ATTRIBUTES);
+            this.state = 6748;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 621) {
+                {
+                this.state = 6745;
+                this.match(PlSqlParser.FOR);
+                this.state = 6746;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 6747;
+                this.partition_name();
+                }
+            }
+
+            this.state = 6757;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.STORAGE:
+                {
+                this.state = 6750;
+                this.physical_attributes_clause();
+                }
+                break;
+            case PlSqlParser.TABLESPACE:
+                {
+                this.state = 6751;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 6754;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 6752;
+                    this.tablespace();
+                    }
+                    break;
+                case PlSqlParser.DEFAULT:
+                    {
+                    this.state = 6753;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.NOLOGGING:
+                {
+                this.state = 6756;
+                this.logging_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_hash_index_partition(): Add_hash_index_partitionContext {
+        let localContext = new Add_hash_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 542, PlSqlParser.RULE_add_hash_index_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6759;
+            this.match(PlSqlParser.ADD);
+            this.state = 6760;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6762;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 654, this.context) ) {
+            case 1:
+                {
+                this.state = 6761;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 6766;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 655, this.context) ) {
+            case 1:
+                {
+                this.state = 6764;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 6765;
+                this.tablespace();
+                }
+                break;
+            }
+            this.state = 6769;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 656, this.context) ) {
+            case 1:
+                {
+                this.state = 6768;
+                this.key_compression();
+                }
+                break;
+            }
+            this.state = 6772;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 657, this.context) ) {
+            case 1:
+                {
+                this.state = 6771;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public coalesce_index_partition(): Coalesce_index_partitionContext {
+        let localContext = new Coalesce_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 544, PlSqlParser.RULE_coalesce_index_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6774;
+            this.match(PlSqlParser.COALESCE);
+            this.state = 6775;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6777;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 658, this.context) ) {
+            case 1:
+                {
+                this.state = 6776;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_index_partition(): Modify_index_partitionContext {
+        let localContext = new Modify_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 546, PlSqlParser.RULE_modify_index_partition);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6779;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 6780;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6781;
+            this.partition_name();
+            this.state = 6797;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.STORAGE:
+                {
+                this.state = 6783;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 6782;
+                        this.modify_index_partitions_ops();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 6785;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 659, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.PARAMETERS:
+                {
+                this.state = 6787;
+                this.match(PlSqlParser.PARAMETERS);
+                this.state = 6788;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6789;
+                this.odci_parameters();
+                this.state = 6790;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.COALESCE:
+                {
+                this.state = 6792;
+                this.match(PlSqlParser.COALESCE);
+                }
+                break;
+            case PlSqlParser.UPDATE:
+                {
+                this.state = 6793;
+                this.match(PlSqlParser.UPDATE);
+                this.state = 6794;
+                this.match(PlSqlParser.BLOCK);
+                this.state = 6795;
+                this.match(PlSqlParser.REFERENCES);
+                }
+                break;
+            case PlSqlParser.UNUSABLE:
+                {
+                this.state = 6796;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_index_partitions_ops(): Modify_index_partitions_opsContext {
+        let localContext = new Modify_index_partitions_opsContext(this.context, this.state);
+        this.enterRule(localContext, 548, PlSqlParser.RULE_modify_index_partitions_ops);
+        try {
+            this.state = 6805;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DEALLOCATE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6799;
+                this.deallocate_unused_clause();
+                }
+                break;
+            case PlSqlParser.ALLOCATE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6800;
+                this.allocate_extent_clause();
+                }
+                break;
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.STORAGE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 6801;
+                this.physical_attributes_clause();
+                }
+                break;
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.NOLOGGING:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 6802;
+                this.logging_clause();
+                }
+                break;
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.NOCOMPRESS:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 6803;
+                this.key_compression();
+                }
+                break;
+            case PlSqlParser.SHRINK:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 6804;
+                this.shrink_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rename_index_partition(): Rename_index_partitionContext {
+        let localContext = new Rename_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 550, PlSqlParser.RULE_rename_index_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6807;
+            this.match(PlSqlParser.RENAME);
+            this.state = 6812;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+                {
+                this.state = 6808;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 6809;
+                this.partition_name();
+                }
+                break;
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 6810;
+                this.match(PlSqlParser.SUBPARTITION);
+                this.state = 6811;
+                this.subpartition_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 6814;
+            this.match(PlSqlParser.TO);
+            this.state = 6815;
+            this.new_partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_index_partition(): Drop_index_partitionContext {
+        let localContext = new Drop_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 552, PlSqlParser.RULE_drop_index_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6817;
+            this.match(PlSqlParser.DROP);
+            this.state = 6818;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6819;
+            this.partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public split_index_partition(): Split_index_partitionContext {
+        let localContext = new Split_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 554, PlSqlParser.RULE_split_index_partition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6821;
+            this.match(PlSqlParser.SPLIT);
+            this.state = 6822;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6823;
+            this.partition_name_old();
+            this.state = 6824;
+            this.match(PlSqlParser.AT);
+            this.state = 6825;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6826;
+            this.literal();
+            this.state = 6831;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 6827;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6828;
+                this.literal();
+                }
+                }
+                this.state = 6833;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 6834;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 6842;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 664, this.context) ) {
+            case 1:
+                {
+                this.state = 6835;
+                this.match(PlSqlParser.INTO);
+                this.state = 6836;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 6837;
+                this.index_partition_description();
+                this.state = 6838;
+                this.match(PlSqlParser.COMMA);
+                this.state = 6839;
+                this.index_partition_description();
+                this.state = 6840;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 6845;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 665, this.context) ) {
+            case 1:
+                {
+                this.state = 6844;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_partition_description(): Index_partition_descriptionContext {
+        let localContext = new Index_partition_descriptionContext(this.context, this.state);
+        this.enterRule(localContext, 556, PlSqlParser.RULE_index_partition_description);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6847;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 6865;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 670, this.context) ) {
+            case 1:
+                {
+                this.state = 6848;
+                this.partition_name();
+                this.state = 6860;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COMPRESS:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.NOCOMPRESS:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.PCTFREE:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.ROW:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.TABLESPACE:
+                    {
+                    this.state = 6851;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    do {
+                        {
+                        this.state = 6851;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 666, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 6849;
+                            this.segment_attributes_clause();
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 6850;
+                            this.key_compression();
+                            }
+                            break;
+                        }
+                        }
+                        this.state = 6853;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    } while (((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 10485761) !== 0) || _la === 594 || _la === 744 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1764 || _la === 2082);
+                    }
+                    break;
+                case PlSqlParser.PARAMETERS:
+                    {
+                    this.state = 6855;
+                    this.match(PlSqlParser.PARAMETERS);
+                    this.state = 6856;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 6857;
+                    this.odci_parameters();
+                    this.state = 6858;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 6863;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2205) {
+                    {
+                    this.state = 6862;
+                    this.match(PlSqlParser.UNUSABLE);
+                    }
+                }
+
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_index_subpartition(): Modify_index_subpartitionContext {
+        let localContext = new Modify_index_subpartitionContext(this.context, this.state);
+        this.enterRule(localContext, 558, PlSqlParser.RULE_modify_index_subpartition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6867;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 6868;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 6869;
+            this.subpartition_name();
+            this.state = 6872;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNUSABLE:
+                {
+                this.state = 6870;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+                break;
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.STORAGE:
+                {
+                this.state = 6871;
+                this.modify_index_partitions_ops();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_name_old(): Partition_name_oldContext {
+        let localContext = new Partition_name_oldContext(this.context, this.state);
+        this.enterRule(localContext, 560, PlSqlParser.RULE_partition_name_old);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6874;
+            this.partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public new_partition_name(): New_partition_nameContext {
+        let localContext = new New_partition_nameContext(this.context, this.state);
+        this.enterRule(localContext, 562, PlSqlParser.RULE_new_partition_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6876;
+            this.partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public new_index_name(): New_index_nameContext {
+        let localContext = new New_index_nameContext(this.context, this.state);
+        this.enterRule(localContext, 564, PlSqlParser.RULE_new_index_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6878;
+            this.index_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_inmemory_join_group(): Alter_inmemory_join_groupContext {
+        let localContext = new Alter_inmemory_join_groupContext(this.context, this.state);
+        this.enterRule(localContext, 566, PlSqlParser.RULE_alter_inmemory_join_group);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6880;
+            this.match(PlSqlParser.ALTER);
+            this.state = 6881;
+            this.match(PlSqlParser.INMEMORY);
+            this.state = 6882;
+            this.match(PlSqlParser.JOIN);
+            this.state = 6883;
+            this.match(PlSqlParser.GROUP);
+            this.state = 6887;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 672, this.context) ) {
+            case 1:
+                {
+                this.state = 6884;
+                this.schema_name();
+                this.state = 6885;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 6889;
+            localContext._jg = this.id_expression();
+            this.state = 6890;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 21 || _la === 1560)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 6891;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6895;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 673, this.context) ) {
+            case 1:
+                {
+                this.state = 6892;
+                this.schema_name();
+                this.state = 6893;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 6897;
+            localContext._t = this.id_expression();
+            this.state = 6898;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 6899;
+            localContext._c = this.id_expression();
+            this.state = 6900;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 6901;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_user(): Create_userContext {
+        let localContext = new Create_userContext(this.context, this.state);
+        this.enterRule(localContext, 568, PlSqlParser.RULE_create_user);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6903;
+            this.match(PlSqlParser.CREATE);
+            this.state = 6904;
+            this.match(PlSqlParser.USER);
+            this.state = 6905;
+            this.user_object_name();
+            this.state = 6909;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 692) {
+                {
+                this.state = 6906;
+                this.match(PlSqlParser.IF);
+                this.state = 6907;
+                this.match(PlSqlParser.NOT);
+                this.state = 6908;
+                this.match(PlSqlParser.EXISTS);
+                }
+            }
+
+            this.state = 6920;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 6920;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 675, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 6911;
+                        this.identified_by();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 6912;
+                        this.identified_other_clause();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 6913;
+                        this.user_tablespace_clause();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 6914;
+                        this.quota_clause();
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 6915;
+                        this.profile_clause();
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 6916;
+                        this.password_expire_clause();
+                        }
+                        break;
+                    case 7:
+                        {
+                        this.state = 6917;
+                        this.user_lock_clause();
+                        }
+                        break;
+                    case 8:
+                        {
+                        this.state = 6918;
+                        this.user_editions_clause();
+                        }
+                        break;
+                    case 9:
+                        {
+                        this.state = 6919;
+                        this.container_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 6922;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 676, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_user(): Alter_userContext {
+        let localContext = new Alter_userContext(this.context, this.state);
+        this.enterRule(localContext, 570, PlSqlParser.RULE_alter_user);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 6952;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALTER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6924;
+                this.match(PlSqlParser.ALTER);
+                this.state = 6925;
+                this.match(PlSqlParser.USER);
+                this.state = 6926;
+                this.user_object_name();
+                this.state = 6938;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 6938;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 677, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 6927;
+                            this.alter_identified_by();
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 6928;
+                            this.identified_other_clause();
+                            }
+                            break;
+                        case 3:
+                            {
+                            this.state = 6929;
+                            this.user_tablespace_clause();
+                            }
+                            break;
+                        case 4:
+                            {
+                            this.state = 6930;
+                            this.quota_clause();
+                            }
+                            break;
+                        case 5:
+                            {
+                            this.state = 6931;
+                            this.profile_clause();
+                            }
+                            break;
+                        case 6:
+                            {
+                            this.state = 6932;
+                            this.user_default_role_clause();
+                            }
+                            break;
+                        case 7:
+                            {
+                            this.state = 6933;
+                            this.password_expire_clause();
+                            }
+                            break;
+                        case 8:
+                            {
+                            this.state = 6934;
+                            this.user_lock_clause();
+                            }
+                            break;
+                        case 9:
+                            {
+                            this.state = 6935;
+                            this.alter_user_editions_clause();
+                            }
+                            break;
+                        case 10:
+                            {
+                            this.state = 6936;
+                            this.container_clause();
+                            }
+                            break;
+                        case 11:
+                            {
+                            this.state = 6937;
+                            this.container_data_clause();
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 6940;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 678, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 6942;
+                this.user_object_name();
+                this.state = 6947;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 6943;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 6944;
+                    this.user_object_name();
+                    }
+                    }
+                    this.state = 6949;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 6950;
+                this.proxy_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_user(): Drop_userContext {
+        let localContext = new Drop_userContext(this.context, this.state);
+        this.enterRule(localContext, 572, PlSqlParser.RULE_drop_user);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6954;
+            this.match(PlSqlParser.DROP);
+            this.state = 6955;
+            this.match(PlSqlParser.USER);
+            this.state = 6956;
+            this.user_object_name();
+            this.state = 6959;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 681, this.context) ) {
+            case 1:
+                {
+                this.state = 6957;
+                this.match(PlSqlParser.IF);
+                this.state = 6958;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 6962;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 682, this.context) ) {
+            case 1:
+                {
+                this.state = 6961;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_identified_by(): Alter_identified_byContext {
+        let localContext = new Alter_identified_byContext(this.context, this.state);
+        this.enterRule(localContext, 574, PlSqlParser.RULE_alter_identified_by);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6964;
+            this.identified_by();
+            this.state = 6967;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 683, this.context) ) {
+            case 1:
+                {
+                this.state = 6965;
+                this.match(PlSqlParser.REPLACE);
+                this.state = 6966;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identified_by(): Identified_byContext {
+        let localContext = new Identified_byContext(this.context, this.state);
+        this.enterRule(localContext, 576, PlSqlParser.RULE_identified_by);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6969;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 6970;
+            this.match(PlSqlParser.BY);
+            this.state = 6971;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identified_other_clause(): Identified_other_clauseContext {
+        let localContext = new Identified_other_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 578, PlSqlParser.RULE_identified_other_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6973;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 6974;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 562 || _la === 644)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 6977;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 684, this.context) ) {
+            case 1:
+                {
+                this.state = 6975;
+                this.match(PlSqlParser.AS);
+                this.state = 6976;
+                this.quoted_string();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public user_tablespace_clause(): User_tablespace_clauseContext {
+        let localContext = new User_tablespace_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 580, PlSqlParser.RULE_user_tablespace_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6979;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 389 || _la === 2094)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 6980;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 6981;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public quota_clause(): Quota_clauseContext {
+        let localContext = new Quota_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 582, PlSqlParser.RULE_quota_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6983;
+            this.match(PlSqlParser.QUOTA);
+            this.state = 6986;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 6984;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.UNLIMITED:
+                {
+                this.state = 6985;
+                this.match(PlSqlParser.UNLIMITED);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 6988;
+            this.match(PlSqlParser.ON);
+            this.state = 6989;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public profile_clause(): Profile_clauseContext {
+        let localContext = new Profile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 584, PlSqlParser.RULE_profile_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 6991;
+            this.match(PlSqlParser.PROFILE);
+            this.state = 6992;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public role_clause(): Role_clauseContext {
+        let localContext = new Role_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 586, PlSqlParser.RULE_role_clause);
+        try {
+            let alternative: number;
+            this.state = 7017;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 6994;
+                this.role_name();
+                this.state = 6999;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 686, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 6995;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 6996;
+                        this.role_name();
+                        }
+                        }
+                    }
+                    this.state = 7001;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 686, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.ALL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7002;
+                this.match(PlSqlParser.ALL);
+                this.state = 7014;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 688, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 7003;
+                        this.match(PlSqlParser.EXCEPT);
+                        this.state = 7004;
+                        this.role_name();
+                        this.state = 7009;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 687, this.context);
+                        while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                            if (alternative === 1) {
+                                {
+                                {
+                                this.state = 7005;
+                                this.match(PlSqlParser.COMMA);
+                                this.state = 7006;
+                                this.role_name();
+                                }
+                                }
+                            }
+                            this.state = 7011;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 687, this.context);
+                        }
+                        }
+                        }
+                    }
+                    this.state = 7016;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 688, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public user_default_role_clause(): User_default_role_clauseContext {
+        let localContext = new User_default_role_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 588, PlSqlParser.RULE_user_default_role_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7019;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 7020;
+            this.match(PlSqlParser.ROLE);
+            this.state = 7023;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 690, this.context) ) {
+            case 1:
+                {
+                this.state = 7021;
+                this.match(PlSqlParser.NONE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 7022;
+                this.role_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public password_expire_clause(): Password_expire_clauseContext {
+        let localContext = new Password_expire_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 590, PlSqlParser.RULE_password_expire_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7025;
+            this.match(PlSqlParser.PASSWORD);
+            this.state = 7026;
+            this.match(PlSqlParser.EXPIRE);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public user_lock_clause(): User_lock_clauseContext {
+        let localContext = new User_lock_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 592, PlSqlParser.RULE_user_lock_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7028;
+            this.match(PlSqlParser.ACCOUNT);
+            this.state = 7029;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 882 || _la === 2189)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public user_editions_clause(): User_editions_clauseContext {
+        let localContext = new User_editions_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 594, PlSqlParser.RULE_user_editions_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7031;
+            this.match(PlSqlParser.ENABLE);
+            this.state = 7032;
+            this.match(PlSqlParser.EDITIONS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_user_editions_clause(): Alter_user_editions_clauseContext {
+        let localContext = new Alter_user_editions_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 596, PlSqlParser.RULE_alter_user_editions_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7034;
+            this.user_editions_clause();
+            this.state = 7044;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 692, this.context) ) {
+            case 1:
+                {
+                this.state = 7035;
+                this.match(PlSqlParser.FOR);
+                this.state = 7036;
+                this.regular_id();
+                this.state = 7041;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 691, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 7037;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 7038;
+                        this.regular_id();
+                        }
+                        }
+                    }
+                    this.state = 7043;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 691, this.context);
+                }
+                }
+                break;
+            }
+            this.state = 7047;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 693, this.context) ) {
+            case 1:
+                {
+                this.state = 7046;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public proxy_clause(): Proxy_clauseContext {
+        let localContext = new Proxy_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 598, PlSqlParser.RULE_proxy_clause);
+        try {
+            this.state = 7088;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.REVOKE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7049;
+                this.match(PlSqlParser.REVOKE);
+                this.state = 7050;
+                this.match(PlSqlParser.CONNECT);
+                this.state = 7051;
+                this.match(PlSqlParser.THROUGH);
+                this.state = 7055;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 694, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7052;
+                    this.match(PlSqlParser.ENTERPRISE);
+                    this.state = 7053;
+                    this.match(PlSqlParser.USERS);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 7054;
+                    this.user_object_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.GRANT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7057;
+                this.match(PlSqlParser.GRANT);
+                this.state = 7058;
+                this.match(PlSqlParser.CONNECT);
+                this.state = 7059;
+                this.match(PlSqlParser.THROUGH);
+                this.state = 7086;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 700, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7060;
+                    this.match(PlSqlParser.ENTERPRISE);
+                    this.state = 7061;
+                    this.match(PlSqlParser.USERS);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 7062;
+                    this.user_object_name();
+                    this.state = 7070;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 696, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 7063;
+                        this.match(PlSqlParser.WITH);
+                        this.state = 7068;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.NO:
+                            {
+                            this.state = 7064;
+                            this.match(PlSqlParser.NO);
+                            this.state = 7065;
+                            this.match(PlSqlParser.ROLES);
+                            }
+                            break;
+                        case PlSqlParser.ROLE:
+                            {
+                            this.state = 7066;
+                            this.match(PlSqlParser.ROLE);
+                            this.state = 7067;
+                            this.role_clause();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    }
+                    this.state = 7074;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 697, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 7072;
+                        this.match(PlSqlParser.AUTHENTICATION);
+                        this.state = 7073;
+                        this.match(PlSqlParser.REQUIRED);
+                        }
+                        break;
+                    }
+                    this.state = 7084;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 699, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 7076;
+                        this.match(PlSqlParser.AUTHENTICATED);
+                        this.state = 7077;
+                        this.match(PlSqlParser.USING);
+                        this.state = 7082;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.PASSWORD:
+                            {
+                            this.state = 7078;
+                            this.match(PlSqlParser.PASSWORD);
+                            }
+                            break;
+                        case PlSqlParser.CERTIFICATE:
+                            {
+                            this.state = 7079;
+                            this.match(PlSqlParser.CERTIFICATE);
+                            }
+                            break;
+                        case PlSqlParser.DISTINGUISHED:
+                            {
+                            this.state = 7080;
+                            this.match(PlSqlParser.DISTINGUISHED);
+                            this.state = 7081;
+                            this.match(PlSqlParser.NAME);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public container_names(): Container_namesContext {
+        let localContext = new Container_namesContext(this.context, this.state);
+        this.enterRule(localContext, 600, PlSqlParser.RULE_container_names);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7090;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 7091;
+            this.id_expression();
+            this.state = 7096;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 7092;
+                this.match(PlSqlParser.COMMA);
+                this.state = 7093;
+                this.id_expression();
+                }
+                }
+                this.state = 7098;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 7099;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_container_data(): Set_container_dataContext {
+        let localContext = new Set_container_dataContext(this.context, this.state);
+        this.enterRule(localContext, 602, PlSqlParser.RULE_set_container_data);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7101;
+            this.match(PlSqlParser.SET);
+            this.state = 7102;
+            this.match(PlSqlParser.CONTAINER_DATA);
+            this.state = 7103;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 7107;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALL:
+                {
+                this.state = 7104;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            case PlSqlParser.DEFAULT:
+                {
+                this.state = 7105;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 7106;
+                this.container_names();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_rem_container_data(): Add_rem_container_dataContext {
+        let localContext = new Add_rem_container_dataContext(this.context, this.state);
+        this.enterRule(localContext, 604, PlSqlParser.RULE_add_rem_container_data);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7109;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 21 || _la === 1560)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 7110;
+            this.match(PlSqlParser.CONTAINER_DATA);
+            this.state = 7111;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 7112;
+            this.container_names();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public container_data_clause(): Container_data_clauseContext {
+        let localContext = new Container_data_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 606, PlSqlParser.RULE_container_data_clause);
+        try {
+            this.state = 7120;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SET:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7114;
+                this.set_container_data();
+                }
+                break;
+            case PlSqlParser.ADD:
+            case PlSqlParser.REMOVE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7115;
+                this.add_rem_container_data();
+                this.state = 7118;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 704, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7116;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 7117;
+                    this.container_tableview_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public administer_key_management(): Administer_key_managementContext {
+        let localContext = new Administer_key_managementContext(this.context, this.state);
+        this.enterRule(localContext, 608, PlSqlParser.RULE_administer_key_management);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7122;
+            this.match(PlSqlParser.ADMINISTER);
+            this.state = 7123;
+            this.match(PlSqlParser.KEY);
+            this.state = 7124;
+            this.match(PlSqlParser.MANAGEMENT);
+            this.state = 7129;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 706, this.context) ) {
+            case 1:
+                {
+                this.state = 7125;
+                this.keystore_management_clauses();
+                }
+                break;
+            case 2:
+                {
+                this.state = 7126;
+                this.key_management_clauses();
+                }
+                break;
+            case 3:
+                {
+                this.state = 7127;
+                this.secret_management_clauses();
+                }
+                break;
+            case 4:
+                {
+                this.state = 7128;
+                this.zero_downtime_software_patching_clauses();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public keystore_management_clauses(): Keystore_management_clausesContext {
+        let localContext = new Keystore_management_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 610, PlSqlParser.RULE_keystore_management_clauses);
+        try {
+            this.state = 7140;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 707, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7131;
+                this.create_keystore();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7132;
+                this.open_keystore();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 7133;
+                this.close_keystore();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 7134;
+                this.backup_keystore();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 7135;
+                this.alter_keystore_password();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 7136;
+                this.merge_into_new_keystore();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 7137;
+                this.merge_into_existing_keystore();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 7138;
+                this.isolate_keystore();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 7139;
+                this.unite_keystore();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_keystore(): Create_keystoreContext {
+        let localContext = new Create_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 612, PlSqlParser.RULE_create_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7142;
+            this.match(PlSqlParser.CREATE);
+            this.state = 7153;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.KEYSTORE:
+                {
+                this.state = 7143;
+                this.match(PlSqlParser.KEYSTORE);
+                this.state = 7144;
+                localContext._ksl = this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.LOCAL:
+                {
+                this.state = 7146;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 874) {
+                    {
+                    this.state = 7145;
+                    this.match(PlSqlParser.LOCAL);
+                    }
+                }
+
+                this.state = 7148;
+                this.match(PlSqlParser.AUTO_LOGIN);
+                this.state = 7149;
+                this.match(PlSqlParser.KEYSTORE);
+                this.state = 7150;
+                this.match(PlSqlParser.FROM);
+                this.state = 7151;
+                this.match(PlSqlParser.KEYSTORE);
+                this.state = 7152;
+                localContext._ksl = this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 7155;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7156;
+            this.match(PlSqlParser.BY);
+            this.state = 7157;
+            this.keystore_password();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public open_keystore(): Open_keystoreContext {
+        let localContext = new Open_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 614, PlSqlParser.RULE_open_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7159;
+            this.match(PlSqlParser.SET);
+            this.state = 7160;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7161;
+            this.match(PlSqlParser.OPEN);
+            this.state = 7163;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7162;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7165;
+            this.identified_by_store();
+            this.state = 7167;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 711, this.context) ) {
+            case 1:
+                {
+                this.state = 7166;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public force_keystore(): Force_keystoreContext {
+        let localContext = new Force_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 616, PlSqlParser.RULE_force_keystore);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7169;
+            this.match(PlSqlParser.FORCE);
+            this.state = 7170;
+            this.match(PlSqlParser.KEYSTORE);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public close_keystore(): Close_keystoreContext {
+        let localContext = new Close_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 618, PlSqlParser.RULE_close_keystore);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7172;
+            this.match(PlSqlParser.SET);
+            this.state = 7173;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7174;
+            this.match(PlSqlParser.CLOSE);
+            this.state = 7176;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 712, this.context) ) {
+            case 1:
+                {
+                this.state = 7175;
+                this.identified_by_store();
+                }
+                break;
+            }
+            this.state = 7179;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 713, this.context) ) {
+            case 1:
+                {
+                this.state = 7178;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public backup_keystore(): Backup_keystoreContext {
+        let localContext = new Backup_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 620, PlSqlParser.RULE_backup_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7181;
+            this.match(PlSqlParser.BACKUP);
+            this.state = 7182;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7185;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2248) {
+                {
+                this.state = 7183;
+                this.match(PlSqlParser.USING);
+                this.state = 7184;
+                localContext._bi = this.match(PlSqlParser.CHAR_STRING);
+                }
+            }
+
+            this.state = 7188;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7187;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7190;
+            this.identified_by_store();
+            this.state = 7193;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 716, this.context) ) {
+            case 1:
+                {
+                this.state = 7191;
+                this.match(PlSqlParser.TO);
+                this.state = 7192;
+                localContext._ksl = this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_keystore_password(): Alter_keystore_passwordContext {
+        let localContext = new Alter_keystore_passwordContext(this.context, this.state);
+        this.enterRule(localContext, 622, PlSqlParser.RULE_alter_keystore_password);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7195;
+            this.match(PlSqlParser.ALTER);
+            this.state = 7196;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7197;
+            this.match(PlSqlParser.PASSWORD);
+            this.state = 7199;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7198;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7201;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7202;
+            this.match(PlSqlParser.BY);
+            this.state = 7203;
+            localContext._o = this.keystore_password();
+            this.state = 7204;
+            this.match(PlSqlParser.SET);
+            this.state = 7205;
+            localContext._n = this.keystore_password();
+            this.state = 7207;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 718, this.context) ) {
+            case 1:
+                {
+                this.state = 7206;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_into_new_keystore(): Merge_into_new_keystoreContext {
+        let localContext = new Merge_into_new_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 624, PlSqlParser.RULE_merge_into_new_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7209;
+            this.match(PlSqlParser.MERGE);
+            this.state = 7210;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7211;
+            localContext._ksl1 = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7213;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 686) {
+                {
+                this.state = 7212;
+                this.identified_by_password_clause();
+                }
+            }
+
+            this.state = 7215;
+            this.match(PlSqlParser.AND);
+            this.state = 7216;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7217;
+            localContext._ksl2 = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7219;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 686) {
+                {
+                this.state = 7218;
+                this.identified_by_password_clause();
+                }
+            }
+
+            this.state = 7221;
+            this.match(PlSqlParser.INTO);
+            this.state = 7222;
+            this.match(PlSqlParser.NEW);
+            this.state = 7223;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7224;
+            localContext._ksl2 = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7225;
+            this.identified_by_password_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_into_existing_keystore(): Merge_into_existing_keystoreContext {
+        let localContext = new Merge_into_existing_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 626, PlSqlParser.RULE_merge_into_existing_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7227;
+            this.match(PlSqlParser.MERGE);
+            this.state = 7228;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7229;
+            localContext._ksl1 = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7231;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 686) {
+                {
+                this.state = 7230;
+                this.identified_by_password_clause();
+                }
+            }
+
+            this.state = 7233;
+            this.match(PlSqlParser.INTO);
+            this.state = 7234;
+            this.match(PlSqlParser.EXISTING);
+            this.state = 7235;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7236;
+            localContext._ksl2 = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7237;
+            this.identified_by_password_clause();
+            this.state = 7239;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 722, this.context) ) {
+            case 1:
+                {
+                this.state = 7238;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public isolate_keystore(): Isolate_keystoreContext {
+        let localContext = new Isolate_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 628, PlSqlParser.RULE_isolate_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7242;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7241;
+                this.match(PlSqlParser.FORCE);
+                }
+            }
+
+            this.state = 7244;
+            this.match(PlSqlParser.ISOLATE);
+            this.state = 7245;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7246;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7247;
+            this.match(PlSqlParser.BY);
+            this.state = 7248;
+            localContext._i = this.keystore_password();
+            this.state = 7249;
+            this.match(PlSqlParser.FROM);
+            this.state = 7250;
+            this.match(PlSqlParser.ROOT);
+            this.state = 7251;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7253;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7252;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7255;
+            this.identified_by_store();
+            this.state = 7257;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 725, this.context) ) {
+            case 1:
+                {
+                this.state = 7256;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unite_keystore(): Unite_keystoreContext {
+        let localContext = new Unite_keystoreContext(this.context, this.state);
+        this.enterRule(localContext, 630, PlSqlParser.RULE_unite_keystore);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7259;
+            this.match(PlSqlParser.UNITE);
+            this.state = 7260;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7261;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7262;
+            this.match(PlSqlParser.BY);
+            this.state = 7263;
+            localContext._i = this.keystore_password();
+            this.state = 7264;
+            this.match(PlSqlParser.WITH);
+            this.state = 7265;
+            this.match(PlSqlParser.ROOT);
+            this.state = 7266;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7268;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7267;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7270;
+            this.identified_by_store();
+            this.state = 7272;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 727, this.context) ) {
+            case 1:
+                {
+                this.state = 7271;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public key_management_clauses(): Key_management_clausesContext {
+        let localContext = new Key_management_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 632, PlSqlParser.RULE_key_management_clauses);
+        try {
+            this.state = 7283;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 728, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7274;
+                this.set_key();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7275;
+                this.create_key();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 7276;
+                this.use_key();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 7277;
+                this.set_key_tag();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 7278;
+                this.export_keys();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 7279;
+                this.import_keys();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 7280;
+                this.migrate_keys();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 7281;
+                this.reverse_migrate_keys();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 7282;
+                this.move_keys();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_key(): Set_keyContext {
+        let localContext = new Set_keyContext(this.context, this.state);
+        this.enterRule(localContext, 634, PlSqlParser.RULE_set_key);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7285;
+            this.match(PlSqlParser.SET);
+            this.state = 7287;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7286;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7289;
+            this.match(PlSqlParser.KEY);
+            this.state = 7296;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2445) {
+                {
+                this.state = 7293;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 730, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7290;
+                    this.mkid();
+                    this.state = 7291;
+                    this.match(PlSqlParser.COLON);
+                    }
+                    break;
+                }
+                this.state = 7295;
+                this.mk();
+                }
+            }
+
+            this.state = 7299;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 732, this.context) ) {
+            case 1:
+                {
+                this.state = 7298;
+                this.using_tag_clause();
+                }
+                break;
+            }
+            this.state = 7302;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2248) {
+                {
+                this.state = 7301;
+                this.using_algorithm_clause();
+                }
+            }
+
+            this.state = 7305;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7304;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7307;
+            this.identified_by_store();
+            this.state = 7309;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 735, this.context) ) {
+            case 1:
+                {
+                this.state = 7308;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            this.state = 7312;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 736, this.context) ) {
+            case 1:
+                {
+                this.state = 7311;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_key(): Create_keyContext {
+        let localContext = new Create_keyContext(this.context, this.state);
+        this.enterRule(localContext, 636, PlSqlParser.RULE_create_key);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7314;
+            this.match(PlSqlParser.CREATE);
+            this.state = 7316;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7315;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7318;
+            this.match(PlSqlParser.KEY);
+            this.state = 7325;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2445) {
+                {
+                this.state = 7322;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 738, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7319;
+                    this.mkid();
+                    this.state = 7320;
+                    this.match(PlSqlParser.COLON);
+                    }
+                    break;
+                }
+                this.state = 7324;
+                this.mk();
+                }
+            }
+
+            this.state = 7328;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 740, this.context) ) {
+            case 1:
+                {
+                this.state = 7327;
+                this.using_tag_clause();
+                }
+                break;
+            }
+            this.state = 7331;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2248) {
+                {
+                this.state = 7330;
+                this.using_algorithm_clause();
+                }
+            }
+
+            this.state = 7334;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7333;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7336;
+            this.identified_by_store();
+            this.state = 7338;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 743, this.context) ) {
+            case 1:
+                {
+                this.state = 7337;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            this.state = 7341;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 744, this.context) ) {
+            case 1:
+                {
+                this.state = 7340;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public mkid(): MkidContext {
+        let localContext = new MkidContext(this.context, this.state);
+        this.enterRule(localContext, 638, PlSqlParser.RULE_mkid);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7343;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public mk(): MkContext {
+        let localContext = new MkContext(this.context, this.state);
+        this.enterRule(localContext, 640, PlSqlParser.RULE_mk);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7345;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public use_key(): Use_keyContext {
+        let localContext = new Use_keyContext(this.context, this.state);
+        this.enterRule(localContext, 642, PlSqlParser.RULE_use_key);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7347;
+            this.match(PlSqlParser.USE);
+            this.state = 7349;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7348;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7351;
+            this.match(PlSqlParser.KEY);
+            this.state = 7352;
+            localContext._k = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7354;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2248) {
+                {
+                this.state = 7353;
+                this.using_tag_clause();
+                }
+            }
+
+            this.state = 7357;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7356;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7359;
+            this.identified_by_store();
+            this.state = 7361;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 748, this.context) ) {
+            case 1:
+                {
+                this.state = 7360;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_key_tag(): Set_key_tagContext {
+        let localContext = new Set_key_tagContext(this.context, this.state);
+        this.enterRule(localContext, 644, PlSqlParser.RULE_set_key_tag);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7363;
+            this.match(PlSqlParser.SET);
+            this.state = 7364;
+            this.match(PlSqlParser.TAG);
+            this.state = 7365;
+            localContext._t = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7366;
+            this.match(PlSqlParser.FOR);
+            this.state = 7367;
+            localContext._k = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7369;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7368;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7371;
+            this.identified_by_store();
+            this.state = 7373;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 750, this.context) ) {
+            case 1:
+                {
+                this.state = 7372;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public export_keys(): Export_keysContext {
+        let localContext = new Export_keysContext(this.context, this.state);
+        this.enterRule(localContext, 646, PlSqlParser.RULE_export_keys);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7375;
+            this.match(PlSqlParser.EXPORT);
+            this.state = 7377;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7376;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7379;
+            this.match(PlSqlParser.KEYS);
+            this.state = 7380;
+            this.match(PlSqlParser.WITH);
+            this.state = 7381;
+            this.match(PlSqlParser.SECRET);
+            this.state = 7382;
+            this.secret();
+            this.state = 7383;
+            this.match(PlSqlParser.TO);
+            this.state = 7384;
+            this.filename();
+            this.state = 7386;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7385;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7388;
+            this.identified_by_store();
+            this.state = 7406;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 755, this.context) ) {
+            case 1:
+                {
+                this.state = 7389;
+                this.match(PlSqlParser.WITH);
+                this.state = 7390;
+                this.match(PlSqlParser.IDENTIFIER);
+                this.state = 7391;
+                this.match(PlSqlParser.IN);
+                this.state = 7404;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 7392;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 7397;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 753, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 7393;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 7394;
+                            this.match(PlSqlParser.CHAR_STRING);
+                            }
+                            }
+                        }
+                        this.state = 7399;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 753, this.context);
+                    }
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 7400;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 7401;
+                    this.subquery();
+                    this.state = 7402;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public import_keys(): Import_keysContext {
+        let localContext = new Import_keysContext(this.context, this.state);
+        this.enterRule(localContext, 648, PlSqlParser.RULE_import_keys);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7408;
+            this.match(PlSqlParser.IMPORT);
+            this.state = 7410;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7409;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7412;
+            this.match(PlSqlParser.KEYS);
+            this.state = 7413;
+            this.match(PlSqlParser.WITH);
+            this.state = 7414;
+            this.match(PlSqlParser.SECRET);
+            this.state = 7415;
+            this.secret();
+            this.state = 7416;
+            this.match(PlSqlParser.FROM);
+            this.state = 7417;
+            this.filename();
+            this.state = 7419;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7418;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7421;
+            this.identified_by_store();
+            this.state = 7423;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 758, this.context) ) {
+            case 1:
+                {
+                this.state = 7422;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public migrate_keys(): Migrate_keysContext {
+        let localContext = new Migrate_keysContext(this.context, this.state);
+        this.enterRule(localContext, 650, PlSqlParser.RULE_migrate_keys);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7425;
+            this.match(PlSqlParser.SET);
+            this.state = 7427;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7426;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7429;
+            this.match(PlSqlParser.KEY);
+            this.state = 7430;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7431;
+            this.match(PlSqlParser.BY);
+            this.state = 7432;
+            localContext._hsm = this.secret();
+            this.state = 7434;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7433;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7436;
+            this.match(PlSqlParser.MIGRATE);
+            this.state = 7437;
+            this.match(PlSqlParser.USING);
+            this.state = 7438;
+            this.keystore_password();
+            this.state = 7440;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 761, this.context) ) {
+            case 1:
+                {
+                this.state = 7439;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public reverse_migrate_keys(): Reverse_migrate_keysContext {
+        let localContext = new Reverse_migrate_keysContext(this.context, this.state);
+        this.enterRule(localContext, 652, PlSqlParser.RULE_reverse_migrate_keys);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7442;
+            this.match(PlSqlParser.SET);
+            this.state = 7444;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7443;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7446;
+            this.match(PlSqlParser.KEY);
+            this.state = 7447;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7448;
+            this.match(PlSqlParser.BY);
+            this.state = 7449;
+            localContext._s = this.secret();
+            this.state = 7451;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7450;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7453;
+            this.match(PlSqlParser.REVERSE);
+            this.state = 7454;
+            this.match(PlSqlParser.MIGRATE);
+            this.state = 7455;
+            this.match(PlSqlParser.USING);
+            this.state = 7456;
+            localContext._hsm = this.secret();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public move_keys(): Move_keysContext {
+        let localContext = new Move_keysContext(this.context, this.state);
+        this.enterRule(localContext, 654, PlSqlParser.RULE_move_keys);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7458;
+            this.match(PlSqlParser.MOVE);
+            this.state = 7460;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 506) {
+                {
+                this.state = 7459;
+                this.match(PlSqlParser.ENCRYPTION);
+                }
+            }
+
+            this.state = 7462;
+            this.match(PlSqlParser.KEYS);
+            this.state = 7463;
+            this.match(PlSqlParser.TO);
+            this.state = 7464;
+            this.match(PlSqlParser.NEW);
+            this.state = 7465;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7466;
+            localContext._ksl1 = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7467;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7468;
+            this.match(PlSqlParser.BY);
+            this.state = 7469;
+            localContext._ksp1 = this.keystore_password();
+            this.state = 7470;
+            this.match(PlSqlParser.FROM);
+            this.state = 7472;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7471;
+                this.match(PlSqlParser.FORCE);
+                }
+            }
+
+            this.state = 7474;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7475;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7476;
+            this.match(PlSqlParser.BY);
+            this.state = 7477;
+            localContext._ksp = this.keystore_password();
+            this.state = 7492;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 768, this.context) ) {
+            case 1:
+                {
+                this.state = 7478;
+                this.match(PlSqlParser.WITH);
+                this.state = 7479;
+                this.match(PlSqlParser.IDENTIFIER);
+                this.state = 7480;
+                this.match(PlSqlParser.IN);
+                this.state = 7490;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 7481;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 7486;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 766, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 7482;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 7483;
+                            this.match(PlSqlParser.CHAR_STRING);
+                            }
+                            }
+                        }
+                        this.state = 7488;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 766, this.context);
+                    }
+                    }
+                    break;
+                case PlSqlParser.SELECT:
+                case PlSqlParser.WITH:
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 7489;
+                    this.subquery();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 7495;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 769, this.context) ) {
+            case 1:
+                {
+                this.state = 7494;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        let localContext = new Identified_by_storeContext(this.context, this.state);
+        this.enterRule(localContext, 656, PlSqlParser.RULE_identified_by_store);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7497;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7498;
+            this.match(PlSqlParser.BY);
+            this.state = 7502;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.EXTERNAL:
+                {
+                this.state = 7499;
+                this.match(PlSqlParser.EXTERNAL);
+                this.state = 7500;
+                this.match(PlSqlParser.STORE);
+                }
+                break;
+            case PlSqlParser.DELIMITED_ID:
+                {
+                this.state = 7501;
+                this.keystore_password();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_algorithm_clause(): Using_algorithm_clauseContext {
+        let localContext = new Using_algorithm_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 658, PlSqlParser.RULE_using_algorithm_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7504;
+            this.match(PlSqlParser.USING);
+            this.state = 7505;
+            this.match(PlSqlParser.ALGORITHM);
+            this.state = 7506;
+            localContext._ea = this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_tag_clause(): Using_tag_clauseContext {
+        let localContext = new Using_tag_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 660, PlSqlParser.RULE_using_tag_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7508;
+            this.match(PlSqlParser.USING);
+            this.state = 7509;
+            this.match(PlSqlParser.TAG);
+            this.state = 7510;
+            localContext._t = this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public secret_management_clauses(): Secret_management_clausesContext {
+        let localContext = new Secret_management_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 662, PlSqlParser.RULE_secret_management_clauses);
+        try {
+            this.state = 7516;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 771, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7512;
+                this.add_update_secret();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7513;
+                this.delete_secret();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 7514;
+                this.add_update_secret_seps();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 7515;
+                this.delete_secret_seps();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_update_secret(): Add_update_secretContext {
+        let localContext = new Add_update_secretContext(this.context, this.state);
+        this.enterRule(localContext, 664, PlSqlParser.RULE_add_update_secret);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7518;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 21 || _la === 2209)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 7519;
+            this.match(PlSqlParser.SECRET);
+            this.state = 7520;
+            localContext._s = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7521;
+            this.match(PlSqlParser.FOR);
+            this.state = 7522;
+            this.match(PlSqlParser.CLIENT);
+            this.state = 7523;
+            localContext._ci = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7525;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 772, this.context) ) {
+            case 1:
+                {
+                this.state = 7524;
+                this.using_tag_clause();
+                }
+                break;
+            }
+            this.state = 7528;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 773, this.context) ) {
+            case 1:
+                {
+                this.state = 7527;
+                this.force_keystore();
+                }
+                break;
+            }
+            this.state = 7531;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 774, this.context) ) {
+            case 1:
+                {
+                this.state = 7530;
+                this.identified_by_store();
+                }
+                break;
+            }
+            this.state = 7534;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 775, this.context) ) {
+            case 1:
+                {
+                this.state = 7533;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public delete_secret(): Delete_secretContext {
+        let localContext = new Delete_secretContext(this.context, this.state);
+        this.enterRule(localContext, 666, PlSqlParser.RULE_delete_secret);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7536;
+            this.match(PlSqlParser.DELETE);
+            this.state = 7537;
+            this.match(PlSqlParser.SECRET);
+            this.state = 7538;
+            this.match(PlSqlParser.FOR);
+            this.state = 7539;
+            this.match(PlSqlParser.CLIENT);
+            this.state = 7540;
+            localContext._ci = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7542;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 7541;
+                this.force_keystore();
+                }
+            }
+
+            this.state = 7544;
+            this.identified_by_store();
+            this.state = 7546;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 777, this.context) ) {
+            case 1:
+                {
+                this.state = 7545;
+                this.with_backup_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_update_secret_seps(): Add_update_secret_sepsContext {
+        let localContext = new Add_update_secret_sepsContext(this.context, this.state);
+        this.enterRule(localContext, 668, PlSqlParser.RULE_add_update_secret_seps);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7548;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 21 || _la === 2209)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 7549;
+            this.match(PlSqlParser.SECRET);
+            this.state = 7550;
+            localContext._s = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7551;
+            this.match(PlSqlParser.FOR);
+            this.state = 7552;
+            this.match(PlSqlParser.CLIENT);
+            this.state = 7553;
+            localContext._ci = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7555;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2248) {
+                {
+                this.state = 7554;
+                this.using_tag_clause();
+                }
+            }
+
+            this.state = 7557;
+            this.match(PlSqlParser.TO);
+            this.state = 7559;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 874) {
+                {
+                this.state = 7558;
+                this.match(PlSqlParser.LOCAL);
+                }
+            }
+
+            this.state = 7561;
+            this.match(PlSqlParser.AUTO_LOGIN);
+            this.state = 7562;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7563;
+            this.directory_path();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public delete_secret_seps(): Delete_secret_sepsContext {
+        let localContext = new Delete_secret_sepsContext(this.context, this.state);
+        this.enterRule(localContext, 670, PlSqlParser.RULE_delete_secret_seps);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7565;
+            this.match(PlSqlParser.DELETE);
+            this.state = 7566;
+            this.match(PlSqlParser.SECRET);
+            this.state = 7567;
+            localContext._s = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7568;
+            this.match(PlSqlParser.SQ);
+            this.state = 7569;
+            this.match(PlSqlParser.FOR);
+            this.state = 7570;
+            this.match(PlSqlParser.CLIENT);
+            this.state = 7571;
+            localContext._ci = this.match(PlSqlParser.CHAR_STRING);
+            this.state = 7572;
+            this.match(PlSqlParser.FROM);
+            this.state = 7574;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 874) {
+                {
+                this.state = 7573;
+                this.match(PlSqlParser.LOCAL);
+                }
+            }
+
+            this.state = 7576;
+            this.match(PlSqlParser.AUTO_LOGIN);
+            this.state = 7577;
+            this.match(PlSqlParser.KEYSTORE);
+            this.state = 7578;
+            this.directory_path();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public zero_downtime_software_patching_clauses(): Zero_downtime_software_patching_clausesContext {
+        let localContext = new Zero_downtime_software_patching_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 672, PlSqlParser.RULE_zero_downtime_software_patching_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7580;
+            this.match(PlSqlParser.SWITCHOVER);
+            this.state = 7582;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2143) {
+                {
+                this.state = 7581;
+                this.match(PlSqlParser.TO);
+                }
+            }
+
+            this.state = 7584;
+            this.match(PlSqlParser.LIBRARY);
+            this.state = 7585;
+            this.path();
+            this.state = 7586;
+            this.match(PlSqlParser.FOR);
+            this.state = 7587;
+            this.match(PlSqlParser.ALL);
+            this.state = 7588;
+            this.match(PlSqlParser.CONTAINERS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public with_backup_clause(): With_backup_clauseContext {
+        let localContext = new With_backup_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 674, PlSqlParser.RULE_with_backup_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7590;
+            this.match(PlSqlParser.WITH);
+            this.state = 7591;
+            this.match(PlSqlParser.BACKUP);
+            this.state = 7594;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 782, this.context) ) {
+            case 1:
+                {
+                this.state = 7592;
+                this.match(PlSqlParser.USING);
+                this.state = 7593;
+                localContext._bi = this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identified_by_password_clause(): Identified_by_password_clauseContext {
+        let localContext = new Identified_by_password_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 676, PlSqlParser.RULE_identified_by_password_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7596;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 7597;
+            this.match(PlSqlParser.BY);
+            this.state = 7598;
+            this.keystore_password();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public keystore_password(): Keystore_passwordContext {
+        let localContext = new Keystore_passwordContext(this.context, this.state);
+        this.enterRule(localContext, 678, PlSqlParser.RULE_keystore_password);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7600;
+            this.match(PlSqlParser.DELIMITED_ID);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public path(): PathContext {
+        let localContext = new PathContext(this.context, this.state);
+        this.enterRule(localContext, 680, PlSqlParser.RULE_path);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7602;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public secret(): SecretContext {
+        let localContext = new SecretContext(this.context, this.state);
+        this.enterRule(localContext, 682, PlSqlParser.RULE_secret);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7604;
+            this.match(PlSqlParser.DELIMITED_ID);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public analyze(): AnalyzeContext {
+        let localContext = new AnalyzeContext(this.context, this.state);
+        this.enterRule(localContext, 684, PlSqlParser.RULE_analyze);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7619;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 785, this.context) ) {
+            case 1:
+                {
+                this.state = 7606;
+                this.match(PlSqlParser.ANALYZE);
+                this.state = 7611;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.TABLE:
+                    {
+                    this.state = 7607;
+                    this.match(PlSqlParser.TABLE);
+                    this.state = 7608;
+                    this.tableview_name();
+                    }
+                    break;
+                case PlSqlParser.INDEX:
+                    {
+                    this.state = 7609;
+                    this.match(PlSqlParser.INDEX);
+                    this.state = 7610;
+                    this.index_name();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 7614;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1350 || _la === 1777) {
+                    {
+                    this.state = 7613;
+                    this.partition_extention_clause();
+                    }
+                }
+
+                }
+                break;
+            case 2:
+                {
+                this.state = 7616;
+                this.match(PlSqlParser.ANALYZE);
+                this.state = 7617;
+                this.match(PlSqlParser.CLUSTER);
+                this.state = 7618;
+                this.cluster_name();
+                }
+                break;
+            }
+            this.state = 7647;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VALIDATE:
+                {
+                this.state = 7621;
+                this.validation_clauses();
+                }
+                break;
+            case PlSqlParser.COMPUTE:
+                {
+                this.state = 7622;
+                this.compute_clauses();
+                }
+                break;
+            case PlSqlParser.ESTIMATE:
+                {
+                this.state = 7623;
+                this.match(PlSqlParser.ESTIMATE);
+                this.state = 7625;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1951) {
+                    {
+                    this.state = 7624;
+                    this.match(PlSqlParser.SYSTEM);
+                    }
+                }
+
+                this.state = 7627;
+                this.match(PlSqlParser.STATISTICS);
+                this.state = 7629;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 787, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7628;
+                    this.for_clause();
+                    }
+                    break;
+                }
+                this.state = 7634;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 788, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7631;
+                    this.match(PlSqlParser.SAMPLE);
+                    this.state = 7632;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 7633;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1380 || _la === 1609)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.LIST:
+                {
+                this.state = 7636;
+                this.match(PlSqlParser.LIST);
+                this.state = 7637;
+                this.match(PlSqlParser.CHAINED);
+                this.state = 7638;
+                this.match(PlSqlParser.ROWS);
+                this.state = 7640;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 789, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7639;
+                    this.into_clause1();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.DELETE:
+                {
+                this.state = 7642;
+                this.match(PlSqlParser.DELETE);
+                this.state = 7644;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1951) {
+                    {
+                    this.state = 7643;
+                    this.match(PlSqlParser.SYSTEM);
+                    }
+                }
+
+                this.state = 7646;
+                this.match(PlSqlParser.STATISTICS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_extention_clause(): Partition_extention_clauseContext {
+        let localContext = new Partition_extention_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 686, PlSqlParser.RULE_partition_extention_clause);
+        let _la: number;
+        try {
+            this.state = 7687;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7649;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 7666;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 7650;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 7651;
+                    this.partition_name();
+                    this.state = 7652;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case PlSqlParser.FOR:
+                    {
+                    this.state = 7654;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 7655;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 7656;
+                    this.partition_key_value();
+                    this.state = 7661;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 7657;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 7658;
+                        this.partition_key_value();
+                        }
+                        }
+                        this.state = 7663;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 7664;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.SUBPARTITION:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7668;
+                this.match(PlSqlParser.SUBPARTITION);
+                this.state = 7685;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 7669;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 7670;
+                    this.subpartition_name();
+                    this.state = 7671;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case PlSqlParser.FOR:
+                    {
+                    this.state = 7673;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 7674;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 7675;
+                    this.subpartition_key_value();
+                    this.state = 7680;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 7676;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 7677;
+                        this.subpartition_key_value();
+                        }
+                        }
+                        this.state = 7682;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 7683;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public validation_clauses(): Validation_clausesContext {
+        let localContext = new Validation_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 688, PlSqlParser.RULE_validation_clauses);
+        try {
+            this.state = 7718;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 803, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7689;
+                this.match(PlSqlParser.VALIDATE);
+                this.state = 7690;
+                this.match(PlSqlParser.REF);
+                this.state = 7691;
+                this.match(PlSqlParser.UPDATE);
+                this.state = 7696;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 797, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7692;
+                    this.match(PlSqlParser.SET);
+                    this.state = 7693;
+                    this.match(PlSqlParser.DANGLING);
+                    this.state = 7694;
+                    this.match(PlSqlParser.TO);
+                    this.state = 7695;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7698;
+                this.match(PlSqlParser.VALIDATE);
+                this.state = 7699;
+                this.match(PlSqlParser.STRUCTURE);
+                this.state = 7710;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 800, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7700;
+                    this.match(PlSqlParser.CASCADE);
+                    this.state = 7701;
+                    this.match(PlSqlParser.FAST);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 7702;
+                    this.match(PlSqlParser.CASCADE);
+                    this.state = 7704;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 798, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 7703;
+                        this.online_or_offline();
+                        }
+                        break;
+                    }
+                    this.state = 7707;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 799, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 7706;
+                        this.into_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 7709;
+                    this.match(PlSqlParser.CASCADE);
+                    }
+                    break;
+                }
+                this.state = 7713;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 801, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7712;
+                    this.online_or_offline();
+                    }
+                    break;
+                }
+                this.state = 7716;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 802, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7715;
+                    this.into_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public compute_clauses(): Compute_clausesContext {
+        let localContext = new Compute_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 690, PlSqlParser.RULE_compute_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7720;
+            this.match(PlSqlParser.COMPUTE);
+            this.state = 7722;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1951) {
+                {
+                this.state = 7721;
+                this.match(PlSqlParser.SYSTEM);
+                }
+            }
+
+            this.state = 7724;
+            this.match(PlSqlParser.STATISTICS);
+            this.state = 7726;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 805, this.context) ) {
+            case 1:
+                {
+                this.state = 7725;
+                this.for_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public for_clause(): For_clauseContext {
+        let localContext = new For_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 692, PlSqlParser.RULE_for_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7728;
+            this.match(PlSqlParser.FOR);
+            this.state = 7776;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TABLE:
+                {
+                this.state = 7729;
+                this.match(PlSqlParser.TABLE);
+                this.state = 7733;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 806, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 7730;
+                        this.for_clause();
+                        }
+                        }
+                    }
+                    this.state = 7735;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 806, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 7736;
+                this.match(PlSqlParser.ALL);
+                this.state = 7755;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.INDEXED:
+                    {
+                    this.state = 7738;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 714) {
+                        {
+                        this.state = 7737;
+                        this.match(PlSqlParser.INDEXED);
+                        }
+                    }
+
+                    this.state = 7740;
+                    this.match(PlSqlParser.COLUMNS);
+                    this.state = 7743;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 808, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 7741;
+                        this.match(PlSqlParser.SIZE);
+                        this.state = 7742;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    }
+                    this.state = 7748;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 809, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 7745;
+                            this.for_clause();
+                            }
+                            }
+                        }
+                        this.state = 7750;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 809, this.context);
+                    }
+                    }
+                    break;
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.LOCAL:
+                    {
+                    this.state = 7752;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 874) {
+                        {
+                        this.state = 7751;
+                        this.match(PlSqlParser.LOCAL);
+                        }
+                    }
+
+                    this.state = 7754;
+                    this.match(PlSqlParser.INDEXES);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.COLUMNS:
+                {
+                this.state = 7757;
+                this.match(PlSqlParser.COLUMNS);
+                this.state = 7760;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1701) {
+                    {
+                    this.state = 7758;
+                    this.match(PlSqlParser.SIZE);
+                    this.state = 7759;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                }
+
+                this.state = 7766;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 7762;
+                        this.column_name();
+                        this.state = 7763;
+                        this.match(PlSqlParser.SIZE);
+                        this.state = 7764;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 7768;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 813, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                this.state = 7773;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 814, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 7770;
+                        this.for_clause();
+                        }
+                        }
+                    }
+                    this.state = 7775;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 814, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public online_or_offline(): Online_or_offlineContext {
+        let localContext = new Online_or_offlineContext(this.context, this.state);
+        this.enterRule(localContext, 694, PlSqlParser.RULE_online_or_offline);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7778;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1245 || _la === 1258)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public into_clause1(): Into_clause1Context {
+        let localContext = new Into_clause1Context(this.context, this.state);
+        this.enterRule(localContext, 696, PlSqlParser.RULE_into_clause1);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7780;
+            this.match(PlSqlParser.INTO);
+            this.state = 7782;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 816, this.context) ) {
+            case 1:
+                {
+                this.state = 7781;
+                this.tableview_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_key_value(): Partition_key_valueContext {
+        let localContext = new Partition_key_valueContext(this.context, this.state);
+        this.enterRule(localContext, 698, PlSqlParser.RULE_partition_key_value);
+        try {
+            this.state = 7787;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHR:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.DECODE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.MINUS_SIGN:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7784;
+                this.literal();
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7785;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 7786;
+                this.quoted_string();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_key_value(): Subpartition_key_valueContext {
+        let localContext = new Subpartition_key_valueContext(this.context, this.state);
+        this.enterRule(localContext, 700, PlSqlParser.RULE_subpartition_key_value);
+        try {
+            this.state = 7792;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHR:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.DECODE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.MINUS_SIGN:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 7789;
+                this.literal();
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 7790;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 7791;
+                this.quoted_string();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public associate_statistics(): Associate_statisticsContext {
+        let localContext = new Associate_statisticsContext(this.context, this.state);
+        this.enterRule(localContext, 702, PlSqlParser.RULE_associate_statistics);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7794;
+            this.match(PlSqlParser.ASSOCIATE);
+            this.state = 7795;
+            this.match(PlSqlParser.STATISTICS);
+            this.state = 7796;
+            this.match(PlSqlParser.WITH);
+            this.state = 7799;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COLUMNS:
+                {
+                this.state = 7797;
+                this.column_association();
+                }
+                break;
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.TYPES:
+                {
+                this.state = 7798;
+                this.function_association();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 7802;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 820, this.context) ) {
+            case 1:
+                {
+                this.state = 7801;
+                this.storage_table_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_association(): Column_associationContext {
+        let localContext = new Column_associationContext(this.context, this.state);
+        this.enterRule(localContext, 704, PlSqlParser.RULE_column_association);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7804;
+            this.match(PlSqlParser.COLUMNS);
+            this.state = 7805;
+            this.tableview_name();
+            this.state = 7806;
+            this.match(PlSqlParser.PERIOD);
+            this.state = 7807;
+            this.column_name();
+            this.state = 7815;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 7808;
+                this.match(PlSqlParser.COMMA);
+                this.state = 7809;
+                this.tableview_name();
+                this.state = 7810;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 7811;
+                this.column_name();
+                }
+                }
+                this.state = 7817;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 7818;
+            this.using_statistics_type();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_association(): Function_associationContext {
+        let localContext = new Function_associationContext(this.context, this.state);
+        this.enterRule(localContext, 706, PlSqlParser.RULE_function_association);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7865;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.FUNCTIONS:
+                {
+                this.state = 7820;
+                this.match(PlSqlParser.FUNCTIONS);
+                this.state = 7821;
+                this.function_name();
+                this.state = 7826;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 7822;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7823;
+                    this.function_name();
+                    }
+                    }
+                    this.state = 7828;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.PACKAGES:
+                {
+                this.state = 7829;
+                this.match(PlSqlParser.PACKAGES);
+                this.state = 7830;
+                this.package_name();
+                this.state = 7835;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 7831;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7832;
+                    this.package_name();
+                    }
+                    }
+                    this.state = 7837;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.TYPES:
+                {
+                this.state = 7838;
+                this.match(PlSqlParser.TYPES);
+                this.state = 7839;
+                this.type_name();
+                this.state = 7844;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 7840;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7841;
+                    this.type_name();
+                    }
+                    }
+                    this.state = 7846;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.INDEXES:
+                {
+                this.state = 7847;
+                this.match(PlSqlParser.INDEXES);
+                this.state = 7848;
+                this.index_name();
+                this.state = 7853;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 7849;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7850;
+                    this.index_name();
+                    }
+                    }
+                    this.state = 7855;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.INDEXTYPES:
+                {
+                this.state = 7856;
+                this.match(PlSqlParser.INDEXTYPES);
+                this.state = 7857;
+                this.indextype_name();
+                this.state = 7862;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 7858;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7859;
+                    this.indextype_name();
+                    }
+                    }
+                    this.state = 7864;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 7878;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 830, this.context) ) {
+            case 1:
+                {
+                this.state = 7867;
+                this.using_statistics_type();
+                }
+                break;
+            case 2:
+                {
+                this.state = 7868;
+                this.default_cost_clause();
+                this.state = 7871;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 828, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7869;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7870;
+                    this.default_selectivity_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 7873;
+                this.default_selectivity_clause();
+                this.state = 7876;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 829, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7874;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 7875;
+                    this.default_cost_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public indextype_name(): Indextype_nameContext {
+        let localContext = new Indextype_nameContext(this.context, this.state);
+        this.enterRule(localContext, 708, PlSqlParser.RULE_indextype_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7880;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_statistics_type(): Using_statistics_typeContext {
+        let localContext = new Using_statistics_typeContext(this.context, this.state);
+        this.enterRule(localContext, 710, PlSqlParser.RULE_using_statistics_type);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7882;
+            this.match(PlSqlParser.USING);
+            this.state = 7885;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 7883;
+                this.statistics_type_name();
+                }
+                break;
+            case PlSqlParser.NULL_:
+                {
+                this.state = 7884;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public statistics_type_name(): Statistics_type_nameContext {
+        let localContext = new Statistics_type_nameContext(this.context, this.state);
+        this.enterRule(localContext, 712, PlSqlParser.RULE_statistics_type_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7887;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_cost_clause(): Default_cost_clauseContext {
+        let localContext = new Default_cost_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 714, PlSqlParser.RULE_default_cost_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7889;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 7890;
+            this.match(PlSqlParser.COST);
+            this.state = 7891;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 7892;
+            this.cpu_cost();
+            this.state = 7893;
+            this.match(PlSqlParser.COMMA);
+            this.state = 7894;
+            this.io_cost();
+            this.state = 7895;
+            this.match(PlSqlParser.COMMA);
+            this.state = 7896;
+            this.network_cost();
+            this.state = 7897;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cpu_cost(): Cpu_costContext {
+        let localContext = new Cpu_costContext(this.context, this.state);
+        this.enterRule(localContext, 716, PlSqlParser.RULE_cpu_cost);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7899;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public io_cost(): Io_costContext {
+        let localContext = new Io_costContext(this.context, this.state);
+        this.enterRule(localContext, 718, PlSqlParser.RULE_io_cost);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7901;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public network_cost(): Network_costContext {
+        let localContext = new Network_costContext(this.context, this.state);
+        this.enterRule(localContext, 720, PlSqlParser.RULE_network_cost);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7903;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_selectivity_clause(): Default_selectivity_clauseContext {
+        let localContext = new Default_selectivity_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 722, PlSqlParser.RULE_default_selectivity_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7905;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 7906;
+            this.match(PlSqlParser.SELECTIVITY);
+            this.state = 7907;
+            this.default_selectivity();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_selectivity(): Default_selectivityContext {
+        let localContext = new Default_selectivityContext(this.context, this.state);
+        this.enterRule(localContext, 724, PlSqlParser.RULE_default_selectivity);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7909;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public storage_table_clause(): Storage_table_clauseContext {
+        let localContext = new Storage_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 726, PlSqlParser.RULE_storage_table_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7911;
+            this.match(PlSqlParser.WITH);
+            this.state = 7912;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1951 || _la === 2239)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 7913;
+            this.match(PlSqlParser.MANAGED);
+            this.state = 7914;
+            this.match(PlSqlParser.STORAGE);
+            this.state = 7915;
+            this.match(PlSqlParser.TABLES);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unified_auditing(): Unified_auditingContext {
+        let localContext = new Unified_auditingContext(this.context, this.state);
+        this.enterRule(localContext, 728, PlSqlParser.RULE_unified_auditing);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7917;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            this.state = 7918;
+            this.match(PlSqlParser.AUDIT);
+            this.state = 7962;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.POLICY:
+                {
+                this.state = 7919;
+                this.match(PlSqlParser.POLICY);
+                this.state = 7920;
+                this.policy_name();
+                this.state = 7930;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 833, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7921;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 160 || _la === 534)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 7922;
+                    this.audit_user();
+                    this.state = 7927;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 832, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 7923;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 7924;
+                            this.audit_user();
+                            }
+                            }
+                        }
+                        this.state = 7929;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 832, this.context);
+                    }
+                    }
+                    break;
+                }
+                this.state = 7937;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 835, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7932;
+                    this.match(PlSqlParser.WHENEVER);
+                    this.state = 7934;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1206) {
+                        {
+                        this.state = 7933;
+                        this.match(PlSqlParser.NOT);
+                        }
+                    }
+
+                    this.state = 7936;
+                    this.match(PlSqlParser.SUCCESSFUL);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.CONTEXT:
+                {
+                this.state = 7939;
+                this.match(PlSqlParser.CONTEXT);
+                this.state = 7940;
+                this.match(PlSqlParser.NAMESPACE);
+                this.state = 7941;
+                this.oracle_namespace();
+                this.state = 7942;
+                this.match(PlSqlParser.ATTRIBUTES);
+                this.state = 7943;
+                this.attribute_name();
+                this.state = 7948;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 836, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 7944;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 7945;
+                        this.attribute_name();
+                        }
+                        }
+                    }
+                    this.state = 7950;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 836, this.context);
+                }
+                this.state = 7960;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 838, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7951;
+                    this.match(PlSqlParser.BY);
+                    this.state = 7952;
+                    this.audit_user();
+                    this.state = 7957;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 837, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 7953;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 7954;
+                            this.audit_user();
+                            }
+                            }
+                        }
+                        this.state = 7959;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 837, this.context);
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public policy_name(): Policy_nameContext {
+        let localContext = new Policy_nameContext(this.context, this.state);
+        this.enterRule(localContext, 730, PlSqlParser.RULE_policy_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7964;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public audit_traditional(): Audit_traditionalContext {
+        let localContext = new Audit_traditionalContext(this.context, this.state);
+        this.enterRule(localContext, 732, PlSqlParser.RULE_audit_traditional);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7966;
+            this.match(PlSqlParser.AUDIT);
+            this.state = 7977;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 841, this.context) ) {
+            case 1:
+                {
+                this.state = 7967;
+                this.audit_operation_clause();
+                this.state = 7972;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 840, this.context) ) {
+                case 1:
+                    {
+                    this.state = 7968;
+                    this.auditing_by_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 7969;
+                    this.match(PlSqlParser.IN);
+                    this.state = 7970;
+                    this.match(PlSqlParser.SESSION);
+                    this.state = 7971;
+                    this.match(PlSqlParser.CURRENT);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 7974;
+                this.audit_schema_object_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 7975;
+                this.match(PlSqlParser.NETWORK);
+                }
+                break;
+            case 4:
+                {
+                this.state = 7976;
+                this.audit_direct_path();
+                }
+                break;
+            }
+            this.state = 7981;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 842, this.context) ) {
+            case 1:
+                {
+                this.state = 7979;
+                this.match(PlSqlParser.BY);
+                this.state = 7980;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 4 || _la === 1669)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 7988;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 844, this.context) ) {
+            case 1:
+                {
+                this.state = 7983;
+                this.match(PlSqlParser.WHENEVER);
+                this.state = 7985;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 7984;
+                    this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 7987;
+                this.match(PlSqlParser.SUCCESSFUL);
+                }
+                break;
+            }
+            this.state = 7991;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 845, this.context) ) {
+            case 1:
+                {
+                this.state = 7990;
+                this.audit_container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public audit_direct_path(): Audit_direct_pathContext {
+        let localContext = new Audit_direct_pathContext(this.context, this.state);
+        this.enterRule(localContext, 734, PlSqlParser.RULE_audit_direct_path);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7993;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            this.state = 7994;
+            this.match(PlSqlParser.DIRECT_PATH);
+            this.state = 7995;
+            this.auditing_by_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public audit_container_clause(): Audit_container_clauseContext {
+        let localContext = new Audit_container_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 736, PlSqlParser.RULE_audit_container_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 7997;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            {
+            this.state = 7998;
+            this.match(PlSqlParser.CONTAINER);
+            this.state = 7999;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 8000;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 38 || _la === 336)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public audit_operation_clause(): Audit_operation_clauseContext {
+        let localContext = new Audit_operation_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 738, PlSqlParser.RULE_audit_operation_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8038;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 854, this.context) ) {
+            case 1:
+                {
+                this.state = 8007;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 847, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8002;
+                    this.sql_statement_shortcut();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 8003;
+                    this.match(PlSqlParser.ALL);
+                    this.state = 8005;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 846, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 8004;
+                        this.match(PlSqlParser.STATEMENTS);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                this.state = 8019;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 850, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8009;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8015;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 849, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8010;
+                            this.sql_statement_shortcut();
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 8011;
+                            this.match(PlSqlParser.ALL);
+                            this.state = 8013;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 848, this.context) ) {
+                            case 1:
+                                {
+                                this.state = 8012;
+                                this.match(PlSqlParser.STATEMENTS);
+                                }
+                                break;
+                            }
+                            }
+                            break;
+                        }
+                        }
+                        }
+                    }
+                    this.state = 8021;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 850, this.context);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 8025;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 851, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8022;
+                    this.system_privilege();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 8023;
+                    this.match(PlSqlParser.ALL);
+                    this.state = 8024;
+                    this.match(PlSqlParser.PRIVILEGES);
+                    }
+                    break;
+                }
+                this.state = 8035;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 853, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8027;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8031;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 852, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8028;
+                            this.system_privilege();
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 8029;
+                            this.match(PlSqlParser.ALL);
+                            this.state = 8030;
+                            this.match(PlSqlParser.PRIVILEGES);
+                            }
+                            break;
+                        }
+                        }
+                        }
+                    }
+                    this.state = 8037;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 853, this.context);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public auditing_by_clause(): Auditing_by_clauseContext {
+        let localContext = new Auditing_by_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 740, PlSqlParser.RULE_auditing_by_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8040;
+            this.match(PlSqlParser.BY);
+            this.state = 8041;
+            this.audit_user();
+            this.state = 8046;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 855, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 8042;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8043;
+                    this.audit_user();
+                    }
+                    }
+                }
+                this.state = 8048;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 855, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public audit_user(): Audit_userContext {
+        let localContext = new Audit_userContext(this.context, this.state);
+        this.enterRule(localContext, 742, PlSqlParser.RULE_audit_user);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8049;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public audit_schema_object_clause(): Audit_schema_object_clauseContext {
+        let localContext = new Audit_schema_object_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 744, PlSqlParser.RULE_audit_schema_object_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8060;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALTER:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.GRANT:
+            case PlSqlParser.INDEX:
+            case PlSqlParser.INSERT:
+            case PlSqlParser.LOCK:
+            case PlSqlParser.READ:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.SELECT:
+            case PlSqlParser.UPDATE:
+                {
+                this.state = 8051;
+                this.sql_operation();
+                this.state = 8056;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 8052;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8053;
+                    this.sql_operation();
+                    }
+                    }
+                    this.state = 8058;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 8059;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 8062;
+            this.auditing_on_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_operation(): Sql_operationContext {
+        let localContext = new Sql_operationContext(this.context, this.state);
+        this.enterRule(localContext, 746, PlSqlParser.RULE_sql_operation);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8064;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 42 || _la === 85 || _la === 241 || _la === 403 || _la === 543 || _la === 606 || _la === 648 || _la === 718 || _la === 757 || _la === 882 || _la === 1507 || _la === 1561 || _la === 1649 || _la === 2209)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public auditing_on_clause(): Auditing_on_clauseContext {
+        let localContext = new Auditing_on_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 748, PlSqlParser.RULE_auditing_on_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8066;
+            this.match(PlSqlParser.ON);
+            this.state = 8079;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 858, this.context) ) {
+            case 1:
+                {
+                this.state = 8067;
+                this.object_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8068;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 8069;
+                this.regular_id();
+                }
+                break;
+            case 3:
+                {
+                this.state = 8070;
+                this.match(PlSqlParser.MINING);
+                this.state = 8071;
+                this.match(PlSqlParser.MODEL);
+                this.state = 8072;
+                this.model_name();
+                }
+                break;
+            case 4:
+                {
+                this.state = 8073;
+                if (!(this.isVersion12())) {
+                    throw this.createFailedPredicateException("this.isVersion12()");
+                }
+                this.state = 8074;
+                this.match(PlSqlParser.SQL);
+                this.state = 8075;
+                this.match(PlSqlParser.TRANSLATION);
+                this.state = 8076;
+                this.match(PlSqlParser.PROFILE);
+                this.state = 8077;
+                this.profile_name();
+                }
+                break;
+            case 5:
+                {
+                this.state = 8078;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_name(): Model_nameContext {
+        let localContext = new Model_nameContext(this.context, this.state);
+        this.enterRule(localContext, 750, PlSqlParser.RULE_model_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8084;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 859, this.context) ) {
+            case 1:
+                {
+                this.state = 8081;
+                this.id_expression();
+                this.state = 8082;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8086;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_name(): Object_nameContext {
+        let localContext = new Object_nameContext(this.context, this.state);
+        this.enterRule(localContext, 752, PlSqlParser.RULE_object_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8091;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 860, this.context) ) {
+            case 1:
+                {
+                this.state = 8088;
+                this.id_expression();
+                this.state = 8089;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8093;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public profile_name(): Profile_nameContext {
+        let localContext = new Profile_nameContext(this.context, this.state);
+        this.enterRule(localContext, 754, PlSqlParser.RULE_profile_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8098;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 861, this.context) ) {
+            case 1:
+                {
+                this.state = 8095;
+                this.id_expression();
+                this.state = 8096;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8100;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_statement_shortcut(): Sql_statement_shortcutContext {
+        let localContext = new Sql_statement_shortcutContext(this.context, this.state);
+        this.enterRule(localContext, 756, PlSqlParser.RULE_sql_statement_shortcut);
+        try {
+            this.state = 8172;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 862, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 8102;
+                this.match(PlSqlParser.ALTER);
+                this.state = 8103;
+                this.match(PlSqlParser.SYSTEM);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 8104;
+                this.match(PlSqlParser.CLUSTER);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 8105;
+                this.match(PlSqlParser.CONTEXT);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 8106;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 8107;
+                this.match(PlSqlParser.LINK);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 8108;
+                this.match(PlSqlParser.DIMENSION);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 8109;
+                this.match(PlSqlParser.DIRECTORY);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 8110;
+                this.match(PlSqlParser.INDEX);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 8111;
+                this.match(PlSqlParser.MATERIALIZED);
+                this.state = 8112;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 8113;
+                this.match(PlSqlParser.NOT);
+                this.state = 8114;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 8115;
+                this.match(PlSqlParser.OUTLINE);
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 8116;
+                if (!(this.isVersion12())) {
+                    throw this.createFailedPredicateException("this.isVersion12()");
+                }
+                this.state = 8117;
+                this.match(PlSqlParser.PLUGGABLE);
+                this.state = 8118;
+                this.match(PlSqlParser.DATABASE);
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 8119;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 8120;
+                this.match(PlSqlParser.PROFILE);
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 8121;
+                this.match(PlSqlParser.PUBLIC);
+                this.state = 8122;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 8123;
+                this.match(PlSqlParser.LINK);
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 8124;
+                this.match(PlSqlParser.PUBLIC);
+                this.state = 8125;
+                this.match(PlSqlParser.SYNONYM);
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 8126;
+                this.match(PlSqlParser.ROLE);
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 8127;
+                this.match(PlSqlParser.ROLLBACK);
+                this.state = 8128;
+                this.match(PlSqlParser.SEGMENT);
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 8129;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 8130;
+                this.match(PlSqlParser.SESSION);
+                }
+                break;
+            case 20:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 8131;
+                this.match(PlSqlParser.SYNONYM);
+                }
+                break;
+            case 21:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 8132;
+                this.match(PlSqlParser.SYSTEM);
+                this.state = 8133;
+                this.match(PlSqlParser.AUDIT);
+                }
+                break;
+            case 22:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 8134;
+                this.match(PlSqlParser.SYSTEM);
+                this.state = 8135;
+                this.match(PlSqlParser.GRANT);
+                }
+                break;
+            case 23:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 8136;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 24:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 8137;
+                this.match(PlSqlParser.TABLESPACE);
+                }
+                break;
+            case 25:
+                this.enterOuterAlt(localContext, 25);
+                {
+                this.state = 8138;
+                this.match(PlSqlParser.TRIGGER);
+                }
+                break;
+            case 26:
+                this.enterOuterAlt(localContext, 26);
+                {
+                this.state = 8139;
+                this.match(PlSqlParser.TYPE);
+                }
+                break;
+            case 27:
+                this.enterOuterAlt(localContext, 27);
+                {
+                this.state = 8140;
+                this.match(PlSqlParser.USER);
+                }
+                break;
+            case 28:
+                this.enterOuterAlt(localContext, 28);
+                {
+                this.state = 8141;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 29:
+                this.enterOuterAlt(localContext, 29);
+                {
+                this.state = 8142;
+                this.match(PlSqlParser.ALTER);
+                this.state = 8143;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 30:
+                this.enterOuterAlt(localContext, 30);
+                {
+                this.state = 8144;
+                this.match(PlSqlParser.ALTER);
+                this.state = 8145;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 31:
+                this.enterOuterAlt(localContext, 31);
+                {
+                this.state = 8146;
+                this.match(PlSqlParser.COMMENT);
+                this.state = 8147;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 32:
+                this.enterOuterAlt(localContext, 32);
+                {
+                this.state = 8148;
+                this.match(PlSqlParser.DELETE);
+                this.state = 8149;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 33:
+                this.enterOuterAlt(localContext, 33);
+                {
+                this.state = 8150;
+                this.match(PlSqlParser.EXECUTE);
+                this.state = 8151;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 34:
+                this.enterOuterAlt(localContext, 34);
+                {
+                this.state = 8152;
+                this.match(PlSqlParser.GRANT);
+                this.state = 8153;
+                this.match(PlSqlParser.DIRECTORY);
+                }
+                break;
+            case 35:
+                this.enterOuterAlt(localContext, 35);
+                {
+                this.state = 8154;
+                this.match(PlSqlParser.GRANT);
+                this.state = 8155;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 36:
+                this.enterOuterAlt(localContext, 36);
+                {
+                this.state = 8156;
+                this.match(PlSqlParser.GRANT);
+                this.state = 8157;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 37:
+                this.enterOuterAlt(localContext, 37);
+                {
+                this.state = 8158;
+                this.match(PlSqlParser.GRANT);
+                this.state = 8159;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 38:
+                this.enterOuterAlt(localContext, 38);
+                {
+                this.state = 8160;
+                this.match(PlSqlParser.GRANT);
+                this.state = 8161;
+                this.match(PlSqlParser.TYPE);
+                }
+                break;
+            case 39:
+                this.enterOuterAlt(localContext, 39);
+                {
+                this.state = 8162;
+                this.match(PlSqlParser.INSERT);
+                this.state = 8163;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 40:
+                this.enterOuterAlt(localContext, 40);
+                {
+                this.state = 8164;
+                this.match(PlSqlParser.LOCK);
+                this.state = 8165;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 41:
+                this.enterOuterAlt(localContext, 41);
+                {
+                this.state = 8166;
+                this.match(PlSqlParser.SELECT);
+                this.state = 8167;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 42:
+                this.enterOuterAlt(localContext, 42);
+                {
+                this.state = 8168;
+                this.match(PlSqlParser.SELECT);
+                this.state = 8169;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 43:
+                this.enterOuterAlt(localContext, 43);
+                {
+                this.state = 8170;
+                this.match(PlSqlParser.UPDATE);
+                this.state = 8171;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_index(): Drop_indexContext {
+        let localContext = new Drop_indexContext(this.context, this.state);
+        this.enterRule(localContext, 758, PlSqlParser.RULE_drop_index);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8174;
+            this.match(PlSqlParser.DROP);
+            this.state = 8175;
+            this.match(PlSqlParser.INDEX);
+            this.state = 8176;
+            this.index_name();
+            this.state = 8179;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 863, this.context) ) {
+            case 1:
+                {
+                this.state = 8177;
+                this.match(PlSqlParser.IF);
+                this.state = 8178;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public disassociate_statistics(): Disassociate_statisticsContext {
+        let localContext = new Disassociate_statisticsContext(this.context, this.state);
+        this.enterRule(localContext, 760, PlSqlParser.RULE_disassociate_statistics);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8181;
+            this.match(PlSqlParser.DISASSOCIATE);
+            this.state = 8182;
+            this.match(PlSqlParser.STATISTICS);
+            this.state = 8183;
+            this.match(PlSqlParser.FROM);
+            this.state = 8303;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COLUMNS:
+                {
+                this.state = 8184;
+                this.match(PlSqlParser.COLUMNS);
+                this.state = 8188;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 864, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8185;
+                    this.schema_name();
+                    this.state = 8186;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8190;
+                localContext._tb = this.id_expression();
+                this.state = 8191;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 8192;
+                localContext._c = this.id_expression();
+                this.state = 8205;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 866, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8193;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8197;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 865, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8194;
+                            this.schema_name();
+                            this.state = 8195;
+                            this.match(PlSqlParser.PERIOD);
+                            }
+                            break;
+                        }
+                        this.state = 8199;
+                        localContext._tb = this.id_expression();
+                        this.state = 8200;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 8201;
+                        localContext._c = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 8207;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 866, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.FUNCTIONS:
+                {
+                this.state = 8208;
+                this.match(PlSqlParser.FUNCTIONS);
+                this.state = 8212;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 867, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8209;
+                    this.schema_name();
+                    this.state = 8210;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8214;
+                localContext._fn = this.id_expression();
+                this.state = 8224;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 869, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8215;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8219;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 868, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8216;
+                            this.schema_name();
+                            this.state = 8217;
+                            this.match(PlSqlParser.PERIOD);
+                            }
+                            break;
+                        }
+                        this.state = 8221;
+                        localContext._fn = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 8226;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 869, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.PACKAGES:
+                {
+                this.state = 8227;
+                this.match(PlSqlParser.PACKAGES);
+                this.state = 8231;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 870, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8228;
+                    this.schema_name();
+                    this.state = 8229;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8233;
+                localContext._pkg = this.id_expression();
+                this.state = 8243;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 872, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8234;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8238;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 871, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8235;
+                            this.schema_name();
+                            this.state = 8236;
+                            this.match(PlSqlParser.PERIOD);
+                            }
+                            break;
+                        }
+                        this.state = 8240;
+                        localContext._pkg = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 8245;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 872, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.TYPES:
+                {
+                this.state = 8246;
+                this.match(PlSqlParser.TYPES);
+                this.state = 8250;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 873, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8247;
+                    this.schema_name();
+                    this.state = 8248;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8252;
+                localContext._t = this.id_expression();
+                this.state = 8262;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 875, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8253;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8257;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 874, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8254;
+                            this.schema_name();
+                            this.state = 8255;
+                            this.match(PlSqlParser.PERIOD);
+                            }
+                            break;
+                        }
+                        this.state = 8259;
+                        localContext._t = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 8264;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 875, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.INDEXES:
+                {
+                this.state = 8265;
+                this.match(PlSqlParser.INDEXES);
+                this.state = 8269;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 876, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8266;
+                    this.schema_name();
+                    this.state = 8267;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8271;
+                localContext._ix = this.id_expression();
+                this.state = 8281;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 878, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8272;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8276;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 877, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8273;
+                            this.schema_name();
+                            this.state = 8274;
+                            this.match(PlSqlParser.PERIOD);
+                            }
+                            break;
+                        }
+                        this.state = 8278;
+                        localContext._ix = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 8283;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 878, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.INDEXTYPES:
+                {
+                this.state = 8284;
+                this.match(PlSqlParser.INDEXTYPES);
+                this.state = 8288;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 879, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8285;
+                    this.schema_name();
+                    this.state = 8286;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8290;
+                localContext._it = this.id_expression();
+                this.state = 8300;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 881, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8291;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 8295;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 880, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8292;
+                            this.schema_name();
+                            this.state = 8293;
+                            this.match(PlSqlParser.PERIOD);
+                            }
+                            break;
+                        }
+                        this.state = 8297;
+                        localContext._it = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 8302;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 881, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 8306;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 883, this.context) ) {
+            case 1:
+                {
+                this.state = 8305;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_indextype(): Drop_indextypeContext {
+        let localContext = new Drop_indextypeContext(this.context, this.state);
+        this.enterRule(localContext, 762, PlSqlParser.RULE_drop_indextype);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8308;
+            this.match(PlSqlParser.DROP);
+            this.state = 8309;
+            this.match(PlSqlParser.INDEXTYPE);
+            this.state = 8313;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 884, this.context) ) {
+            case 1:
+                {
+                this.state = 8310;
+                this.schema_name();
+                this.state = 8311;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8315;
+            localContext._it = this.id_expression();
+            this.state = 8317;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 885, this.context) ) {
+            case 1:
+                {
+                this.state = 8316;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_inmemory_join_group(): Drop_inmemory_join_groupContext {
+        let localContext = new Drop_inmemory_join_groupContext(this.context, this.state);
+        this.enterRule(localContext, 764, PlSqlParser.RULE_drop_inmemory_join_group);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8319;
+            this.match(PlSqlParser.DROP);
+            this.state = 8320;
+            this.match(PlSqlParser.INMEMORY);
+            this.state = 8321;
+            this.match(PlSqlParser.JOIN);
+            this.state = 8322;
+            this.match(PlSqlParser.GROUP);
+            this.state = 8326;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 886, this.context) ) {
+            case 1:
+                {
+                this.state = 8323;
+                this.schema_name();
+                this.state = 8324;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8328;
+            localContext._jg = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public flashback_table(): Flashback_tableContext {
+        let localContext = new Flashback_tableContext(this.context, this.state);
+        this.enterRule(localContext, 766, PlSqlParser.RULE_flashback_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8330;
+            this.match(PlSqlParser.FLASHBACK);
+            this.state = 8331;
+            this.match(PlSqlParser.TABLE);
+            this.state = 8332;
+            this.tableview_name();
+            this.state = 8337;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 8333;
+                this.match(PlSqlParser.COMMA);
+                this.state = 8334;
+                this.tableview_name();
+                }
+                }
+                this.state = 8339;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 8340;
+            this.match(PlSqlParser.TO);
+            this.state = 8359;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.SCN:
+            case PlSqlParser.TIMESTAMP:
+                {
+                this.state = 8346;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.SCN:
+                case PlSqlParser.TIMESTAMP:
+                    {
+                    this.state = 8341;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1629 || _la === 2110)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 8342;
+                    this.expression();
+                    }
+                    break;
+                case PlSqlParser.RESTORE:
+                    {
+                    this.state = 8343;
+                    this.match(PlSqlParser.RESTORE);
+                    this.state = 8344;
+                    this.match(PlSqlParser.POINT);
+                    this.state = 8345;
+                    this.restore_point();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 8350;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 889, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8348;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 429 || _la === 499)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 8349;
+                    this.match(PlSqlParser.TRIGGERS);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.BEFORE:
+                {
+                this.state = 8352;
+                this.match(PlSqlParser.BEFORE);
+                this.state = 8353;
+                this.match(PlSqlParser.DROP);
+                this.state = 8357;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 890, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8354;
+                    this.match(PlSqlParser.RENAME);
+                    this.state = 8355;
+                    this.match(PlSqlParser.TO);
+                    this.state = 8356;
+                    this.tableview_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public restore_point(): Restore_pointContext {
+        let localContext = new Restore_pointContext(this.context, this.state);
+        this.enterRule(localContext, 768, PlSqlParser.RULE_restore_point);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8361;
+            this.identifier();
+            this.state = 8366;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 892, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 8362;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 8363;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 8368;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 892, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public purge_statement(): Purge_statementContext {
+        let localContext = new Purge_statementContext(this.context, this.state);
+        this.enterRule(localContext, 770, PlSqlParser.RULE_purge_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8369;
+            this.match(PlSqlParser.PURGE);
+            this.state = 8383;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INDEX:
+            case PlSqlParser.TABLE:
+                {
+                this.state = 8370;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 718 || _la === 2085)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 8371;
+                this.id_expression();
+                }
+                break;
+            case PlSqlParser.TABLESPACE:
+                {
+                this.state = 8372;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 8374;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 893, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8373;
+                    this.match(PlSqlParser.SET);
+                    }
+                    break;
+                }
+                this.state = 8376;
+                localContext._ts = this.id_expression();
+                this.state = 8379;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 894, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8377;
+                    this.match(PlSqlParser.USER);
+                    this.state = 8378;
+                    localContext._u = this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.RECYCLEBIN:
+                {
+                this.state = 8381;
+                this.match(PlSqlParser.RECYCLEBIN);
+                }
+                break;
+            case PlSqlParser.DBA_RECYCLEBIN:
+                {
+                this.state = 8382;
+                this.match(PlSqlParser.DBA_RECYCLEBIN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public noaudit_statement(): Noaudit_statementContext {
+        let localContext = new Noaudit_statementContext(this.context, this.state);
+        this.enterRule(localContext, 772, PlSqlParser.RULE_noaudit_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8385;
+            this.match(PlSqlParser.NOAUDIT);
+            this.state = 8397;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 898, this.context) ) {
+            case 1:
+                {
+                this.state = 8386;
+                this.audit_operation_clause();
+                this.state = 8388;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 896, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8387;
+                    this.auditing_by_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 8390;
+                this.audit_schema_object_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 8391;
+                this.match(PlSqlParser.NETWORK);
+                }
+                break;
+            case 4:
+                {
+                this.state = 8392;
+                this.match(PlSqlParser.DIRECT_PATH);
+                this.state = 8393;
+                this.match(PlSqlParser.LOAD);
+                this.state = 8395;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 897, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8394;
+                    this.auditing_by_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 8404;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 900, this.context) ) {
+            case 1:
+                {
+                this.state = 8399;
+                this.match(PlSqlParser.WHENEVER);
+                this.state = 8401;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 8400;
+                    this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 8403;
+                this.match(PlSqlParser.SUCCESSFUL);
+                }
+                break;
+            }
+            this.state = 8407;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 901, this.context) ) {
+            case 1:
+                {
+                this.state = 8406;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rename_object(): Rename_objectContext {
+        let localContext = new Rename_objectContext(this.context, this.state);
+        this.enterRule(localContext, 774, PlSqlParser.RULE_rename_object);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8409;
+            this.match(PlSqlParser.RENAME);
+            this.state = 8410;
+            this.object_name();
+            this.state = 8411;
+            this.match(PlSqlParser.TO);
+            this.state = 8412;
+            this.object_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public grant_statement(): Grant_statementContext {
+        let localContext = new Grant_statementContext(this.context, this.state);
+        this.enterRule(localContext, 776, PlSqlParser.RULE_grant_statement);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8414;
+            this.match(PlSqlParser.GRANT);
+            this.state = 8426;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 8416;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 8415;
+                        this.match(PlSqlParser.COMMA);
+                        }
+                    }
+
+                    this.state = 8424;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 904, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 8418;
+                        this.role_name();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 8419;
+                        this.system_privilege();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 8420;
+                        this.object_privilege();
+                        this.state = 8422;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 2449) {
+                            {
+                            this.state = 8421;
+                            this.paren_column_list();
+                            }
+                        }
+
+                        }
+                        break;
+                    }
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 8428;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 905, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            this.state = 8432;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1261) {
+                {
+                this.state = 8430;
+                this.match(PlSqlParser.ON);
+                this.state = 8431;
+                this.grant_object_name();
+                }
+            }
+
+            this.state = 8434;
+            this.match(PlSqlParser.TO);
+            this.state = 8437;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 907, this.context) ) {
+            case 1:
+                {
+                this.state = 8435;
+                this.grantee_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8436;
+                this.match(PlSqlParser.PUBLIC);
+                }
+                break;
+            }
+            this.state = 8446;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 909, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 8439;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8442;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 908, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 8440;
+                        this.grantee_name();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 8441;
+                        this.match(PlSqlParser.PUBLIC);
+                        }
+                        break;
+                    }
+                    }
+                    }
+                }
+                this.state = 8448;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 909, this.context);
+            }
+            this.state = 8452;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 910, this.context) ) {
+            case 1:
+                {
+                this.state = 8449;
+                this.match(PlSqlParser.WITH);
+                this.state = 8450;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 26 || _la === 401)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 8451;
+                this.match(PlSqlParser.OPTION);
+                }
+                break;
+            }
+            this.state = 8457;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 911, this.context) ) {
+            case 1:
+                {
+                this.state = 8454;
+                this.match(PlSqlParser.WITH);
+                this.state = 8455;
+                this.match(PlSqlParser.HIERARCHY);
+                this.state = 8456;
+                this.match(PlSqlParser.OPTION);
+                }
+                break;
+            }
+            this.state = 8462;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 912, this.context) ) {
+            case 1:
+                {
+                this.state = 8459;
+                this.match(PlSqlParser.WITH);
+                this.state = 8460;
+                this.match(PlSqlParser.GRANT);
+                this.state = 8461;
+                this.match(PlSqlParser.OPTION);
+                }
+                break;
+            }
+            this.state = 8465;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 913, this.context) ) {
+            case 1:
+                {
+                this.state = 8464;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public container_clause(): Container_clauseContext {
+        let localContext = new Container_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 778, PlSqlParser.RULE_container_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8467;
+            this.match(PlSqlParser.CONTAINER);
+            this.state = 8468;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 8469;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 38 || _la === 336)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public revoke_statement(): Revoke_statementContext {
+        let localContext = new Revoke_statementContext(this.context, this.state);
+        this.enterRule(localContext, 780, PlSqlParser.RULE_revoke_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8471;
+            this.match(PlSqlParser.REVOKE);
+            this.state = 8480;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 916, this.context) ) {
+            case 1:
+                {
+                this.state = 8474;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 914, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8472;
+                    this.revoke_system_privilege();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 8473;
+                    this.revoke_object_privileges();
+                    }
+                    break;
+                }
+                this.state = 8477;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 915, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8476;
+                    this.container_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 8479;
+                this.revoke_roles_from_programs();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public revoke_system_privilege(): Revoke_system_privilegeContext {
+        let localContext = new Revoke_system_privilegeContext(this.context, this.state);
+        this.enterRule(localContext, 782, PlSqlParser.RULE_revoke_system_privilege);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8486;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 917, this.context) ) {
+            case 1:
+                {
+                this.state = 8482;
+                this.system_privilege();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8483;
+                this.role_name();
+                }
+                break;
+            case 3:
+                {
+                this.state = 8484;
+                this.match(PlSqlParser.ALL);
+                this.state = 8485;
+                this.match(PlSqlParser.PRIVILEGES);
+                }
+                break;
+            }
+            this.state = 8488;
+            this.match(PlSqlParser.FROM);
+            this.state = 8489;
+            this.revokee_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public revokee_clause(): Revokee_clauseContext {
+        let localContext = new Revokee_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 784, PlSqlParser.RULE_revokee_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8493;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 918, this.context) ) {
+            case 1:
+                {
+                this.state = 8491;
+                this.id_expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8492;
+                this.match(PlSqlParser.PUBLIC);
+                }
+                break;
+            }
+            this.state = 8502;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 920, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 8495;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8498;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 919, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 8496;
+                        this.id_expression();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 8497;
+                        this.match(PlSqlParser.PUBLIC);
+                        }
+                        break;
+                    }
+                    }
+                    }
+                }
+                this.state = 8504;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 920, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public revoke_object_privileges(): Revoke_object_privilegesContext {
+        let localContext = new Revoke_object_privilegesContext(this.context, this.state);
+        this.enterRule(localContext, 786, PlSqlParser.RULE_revoke_object_privileges);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8510;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 922, this.context) ) {
+            case 1:
+                {
+                this.state = 8505;
+                this.object_privilege();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8506;
+                this.match(PlSqlParser.ALL);
+                this.state = 8508;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1461) {
+                    {
+                    this.state = 8507;
+                    this.match(PlSqlParser.PRIVILEGES);
+                    }
+                }
+
+                }
+                break;
+            }
+            this.state = 8522;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 8512;
+                this.match(PlSqlParser.COMMA);
+                this.state = 8518;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 924, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8513;
+                    this.object_privilege();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 8514;
+                    this.match(PlSqlParser.ALL);
+                    this.state = 8516;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1461) {
+                        {
+                        this.state = 8515;
+                        this.match(PlSqlParser.PRIVILEGES);
+                        }
+                    }
+
+                    }
+                    break;
+                }
+                }
+                }
+                this.state = 8524;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 8525;
+            this.on_object_clause();
+            this.state = 8526;
+            this.match(PlSqlParser.FROM);
+            this.state = 8527;
+            this.revokee_clause();
+            this.state = 8531;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 926, this.context) ) {
+            case 1:
+                {
+                this.state = 8528;
+                this.match(PlSqlParser.CASCADE);
+                this.state = 8529;
+                this.match(PlSqlParser.CONSTRAINTS);
+                }
+                break;
+            case 2:
+                {
+                this.state = 8530;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_object_clause(): On_object_clauseContext {
+        let localContext = new On_object_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 788, PlSqlParser.RULE_on_object_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8533;
+            this.match(PlSqlParser.ON);
+            this.state = 8578;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 932, this.context) ) {
+            case 1:
+                {
+                this.state = 8537;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 927, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8534;
+                    this.schema_name();
+                    this.state = 8535;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8539;
+                localContext._o = this.id_expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8540;
+                this.match(PlSqlParser.USER);
+                this.state = 8541;
+                this.id_expression();
+                this.state = 8546;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 8542;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8543;
+                    this.id_expression();
+                    }
+                    }
+                    this.state = 8548;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 8549;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 8550;
+                this.directory_name();
+                }
+                break;
+            case 4:
+                {
+                this.state = 8551;
+                this.match(PlSqlParser.EDITION);
+                this.state = 8552;
+                this.edition_name();
+                }
+                break;
+            case 5:
+                {
+                this.state = 8553;
+                this.match(PlSqlParser.MINING);
+                this.state = 8554;
+                this.match(PlSqlParser.MODEL);
+                this.state = 8558;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 929, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8555;
+                    this.schema_name();
+                    this.state = 8556;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8560;
+                localContext._mmn = this.id_expression();
+                }
+                break;
+            case 6:
+                {
+                this.state = 8561;
+                this.match(PlSqlParser.JAVA);
+                this.state = 8562;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1572 || _la === 1715)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 8566;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 930, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8563;
+                    this.schema_name();
+                    this.state = 8564;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8568;
+                localContext._o2 = this.id_expression();
+                }
+                break;
+            case 7:
+                {
+                this.state = 8569;
+                this.match(PlSqlParser.SQL);
+                this.state = 8570;
+                this.match(PlSqlParser.TRANSLATION);
+                this.state = 8571;
+                this.match(PlSqlParser.PROFILE);
+                this.state = 8575;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 931, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8572;
+                    this.schema_name();
+                    this.state = 8573;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8577;
+                localContext._p = this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public revoke_roles_from_programs(): Revoke_roles_from_programsContext {
+        let localContext = new Revoke_roles_from_programsContext(this.context, this.state);
+        this.enterRule(localContext, 790, PlSqlParser.RULE_revoke_roles_from_programs);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8589;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 8580;
+                this.role_name();
+                this.state = 8585;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 8581;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8582;
+                    this.role_name();
+                    }
+                    }
+                    this.state = 8587;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.ALL:
+                {
+                this.state = 8588;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 8591;
+            this.match(PlSqlParser.FROM);
+            this.state = 8592;
+            this.program_unit();
+            this.state = 8597;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 935, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 8593;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8594;
+                    this.program_unit();
+                    }
+                    }
+                }
+                this.state = 8599;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 935, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public program_unit(): Program_unitContext {
+        let localContext = new Program_unitContext(this.context, this.state);
+        this.enterRule(localContext, 792, PlSqlParser.RULE_program_unit);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8600;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 633 || _la === 1331 || _la === 1463)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 8604;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 936, this.context) ) {
+            case 1:
+                {
+                this.state = 8601;
+                this.schema_name();
+                this.state = 8602;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8606;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_dimension(): Create_dimensionContext {
+        let localContext = new Create_dimensionContext(this.context, this.state);
+        this.enterRule(localContext, 794, PlSqlParser.RULE_create_dimension);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8608;
+            this.match(PlSqlParser.CREATE);
+            this.state = 8609;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 8610;
+            this.identifier();
+            this.state = 8612;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 8611;
+                this.level_clause();
+                }
+                }
+                this.state = 8614;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 847);
+            this.state = 8619;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 8619;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 938, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 8616;
+                        this.hierarchy_clause();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 8617;
+                        this.attribute_clause();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 8618;
+                        this.extended_attribute_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 8621;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 939, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_directory(): Create_directoryContext {
+        let localContext = new Create_directoryContext(this.context, this.state);
+        this.enterRule(localContext, 796, PlSqlParser.RULE_create_directory);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8623;
+            this.match(PlSqlParser.CREATE);
+            this.state = 8626;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 8624;
+                this.match(PlSqlParser.OR);
+                this.state = 8625;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 8628;
+            this.match(PlSqlParser.DIRECTORY);
+            this.state = 8629;
+            this.directory_name();
+            this.state = 8633;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1683) {
+                {
+                this.state = 8630;
+                this.match(PlSqlParser.SHARING);
+                this.state = 8631;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 8632;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 8635;
+            this.match(PlSqlParser.AS);
+            this.state = 8636;
+            this.directory_path();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public directory_name(): Directory_nameContext {
+        let localContext = new Directory_nameContext(this.context, this.state);
+        this.enterRule(localContext, 798, PlSqlParser.RULE_directory_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8638;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public directory_path(): Directory_pathContext {
+        let localContext = new Directory_pathContext(this.context, this.state);
+        this.enterRule(localContext, 800, PlSqlParser.RULE_directory_path);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8640;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_inmemory_join_group(): Create_inmemory_join_groupContext {
+        let localContext = new Create_inmemory_join_groupContext(this.context, this.state);
+        this.enterRule(localContext, 802, PlSqlParser.RULE_create_inmemory_join_group);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8642;
+            this.match(PlSqlParser.CREATE);
+            this.state = 8643;
+            this.match(PlSqlParser.INMEMORY);
+            this.state = 8644;
+            this.match(PlSqlParser.JOIN);
+            this.state = 8645;
+            this.match(PlSqlParser.GROUP);
+            this.state = 8649;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 942, this.context) ) {
+            case 1:
+                {
+                this.state = 8646;
+                this.schema_name();
+                this.state = 8647;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8651;
+            localContext._jg = this.id_expression();
+            this.state = 8652;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 8656;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 943, this.context) ) {
+            case 1:
+                {
+                this.state = 8653;
+                this.schema_name();
+                this.state = 8654;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8658;
+            localContext._t = this.id_expression();
+            this.state = 8659;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 8660;
+            localContext._c = this.id_expression();
+            this.state = 8661;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 8673;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 8662;
+                this.match(PlSqlParser.COMMA);
+                this.state = 8666;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 944, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8663;
+                    this.schema_name();
+                    this.state = 8664;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8668;
+                localContext._t = this.id_expression();
+                this.state = 8669;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 8670;
+                localContext._c = this.id_expression();
+                this.state = 8671;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                }
+                this.state = 8675;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2455);
+            this.state = 8677;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_hierarchy(): Drop_hierarchyContext {
+        let localContext = new Drop_hierarchyContext(this.context, this.state);
+        this.enterRule(localContext, 804, PlSqlParser.RULE_drop_hierarchy);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8679;
+            this.match(PlSqlParser.DROP);
+            this.state = 8680;
+            this.match(PlSqlParser.HIERARCHY);
+            this.state = 8684;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 946, this.context) ) {
+            case 1:
+                {
+                this.state = 8681;
+                this.schema_name();
+                this.state = 8682;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8686;
+            localContext._hn = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_library(): Alter_libraryContext {
+        let localContext = new Alter_libraryContext(this.context, this.state);
+        this.enterRule(localContext, 806, PlSqlParser.RULE_alter_library);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8688;
+            this.match(PlSqlParser.ALTER);
+            this.state = 8689;
+            this.match(PlSqlParser.LIBRARY);
+            this.state = 8690;
+            this.library_name();
+            this.state = 8706;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 950, this.context) ) {
+            case 1:
+                {
+                this.state = 8691;
+                this.match(PlSqlParser.COMPILE);
+                this.state = 8693;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 947, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8692;
+                    this.library_debug();
+                    }
+                    break;
+                }
+                this.state = 8698;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 948, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 8695;
+                        this.compiler_parameters_clause();
+                        }
+                        }
+                    }
+                    this.state = 8700;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 948, this.context);
+                }
+                this.state = 8703;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 949, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8701;
+                    this.match(PlSqlParser.REUSE);
+                    this.state = 8702;
+                    this.match(PlSqlParser.SETTINGS);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 8705;
+                this.library_editionable();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_java(): Drop_javaContext {
+        let localContext = new Drop_javaContext(this.context, this.state);
+        this.enterRule(localContext, 808, PlSqlParser.RULE_drop_java);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8708;
+            this.match(PlSqlParser.DROP);
+            this.state = 8709;
+            this.match(PlSqlParser.JAVA);
+            this.state = 8710;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 206 || _la === 1572 || _la === 1715)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 8714;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 951, this.context) ) {
+            case 1:
+                {
+                this.state = 8711;
+                this.schema_name();
+                this.state = 8712;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8716;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_library(): Drop_libraryContext {
+        let localContext = new Drop_libraryContext(this.context, this.state);
+        this.enterRule(localContext, 810, PlSqlParser.RULE_drop_library);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8718;
+            this.match(PlSqlParser.DROP);
+            this.state = 8719;
+            this.match(PlSqlParser.LIBRARY);
+            this.state = 8720;
+            this.library_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_java(): Create_javaContext {
+        let localContext = new Create_javaContext(this.context, this.state);
+        this.enterRule(localContext, 812, PlSqlParser.RULE_create_java);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8722;
+            this.match(PlSqlParser.CREATE);
+            this.state = 8725;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 8723;
+                this.match(PlSqlParser.OR);
+                this.state = 8724;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 8729;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 49) {
+                {
+                this.state = 8727;
+                this.match(PlSqlParser.AND);
+                this.state = 8728;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 249 || _la === 1570)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 8732;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1105) {
+                {
+                this.state = 8731;
+                this.match(PlSqlParser.NOFORCE);
+                }
+            }
+
+            this.state = 8734;
+            this.match(PlSqlParser.JAVA);
+            this.state = 8748;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RESOURCE:
+            case PlSqlParser.SOURCE:
+                {
+                this.state = 8735;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1572 || _la === 1715)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 8736;
+                this.match(PlSqlParser.NAMED);
+                this.state = 8740;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 955, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8737;
+                    this.schema_name();
+                    this.state = 8738;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 8742;
+                localContext._pn = this.id_expression();
+                }
+                break;
+            case PlSqlParser.CLASS:
+                {
+                this.state = 8743;
+                this.match(PlSqlParser.CLASS);
+                this.state = 8746;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1627) {
+                    {
+                    this.state = 8744;
+                    this.match(PlSqlParser.SCHEMA);
+                    this.state = 8745;
+                    this.id_expression();
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 8753;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1683) {
+                {
+                this.state = 8750;
+                this.match(PlSqlParser.SHARING);
+                this.state = 8751;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 8752;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 8756;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 88) {
+                {
+                this.state = 8755;
+                this.invoker_rights_clause();
+                }
+            }
+
+            this.state = 8775;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1571) {
+                {
+                this.state = 8758;
+                this.match(PlSqlParser.RESOLVER);
+                this.state = 8759;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 8770;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 8760;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 8761;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 8763;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 8762;
+                        this.match(PlSqlParser.COMMA);
+                        }
+                    }
+
+                    this.state = 8767;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.ABORT:
+                    case PlSqlParser.ABS:
+                    case PlSqlParser.ABSENT:
+                    case PlSqlParser.ACCESS:
+                    case PlSqlParser.ACCESSED:
+                    case PlSqlParser.ACCESSIBLE:
+                    case PlSqlParser.ACCOUNT:
+                    case PlSqlParser.ACL:
+                    case PlSqlParser.ACOS:
+                    case PlSqlParser.ACROSS:
+                    case PlSqlParser.ACTION:
+                    case PlSqlParser.ACTIONS:
+                    case PlSqlParser.ACTIVATE:
+                    case PlSqlParser.ACTIVE:
+                    case PlSqlParser.ACTIVE_COMPONENT:
+                    case PlSqlParser.ACTIVE_DATA:
+                    case PlSqlParser.ACTIVE_FUNCTION:
+                    case PlSqlParser.ACTIVE_TAG:
+                    case PlSqlParser.ACTIVITY:
+                    case PlSqlParser.ADAPTIVE_PLAN:
+                    case PlSqlParser.ADD:
+                    case PlSqlParser.ADD_COLUMN:
+                    case PlSqlParser.ADD_GROUP:
+                    case PlSqlParser.ADD_MONTHS:
+                    case PlSqlParser.ADJ_DATE:
+                    case PlSqlParser.ADMIN:
+                    case PlSqlParser.ADMINISTER:
+                    case PlSqlParser.ADMINISTRATOR:
+                    case PlSqlParser.ADVANCED:
+                    case PlSqlParser.ADVISE:
+                    case PlSqlParser.ADVISOR:
+                    case PlSqlParser.AFD_DISKSTRING:
+                    case PlSqlParser.AFTER:
+                    case PlSqlParser.AGENT:
+                    case PlSqlParser.AGGREGATE:
+                    case PlSqlParser.A_LETTER:
+                    case PlSqlParser.ALIAS:
+                    case PlSqlParser.ALLOCATE:
+                    case PlSqlParser.ALLOW:
+                    case PlSqlParser.ALL_ROWS:
+                    case PlSqlParser.ALTERNATE:
+                    case PlSqlParser.ALWAYS:
+                    case PlSqlParser.ANALYTIC:
+                    case PlSqlParser.ANALYZE:
+                    case PlSqlParser.ANCESTOR:
+                    case PlSqlParser.ANCILLARY:
+                    case PlSqlParser.AND_EQUAL:
+                    case PlSqlParser.ANOMALY:
+                    case PlSqlParser.ANSI_REARCH:
+                    case PlSqlParser.ANTIJOIN:
+                    case PlSqlParser.ANYSCHEMA:
+                    case PlSqlParser.APPEND:
+                    case PlSqlParser.APPENDCHILDXML:
+                    case PlSqlParser.APPEND_VALUES:
+                    case PlSqlParser.APPLICATION:
+                    case PlSqlParser.APPLY:
+                    case PlSqlParser.APPROX_COUNT_DISTINCT:
+                    case PlSqlParser.ARCHIVAL:
+                    case PlSqlParser.ARCHIVE:
+                    case PlSqlParser.ARCHIVED:
+                    case PlSqlParser.ARCHIVELOG:
+                    case PlSqlParser.ARRAY:
+                    case PlSqlParser.ASCII:
+                    case PlSqlParser.ASCIISTR:
+                    case PlSqlParser.ASIN:
+                    case PlSqlParser.ASIS:
+                    case PlSqlParser.ASSEMBLY:
+                    case PlSqlParser.ASSIGN:
+                    case PlSqlParser.ASSOCIATE:
+                    case PlSqlParser.ASYNC:
+                    case PlSqlParser.ASYNCHRONOUS:
+                    case PlSqlParser.ATAN2:
+                    case PlSqlParser.ATAN:
+                    case PlSqlParser.AT:
+                    case PlSqlParser.ATTRIBUTE:
+                    case PlSqlParser.ATTRIBUTES:
+                    case PlSqlParser.AUDIT:
+                    case PlSqlParser.AUTHENTICATED:
+                    case PlSqlParser.AUTHENTICATION:
+                    case PlSqlParser.AUTHID:
+                    case PlSqlParser.AUTHORIZATION:
+                    case PlSqlParser.AUTOALLOCATE:
+                    case PlSqlParser.AUTO:
+                    case PlSqlParser.AUTOEXTEND:
+                    case PlSqlParser.AUTO_LOGIN:
+                    case PlSqlParser.AUTOMATIC:
+                    case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                    case PlSqlParser.AUTO_REOPTIMIZE:
+                    case PlSqlParser.AVAILABILITY:
+                    case PlSqlParser.AVRO:
+                    case PlSqlParser.BACKGROUND:
+                    case PlSqlParser.BACKINGFILE:
+                    case PlSqlParser.BACKUP:
+                    case PlSqlParser.BACKUPS:
+                    case PlSqlParser.BASIC:
+                    case PlSqlParser.BASICFILE:
+                    case PlSqlParser.BATCH:
+                    case PlSqlParser.BATCHSIZE:
+                    case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.BECOME:
+                    case PlSqlParser.BEFORE:
+                    case PlSqlParser.BEGIN:
+                    case PlSqlParser.BEGINNING:
+                    case PlSqlParser.BEGIN_OUTLINE_DATA:
+                    case PlSqlParser.BEHALF:
+                    case PlSqlParser.BEQUEATH:
+                    case PlSqlParser.BFILE:
+                    case PlSqlParser.BFILENAME:
+                    case PlSqlParser.BIGFILE:
+                    case PlSqlParser.BINARY:
+                    case PlSqlParser.BINARY_DOUBLE:
+                    case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                    case PlSqlParser.BINARY_DOUBLE_NAN:
+                    case PlSqlParser.BINARY_FLOAT:
+                    case PlSqlParser.BINARY_FLOAT_INFINITY:
+                    case PlSqlParser.BINARY_FLOAT_NAN:
+                    case PlSqlParser.BINARY_INTEGER:
+                    case PlSqlParser.BIND_AWARE:
+                    case PlSqlParser.BINDING:
+                    case PlSqlParser.BIN_TO_NUM:
+                    case PlSqlParser.BITAND:
+                    case PlSqlParser.BITMAP_AND:
+                    case PlSqlParser.BITMAP:
+                    case PlSqlParser.BITMAPS:
+                    case PlSqlParser.BITMAP_TREE:
+                    case PlSqlParser.BITS:
+                    case PlSqlParser.BLOB:
+                    case PlSqlParser.BLOCK:
+                    case PlSqlParser.BLOCK_RANGE:
+                    case PlSqlParser.BLOCKS:
+                    case PlSqlParser.BLOCKSIZE:
+                    case PlSqlParser.BODY:
+                    case PlSqlParser.BOOLEAN:
+                    case PlSqlParser.BOTH:
+                    case PlSqlParser.BOUND:
+                    case PlSqlParser.BRANCH:
+                    case PlSqlParser.BREADTH:
+                    case PlSqlParser.BROADCAST:
+                    case PlSqlParser.BSON:
+                    case PlSqlParser.BUFFER:
+                    case PlSqlParser.BUFFER_CACHE:
+                    case PlSqlParser.BUFFER_POOL:
+                    case PlSqlParser.BUILD:
+                    case PlSqlParser.BULK:
+                    case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                    case PlSqlParser.BYPASS_UJVC:
+                    case PlSqlParser.BYTE:
+                    case PlSqlParser.BYTES:
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.CACHE_CB:
+                    case PlSqlParser.CACHE_INSTANCES:
+                    case PlSqlParser.CACHE_TEMP_TABLE:
+                    case PlSqlParser.CACHING:
+                    case PlSqlParser.CALCULATED:
+                    case PlSqlParser.CALLBACK:
+                    case PlSqlParser.CALL:
+                    case PlSqlParser.CANCEL:
+                    case PlSqlParser.CAPACITY:
+                    case PlSqlParser.CAPTION:
+                    case PlSqlParser.CARDINALITY:
+                    case PlSqlParser.CASCADE:
+                    case PlSqlParser.CASE:
+                    case PlSqlParser.CAST:
+                    case PlSqlParser.CASESENSITIVE:
+                    case PlSqlParser.CATEGORY:
+                    case PlSqlParser.CDBDEFAULT:
+                    case PlSqlParser.CEIL:
+                    case PlSqlParser.CELL_FLASH_CACHE:
+                    case PlSqlParser.CERTIFICATE:
+                    case PlSqlParser.CFILE:
+                    case PlSqlParser.CHAINED:
+                    case PlSqlParser.CHANGE:
+                    case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                    case PlSqlParser.CHARACTER:
+                    case PlSqlParser.CHARACTERSET:
+                    case PlSqlParser.CHAR:
+                    case PlSqlParser.CHAR_CS:
+                    case PlSqlParser.CHARTOROWID:
+                    case PlSqlParser.CHECK_ACL_REWRITE:
+                    case PlSqlParser.CHECKPOINT:
+                    case PlSqlParser.CHILD:
+                    case PlSqlParser.CHOOSE:
+                    case PlSqlParser.CHR:
+                    case PlSqlParser.CHUNK:
+                    case PlSqlParser.CLASS:
+                    case PlSqlParser.CLASSIFICATION:
+                    case PlSqlParser.CLASSIFIER:
+                    case PlSqlParser.CLAUSE:
+                    case PlSqlParser.CLEAN:
+                    case PlSqlParser.CLEANUP:
+                    case PlSqlParser.CLEAR:
+                    case PlSqlParser.C_LETTER:
+                    case PlSqlParser.CLIENT:
+                    case PlSqlParser.CLOB:
+                    case PlSqlParser.CLONE:
+                    case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                    case PlSqlParser.CLOSE:
+                    case PlSqlParser.CLUSTER_BY_ROWID:
+                    case PlSqlParser.CLUSTER:
+                    case PlSqlParser.CLUSTER_DETAILS:
+                    case PlSqlParser.CLUSTER_DISTANCE:
+                    case PlSqlParser.CLUSTER_ID:
+                    case PlSqlParser.CLUSTERING:
+                    case PlSqlParser.CLUSTERING_FACTOR:
+                    case PlSqlParser.CLUSTER_PROBABILITY:
+                    case PlSqlParser.CLUSTER_SET:
+                    case PlSqlParser.COALESCE:
+                    case PlSqlParser.COALESCE_SQ:
+                    case PlSqlParser.COARSE:
+                    case PlSqlParser.CO_AUTH_IND:
+                    case PlSqlParser.COLD:
+                    case PlSqlParser.COLLECT:
+                    case PlSqlParser.COLUMNAR:
+                    case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                    case PlSqlParser.COLUMN:
+                    case PlSqlParser.COLUMNS:
+                    case PlSqlParser.COLUMN_STATS:
+                    case PlSqlParser.COLUMN_VALUE:
+                    case PlSqlParser.COMMENT:
+                    case PlSqlParser.COMMIT:
+                    case PlSqlParser.COMMITTED:
+                    case PlSqlParser.COMMON:
+                    case PlSqlParser.COMMON_DATA:
+                    case PlSqlParser.COMPACT:
+                    case PlSqlParser.COMPATIBILITY:
+                    case PlSqlParser.COMPILE:
+                    case PlSqlParser.COMPLETE:
+                    case PlSqlParser.COMPLIANCE:
+                    case PlSqlParser.COMPONENT:
+                    case PlSqlParser.COMPONENTS:
+                    case PlSqlParser.COMPOSE:
+                    case PlSqlParser.COMPOSITE:
+                    case PlSqlParser.COMPOSITE_LIMIT:
+                    case PlSqlParser.COMPOUND:
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.CONCAT:
+                    case PlSqlParser.CON_DBID_TO_ID:
+                    case PlSqlParser.CONDITIONAL:
+                    case PlSqlParser.CONDITION:
+                    case PlSqlParser.CONFIRM:
+                    case PlSqlParser.CONFORMING:
+                    case PlSqlParser.CON_GUID_TO_ID:
+                    case PlSqlParser.CON_ID:
+                    case PlSqlParser.CON_NAME_TO_ID:
+                    case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.CONNECT_BY_COST_BASED:
+                    case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.CONNECT_BY_FILTERING:
+                    case PlSqlParser.CONNECT_BY_ISCYCLE:
+                    case PlSqlParser.CONNECT_BY_ISLEAF:
+                    case PlSqlParser.CONNECT_BY_ROOT:
+                    case PlSqlParser.CONNECT_TIME:
+                    case PlSqlParser.CONSIDER:
+                    case PlSqlParser.CONSISTENT:
+                    case PlSqlParser.CONSTANT:
+                    case PlSqlParser.CONST:
+                    case PlSqlParser.CONSTRAINT:
+                    case PlSqlParser.CONSTRAINTS:
+                    case PlSqlParser.CONSTRUCTOR:
+                    case PlSqlParser.CONTAINER:
+                    case PlSqlParser.CONTAINERS:
+                    case PlSqlParser.CONTAINERS_DEFAULT:
+                    case PlSqlParser.CONTAINER_DATA:
+                    case PlSqlParser.CONTAINER_MAP:
+                    case PlSqlParser.CONTENT:
+                    case PlSqlParser.CONTENTS:
+                    case PlSqlParser.CONTEXT:
+                    case PlSqlParser.CONTINUE:
+                    case PlSqlParser.CONTROLFILE:
+                    case PlSqlParser.CON_UID_TO_ID:
+                    case PlSqlParser.CONVERT:
+                    case PlSqlParser.CONVERSION:
+                    case PlSqlParser.COOKIE:
+                    case PlSqlParser.COPY:
+                    case PlSqlParser.CORR_K:
+                    case PlSqlParser.CORR_S:
+                    case PlSqlParser.CORRUPTION:
+                    case PlSqlParser.CORRUPT_XID_ALL:
+                    case PlSqlParser.CORRUPT_XID:
+                    case PlSqlParser.COS:
+                    case PlSqlParser.COSH:
+                    case PlSqlParser.COST:
+                    case PlSqlParser.COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.COUNT:
+                    case PlSqlParser.COUNTED:
+                    case PlSqlParser.COVAR_POP:
+                    case PlSqlParser.COVAR_SAMP:
+                    case PlSqlParser.CPU_COSTING:
+                    case PlSqlParser.CPU_PER_CALL:
+                    case PlSqlParser.CPU_PER_SESSION:
+                    case PlSqlParser.CRASH:
+                    case PlSqlParser.CREATE_FILE_DEST:
+                    case PlSqlParser.CREATE_STORED_OUTLINES:
+                    case PlSqlParser.CREATION:
+                    case PlSqlParser.CREDENTIAL:
+                    case PlSqlParser.CRITICAL:
+                    case PlSqlParser.CROSS:
+                    case PlSqlParser.CROSSEDITION:
+                    case PlSqlParser.CSCONVERT:
+                    case PlSqlParser.CSV:
+                    case PlSqlParser.CUBE_AJ:
+                    case PlSqlParser.CUBE:
+                    case PlSqlParser.CUBE_GB:
+                    case PlSqlParser.CUBE_SJ:
+                    case PlSqlParser.CUME_DISTM:
+                    case PlSqlParser.CURRENT:
+                    case PlSqlParser.CURRENT_DATE:
+                    case PlSqlParser.CURRENT_SCHEMA:
+                    case PlSqlParser.CURRENT_TIME:
+                    case PlSqlParser.CURRENT_TIMESTAMP:
+                    case PlSqlParser.CURRENT_USER:
+                    case PlSqlParser.CURRENTV:
+                    case PlSqlParser.CURSOR:
+                    case PlSqlParser.CURSOR_SHARING_EXACT:
+                    case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                    case PlSqlParser.CUSTOMDATUM:
+                    case PlSqlParser.CV:
+                    case PlSqlParser.CYCLE:
+                    case PlSqlParser.DANGLING:
+                    case PlSqlParser.DATABASE:
+                    case PlSqlParser.DATA:
+                    case PlSqlParser.DATAFILE:
+                    case PlSqlParser.DATAFILES:
+                    case PlSqlParser.DATAMOVEMENT:
+                    case PlSqlParser.DATAOBJNO:
+                    case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                    case PlSqlParser.DATAOBJ_TO_PARTITION:
+                    case PlSqlParser.DATAPUMP:
+                    case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                    case PlSqlParser.DATE:
+                    case PlSqlParser.DATE_FORMAT:
+                    case PlSqlParser.DATE_MODE:
+                    case PlSqlParser.DAY:
+                    case PlSqlParser.DAYS:
+                    case PlSqlParser.DBA:
+                    case PlSqlParser.DBA_RECYCLEBIN:
+                    case PlSqlParser.DBLINK:
+                    case PlSqlParser.DBMS_STATS:
+                    case PlSqlParser.DB_ROLE_CHANGE:
+                    case PlSqlParser.DBTIMEZONE:
+                    case PlSqlParser.DB_UNIQUE_NAME:
+                    case PlSqlParser.DB_VERSION:
+                    case PlSqlParser.DDL:
+                    case PlSqlParser.DEALLOCATE:
+                    case PlSqlParser.DEBUG:
+                    case PlSqlParser.DEBUGGER:
+                    case PlSqlParser.DEC:
+                    case PlSqlParser.DECIMAL:
+                    case PlSqlParser.DECLARE:
+                    case PlSqlParser.DECOMPOSE:
+                    case PlSqlParser.DECORRELATE:
+                    case PlSqlParser.DECR:
+                    case PlSqlParser.DECREMENT:
+                    case PlSqlParser.DECRYPT:
+                    case PlSqlParser.DEDUPLICATE:
+                    case PlSqlParser.DEFAULTS:
+                    case PlSqlParser.DEFAULT_COLLATION:
+                    case PlSqlParser.DEFAULT_CREDENTIAL:
+                    case PlSqlParser.DEFERRABLE:
+                    case PlSqlParser.DEFERRED:
+                    case PlSqlParser.DEFINED:
+                    case PlSqlParser.DEFINE:
+                    case PlSqlParser.DEFINER:
+                    case PlSqlParser.DEGREE:
+                    case PlSqlParser.DELAY:
+                    case PlSqlParser.DELEGATE:
+                    case PlSqlParser.DELETE_ALL:
+                    case PlSqlParser.DELETE:
+                    case PlSqlParser.DELETEXML:
+                    case PlSqlParser.DEMAND:
+                    case PlSqlParser.DENSE_RANKM:
+                    case PlSqlParser.DEPENDENT:
+                    case PlSqlParser.DEPRECATE:
+                    case PlSqlParser.DEPTH:
+                    case PlSqlParser.DEQUEUE:
+                    case PlSqlParser.DEREF:
+                    case PlSqlParser.DEREF_NO_REWRITE:
+                    case PlSqlParser.DESCRIPTION:
+                    case PlSqlParser.DESTROY:
+                    case PlSqlParser.DETACHED:
+                    case PlSqlParser.DETECTED:
+                    case PlSqlParser.DETERMINES:
+                    case PlSqlParser.DETERMINISTIC:
+                    case PlSqlParser.DICTIONARY:
+                    case PlSqlParser.DIMENSION:
+                    case PlSqlParser.DIMENSIONS:
+                    case PlSqlParser.DIRECT_LOAD:
+                    case PlSqlParser.DIRECTORY:
+                    case PlSqlParser.DIRECT_PATH:
+                    case PlSqlParser.DISABLE_ALL:
+                    case PlSqlParser.DISABLE:
+                    case PlSqlParser.DISABLED:
+                    case PlSqlParser.DISABLE_PARALLEL_DML:
+                    case PlSqlParser.DISABLE_PRESET:
+                    case PlSqlParser.DISABLE_RPKE:
+                    case PlSqlParser.DISALLOW:
+                    case PlSqlParser.DISASSOCIATE:
+                    case PlSqlParser.DISCARD:
+                    case PlSqlParser.DISCONNECT:
+                    case PlSqlParser.DISK:
+                    case PlSqlParser.DISKGROUP:
+                    case PlSqlParser.DISKS:
+                    case PlSqlParser.DISMOUNT:
+                    case PlSqlParser.DISTINGUISHED:
+                    case PlSqlParser.DISTRIBUTED:
+                    case PlSqlParser.DISTRIBUTE:
+                    case PlSqlParser.DML:
+                    case PlSqlParser.DML_UPDATE:
+                    case PlSqlParser.DOCFIDELITY:
+                    case PlSqlParser.DOCUMENT:
+                    case PlSqlParser.DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                    case PlSqlParser.DOMAIN_INDEX_SORT:
+                    case PlSqlParser.DOUBLE:
+                    case PlSqlParser.DOWNGRADE:
+                    case PlSqlParser.DRIVING_SITE:
+                    case PlSqlParser.DROP_COLUMN:
+                    case PlSqlParser.DROP_GROUP:
+                    case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.DUMP:
+                    case PlSqlParser.DUPLICATE:
+                    case PlSqlParser.DV:
+                    case PlSqlParser.DYNAMIC:
+                    case PlSqlParser.DYNAMIC_SAMPLING:
+                    case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                    case PlSqlParser.E_LETTER:
+                    case PlSqlParser.EACH:
+                    case PlSqlParser.EDITIONABLE:
+                    case PlSqlParser.EDITION:
+                    case PlSqlParser.EDITIONING:
+                    case PlSqlParser.EDITIONS:
+                    case PlSqlParser.ELEMENT:
+                    case PlSqlParser.ELIM_GROUPBY:
+                    case PlSqlParser.ELIMINATE_JOIN:
+                    case PlSqlParser.ELIMINATE_OBY:
+                    case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.EM:
+                    case PlSqlParser.EMPTY_BLOB:
+                    case PlSqlParser.EMPTY_CLOB:
+                    case PlSqlParser.EMPTY_:
+                    case PlSqlParser.ENABLE_ALL:
+                    case PlSqlParser.ENABLE:
+                    case PlSqlParser.ENABLED:
+                    case PlSqlParser.ENABLE_PARALLEL_DML:
+                    case PlSqlParser.ENABLE_PRESET:
+                    case PlSqlParser.ENCLOSED:
+                    case PlSqlParser.ENCODING:
+                    case PlSqlParser.ENCRYPT:
+                    case PlSqlParser.ENCRYPTION:
+                    case PlSqlParser.END_OUTLINE_DATA:
+                    case PlSqlParser.ENFORCED:
+                    case PlSqlParser.ENFORCE:
+                    case PlSqlParser.ENQUEUE:
+                    case PlSqlParser.ENTERPRISE:
+                    case PlSqlParser.ENTITYESCAPING:
+                    case PlSqlParser.ENTRY:
+                    case PlSqlParser.EQUIPART:
+                    case PlSqlParser.ERR:
+                    case PlSqlParser.ERROR_ARGUMENT:
+                    case PlSqlParser.ERROR:
+                    case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                    case PlSqlParser.ERRORS:
+                    case PlSqlParser.ERROR_INDEX:
+                    case PlSqlParser.ERROR_CODE:
+                    case PlSqlParser.ESCAPE:
+                    case PlSqlParser.ESTIMATE:
+                    case PlSqlParser.EVAL:
+                    case PlSqlParser.EVALNAME:
+                    case PlSqlParser.EVALUATE:
+                    case PlSqlParser.EVALUATION:
+                    case PlSqlParser.EVENTS:
+                    case PlSqlParser.EVERY:
+                    case PlSqlParser.EXCEPT:
+                    case PlSqlParser.EXCEPTION:
+                    case PlSqlParser.EXCEPTION_INIT:
+                    case PlSqlParser.EXCEPTIONS:
+                    case PlSqlParser.EXCHANGE:
+                    case PlSqlParser.EXCLUDE:
+                    case PlSqlParser.EXCLUDING:
+                    case PlSqlParser.EXEC:
+                    case PlSqlParser.EXECUTE:
+                    case PlSqlParser.EXEMPT:
+                    case PlSqlParser.EXISTING:
+                    case PlSqlParser.EXISTS:
+                    case PlSqlParser.EXISTSNODE:
+                    case PlSqlParser.EXIT:
+                    case PlSqlParser.EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.EXPAND_TABLE:
+                    case PlSqlParser.EXP:
+                    case PlSqlParser.EXPIRE:
+                    case PlSqlParser.EXPLAIN:
+                    case PlSqlParser.EXPLOSION:
+                    case PlSqlParser.EXPORT:
+                    case PlSqlParser.EXPR_CORR_CHECK:
+                    case PlSqlParser.EXPRESS:
+                    case PlSqlParser.EXTENDS:
+                    case PlSqlParser.EXTENT:
+                    case PlSqlParser.EXTENTS:
+                    case PlSqlParser.EXTERNAL:
+                    case PlSqlParser.EXTERNALLY:
+                    case PlSqlParser.EXTRACTCLOBXML:
+                    case PlSqlParser.EXTRACT:
+                    case PlSqlParser.EXTRACTVALUE:
+                    case PlSqlParser.EXTRA:
+                    case PlSqlParser.FACILITY:
+                    case PlSqlParser.FACT:
+                    case PlSqlParser.FACTOR:
+                    case PlSqlParser.FACTORIZE_JOIN:
+                    case PlSqlParser.FAILED:
+                    case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                    case PlSqlParser.FAILGROUP:
+                    case PlSqlParser.FAILOVER:
+                    case PlSqlParser.FAILURE:
+                    case PlSqlParser.FALSE:
+                    case PlSqlParser.FAMILY:
+                    case PlSqlParser.FAR:
+                    case PlSqlParser.FAST:
+                    case PlSqlParser.FASTSTART:
+                    case PlSqlParser.FBTSCAN:
+                    case PlSqlParser.FEATURE:
+                    case PlSqlParser.FEATURE_DETAILS:
+                    case PlSqlParser.FEATURE_ID:
+                    case PlSqlParser.FEATURE_SET:
+                    case PlSqlParser.FEATURE_VALUE:
+                    case PlSqlParser.FETCH:
+                    case PlSqlParser.FIELD:
+                    case PlSqlParser.FIELDS:
+                    case PlSqlParser.FILE:
+                    case PlSqlParser.FILE_NAME_CONVERT:
+                    case PlSqlParser.FILEGROUP:
+                    case PlSqlParser.FILESTORE:
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.FILTER:
+                    case PlSqlParser.FINAL:
+                    case PlSqlParser.FINE:
+                    case PlSqlParser.FINISH:
+                    case PlSqlParser.FIRST:
+                    case PlSqlParser.FIRSTM:
+                    case PlSqlParser.FIRST_ROWS:
+                    case PlSqlParser.FIRST_VALUE:
+                    case PlSqlParser.FIXED_VIEW_DATA:
+                    case PlSqlParser.FLAGGER:
+                    case PlSqlParser.FLASHBACK:
+                    case PlSqlParser.FLASH_CACHE:
+                    case PlSqlParser.FLOAT:
+                    case PlSqlParser.FLOB:
+                    case PlSqlParser.FLEX:
+                    case PlSqlParser.FLOOR:
+                    case PlSqlParser.FLUSH:
+                    case PlSqlParser.FOLDER:
+                    case PlSqlParser.FOLLOWING:
+                    case PlSqlParser.FOLLOWS:
+                    case PlSqlParser.FORALL:
+                    case PlSqlParser.FORCE:
+                    case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                    case PlSqlParser.FOREIGN:
+                    case PlSqlParser.FOREVER:
+                    case PlSqlParser.FORMAT:
+                    case PlSqlParser.FORWARD:
+                    case PlSqlParser.FRAGMENT_NUMBER:
+                    case PlSqlParser.FREELIST:
+                    case PlSqlParser.FREELISTS:
+                    case PlSqlParser.FREEPOOLS:
+                    case PlSqlParser.FRESH:
+                    case PlSqlParser.FROM_TZ:
+                    case PlSqlParser.FULL:
+                    case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.FUNCTION:
+                    case PlSqlParser.FUNCTIONS:
+                    case PlSqlParser.FTP:
+                    case PlSqlParser.G_LETTER:
+                    case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.GATHER_PLAN_STATISTICS:
+                    case PlSqlParser.GBY_CONC_ROLLUP:
+                    case PlSqlParser.GBY_PUSHDOWN:
+                    case PlSqlParser.GENERATED:
+                    case PlSqlParser.GET:
+                    case PlSqlParser.GLOBAL:
+                    case PlSqlParser.GLOBALLY:
+                    case PlSqlParser.GLOBAL_NAME:
+                    case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                    case PlSqlParser.GROUP_BY:
+                    case PlSqlParser.GROUP_ID:
+                    case PlSqlParser.GROUPING:
+                    case PlSqlParser.GROUPING_ID:
+                    case PlSqlParser.GROUPS:
+                    case PlSqlParser.GUARANTEED:
+                    case PlSqlParser.GUARANTEE:
+                    case PlSqlParser.GUARD:
+                    case PlSqlParser.HALF_YEARS:
+                    case PlSqlParser.HASH_AJ:
+                    case PlSqlParser.HASH:
+                    case PlSqlParser.HASHKEYS:
+                    case PlSqlParser.HASH_SJ:
+                    case PlSqlParser.HEADER:
+                    case PlSqlParser.HEAP:
+                    case PlSqlParser.HELP:
+                    case PlSqlParser.HEXTORAW:
+                    case PlSqlParser.HEXTOREF:
+                    case PlSqlParser.HIDDEN_KEYWORD:
+                    case PlSqlParser.HIDE:
+                    case PlSqlParser.HIER_ORDER:
+                    case PlSqlParser.HIERARCHICAL:
+                    case PlSqlParser.HIERARCHY:
+                    case PlSqlParser.HIGH:
+                    case PlSqlParser.HINTSET_BEGIN:
+                    case PlSqlParser.HINTSET_END:
+                    case PlSqlParser.HOT:
+                    case PlSqlParser.HOUR:
+                    case PlSqlParser.HOURS:
+                    case PlSqlParser.HTTP:
+                    case PlSqlParser.HWM_BROKERED:
+                    case PlSqlParser.HYBRID:
+                    case PlSqlParser.H_LETTER:
+                    case PlSqlParser.IDENTIFIER:
+                    case PlSqlParser.IDENTITY:
+                    case PlSqlParser.IDGENERATORS:
+                    case PlSqlParser.ID:
+                    case PlSqlParser.IDLE_TIME:
+                    case PlSqlParser.IF:
+                    case PlSqlParser.IGNORE:
+                    case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                    case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                    case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                    case PlSqlParser.ILM:
+                    case PlSqlParser.IMMEDIATE:
+                    case PlSqlParser.IMPACT:
+                    case PlSqlParser.IMPORT:
+                    case PlSqlParser.INACTIVE:
+                    case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                    case PlSqlParser.INCLUDE:
+                    case PlSqlParser.INCLUDE_VERSION:
+                    case PlSqlParser.INCLUDING:
+                    case PlSqlParser.INCREMENTAL:
+                    case PlSqlParser.INCREMENT:
+                    case PlSqlParser.INCR:
+                    case PlSqlParser.INDENT:
+                    case PlSqlParser.INDEX_ASC:
+                    case PlSqlParser.INDEX_COMBINE:
+                    case PlSqlParser.INDEX_DESC:
+                    case PlSqlParser.INDEXED:
+                    case PlSqlParser.INDEXES:
+                    case PlSqlParser.INDEX_FFS:
+                    case PlSqlParser.INDEX_FILTER:
+                    case PlSqlParser.INDEXING:
+                    case PlSqlParser.INDEX_JOIN:
+                    case PlSqlParser.INDEX_ROWS:
+                    case PlSqlParser.INDEX_RRS:
+                    case PlSqlParser.INDEX_RS_ASC:
+                    case PlSqlParser.INDEX_RS_DESC:
+                    case PlSqlParser.INDEX_RS:
+                    case PlSqlParser.INDEX_SCAN:
+                    case PlSqlParser.INDEX_SKIP_SCAN:
+                    case PlSqlParser.INDEX_SS_ASC:
+                    case PlSqlParser.INDEX_SS_DESC:
+                    case PlSqlParser.INDEX_SS:
+                    case PlSqlParser.INDEX_STATS:
+                    case PlSqlParser.INDEXTYPE:
+                    case PlSqlParser.INDEXTYPES:
+                    case PlSqlParser.INDICATOR:
+                    case PlSqlParser.INDICES:
+                    case PlSqlParser.INFINITE:
+                    case PlSqlParser.INFORMATIONAL:
+                    case PlSqlParser.INHERIT:
+                    case PlSqlParser.INITCAP:
+                    case PlSqlParser.INITIAL:
+                    case PlSqlParser.INITIALIZED:
+                    case PlSqlParser.INITIALLY:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.INLINE:
+                    case PlSqlParser.INLINE_XMLTYPE_NT:
+                    case PlSqlParser.INMEMORY:
+                    case PlSqlParser.IN_MEMORY_METADATA:
+                    case PlSqlParser.INMEMORY_PRUNING:
+                    case PlSqlParser.INNER:
+                    case PlSqlParser.INOUT:
+                    case PlSqlParser.INPLACE:
+                    case PlSqlParser.INSERTCHILDXMLAFTER:
+                    case PlSqlParser.INSERTCHILDXMLBEFORE:
+                    case PlSqlParser.INSERTCHILDXML:
+                    case PlSqlParser.INSERTXMLAFTER:
+                    case PlSqlParser.INSERTXMLBEFORE:
+                    case PlSqlParser.INSTANCE:
+                    case PlSqlParser.INSTANCES:
+                    case PlSqlParser.INSTANTIABLE:
+                    case PlSqlParser.INSTANTLY:
+                    case PlSqlParser.INSTEAD:
+                    case PlSqlParser.INSTR2:
+                    case PlSqlParser.INSTR4:
+                    case PlSqlParser.INSTRB:
+                    case PlSqlParser.INSTRC:
+                    case PlSqlParser.INSTR:
+                    case PlSqlParser.INTEGER:
+                    case PlSqlParser.INTERLEAVED:
+                    case PlSqlParser.INTERMEDIATE:
+                    case PlSqlParser.INTERNAL_CONVERT:
+                    case PlSqlParser.INTERNAL_USE:
+                    case PlSqlParser.INTERPRETED:
+                    case PlSqlParser.INTERVAL:
+                    case PlSqlParser.INT:
+                    case PlSqlParser.INTERNAL:
+                    case PlSqlParser.INVALIDATE:
+                    case PlSqlParser.INVALIDATION:
+                    case PlSqlParser.INVISIBLE:
+                    case PlSqlParser.IN_XQUERY:
+                    case PlSqlParser.IS_LEAF:
+                    case PlSqlParser.ISOLATION:
+                    case PlSqlParser.ISOLATION_LEVEL:
+                    case PlSqlParser.ITEMS:
+                    case PlSqlParser.ITERATE:
+                    case PlSqlParser.ITERATION_NUMBER:
+                    case PlSqlParser.JAVA:
+                    case PlSqlParser.JOB:
+                    case PlSqlParser.JOIN:
+                    case PlSqlParser.JSON_ARRAYAGG:
+                    case PlSqlParser.JSON_ARRAY:
+                    case PlSqlParser.JSON_EQUAL:
+                    case PlSqlParser.JSON_EXISTS2:
+                    case PlSqlParser.JSON_EXISTS:
+                    case PlSqlParser.JSONGET:
+                    case PlSqlParser.JSON:
+                    case PlSqlParser.JSON_OBJECTAGG:
+                    case PlSqlParser.JSON_OBJECT:
+                    case PlSqlParser.JSONPARSE:
+                    case PlSqlParser.JSON_QUERY:
+                    case PlSqlParser.JSON_SERIALIZE:
+                    case PlSqlParser.JSON_TABLE:
+                    case PlSqlParser.JSON_TEXTCONTAINS2:
+                    case PlSqlParser.JSON_TEXTCONTAINS:
+                    case PlSqlParser.JSON_TRANSFORM:
+                    case PlSqlParser.JSON_VALUE:
+                    case PlSqlParser.K_LETTER:
+                    case PlSqlParser.KEEP_DUPLICATES:
+                    case PlSqlParser.KEEP:
+                    case PlSqlParser.KERBEROS:
+                    case PlSqlParser.KEY:
+                    case PlSqlParser.KEY_LENGTH:
+                    case PlSqlParser.KEYSIZE:
+                    case PlSqlParser.KEYS:
+                    case PlSqlParser.KEYSTORE:
+                    case PlSqlParser.KILL:
+                    case PlSqlParser.LABEL:
+                    case PlSqlParser.LANGUAGE:
+                    case PlSqlParser.LAST_DAY:
+                    case PlSqlParser.LAST:
+                    case PlSqlParser.LAST_VALUE:
+                    case PlSqlParser.LATERAL:
+                    case PlSqlParser.LAX:
+                    case PlSqlParser.LAYER:
+                    case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                    case PlSqlParser.LDAP_REGISTRATION:
+                    case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                    case PlSqlParser.LEAF:
+                    case PlSqlParser.LEAD_CDB:
+                    case PlSqlParser.LEAD_CDB_URI:
+                    case PlSqlParser.LEADING:
+                    case PlSqlParser.LEFT:
+                    case PlSqlParser.LENGTH2:
+                    case PlSqlParser.LENGTH4:
+                    case PlSqlParser.LENGTHB:
+                    case PlSqlParser.LENGTHC:
+                    case PlSqlParser.LENGTH:
+                    case PlSqlParser.LESS:
+                    case PlSqlParser.LEVEL:
+                    case PlSqlParser.LEVEL_NAME:
+                    case PlSqlParser.LEVELS:
+                    case PlSqlParser.LIBRARY:
+                    case PlSqlParser.LIFECYCLE:
+                    case PlSqlParser.LIFE:
+                    case PlSqlParser.LIFETIME:
+                    case PlSqlParser.LIKE2:
+                    case PlSqlParser.LIKE4:
+                    case PlSqlParser.LIKEC:
+                    case PlSqlParser.LIKE_EXPAND:
+                    case PlSqlParser.LIMIT:
+                    case PlSqlParser.LINEAR:
+                    case PlSqlParser.LINES:
+                    case PlSqlParser.LINK:
+                    case PlSqlParser.LIST:
+                    case PlSqlParser.LN:
+                    case PlSqlParser.LNNVL:
+                    case PlSqlParser.LOAD:
+                    case PlSqlParser.LOB:
+                    case PlSqlParser.LOBNVL:
+                    case PlSqlParser.LOBS:
+                    case PlSqlParser.LOCAL_INDEXES:
+                    case PlSqlParser.LOCAL:
+                    case PlSqlParser.LOCALTIME:
+                    case PlSqlParser.LOCALTIMESTAMP:
+                    case PlSqlParser.LOCATION:
+                    case PlSqlParser.LOCATOR:
+                    case PlSqlParser.LOCKDOWN:
+                    case PlSqlParser.LOCKED:
+                    case PlSqlParser.LOCKING:
+                    case PlSqlParser.LOGFILE:
+                    case PlSqlParser.LOGFILES:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.LOGICAL:
+                    case PlSqlParser.LOGICAL_READS_PER_CALL:
+                    case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                    case PlSqlParser.LOG:
+                    case PlSqlParser.LOGMINING:
+                    case PlSqlParser.LOGOFF:
+                    case PlSqlParser.LOGON:
+                    case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                    case PlSqlParser.LONG:
+                    case PlSqlParser.LOOP:
+                    case PlSqlParser.LOST:
+                    case PlSqlParser.LOWER:
+                    case PlSqlParser.LOW:
+                    case PlSqlParser.LPAD:
+                    case PlSqlParser.LTRIM:
+                    case PlSqlParser.M_LETTER:
+                    case PlSqlParser.MAIN:
+                    case PlSqlParser.MAKE_REF:
+                    case PlSqlParser.MANAGED:
+                    case PlSqlParser.MANAGE:
+                    case PlSqlParser.MANAGEMENT:
+                    case PlSqlParser.MANAGER:
+                    case PlSqlParser.MANDATORY:
+                    case PlSqlParser.MANUAL:
+                    case PlSqlParser.MAP:
+                    case PlSqlParser.MAPPING:
+                    case PlSqlParser.MASK:
+                    case PlSqlParser.MASTER:
+                    case PlSqlParser.MATCHED:
+                    case PlSqlParser.MATCHES:
+                    case PlSqlParser.MATCH:
+                    case PlSqlParser.MATCH_NUMBER:
+                    case PlSqlParser.MATCH_RECOGNIZE:
+                    case PlSqlParser.MATERIALIZED:
+                    case PlSqlParser.MATERIALIZE:
+                    case PlSqlParser.MAXARCHLOGS:
+                    case PlSqlParser.MAXDATAFILES:
+                    case PlSqlParser.MAXEXTENTS:
+                    case PlSqlParser.MAXIMIZE:
+                    case PlSqlParser.MAXINSTANCES:
+                    case PlSqlParser.MAXLOGFILES:
+                    case PlSqlParser.MAXLOGHISTORY:
+                    case PlSqlParser.MAXLOGMEMBERS:
+                    case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                    case PlSqlParser.MAXSIZE:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.MAXVALUE:
+                    case PlSqlParser.MEASURE:
+                    case PlSqlParser.MEASURES:
+                    case PlSqlParser.MEDIUM:
+                    case PlSqlParser.MEMBER:
+                    case PlSqlParser.MEMBER_CAPTION:
+                    case PlSqlParser.MEMBER_DESCRIPTION:
+                    case PlSqlParser.MEMBER_NAME:
+                    case PlSqlParser.MEMBER_UNIQUE_NAME:
+                    case PlSqlParser.MEMCOMPRESS:
+                    case PlSqlParser.MEMORY:
+                    case PlSqlParser.MERGEACTIONS:
+                    case PlSqlParser.MERGE_AJ:
+                    case PlSqlParser.MERGE_CONST_ON:
+                    case PlSqlParser.MERGE:
+                    case PlSqlParser.MERGE_SJ:
+                    case PlSqlParser.METADATA:
+                    case PlSqlParser.METHOD:
+                    case PlSqlParser.MIGRATE:
+                    case PlSqlParser.MIGRATION:
+                    case PlSqlParser.MINEXTENTS:
+                    case PlSqlParser.MINIMIZE:
+                    case PlSqlParser.MINIMUM:
+                    case PlSqlParser.MINING:
+                    case PlSqlParser.MINUS_NULL:
+                    case PlSqlParser.MINUTE:
+                    case PlSqlParser.MINUTES:
+                    case PlSqlParser.MINVALUE:
+                    case PlSqlParser.MIRRORCOLD:
+                    case PlSqlParser.MIRRORHOT:
+                    case PlSqlParser.MIRROR:
+                    case PlSqlParser.MISSING:
+                    case PlSqlParser.MISMATCH:
+                    case PlSqlParser.MLSLABEL:
+                    case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                    case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                    case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                    case PlSqlParser.MODEL_MIN_ANALYSIS:
+                    case PlSqlParser.MODEL:
+                    case PlSqlParser.MODEL_NB:
+                    case PlSqlParser.MODEL_NO_ANALYSIS:
+                    case PlSqlParser.MODEL_PBY:
+                    case PlSqlParser.MODEL_PUSH_REF:
+                    case PlSqlParser.MODEL_SV:
+                    case PlSqlParser.MODIFICATION:
+                    case PlSqlParser.MODIFY_COLUMN_TYPE:
+                    case PlSqlParser.MODIFY:
+                    case PlSqlParser.MOD:
+                    case PlSqlParser.MODULE:
+                    case PlSqlParser.MONITORING:
+                    case PlSqlParser.MONITOR:
+                    case PlSqlParser.MONTH:
+                    case PlSqlParser.MONTHS_BETWEEN:
+                    case PlSqlParser.MONTHS:
+                    case PlSqlParser.MOUNT:
+                    case PlSqlParser.MOUNTPATH:
+                    case PlSqlParser.MOUNTPOINT:
+                    case PlSqlParser.MOVEMENT:
+                    case PlSqlParser.MOVE:
+                    case PlSqlParser.MULTIDIMENSIONAL:
+                    case PlSqlParser.MULTISET:
+                    case PlSqlParser.MV_MERGE:
+                    case PlSqlParser.NAMED:
+                    case PlSqlParser.NAME:
+                    case PlSqlParser.NAMESPACE:
+                    case PlSqlParser.NAN_:
+                    case PlSqlParser.NANVL:
+                    case PlSqlParser.NATIONAL:
+                    case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NATIVE:
+                    case PlSqlParser.NATURAL:
+                    case PlSqlParser.NAV:
+                    case PlSqlParser.NCHAR_CS:
+                    case PlSqlParser.NCHAR:
+                    case PlSqlParser.NCHR:
+                    case PlSqlParser.NCLOB:
+                    case PlSqlParser.NEEDED:
+                    case PlSqlParser.NEG:
+                    case PlSqlParser.NESTED:
+                    case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                    case PlSqlParser.NESTED_TABLE_GET_REFS:
+                    case PlSqlParser.NESTED_TABLE_ID:
+                    case PlSqlParser.NESTED_TABLE_SET_REFS:
+                    case PlSqlParser.NESTED_TABLE_SET_SETID:
+                    case PlSqlParser.NETWORK:
+                    case PlSqlParser.NEVER:
+                    case PlSqlParser.NEW:
+                    case PlSqlParser.NEWLINE_:
+                    case PlSqlParser.NEW_TIME:
+                    case PlSqlParser.NEXT_DAY:
+                    case PlSqlParser.NEXT:
+                    case PlSqlParser.NL_AJ:
+                    case PlSqlParser.NLJ_BATCHING:
+                    case PlSqlParser.NLJ_INDEX_FILTER:
+                    case PlSqlParser.NLJ_INDEX_SCAN:
+                    case PlSqlParser.NLJ_PREFETCH:
+                    case PlSqlParser.NLS_CALENDAR:
+                    case PlSqlParser.NLS_CHARACTERSET:
+                    case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                    case PlSqlParser.NLS_CHARSET_ID:
+                    case PlSqlParser.NLS_CHARSET_NAME:
+                    case PlSqlParser.NLS_COMP:
+                    case PlSqlParser.NLS_CURRENCY:
+                    case PlSqlParser.NLS_DATE_FORMAT:
+                    case PlSqlParser.NLS_DATE_LANGUAGE:
+                    case PlSqlParser.NLS_INITCAP:
+                    case PlSqlParser.NLS_ISO_CURRENCY:
+                    case PlSqlParser.NL_SJ:
+                    case PlSqlParser.NLS_LANG:
+                    case PlSqlParser.NLS_LANGUAGE:
+                    case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                    case PlSqlParser.NLS_LOWER:
+                    case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                    case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                    case PlSqlParser.NLS_SORT:
+                    case PlSqlParser.NLSSORT:
+                    case PlSqlParser.NLS_SPECIAL_CHARS:
+                    case PlSqlParser.NLS_TERRITORY:
+                    case PlSqlParser.NLS_UPPER:
+                    case PlSqlParser.NO_ACCESS:
+                    case PlSqlParser.NO_ADAPTIVE_PLAN:
+                    case PlSqlParser.NO_ANSI_REARCH:
+                    case PlSqlParser.NOAPPEND:
+                    case PlSqlParser.NOARCHIVELOG:
+                    case PlSqlParser.NOAUDIT:
+                    case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                    case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.NO_BIND_AWARE:
+                    case PlSqlParser.NO_BUFFER:
+                    case PlSqlParser.NOCACHE:
+                    case PlSqlParser.NO_CARTESIAN:
+                    case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                    case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                    case PlSqlParser.NO_CLUSTERING:
+                    case PlSqlParser.NO_COALESCE_SQ:
+                    case PlSqlParser.NO_COMMON_DATA:
+                    case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                    case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                    case PlSqlParser.NOCOPY:
+                    case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_CPU_COSTING:
+                    case PlSqlParser.NOCPU_COSTING:
+                    case PlSqlParser.NOCYCLE:
+                    case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                    case PlSqlParser.NO_DECORRELATE:
+                    case PlSqlParser.NODELAY:
+                    case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.NO_ELIM_GROUPBY:
+                    case PlSqlParser.NO_ELIMINATE_JOIN:
+                    case PlSqlParser.NO_ELIMINATE_OBY:
+                    case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.NOENTITYESCAPING:
+                    case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.NO_EXPAND:
+                    case PlSqlParser.NO_EXPAND_TABLE:
+                    case PlSqlParser.NO_FACT:
+                    case PlSqlParser.NO_FACTORIZE_JOIN:
+                    case PlSqlParser.NO_FILTERING:
+                    case PlSqlParser.NOFORCE:
+                    case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.NO_GBY_PUSHDOWN:
+                    case PlSqlParser.NOGUARANTEE:
+                    case PlSqlParser.NO_INDEX_FFS:
+                    case PlSqlParser.NO_INDEX:
+                    case PlSqlParser.NO_INDEX_SS:
+                    case PlSqlParser.NO_INMEMORY:
+                    case PlSqlParser.NO_INMEMORY_PRUNING:
+                    case PlSqlParser.NOKEEP:
+                    case PlSqlParser.NO_LOAD:
+                    case PlSqlParser.NOLOCAL:
+                    case PlSqlParser.NOLOGGING:
+                    case PlSqlParser.NOMAPPING:
+                    case PlSqlParser.NOMAXVALUE:
+                    case PlSqlParser.NO_MERGE:
+                    case PlSqlParser.NOMINIMIZE:
+                    case PlSqlParser.NOMINVALUE:
+                    case PlSqlParser.NO_MODEL_PUSH_REF:
+                    case PlSqlParser.NO_MONITORING:
+                    case PlSqlParser.NOMONITORING:
+                    case PlSqlParser.NO_MONITOR:
+                    case PlSqlParser.NO_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NONBLOCKING:
+                    case PlSqlParser.NONEDITIONABLE:
+                    case PlSqlParser.NONE:
+                    case PlSqlParser.NONPARTITIONED:
+                    case PlSqlParser.NO_NLJ_BATCHING:
+                    case PlSqlParser.NO_NLJ_PREFETCH:
+                    case PlSqlParser.NO:
+                    case PlSqlParser.NONSCHEMA:
+                    case PlSqlParser.NO_OBJECT_LINK:
+                    case PlSqlParser.NOORDER:
+                    case PlSqlParser.NO_ORDER_ROLLUPS:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.NOOVERRIDE:
+                    case PlSqlParser.NO_PARALLEL_INDEX:
+                    case PlSqlParser.NOPARALLEL_INDEX:
+                    case PlSqlParser.NO_PARALLEL:
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.NO_PARTIAL_COMMIT:
+                    case PlSqlParser.NO_PARTIAL_JOIN:
+                    case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.NOPARTITION:
+                    case PlSqlParser.NO_PLACE_DISTINCT:
+                    case PlSqlParser.NO_PLACE_GROUP_BY:
+                    case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                    case PlSqlParser.NO_PQ_MAP:
+                    case PlSqlParser.NOPROMPT:
+                    case PlSqlParser.NO_PQ_REPLICATE:
+                    case PlSqlParser.NO_PQ_SKEW:
+                    case PlSqlParser.NO_PRUNE_GSETS:
+                    case PlSqlParser.NO_PULL_PRED:
+                    case PlSqlParser.NO_PUSH_PRED:
+                    case PlSqlParser.NO_PUSH_SUBQ:
+                    case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                    case PlSqlParser.NO_PX_JOIN_FILTER:
+                    case PlSqlParser.NO_QKN_BUFF:
+                    case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                    case PlSqlParser.NO_REF_CASCADE:
+                    case PlSqlParser.NORELOCATE:
+                    case PlSqlParser.NORELY:
+                    case PlSqlParser.NOREPAIR:
+                    case PlSqlParser.NOREPLAY:
+                    case PlSqlParser.NORESETLOGS:
+                    case PlSqlParser.NO_RESULT_CACHE:
+                    case PlSqlParser.NOREVERSE:
+                    case PlSqlParser.NO_REWRITE:
+                    case PlSqlParser.NOREWRITE:
+                    case PlSqlParser.NORMAL:
+                    case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                    case PlSqlParser.NOROWDEPENDENCIES:
+                    case PlSqlParser.NOSCHEMACHECK:
+                    case PlSqlParser.NOSEGMENT:
+                    case PlSqlParser.NO_SEMIJOIN:
+                    case PlSqlParser.NO_SEMI_TO_INNER:
+                    case PlSqlParser.NO_SET_TO_JOIN:
+                    case PlSqlParser.NOSORT:
+                    case PlSqlParser.NO_SQL_TRANSLATION:
+                    case PlSqlParser.NO_SQL_TUNE:
+                    case PlSqlParser.NO_STAR_TRANSFORMATION:
+                    case PlSqlParser.NO_STATEMENT_QUEUING:
+                    case PlSqlParser.NO_STATS_GSETS:
+                    case PlSqlParser.NOSTRICT:
+                    case PlSqlParser.NO_SUBQUERY_PRUNING:
+                    case PlSqlParser.NO_SUBSTRB_PAD:
+                    case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                    case PlSqlParser.NOSWITCH:
+                    case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.NO_TEMP_TABLE:
+                    case PlSqlParser.NOTHING:
+                    case PlSqlParser.NOTIFICATION:
+                    case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.NO_UNNEST:
+                    case PlSqlParser.NO_USE_CUBE:
+                    case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                    case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.NO_USE_HASH:
+                    case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.NO_USE_MERGE:
+                    case PlSqlParser.NO_USE_NL:
+                    case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.NOVALIDATE:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM:
+                    case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                    case PlSqlParser.NO_XML_DML_REWRITE:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE:
+                    case PlSqlParser.NO_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_ZONEMAP:
+                    case PlSqlParser.NTH_VALUE:
+                    case PlSqlParser.NULLIF:
+                    case PlSqlParser.NULLS:
+                    case PlSqlParser.NUMBER:
+                    case PlSqlParser.NUMERIC:
+                    case PlSqlParser.NUM_INDEX_KEYS:
+                    case PlSqlParser.NUMTODSINTERVAL:
+                    case PlSqlParser.NUMTOYMINTERVAL:
+                    case PlSqlParser.NVARCHAR2:
+                    case PlSqlParser.NVL2:
+                    case PlSqlParser.OBJECT2XML:
+                    case PlSqlParser.OBJECT:
+                    case PlSqlParser.OBJ_ID:
+                    case PlSqlParser.OBJNO:
+                    case PlSqlParser.OBJNO_REUSE:
+                    case PlSqlParser.OCCURENCES:
+                    case PlSqlParser.OFFLINE:
+                    case PlSqlParser.OFF:
+                    case PlSqlParser.OFFSET:
+                    case PlSqlParser.OIDINDEX:
+                    case PlSqlParser.OID:
+                    case PlSqlParser.OLAP:
+                    case PlSqlParser.OLD:
+                    case PlSqlParser.OLD_PUSH_PRED:
+                    case PlSqlParser.OLS:
+                    case PlSqlParser.OLTP:
+                    case PlSqlParser.OMIT:
+                    case PlSqlParser.ONE:
+                    case PlSqlParser.ONLINE:
+                    case PlSqlParser.ONLY:
+                    case PlSqlParser.OPAQUE:
+                    case PlSqlParser.OPAQUE_TRANSFORM:
+                    case PlSqlParser.OPAQUE_XCANONICAL:
+                    case PlSqlParser.OPCODE:
+                    case PlSqlParser.OPEN:
+                    case PlSqlParser.OPERATIONS:
+                    case PlSqlParser.OPERATOR:
+                    case PlSqlParser.OPT_ESTIMATE:
+                    case PlSqlParser.OPTIMAL:
+                    case PlSqlParser.OPTIMIZE:
+                    case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                    case PlSqlParser.OPTIMIZER_GOAL:
+                    case PlSqlParser.OPT_PARAM:
+                    case PlSqlParser.ORA_BRANCH:
+                    case PlSqlParser.ORA_CHECK_ACL:
+                    case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                    case PlSqlParser.ORA_CLUSTERING:
+                    case PlSqlParser.ORADATA:
+                    case PlSqlParser.ORC:
+                    case PlSqlParser.ORADEBUG:
+                    case PlSqlParser.ORA_DST_AFFECTED:
+                    case PlSqlParser.ORA_DST_CONVERT:
+                    case PlSqlParser.ORA_DST_ERROR:
+                    case PlSqlParser.ORA_GET_ACLIDS:
+                    case PlSqlParser.ORA_GET_PRIVILEGES:
+                    case PlSqlParser.ORA_HASH:
+                    case PlSqlParser.ORA_INVOKING_USERID:
+                    case PlSqlParser.ORA_INVOKING_USER:
+                    case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                    case PlSqlParser.ORA_INVOKING_XS_USER:
+                    case PlSqlParser.ORA_RAWCOMPARE:
+                    case PlSqlParser.ORA_RAWCONCAT:
+                    case PlSqlParser.ORA_ROWSCN:
+                    case PlSqlParser.ORA_ROWSCN_RAW:
+                    case PlSqlParser.ORA_ROWVERSION:
+                    case PlSqlParser.ORA_TABVERSION:
+                    case PlSqlParser.ORA_WRITE_TIME:
+                    case PlSqlParser.ORDERED:
+                    case PlSqlParser.ORDERED_PREDICATES:
+                    case PlSqlParser.ORDINALITY:
+                    case PlSqlParser.OR_EXPAND:
+                    case PlSqlParser.ORGANIZATION:
+                    case PlSqlParser.OR_PREDICATES:
+                    case PlSqlParser.OSERROR:
+                    case PlSqlParser.OTHER:
+                    case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.OUTER:
+                    case PlSqlParser.OUTLINE_LEAF:
+                    case PlSqlParser.OUTLINE:
+                    case PlSqlParser.OUT_OF_LINE:
+                    case PlSqlParser.OUT:
+                    case PlSqlParser.OVERFLOW_NOMOVE:
+                    case PlSqlParser.OVERFLOW_:
+                    case PlSqlParser.OVERLAPS:
+                    case PlSqlParser.OVER:
+                    case PlSqlParser.OVERRIDE:
+                    case PlSqlParser.OVERRIDING:
+                    case PlSqlParser.OWNER:
+                    case PlSqlParser.OWNERSHIP:
+                    case PlSqlParser.OWN:
+                    case PlSqlParser.P_LETTER:
+                    case PlSqlParser.PACKAGE:
+                    case PlSqlParser.PACKAGES:
+                    case PlSqlParser.PARALLEL_ENABLE:
+                    case PlSqlParser.PARALLEL_INDEX:
+                    case PlSqlParser.PARALLEL:
+                    case PlSqlParser.PARAMETERS:
+                    case PlSqlParser.PARAM:
+                    case PlSqlParser.PARENT:
+                    case PlSqlParser.PARENT_LEVEL_NAME:
+                    case PlSqlParser.PARENT_UNIQUE_NAME:
+                    case PlSqlParser.PARITY:
+                    case PlSqlParser.PARTIAL_JOIN:
+                    case PlSqlParser.PARTIALLY:
+                    case PlSqlParser.PARTIAL:
+                    case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.PARTITION_HASH:
+                    case PlSqlParser.PARTITION_LIST:
+                    case PlSqlParser.PARTITION:
+                    case PlSqlParser.PARTITION_RANGE:
+                    case PlSqlParser.PARTITIONS:
+                    case PlSqlParser.PARTNUMINST:
+                    case PlSqlParser.PASSING:
+                    case PlSqlParser.PASSWORD_GRACE_TIME:
+                    case PlSqlParser.PASSWORD_LIFE_TIME:
+                    case PlSqlParser.PASSWORD_LOCK_TIME:
+                    case PlSqlParser.PASSWORD:
+                    case PlSqlParser.PASSWORD_REUSE_MAX:
+                    case PlSqlParser.PASSWORD_REUSE_TIME:
+                    case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                    case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                    case PlSqlParser.PAST:
+                    case PlSqlParser.PATCH:
+                    case PlSqlParser.PATH:
+                    case PlSqlParser.PATH_PREFIX:
+                    case PlSqlParser.PATHS:
+                    case PlSqlParser.PATTERN:
+                    case PlSqlParser.PBL_HS_BEGIN:
+                    case PlSqlParser.PBL_HS_END:
+                    case PlSqlParser.PCTINCREASE:
+                    case PlSqlParser.PCTTHRESHOLD:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.PCTVERSION:
+                    case PlSqlParser.PENDING:
+                    case PlSqlParser.PERCENT_KEYWORD:
+                    case PlSqlParser.PERCENT_RANKM:
+                    case PlSqlParser.PERFORMANCE:
+                    case PlSqlParser.PERIOD_KEYWORD:
+                    case PlSqlParser.PERMANENT:
+                    case PlSqlParser.PERMISSION:
+                    case PlSqlParser.PERMUTE:
+                    case PlSqlParser.PER:
+                    case PlSqlParser.PFILE:
+                    case PlSqlParser.PHYSICAL:
+                    case PlSqlParser.PIKEY:
+                    case PlSqlParser.PIPELINED:
+                    case PlSqlParser.PIV_GB:
+                    case PlSqlParser.PIVOT:
+                    case PlSqlParser.PIV_SSF:
+                    case PlSqlParser.PLACE_DISTINCT:
+                    case PlSqlParser.PLACE_GROUP_BY:
+                    case PlSqlParser.PLAN:
+                    case PlSqlParser.PLSCOPE_SETTINGS:
+                    case PlSqlParser.PLS_INTEGER:
+                    case PlSqlParser.PLSQL_CCFLAGS:
+                    case PlSqlParser.PLSQL_CODE_TYPE:
+                    case PlSqlParser.PLSQL_DEBUG:
+                    case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                    case PlSqlParser.PLSQL_WARNINGS:
+                    case PlSqlParser.PLUGGABLE:
+                    case PlSqlParser.PMEM:
+                    case PlSqlParser.POINT:
+                    case PlSqlParser.POLICY:
+                    case PlSqlParser.POOL_16K:
+                    case PlSqlParser.POOL_2K:
+                    case PlSqlParser.POOL_32K:
+                    case PlSqlParser.POOL_4K:
+                    case PlSqlParser.POOL_8K:
+                    case PlSqlParser.POSITION:
+                    case PlSqlParser.POSITIVEN:
+                    case PlSqlParser.POSITIVE:
+                    case PlSqlParser.POST_TRANSACTION:
+                    case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                    case PlSqlParser.POWERMULTISET:
+                    case PlSqlParser.POWER:
+                    case PlSqlParser.PQ_CONCURRENT_UNION:
+                    case PlSqlParser.PQ_DISTRIBUTE:
+                    case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                    case PlSqlParser.PQ_FILTER:
+                    case PlSqlParser.PQ_MAP:
+                    case PlSqlParser.PQ_NOMAP:
+                    case PlSqlParser.PQ_REPLICATE:
+                    case PlSqlParser.PQ_SKEW:
+                    case PlSqlParser.PRAGMA:
+                    case PlSqlParser.PREBUILT:
+                    case PlSqlParser.PRECEDES:
+                    case PlSqlParser.PRECEDING:
+                    case PlSqlParser.PRECISION:
+                    case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                    case PlSqlParser.PREDICATE_REORDERS:
+                    case PlSqlParser.PRELOAD:
+                    case PlSqlParser.PREPARE:
+                    case PlSqlParser.PRESENTNNV:
+                    case PlSqlParser.PRESENT:
+                    case PlSqlParser.PRESENTV:
+                    case PlSqlParser.PRESERVE_OID:
+                    case PlSqlParser.PRESERVE:
+                    case PlSqlParser.PRETTY:
+                    case PlSqlParser.PREVIOUS:
+                    case PlSqlParser.PREV:
+                    case PlSqlParser.PRIMARY:
+                    case PlSqlParser.PRINTBLOBTOCLOB:
+                    case PlSqlParser.PRIORITY:
+                    case PlSqlParser.PRIVATE:
+                    case PlSqlParser.PRIVATE_SGA:
+                    case PlSqlParser.PRIVILEGED:
+                    case PlSqlParser.PRIVILEGE:
+                    case PlSqlParser.PRIVILEGES:
+                    case PlSqlParser.PROCEDURAL:
+                    case PlSqlParser.PROCEDURE:
+                    case PlSqlParser.PROCESS:
+                    case PlSqlParser.PROFILE:
+                    case PlSqlParser.PROGRAM:
+                    case PlSqlParser.PROJECT:
+                    case PlSqlParser.PROPAGATE:
+                    case PlSqlParser.PROPERTY:
+                    case PlSqlParser.PROTECTED:
+                    case PlSqlParser.PROTECTION:
+                    case PlSqlParser.PROTOCOL:
+                    case PlSqlParser.PROXY:
+                    case PlSqlParser.PRUNING:
+                    case PlSqlParser.PUBLIC:
+                    case PlSqlParser.PULL_PRED:
+                    case PlSqlParser.PURGE:
+                    case PlSqlParser.PUSH_PRED:
+                    case PlSqlParser.PUSH_SUBQ:
+                    case PlSqlParser.PX_FAULT_TOLERANCE:
+                    case PlSqlParser.PX_GRANULE:
+                    case PlSqlParser.PX_JOIN_FILTER:
+                    case PlSqlParser.QB_NAME:
+                    case PlSqlParser.QUARTERS:
+                    case PlSqlParser.QUERY_BLOCK:
+                    case PlSqlParser.QUERY:
+                    case PlSqlParser.QUEUE_CURR:
+                    case PlSqlParser.QUEUE:
+                    case PlSqlParser.QUEUE_ROWP:
+                    case PlSqlParser.QUIESCE:
+                    case PlSqlParser.QUORUM:
+                    case PlSqlParser.QUOTA:
+                    case PlSqlParser.QUOTAGROUP:
+                    case PlSqlParser.RAISE:
+                    case PlSqlParser.RANDOM_LOCAL:
+                    case PlSqlParser.RANDOM:
+                    case PlSqlParser.RANGE:
+                    case PlSqlParser.RANKM:
+                    case PlSqlParser.RAPIDLY:
+                    case PlSqlParser.RAW:
+                    case PlSqlParser.RAWTOHEX:
+                    case PlSqlParser.RAWTONHEX:
+                    case PlSqlParser.RBA:
+                    case PlSqlParser.RBO_OUTLINE:
+                    case PlSqlParser.RDBA:
+                    case PlSqlParser.READ:
+                    case PlSqlParser.READS:
+                    case PlSqlParser.REALM:
+                    case PlSqlParser.REAL:
+                    case PlSqlParser.REBALANCE:
+                    case PlSqlParser.REBUILD:
+                    case PlSqlParser.RECORD:
+                    case PlSqlParser.RECORDS:
+                    case PlSqlParser.RECORDS_PER_BLOCK:
+                    case PlSqlParser.RECOVERABLE:
+                    case PlSqlParser.RECOVER:
+                    case PlSqlParser.RECOVERY:
+                    case PlSqlParser.RECYCLEBIN:
+                    case PlSqlParser.RECYCLE:
+                    case PlSqlParser.REDACTION:
+                    case PlSqlParser.REDEFINE:
+                    case PlSqlParser.REDO:
+                    case PlSqlParser.REDUCED:
+                    case PlSqlParser.REDUNDANCY:
+                    case PlSqlParser.REF_CASCADE_CURSOR:
+                    case PlSqlParser.REFERENCED:
+                    case PlSqlParser.REFERENCE:
+                    case PlSqlParser.REFERENCES:
+                    case PlSqlParser.REFERENCING:
+                    case PlSqlParser.REF:
+                    case PlSqlParser.REFRESH:
+                    case PlSqlParser.REFTOHEX:
+                    case PlSqlParser.REGEXP_COUNT:
+                    case PlSqlParser.REGEXP_INSTR:
+                    case PlSqlParser.REGEXP_LIKE:
+                    case PlSqlParser.REGEXP_REPLACE:
+                    case PlSqlParser.REGEXP_SUBSTR:
+                    case PlSqlParser.REGISTER:
+                    case PlSqlParser.REGR_AVGX:
+                    case PlSqlParser.REGR_AVGY:
+                    case PlSqlParser.REGR_COUNT:
+                    case PlSqlParser.REGR_INTERCEPT:
+                    case PlSqlParser.REGR_R2:
+                    case PlSqlParser.REGR_SLOPE:
+                    case PlSqlParser.REGR_SXX:
+                    case PlSqlParser.REGR_SXY:
+                    case PlSqlParser.REGR_SYY:
+                    case PlSqlParser.REGULAR:
+                    case PlSqlParser.REJECT:
+                    case PlSqlParser.REKEY:
+                    case PlSqlParser.RELATIONAL:
+                    case PlSqlParser.RELOCATE:
+                    case PlSqlParser.RELY:
+                    case PlSqlParser.REMAINDER:
+                    case PlSqlParser.REMOTE:
+                    case PlSqlParser.REMOTE_MAPPED:
+                    case PlSqlParser.REMOVE:
+                    case PlSqlParser.RENAME:
+                    case PlSqlParser.REPAIR:
+                    case PlSqlParser.REPEAT:
+                    case PlSqlParser.REPLACE:
+                    case PlSqlParser.REPLICATION:
+                    case PlSqlParser.REQUIRED:
+                    case PlSqlParser.RESETLOGS:
+                    case PlSqlParser.RESET:
+                    case PlSqlParser.RESIZE:
+                    case PlSqlParser.RESOLVE:
+                    case PlSqlParser.RESOLVER:
+                    case PlSqlParser.RESPECT:
+                    case PlSqlParser.RESTART:
+                    case PlSqlParser.RESTORE_AS_INTERVALS:
+                    case PlSqlParser.RESTORE:
+                    case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                    case PlSqlParser.RESTRICTED:
+                    case PlSqlParser.RESTRICT_REFERENCES:
+                    case PlSqlParser.RESTRICT:
+                    case PlSqlParser.RESULT_CACHE:
+                    case PlSqlParser.RESULT:
+                    case PlSqlParser.RESUMABLE:
+                    case PlSqlParser.RESUME:
+                    case PlSqlParser.RETENTION:
+                    case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                    case PlSqlParser.RETURNING:
+                    case PlSqlParser.RETURN:
+                    case PlSqlParser.REUSE:
+                    case PlSqlParser.REVERSE:
+                    case PlSqlParser.REWRITE_OR_ERROR:
+                    case PlSqlParser.REWRITE:
+                    case PlSqlParser.RIGHT:
+                    case PlSqlParser.ROLE:
+                    case PlSqlParser.ROLESET:
+                    case PlSqlParser.ROLES:
+                    case PlSqlParser.ROLLBACK:
+                    case PlSqlParser.ROLLING:
+                    case PlSqlParser.ROLLUP:
+                    case PlSqlParser.ROWDEPENDENCIES:
+                    case PlSqlParser.ROWID_MAPPING_TABLE:
+                    case PlSqlParser.ROWID:
+                    case PlSqlParser.ROWIDTOCHAR:
+                    case PlSqlParser.ROWIDTONCHAR:
+                    case PlSqlParser.ROW_LENGTH:
+                    case PlSqlParser.ROWNUM:
+                    case PlSqlParser.ROW:
+                    case PlSqlParser.ROWS:
+                    case PlSqlParser.RPAD:
+                    case PlSqlParser.RTRIM:
+                    case PlSqlParser.RULE:
+                    case PlSqlParser.RULES:
+                    case PlSqlParser.RUNNING:
+                    case PlSqlParser.SALT:
+                    case PlSqlParser.SAMPLE:
+                    case PlSqlParser.SAVE_AS_INTERVALS:
+                    case PlSqlParser.SAVEPOINT:
+                    case PlSqlParser.SAVE:
+                    case PlSqlParser.SB4:
+                    case PlSqlParser.SCALE_ROWS:
+                    case PlSqlParser.SCALE:
+                    case PlSqlParser.SCAN_INSTANCES:
+                    case PlSqlParser.SCAN:
+                    case PlSqlParser.SCHEDULER:
+                    case PlSqlParser.SCHEMACHECK:
+                    case PlSqlParser.SCHEMA:
+                    case PlSqlParser.SCN_ASCENDING:
+                    case PlSqlParser.SCN:
+                    case PlSqlParser.SCOPE:
+                    case PlSqlParser.SCRUB:
+                    case PlSqlParser.SD_ALL:
+                    case PlSqlParser.SD_INHIBIT:
+                    case PlSqlParser.SDO_GEOM_MBR:
+                    case PlSqlParser.SDO_GEOMETRY:
+                    case PlSqlParser.SD_SHOW:
+                    case PlSqlParser.SEARCH:
+                    case PlSqlParser.SECOND:
+                    case PlSqlParser.SECONDS:
+                    case PlSqlParser.SECRET:
+                    case PlSqlParser.SECUREFILE_DBA:
+                    case PlSqlParser.SECUREFILE:
+                    case PlSqlParser.SECURITY:
+                    case PlSqlParser.SEED:
+                    case PlSqlParser.SEG_BLOCK:
+                    case PlSqlParser.SEG_FILE:
+                    case PlSqlParser.SEGMENT:
+                    case PlSqlParser.SELECTIVITY:
+                    case PlSqlParser.SELF:
+                    case PlSqlParser.SEMIJOIN_DRIVER:
+                    case PlSqlParser.SEMIJOIN:
+                    case PlSqlParser.SEMI_TO_INNER:
+                    case PlSqlParser.SEQUENCED:
+                    case PlSqlParser.SEQUENCE:
+                    case PlSqlParser.SEQUENTIAL:
+                    case PlSqlParser.SEQ:
+                    case PlSqlParser.SERIALIZABLE:
+                    case PlSqlParser.SERIALLY_REUSABLE:
+                    case PlSqlParser.SERIAL:
+                    case PlSqlParser.SERVERERROR:
+                    case PlSqlParser.SERVICE_NAME_CONVERT:
+                    case PlSqlParser.SERVICE:
+                    case PlSqlParser.SERVICES:
+                    case PlSqlParser.SESSION_CACHED_CURSORS:
+                    case PlSqlParser.SESSION:
+                    case PlSqlParser.SESSIONS_PER_USER:
+                    case PlSqlParser.SESSIONTIMEZONE:
+                    case PlSqlParser.SESSIONTZNAME:
+                    case PlSqlParser.SET:
+                    case PlSqlParser.SETS:
+                    case PlSqlParser.SETTINGS:
+                    case PlSqlParser.SET_TO_JOIN:
+                    case PlSqlParser.SEVERE:
+                    case PlSqlParser.SHARDSPACE:
+                    case PlSqlParser.SHARED_POOL:
+                    case PlSqlParser.SHARED:
+                    case PlSqlParser.SHARING:
+                    case PlSqlParser.SHELFLIFE:
+                    case PlSqlParser.SHOW:
+                    case PlSqlParser.SHRINK:
+                    case PlSqlParser.SHUTDOWN:
+                    case PlSqlParser.SIBLINGS:
+                    case PlSqlParser.SID:
+                    case PlSqlParser.SITE:
+                    case PlSqlParser.SIGNAL_COMPONENT:
+                    case PlSqlParser.SIGNAL_FUNCTION:
+                    case PlSqlParser.SIGN:
+                    case PlSqlParser.SIGNTYPE:
+                    case PlSqlParser.SIMPLE_INTEGER:
+                    case PlSqlParser.SIMPLE:
+                    case PlSqlParser.SINGLE:
+                    case PlSqlParser.SINGLETASK:
+                    case PlSqlParser.SINH:
+                    case PlSqlParser.SIN:
+                    case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                    case PlSqlParser.SKIP_:
+                    case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                    case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                    case PlSqlParser.SMALLFILE:
+                    case PlSqlParser.SMALLINT:
+                    case PlSqlParser.SNAPSHOT:
+                    case PlSqlParser.SOME:
+                    case PlSqlParser.SORT:
+                    case PlSqlParser.SOUNDEX:
+                    case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                    case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                    case PlSqlParser.SOURCE:
+                    case PlSqlParser.SPACE_KEYWORD:
+                    case PlSqlParser.SPECIFICATION:
+                    case PlSqlParser.SPFILE:
+                    case PlSqlParser.SPLIT:
+                    case PlSqlParser.SPREADSHEET:
+                    case PlSqlParser.SQLDATA:
+                    case PlSqlParser.SQLERROR:
+                    case PlSqlParser.SQLLDR:
+                    case PlSqlParser.SQL:
+                    case PlSqlParser.FILE_EXT:
+                    case PlSqlParser.SQL_MACRO:
+                    case PlSqlParser.SQL_TRACE:
+                    case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                    case PlSqlParser.SQRT:
+                    case PlSqlParser.STALE:
+                    case PlSqlParser.STANDALONE:
+                    case PlSqlParser.STANDARD:
+                    case PlSqlParser.STANDARD_HASH:
+                    case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                    case PlSqlParser.STANDBYS:
+                    case PlSqlParser.STANDBY:
+                    case PlSqlParser.STAR:
+                    case PlSqlParser.STAR_TRANSFORMATION:
+                    case PlSqlParser.STARTUP:
+                    case PlSqlParser.STATEMENT_ID:
+                    case PlSqlParser.STATEMENT_QUEUING:
+                    case PlSqlParser.STATEMENTS:
+                    case PlSqlParser.STATEMENT:
+                    case PlSqlParser.STATE:
+                    case PlSqlParser.STATIC:
+                    case PlSqlParser.STATISTICS:
+                    case PlSqlParser.STATS_BINOMIAL_TEST:
+                    case PlSqlParser.STATS_CROSSTAB:
+                    case PlSqlParser.STATS_F_TEST:
+                    case PlSqlParser.STATS_KS_TEST:
+                    case PlSqlParser.STATS_MODE:
+                    case PlSqlParser.STATS_MW_TEST:
+                    case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                    case PlSqlParser.STATS_T_TEST_INDEP:
+                    case PlSqlParser.STATS_T_TEST_INDEPU:
+                    case PlSqlParser.STATS_T_TEST_ONE:
+                    case PlSqlParser.STATS_T_TEST_PAIRED:
+                    case PlSqlParser.STATS_WSR_TEST:
+                    case PlSqlParser.STDDEV_POP:
+                    case PlSqlParser.STDDEV_SAMP:
+                    case PlSqlParser.STOP:
+                    case PlSqlParser.STORAGE:
+                    case PlSqlParser.STORE:
+                    case PlSqlParser.STREAMS:
+                    case PlSqlParser.STREAM:
+                    case PlSqlParser.STRICT:
+                    case PlSqlParser.STRING:
+                    case PlSqlParser.STRIPE_COLUMNS:
+                    case PlSqlParser.STRIPE_WIDTH:
+                    case PlSqlParser.STRIP:
+                    case PlSqlParser.STRUCTURE:
+                    case PlSqlParser.SUBMULTISET:
+                    case PlSqlParser.SUBPARTITION_REL:
+                    case PlSqlParser.SUBPARTITIONS:
+                    case PlSqlParser.SUBPARTITION:
+                    case PlSqlParser.SUBQUERIES:
+                    case PlSqlParser.SUBQUERY_PRUNING:
+                    case PlSqlParser.SUBSCRIBE:
+                    case PlSqlParser.SUBSET:
+                    case PlSqlParser.SUBSTITUTABLE:
+                    case PlSqlParser.SUBSTR2:
+                    case PlSqlParser.SUBSTR4:
+                    case PlSqlParser.SUBSTRB:
+                    case PlSqlParser.SUBSTRC:
+                    case PlSqlParser.SUBTYPE:
+                    case PlSqlParser.SUCCESSFUL:
+                    case PlSqlParser.SUCCESS:
+                    case PlSqlParser.SUMMARY:
+                    case PlSqlParser.SUPPLEMENTAL:
+                    case PlSqlParser.SUSPEND:
+                    case PlSqlParser.SWAP_JOIN_INPUTS:
+                    case PlSqlParser.SWITCHOVER:
+                    case PlSqlParser.SWITCH:
+                    case PlSqlParser.SYNCHRONOUS:
+                    case PlSqlParser.SYNC:
+                    case PlSqlParser.SYS:
+                    case PlSqlParser.SYSASM:
+                    case PlSqlParser.SYS_AUDIT:
+                    case PlSqlParser.SYSAUX:
+                    case PlSqlParser.SYSBACKUP:
+                    case PlSqlParser.SYS_CHECKACL:
+                    case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                    case PlSqlParser.SYS_CONNECT_BY_PATH:
+                    case PlSqlParser.SYS_CONTEXT:
+                    case PlSqlParser.SYSDATE:
+                    case PlSqlParser.SYSDBA:
+                    case PlSqlParser.SYS_DBURIGEN:
+                    case PlSqlParser.SYSDG:
+                    case PlSqlParser.SYS_DL_CURSOR:
+                    case PlSqlParser.SYS_DM_RXFORM_CHR:
+                    case PlSqlParser.SYS_DM_RXFORM_NUM:
+                    case PlSqlParser.SYS_DOM_COMPARE:
+                    case PlSqlParser.SYS_DST_PRIM2SEC:
+                    case PlSqlParser.SYS_DST_SEC2PRIM:
+                    case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                    case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                    case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                    case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                    case PlSqlParser.SYS_EXTPDTXT:
+                    case PlSqlParser.SYS_EXTRACT_UTC:
+                    case PlSqlParser.SYS_FBT_INSDEL:
+                    case PlSqlParser.SYS_FILTER_ACLS:
+                    case PlSqlParser.SYS_FNMATCHES:
+                    case PlSqlParser.SYS_FNREPLACE:
+                    case PlSqlParser.SYS_GET_ACLIDS:
+                    case PlSqlParser.SYS_GET_COL_ACLIDS:
+                    case PlSqlParser.SYS_GET_PRIVILEGES:
+                    case PlSqlParser.SYS_GETTOKENID:
+                    case PlSqlParser.SYS_GETXTIVAL:
+                    case PlSqlParser.SYS_GUID:
+                    case PlSqlParser.SYSGUID:
+                    case PlSqlParser.SYSKM:
+                    case PlSqlParser.SYS_MAKE_XMLNODEID:
+                    case PlSqlParser.SYS_MAKEXML:
+                    case PlSqlParser.SYS_MKXMLATTR:
+                    case PlSqlParser.SYS_MKXTI:
+                    case PlSqlParser.SYSOBJ:
+                    case PlSqlParser.SYS_OP_ADT2BIN:
+                    case PlSqlParser.SYS_OP_ADTCONS:
+                    case PlSqlParser.SYS_OP_ALSCRVAL:
+                    case PlSqlParser.SYS_OP_ATG:
+                    case PlSqlParser.SYS_OP_BIN2ADT:
+                    case PlSqlParser.SYS_OP_BITVEC:
+                    case PlSqlParser.SYS_OP_BL2R:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                    case PlSqlParser.SYS_OP_C2C:
+                    case PlSqlParser.SYS_OP_CAST:
+                    case PlSqlParser.SYS_OP_CEG:
+                    case PlSqlParser.SYS_OP_CL2C:
+                    case PlSqlParser.SYS_OP_COMBINED_HASH:
+                    case PlSqlParser.SYS_OP_COMP:
+                    case PlSqlParser.SYS_OP_CONVERT:
+                    case PlSqlParser.SYS_OP_COUNTCHG:
+                    case PlSqlParser.SYS_OP_CSCONV:
+                    case PlSqlParser.SYS_OP_CSCONVTEST:
+                    case PlSqlParser.SYS_OP_CSR:
+                    case PlSqlParser.SYS_OP_CSX_PATCH:
+                    case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                    case PlSqlParser.SYS_OP_DECOMP:
+                    case PlSqlParser.SYS_OP_DESCEND:
+                    case PlSqlParser.SYS_OP_DISTINCT:
+                    case PlSqlParser.SYS_OP_DRA:
+                    case PlSqlParser.SYS_OP_DUMP:
+                    case PlSqlParser.SYS_OP_DV_CHECK:
+                    case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                    case PlSqlParser.SYSOPER:
+                    case PlSqlParser.SYS_OP_EXTRACT:
+                    case PlSqlParser.SYS_OP_GROUPING:
+                    case PlSqlParser.SYS_OP_GUID:
+                    case PlSqlParser.SYS_OP_HASH:
+                    case PlSqlParser.SYS_OP_IIX:
+                    case PlSqlParser.SYS_OP_ITR:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                    case PlSqlParser.SYS_OP_LBID:
+                    case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2ID:
+                    case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                    case PlSqlParser.SYS_OP_LSVI:
+                    case PlSqlParser.SYS_OP_LVL:
+                    case PlSqlParser.SYS_OP_MAKEOID:
+                    case PlSqlParser.SYS_OP_MAP_NONNULL:
+                    case PlSqlParser.SYS_OP_MSR:
+                    case PlSqlParser.SYS_OP_NICOMBINE:
+                    case PlSqlParser.SYS_OP_NIEXTRACT:
+                    case PlSqlParser.SYS_OP_NII:
+                    case PlSqlParser.SYS_OP_NIX:
+                    case PlSqlParser.SYS_OP_NOEXPAND:
+                    case PlSqlParser.SYS_OP_NTCIMG:
+                    case PlSqlParser.SYS_OP_NUMTORAW:
+                    case PlSqlParser.SYS_OP_OIDVALUE:
+                    case PlSqlParser.SYS_OP_OPNSIZE:
+                    case PlSqlParser.SYS_OP_PAR_1:
+                    case PlSqlParser.SYS_OP_PARGID_1:
+                    case PlSqlParser.SYS_OP_PARGID:
+                    case PlSqlParser.SYS_OP_PAR:
+                    case PlSqlParser.SYS_OP_PART_ID:
+                    case PlSqlParser.SYS_OP_PIVOT:
+                    case PlSqlParser.SYS_OP_R2O:
+                    case PlSqlParser.SYS_OP_RAWTONUM:
+                    case PlSqlParser.SYS_OP_RDTM:
+                    case PlSqlParser.SYS_OP_REF:
+                    case PlSqlParser.SYS_OP_RMTD:
+                    case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                    case PlSqlParser.SYS_OP_RPB:
+                    case PlSqlParser.SYS_OPTLOBPRBSC:
+                    case PlSqlParser.SYS_OP_TOSETID:
+                    case PlSqlParser.SYS_OP_TPR:
+                    case PlSqlParser.SYS_OP_TRTB:
+                    case PlSqlParser.SYS_OPTXICMP:
+                    case PlSqlParser.SYS_OPTXQCASTASNQ:
+                    case PlSqlParser.SYS_OP_UNDESCEND:
+                    case PlSqlParser.SYS_OP_VECAND:
+                    case PlSqlParser.SYS_OP_VECBIT:
+                    case PlSqlParser.SYS_OP_VECOR:
+                    case PlSqlParser.SYS_OP_VECXOR:
+                    case PlSqlParser.SYS_OP_VERSION:
+                    case PlSqlParser.SYS_OP_VREF:
+                    case PlSqlParser.SYS_OP_VVD:
+                    case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                    case PlSqlParser.SYS_OP_XPTHATG:
+                    case PlSqlParser.SYS_OP_XPTHIDX:
+                    case PlSqlParser.SYS_OP_XPTHOP:
+                    case PlSqlParser.SYS_OP_XTXT2SQLT:
+                    case PlSqlParser.SYS_OP_ZONE_ID:
+                    case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                    case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                    case PlSqlParser.SYS_ORDERKEY_PARENT:
+                    case PlSqlParser.SYS_PARALLEL_TXN:
+                    case PlSqlParser.SYS_PATHID_IS_ATTR:
+                    case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                    case PlSqlParser.SYS_PATHID_LASTNAME:
+                    case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                    case PlSqlParser.SYS_PATH_REVERSE:
+                    case PlSqlParser.SYS_PXQEXTRACT:
+                    case PlSqlParser.SYS_RAW_TO_XSID:
+                    case PlSqlParser.SYS_RID_ORDER:
+                    case PlSqlParser.SYS_ROW_DELTA:
+                    case PlSqlParser.SYS_SC_2_XMLT:
+                    case PlSqlParser.SYS_SYNRCIREDO:
+                    case PlSqlParser.SYSTEM_DEFINED:
+                    case PlSqlParser.SYSTEM:
+                    case PlSqlParser.SYSTIMESTAMP:
+                    case PlSqlParser.SYS_TYPEID:
+                    case PlSqlParser.SYS_UMAKEXML:
+                    case PlSqlParser.SYS_XMLANALYZE:
+                    case PlSqlParser.SYS_XMLCONTAINS:
+                    case PlSqlParser.SYS_XMLCONV:
+                    case PlSqlParser.SYS_XMLEXNSURI:
+                    case PlSqlParser.SYS_XMLGEN:
+                    case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                    case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                    case PlSqlParser.SYS_XMLINSTR:
+                    case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETCID:
+                    case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                    case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                    case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                    case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETTID:
+                    case PlSqlParser.SYS_XMLNODEID:
+                    case PlSqlParser.SYS_XMLT_2_SC:
+                    case PlSqlParser.SYS_XMLTRANSLATE:
+                    case PlSqlParser.SYS_XMLTYPE2SQL:
+                    case PlSqlParser.SYS_XQ_ASQLCNV:
+                    case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                    case PlSqlParser.SYS_XQBASEURI:
+                    case PlSqlParser.SYS_XQCASTABLEERRH:
+                    case PlSqlParser.SYS_XQCODEP2STR:
+                    case PlSqlParser.SYS_XQCODEPEQ:
+                    case PlSqlParser.SYS_XQCON2SEQ:
+                    case PlSqlParser.SYS_XQCONCAT:
+                    case PlSqlParser.SYS_XQDELETE:
+                    case PlSqlParser.SYS_XQDFLTCOLATION:
+                    case PlSqlParser.SYS_XQDOC:
+                    case PlSqlParser.SYS_XQDOCURI:
+                    case PlSqlParser.SYS_XQDURDIV:
+                    case PlSqlParser.SYS_XQED4URI:
+                    case PlSqlParser.SYS_XQENDSWITH:
+                    case PlSqlParser.SYS_XQERRH:
+                    case PlSqlParser.SYS_XQERR:
+                    case PlSqlParser.SYS_XQESHTMLURI:
+                    case PlSqlParser.SYS_XQEXLOBVAL:
+                    case PlSqlParser.SYS_XQEXSTWRP:
+                    case PlSqlParser.SYS_XQEXTRACT:
+                    case PlSqlParser.SYS_XQEXTRREF:
+                    case PlSqlParser.SYS_XQEXVAL:
+                    case PlSqlParser.SYS_XQFB2STR:
+                    case PlSqlParser.SYS_XQFNBOOL:
+                    case PlSqlParser.SYS_XQFNCMP:
+                    case PlSqlParser.SYS_XQFNDATIM:
+                    case PlSqlParser.SYS_XQFNLNAME:
+                    case PlSqlParser.SYS_XQFNNM:
+                    case PlSqlParser.SYS_XQFNNSURI:
+                    case PlSqlParser.SYS_XQFNPREDTRUTH:
+                    case PlSqlParser.SYS_XQFNQNM:
+                    case PlSqlParser.SYS_XQFNROOT:
+                    case PlSqlParser.SYS_XQFORMATNUM:
+                    case PlSqlParser.SYS_XQFTCONTAIN:
+                    case PlSqlParser.SYS_XQFUNCR:
+                    case PlSqlParser.SYS_XQGETCONTENT:
+                    case PlSqlParser.SYS_XQINDXOF:
+                    case PlSqlParser.SYS_XQINSERT:
+                    case PlSqlParser.SYS_XQINSPFX:
+                    case PlSqlParser.SYS_XQIRI2URI:
+                    case PlSqlParser.SYS_XQLANG:
+                    case PlSqlParser.SYS_XQLLNMFRMQNM:
+                    case PlSqlParser.SYS_XQMKNODEREF:
+                    case PlSqlParser.SYS_XQNILLED:
+                    case PlSqlParser.SYS_XQNODENAME:
+                    case PlSqlParser.SYS_XQNORMSPACE:
+                    case PlSqlParser.SYS_XQNORMUCODE:
+                    case PlSqlParser.SYS_XQ_NRNG:
+                    case PlSqlParser.SYS_XQNSP4PFX:
+                    case PlSqlParser.SYS_XQNSPFRMQNM:
+                    case PlSqlParser.SYS_XQPFXFRMQNM:
+                    case PlSqlParser.SYS_XQ_PKSQL2XML:
+                    case PlSqlParser.SYS_XQPOLYABS:
+                    case PlSqlParser.SYS_XQPOLYADD:
+                    case PlSqlParser.SYS_XQPOLYCEL:
+                    case PlSqlParser.SYS_XQPOLYCSTBL:
+                    case PlSqlParser.SYS_XQPOLYCST:
+                    case PlSqlParser.SYS_XQPOLYDIV:
+                    case PlSqlParser.SYS_XQPOLYFLR:
+                    case PlSqlParser.SYS_XQPOLYMOD:
+                    case PlSqlParser.SYS_XQPOLYMUL:
+                    case PlSqlParser.SYS_XQPOLYRND:
+                    case PlSqlParser.SYS_XQPOLYSQRT:
+                    case PlSqlParser.SYS_XQPOLYSUB:
+                    case PlSqlParser.SYS_XQPOLYUMUS:
+                    case PlSqlParser.SYS_XQPOLYUPLS:
+                    case PlSqlParser.SYS_XQPOLYVEQ:
+                    case PlSqlParser.SYS_XQPOLYVGE:
+                    case PlSqlParser.SYS_XQPOLYVGT:
+                    case PlSqlParser.SYS_XQPOLYVLE:
+                    case PlSqlParser.SYS_XQPOLYVLT:
+                    case PlSqlParser.SYS_XQPOLYVNE:
+                    case PlSqlParser.SYS_XQREF2VAL:
+                    case PlSqlParser.SYS_XQRENAME:
+                    case PlSqlParser.SYS_XQREPLACE:
+                    case PlSqlParser.SYS_XQRESVURI:
+                    case PlSqlParser.SYS_XQRNDHALF2EVN:
+                    case PlSqlParser.SYS_XQRSLVQNM:
+                    case PlSqlParser.SYS_XQRYENVPGET:
+                    case PlSqlParser.SYS_XQRYVARGET:
+                    case PlSqlParser.SYS_XQRYWRP:
+                    case PlSqlParser.SYS_XQSEQ2CON4XC:
+                    case PlSqlParser.SYS_XQSEQ2CON:
+                    case PlSqlParser.SYS_XQSEQDEEPEQ:
+                    case PlSqlParser.SYS_XQSEQINSB:
+                    case PlSqlParser.SYS_XQSEQRM:
+                    case PlSqlParser.SYS_XQSEQRVS:
+                    case PlSqlParser.SYS_XQSEQSUB:
+                    case PlSqlParser.SYS_XQSEQTYPMATCH:
+                    case PlSqlParser.SYS_XQSTARTSWITH:
+                    case PlSqlParser.SYS_XQSTATBURI:
+                    case PlSqlParser.SYS_XQSTR2CODEP:
+                    case PlSqlParser.SYS_XQSTRJOIN:
+                    case PlSqlParser.SYS_XQSUBSTRAFT:
+                    case PlSqlParser.SYS_XQSUBSTRBEF:
+                    case PlSqlParser.SYS_XQTOKENIZE:
+                    case PlSqlParser.SYS_XQTREATAS:
+                    case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                    case PlSqlParser.SYS_XQXFORM:
+                    case PlSqlParser.SYS_XSID_TO_RAW:
+                    case PlSqlParser.SYS_ZMAP_FILTER:
+                    case PlSqlParser.SYS_ZMAP_REFRESH:
+                    case PlSqlParser.T_LETTER:
+                    case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.TABLESPACE_NO:
+                    case PlSqlParser.TABLESPACE:
+                    case PlSqlParser.TABLES:
+                    case PlSqlParser.TABLE_STATS:
+                    case PlSqlParser.TABLE:
+                    case PlSqlParser.TABNO:
+                    case PlSqlParser.TAG:
+                    case PlSqlParser.TANH:
+                    case PlSqlParser.TAN:
+                    case PlSqlParser.TBLORIDXPARTNUM:
+                    case PlSqlParser.TEMPFILE:
+                    case PlSqlParser.TEMPLATE:
+                    case PlSqlParser.TEMPLATE_TABLE:
+                    case PlSqlParser.TEMPORARY:
+                    case PlSqlParser.TEMP_TABLE:
+                    case PlSqlParser.TEST:
+                    case PlSqlParser.TEXT:
+                    case PlSqlParser.THAN:
+                    case PlSqlParser.THEN:
+                    case PlSqlParser.THE:
+                    case PlSqlParser.THREAD:
+                    case PlSqlParser.THROUGH:
+                    case PlSqlParser.TIER:
+                    case PlSqlParser.TIES:
+                    case PlSqlParser.TIMEOUT:
+                    case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP:
+                    case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                    case PlSqlParser.TIMES:
+                    case PlSqlParser.TIME:
+                    case PlSqlParser.TIMEZONE:
+                    case PlSqlParser.TIMEZONE_ABBR:
+                    case PlSqlParser.TIMEZONE_HOUR:
+                    case PlSqlParser.TIMEZONE_MINUTE:
+                    case PlSqlParser.TIMEZONE_OFFSET:
+                    case PlSqlParser.TIMEZONE_REGION:
+                    case PlSqlParser.TIME_ZONE:
+                    case PlSqlParser.TIMING:
+                    case PlSqlParser.TIV_GB:
+                    case PlSqlParser.TIV_SSF:
+                    case PlSqlParser.TO_ACLID:
+                    case PlSqlParser.TO_BINARY_DOUBLE:
+                    case PlSqlParser.TO_BINARY_FLOAT:
+                    case PlSqlParser.TO_BLOB:
+                    case PlSqlParser.TO_CLOB:
+                    case PlSqlParser.TO_DSINTERVAL:
+                    case PlSqlParser.TO_LOB:
+                    case PlSqlParser.TO_MULTI_BYTE:
+                    case PlSqlParser.TO_NCHAR:
+                    case PlSqlParser.TO_NCLOB:
+                    case PlSqlParser.TO_NUMBER:
+                    case PlSqlParser.TOPLEVEL:
+                    case PlSqlParser.TO_SINGLE_BYTE:
+                    case PlSqlParser.TO_TIMESTAMP:
+                    case PlSqlParser.TO_TIMESTAMP_TZ:
+                    case PlSqlParser.TO_TIME:
+                    case PlSqlParser.TO_TIME_TZ:
+                    case PlSqlParser.TO_YMINTERVAL:
+                    case PlSqlParser.TRACE:
+                    case PlSqlParser.TRACING:
+                    case PlSqlParser.TRACKING:
+                    case PlSqlParser.TRAILING:
+                    case PlSqlParser.TRANSACTION:
+                    case PlSqlParser.TRANSFORM:
+                    case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.TRANSITIONAL:
+                    case PlSqlParser.TRANSITION:
+                    case PlSqlParser.TRANSLATE:
+                    case PlSqlParser.TRANSLATION:
+                    case PlSqlParser.TREAT:
+                    case PlSqlParser.TRIGGERS:
+                    case PlSqlParser.TRIGGER:
+                    case PlSqlParser.TRUE:
+                    case PlSqlParser.TRUNCATE:
+                    case PlSqlParser.TRUNC:
+                    case PlSqlParser.TRUSTED:
+                    case PlSqlParser.TRUST:
+                    case PlSqlParser.TUNING:
+                    case PlSqlParser.TX:
+                    case PlSqlParser.TYPES:
+                    case PlSqlParser.TYPE:
+                    case PlSqlParser.TZ_OFFSET:
+                    case PlSqlParser.UB2:
+                    case PlSqlParser.UBA:
+                    case PlSqlParser.UCS2:
+                    case PlSqlParser.UDF:
+                    case PlSqlParser.UID:
+                    case PlSqlParser.UNARCHIVED:
+                    case PlSqlParser.UNBOUNDED:
+                    case PlSqlParser.UNBOUND:
+                    case PlSqlParser.UNCONDITIONAL:
+                    case PlSqlParser.UNDER:
+                    case PlSqlParser.UNDO:
+                    case PlSqlParser.UNDROP:
+                    case PlSqlParser.UNIFORM:
+                    case PlSqlParser.UNISTR:
+                    case PlSqlParser.UNLIMITED:
+                    case PlSqlParser.UNLOAD:
+                    case PlSqlParser.UNLOCK:
+                    case PlSqlParser.UNMATCHED:
+                    case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                    case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                    case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                    case PlSqlParser.UNNEST:
+                    case PlSqlParser.UNPACKED:
+                    case PlSqlParser.UNPIVOT:
+                    case PlSqlParser.UNPLUG:
+                    case PlSqlParser.UNPROTECTED:
+                    case PlSqlParser.UNQUIESCE:
+                    case PlSqlParser.UNRECOVERABLE:
+                    case PlSqlParser.UNRESTRICTED:
+                    case PlSqlParser.UNSUBSCRIBE:
+                    case PlSqlParser.UNTIL:
+                    case PlSqlParser.UNUSABLE:
+                    case PlSqlParser.UNUSED:
+                    case PlSqlParser.UPDATABLE:
+                    case PlSqlParser.UPDATED:
+                    case PlSqlParser.UPDATEXML:
+                    case PlSqlParser.UPD_INDEXES:
+                    case PlSqlParser.UPD_JOININDEX:
+                    case PlSqlParser.UPGRADE:
+                    case PlSqlParser.UPPER:
+                    case PlSqlParser.UPSERT:
+                    case PlSqlParser.UROWID:
+                    case PlSqlParser.USABLE:
+                    case PlSqlParser.USAGE:
+                    case PlSqlParser.USE_ANTI:
+                    case PlSqlParser.USE_CONCAT:
+                    case PlSqlParser.USE_CUBE:
+                    case PlSqlParser.USE_HASH_AGGREGATION:
+                    case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.USE_HASH:
+                    case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                    case PlSqlParser.USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.USE_MERGE_CARTESIAN:
+                    case PlSqlParser.USE_MERGE:
+                    case PlSqlParser.USE_NL:
+                    case PlSqlParser.USE_NL_WITH_INDEX:
+                    case PlSqlParser.USE_PRIVATE_OUTLINES:
+                    case PlSqlParser.USER_DATA:
+                    case PlSqlParser.USER_DEFINED:
+                    case PlSqlParser.USERENV:
+                    case PlSqlParser.USERGROUP:
+                    case PlSqlParser.USER_RECYCLEBIN:
+                    case PlSqlParser.USERS:
+                    case PlSqlParser.USER_TABLESPACES:
+                    case PlSqlParser.USER:
+                    case PlSqlParser.USE_SEMI:
+                    case PlSqlParser.USE_STORED_OUTLINES:
+                    case PlSqlParser.USE_TTT_FOR_GSETS:
+                    case PlSqlParser.USE:
+                    case PlSqlParser.USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.USE_WEAK_NAME_RESL:
+                    case PlSqlParser.USING_NO_EXPAND:
+                    case PlSqlParser.USING_NLS_COMP:
+                    case PlSqlParser.USING:
+                    case PlSqlParser.UTF16BE:
+                    case PlSqlParser.UTF16LE:
+                    case PlSqlParser.UTF32:
+                    case PlSqlParser.UTF8:
+                    case PlSqlParser.V1:
+                    case PlSqlParser.V2:
+                    case PlSqlParser.VALIDATE:
+                    case PlSqlParser.VALIDATE_CONVERSION:
+                    case PlSqlParser.VALIDATION:
+                    case PlSqlParser.VALID_TIME_END:
+                    case PlSqlParser.VALUE:
+                    case PlSqlParser.VARCHAR2:
+                    case PlSqlParser.VARCHAR:
+                    case PlSqlParser.VARIABLE:
+                    case PlSqlParser.VAR_POP:
+                    case PlSqlParser.VARRAYS:
+                    case PlSqlParser.VARRAY:
+                    case PlSqlParser.VAR_SAMP:
+                    case PlSqlParser.VARYING:
+                    case PlSqlParser.VECTOR_READ_TRACE:
+                    case PlSqlParser.VECTOR_READ:
+                    case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.VECTOR_TRANSFORM:
+                    case PlSqlParser.VERIFIER:
+                    case PlSqlParser.VERIFY:
+                    case PlSqlParser.VERSIONING:
+                    case PlSqlParser.VERSIONS_ENDSCN:
+                    case PlSqlParser.VERSIONS_ENDTIME:
+                    case PlSqlParser.VERSIONS_OPERATION:
+                    case PlSqlParser.VERSIONS_STARTSCN:
+                    case PlSqlParser.VERSIONS_STARTTIME:
+                    case PlSqlParser.VERSIONS:
+                    case PlSqlParser.VERSIONS_XID:
+                    case PlSqlParser.VERSION:
+                    case PlSqlParser.VIOLATION:
+                    case PlSqlParser.VIRTUAL:
+                    case PlSqlParser.VISIBILITY:
+                    case PlSqlParser.VISIBLE:
+                    case PlSqlParser.VOLUME:
+                    case PlSqlParser.VSIZE:
+                    case PlSqlParser.WAIT:
+                    case PlSqlParser.WALLET:
+                    case PlSqlParser.WARNING:
+                    case PlSqlParser.WEEKS:
+                    case PlSqlParser.WEEK:
+                    case PlSqlParser.WELLFORMED:
+                    case PlSqlParser.WHENEVER:
+                    case PlSqlParser.WHEN:
+                    case PlSqlParser.WHILE:
+                    case PlSqlParser.WHITESPACE:
+                    case PlSqlParser.WIDTH_BUCKET:
+                    case PlSqlParser.WITHIN:
+                    case PlSqlParser.WITHOUT:
+                    case PlSqlParser.WITH_PLSQL:
+                    case PlSqlParser.WORK:
+                    case PlSqlParser.WRAPPED:
+                    case PlSqlParser.WRAPPER:
+                    case PlSqlParser.WRITE:
+                    case PlSqlParser.XDB_FASTPATH_INSERT:
+                    case PlSqlParser.X_DYN_PRUNE:
+                    case PlSqlParser.XID:
+                    case PlSqlParser.XML2OBJECT:
+                    case PlSqlParser.XMLAGG:
+                    case PlSqlParser.XMLATTRIBUTES:
+                    case PlSqlParser.XMLCAST:
+                    case PlSqlParser.XMLCDATA:
+                    case PlSqlParser.XMLCOLATTVAL:
+                    case PlSqlParser.XMLCOMMENT:
+                    case PlSqlParser.XMLCONCAT:
+                    case PlSqlParser.XMLDIFF:
+                    case PlSqlParser.XML_DML_RWT_STMT:
+                    case PlSqlParser.XMLELEMENT:
+                    case PlSqlParser.XMLEXISTS2:
+                    case PlSqlParser.XMLEXISTS:
+                    case PlSqlParser.XMLFOREST:
+                    case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.XMLINDEX_REWRITE:
+                    case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                    case PlSqlParser.XMLISNODE:
+                    case PlSqlParser.XMLISVALID:
+                    case PlSqlParser.XMLNAMESPACES:
+                    case PlSqlParser.XMLPARSE:
+                    case PlSqlParser.XMLPATCH:
+                    case PlSqlParser.XMLPI:
+                    case PlSqlParser.XMLQUERYVAL:
+                    case PlSqlParser.XMLQUERY:
+                    case PlSqlParser.XMLROOT:
+                    case PlSqlParser.XMLSCHEMA:
+                    case PlSqlParser.XMLSERIALIZE:
+                    case PlSqlParser.XMLTABLE:
+                    case PlSqlParser.XMLTRANSFORMBLOB:
+                    case PlSqlParser.XMLTRANSFORM:
+                    case PlSqlParser.XMLTYPE:
+                    case PlSqlParser.XML:
+                    case PlSqlParser.XPATHTABLE:
+                    case PlSqlParser.XS_SYS_CONTEXT:
+                    case PlSqlParser.XS:
+                    case PlSqlParser.YEARS:
+                    case PlSqlParser.YEAR:
+                    case PlSqlParser.YES:
+                    case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.ZONEMAP:
+                    case PlSqlParser.ZONE:
+                    case PlSqlParser.PREDICTION:
+                    case PlSqlParser.PREDICTION_BOUNDS:
+                    case PlSqlParser.PREDICTION_COST:
+                    case PlSqlParser.PREDICTION_DETAILS:
+                    case PlSqlParser.PREDICTION_PROBABILITY:
+                    case PlSqlParser.PREDICTION_SET:
+                    case PlSqlParser.BLOCKCHAIN:
+                    case PlSqlParser.COLLATE:
+                    case PlSqlParser.COLLATION:
+                    case PlSqlParser.DEFINITION:
+                    case PlSqlParser.DUPLICATED:
+                    case PlSqlParser.EXTENDED:
+                    case PlSqlParser.HASHING:
+                    case PlSqlParser.IDLE:
+                    case PlSqlParser.IMMUTABLE:
+                    case PlSqlParser.ORACLE_DATAPUMP:
+                    case PlSqlParser.ORACLE_HDFS:
+                    case PlSqlParser.ORACLE_HIVE:
+                    case PlSqlParser.ORACLE_LOADER:
+                    case PlSqlParser.SHARDED:
+                    case PlSqlParser.ISOLATE:
+                    case PlSqlParser.ROOT:
+                    case PlSqlParser.UNITE:
+                    case PlSqlParser.ALGORITHM:
+                    case PlSqlParser.CUME_DIST:
+                    case PlSqlParser.DENSE_RANK:
+                    case PlSqlParser.LISTAGG:
+                    case PlSqlParser.PERCENT_RANK:
+                    case PlSqlParser.PERCENTILE_CONT:
+                    case PlSqlParser.PERCENTILE_DISC:
+                    case PlSqlParser.RANK:
+                    case PlSqlParser.AVG:
+                    case PlSqlParser.CORR:
+                    case PlSqlParser.COVAR_:
+                    case PlSqlParser.LAG:
+                    case PlSqlParser.LEAD:
+                    case PlSqlParser.MAX:
+                    case PlSqlParser.MEDIAN:
+                    case PlSqlParser.MEMOPTIMIZE:
+                    case PlSqlParser.MIN:
+                    case PlSqlParser.NTILE:
+                    case PlSqlParser.NVL:
+                    case PlSqlParser.RATIO_TO_REPORT:
+                    case PlSqlParser.REGR_:
+                    case PlSqlParser.ROUND:
+                    case PlSqlParser.ROW_NUMBER:
+                    case PlSqlParser.SUBSTR:
+                    case PlSqlParser.TO_CHAR:
+                    case PlSqlParser.TRIM:
+                    case PlSqlParser.SUM:
+                    case PlSqlParser.STDDEV:
+                    case PlSqlParser.VAR_:
+                    case PlSqlParser.VARIANCE:
+                    case PlSqlParser.LEAST:
+                    case PlSqlParser.GREATEST:
+                    case PlSqlParser.TO_DATE:
+                    case PlSqlParser.CHARSETID:
+                    case PlSqlParser.CHARSETFORM:
+                    case PlSqlParser.DURATION:
+                    case PlSqlParser.EXTEND:
+                    case PlSqlParser.MAXLEN:
+                    case PlSqlParser.PERSISTABLE:
+                    case PlSqlParser.POLYMORPHIC:
+                    case PlSqlParser.STRUCT:
+                    case PlSqlParser.TDO:
+                    case PlSqlParser.WM_CONCAT:
+                    case PlSqlParser.PERIOD:
+                    case PlSqlParser.DELIMITED_ID:
+                    case PlSqlParser.REGULAR_ID:
+                        {
+                        this.state = 8765;
+                        localContext._sn = this.id_expression();
+                        }
+                        break;
+                    case PlSqlParser.MINUS_SIGN:
+                        {
+                        this.state = 8766;
+                        this.match(PlSqlParser.MINUS_SIGN);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 8769;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    }
+                    this.state = 8772;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 2449);
+                this.state = 8774;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 8792;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.USING:
+                {
+                this.state = 8777;
+                this.match(PlSqlParser.USING);
+                this.state = 8788;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 964, this.context) ) {
+                case 1:
+                    {
+                    this.state = 8778;
+                    this.match(PlSqlParser.BFILE);
+                    this.state = 8779;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 8780;
+                    localContext._d = this.id_expression();
+                    this.state = 8781;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8782;
+                    this.filename();
+                    this.state = 8783;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 8785;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 119 || _la === 142 || _la === 215)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 8786;
+                    this.subquery();
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 8787;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.AS:
+                {
+                this.state = 8790;
+                this.match(PlSqlParser.AS);
+                this.state = 8791;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_library(): Create_libraryContext {
+        let localContext = new Create_libraryContext(this.context, this.state);
+        this.enterRule(localContext, 814, PlSqlParser.RULE_create_library);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8794;
+            this.match(PlSqlParser.CREATE);
+            this.state = 8797;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 8795;
+                this.match(PlSqlParser.OR);
+                this.state = 8796;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 8800;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 1133) {
+                {
+                this.state = 8799;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 482 || _la === 1133)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 8802;
+            this.match(PlSqlParser.LIBRARY);
+            this.state = 8803;
+            this.plsql_library_source();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public plsql_library_source(): Plsql_library_sourceContext {
+        let localContext = new Plsql_library_sourceContext(this.context, this.state);
+        this.enterRule(localContext, 816, PlSqlParser.RULE_plsql_library_source);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8805;
+            this.library_name();
+            this.state = 8806;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 69 || _la === 786)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 8807;
+            this.quoted_string();
+            this.state = 8810;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 968, this.context) ) {
+            case 1:
+                {
+                this.state = 8808;
+                this.match(PlSqlParser.IN);
+                this.state = 8809;
+                this.directory_name();
+                }
+                break;
+            }
+            this.state = 8814;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 969, this.context) ) {
+            case 1:
+                {
+                this.state = 8812;
+                this.match(PlSqlParser.AGENT);
+                this.state = 8813;
+                this.quoted_string();
+                }
+                break;
+            }
+            this.state = 8818;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 970, this.context) ) {
+            case 1:
+                {
+                this.state = 8816;
+                this.match(PlSqlParser.CREDENTIAL);
+                this.state = 8817;
+                this.credential_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public credential_name(): Credential_nameContext {
+        let localContext = new Credential_nameContext(this.context, this.state);
+        this.enterRule(localContext, 818, PlSqlParser.RULE_credential_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8823;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 971, this.context) ) {
+            case 1:
+                {
+                this.state = 8820;
+                this.id_expression();
+                this.state = 8821;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8825;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public library_editionable(): Library_editionableContext {
+        let localContext = new Library_editionableContext(this.context, this.state);
+        this.enterRule(localContext, 820, PlSqlParser.RULE_library_editionable);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8827;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            this.state = 8828;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 482 || _la === 1133)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public library_debug(): Library_debugContext {
+        let localContext = new Library_debugContext(this.context, this.state);
+        this.enterRule(localContext, 822, PlSqlParser.RULE_library_debug);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8830;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            this.state = 8831;
+            this.match(PlSqlParser.DEBUG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext {
+        let localContext = new Compiler_parameters_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 824, PlSqlParser.RULE_compiler_parameters_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8833;
+            this.parameter_name();
+            this.state = 8834;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 8835;
+            this.parameter_value();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parameter_value(): Parameter_valueContext {
+        let localContext = new Parameter_valueContext(this.context, this.state);
+        this.enterRule(localContext, 826, PlSqlParser.RULE_parameter_value);
+        try {
+            this.state = 8839;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 8837;
+                this.regular_id();
+                }
+                break;
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 8838;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public library_name(): Library_nameContext {
+        let localContext = new Library_nameContext(this.context, this.state);
+        this.enterRule(localContext, 828, PlSqlParser.RULE_library_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8844;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 973, this.context) ) {
+            case 1:
+                {
+                this.state = 8841;
+                this.regular_id();
+                this.state = 8842;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 8846;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_dimension(): Alter_dimensionContext {
+        let localContext = new Alter_dimensionContext(this.context, this.state);
+        this.enterRule(localContext, 830, PlSqlParser.RULE_alter_dimension);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8848;
+            this.match(PlSqlParser.ALTER);
+            this.state = 8849;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 8850;
+            this.identifier();
+            this.state = 8895;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                {
+                this.state = 8858;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 8851;
+                        this.match(PlSqlParser.ADD);
+                        this.state = 8856;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 974, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 8852;
+                            this.level_clause();
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 8853;
+                            this.hierarchy_clause();
+                            }
+                            break;
+                        case 3:
+                            {
+                            this.state = 8854;
+                            this.attribute_clause();
+                            }
+                            break;
+                        case 4:
+                            {
+                            this.state = 8855;
+                            this.extended_attribute_clause();
+                            }
+                            break;
+                        }
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 8860;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 975, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.DROP:
+                {
+                this.state = 8890;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 8862;
+                        this.match(PlSqlParser.DROP);
+                        this.state = 8888;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.LEVEL:
+                            {
+                            this.state = 8863;
+                            this.match(PlSqlParser.LEVEL);
+                            this.state = 8864;
+                            this.identifier();
+                            this.state = 8866;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 976, this.context) ) {
+                            case 1:
+                                {
+                                this.state = 8865;
+                                _la = this.tokenStream.LA(1);
+                                if(!(_la === 179 || _la === 1580)) {
+                                this.errorHandler.recoverInline(this);
+                                }
+                                else {
+                                    this.errorHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                                }
+                                break;
+                            }
+                            }
+                            break;
+                        case PlSqlParser.HIERARCHY:
+                            {
+                            this.state = 8868;
+                            this.match(PlSqlParser.HIERARCHY);
+                            this.state = 8869;
+                            this.identifier();
+                            }
+                            break;
+                        case PlSqlParser.ATTRIBUTE:
+                            {
+                            this.state = 8870;
+                            this.match(PlSqlParser.ATTRIBUTE);
+                            this.state = 8871;
+                            this.identifier();
+                            this.state = 8886;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 979, this.context) ) {
+                            case 1:
+                                {
+                                this.state = 8872;
+                                this.match(PlSqlParser.LEVEL);
+                                this.state = 8873;
+                                this.identifier();
+                                this.state = 8884;
+                                this.errorHandler.sync(this);
+                                switch (this.interpreter.adaptivePredict(this.tokenStream, 978, this.context) ) {
+                                case 1:
+                                    {
+                                    this.state = 8874;
+                                    this.match(PlSqlParser.COLUMN);
+                                    this.state = 8875;
+                                    this.column_name();
+                                    this.state = 8881;
+                                    this.errorHandler.sync(this);
+                                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 977, this.context);
+                                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                                        if (alternative === 1) {
+                                            {
+                                            {
+                                            this.state = 8876;
+                                            this.match(PlSqlParser.COMMA);
+                                            this.state = 8877;
+                                            this.match(PlSqlParser.COLUMN);
+                                            this.state = 8878;
+                                            this.column_name();
+                                            }
+                                            }
+                                        }
+                                        this.state = 8883;
+                                        this.errorHandler.sync(this);
+                                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 977, this.context);
+                                    }
+                                    }
+                                    break;
+                                }
+                                }
+                                break;
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 8892;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 981, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 8894;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public level_clause(): Level_clauseContext {
+        let localContext = new Level_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 832, PlSqlParser.RULE_level_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8897;
+            this.match(PlSqlParser.LEVEL);
+            this.state = 8898;
+            this.identifier();
+            this.state = 8899;
+            this.match(PlSqlParser.IS);
+            this.state = 8920;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 8900;
+                this.table_name();
+                this.state = 8901;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 8902;
+                this.column_name();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 8904;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 8905;
+                this.table_name();
+                this.state = 8906;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 8907;
+                this.column_name();
+                this.state = 8915;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 8908;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8909;
+                    this.table_name();
+                    this.state = 8910;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 8911;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 8917;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 8918;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 8925;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 985, this.context) ) {
+            case 1:
+                {
+                this.state = 8922;
+                this.match(PlSqlParser.SKIP_);
+                this.state = 8923;
+                this.match(PlSqlParser.WHEN);
+                this.state = 8924;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hierarchy_clause(): Hierarchy_clauseContext {
+        let localContext = new Hierarchy_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 834, PlSqlParser.RULE_hierarchy_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8927;
+            this.match(PlSqlParser.HIERARCHY);
+            this.state = 8928;
+            this.identifier();
+            this.state = 8929;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 8930;
+            this.identifier();
+            this.state = 8934;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 8931;
+                this.match(PlSqlParser.CHILD);
+                this.state = 8932;
+                this.match(PlSqlParser.OF);
+                this.state = 8933;
+                this.identifier();
+                }
+                }
+                this.state = 8936;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 202);
+            this.state = 8939;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 795) {
+                {
+                this.state = 8938;
+                this.dimension_join_clause();
+                }
+            }
+
+            this.state = 8941;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dimension_join_clause(): Dimension_join_clauseContext {
+        let localContext = new Dimension_join_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 836, PlSqlParser.RULE_dimension_join_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8949;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 8943;
+                this.match(PlSqlParser.JOIN);
+                this.state = 8944;
+                this.match(PlSqlParser.KEY);
+                this.state = 8945;
+                this.column_one_or_more_sub_clause();
+                this.state = 8946;
+                this.match(PlSqlParser.REFERENCES);
+                this.state = 8947;
+                this.identifier();
+                }
+                }
+                this.state = 8951;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 795);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public attribute_clause(): Attribute_clauseContext {
+        let localContext = new Attribute_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 838, PlSqlParser.RULE_attribute_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8958;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 8953;
+                    this.match(PlSqlParser.ATTRIBUTE);
+                    this.state = 8954;
+                    this.identifier();
+                    this.state = 8955;
+                    this.match(PlSqlParser.DETERMINES);
+                    this.state = 8956;
+                    this.column_one_or_more_sub_clause();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 8960;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 989, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public extended_attribute_clause(): Extended_attribute_clauseContext {
+        let localContext = new Extended_attribute_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 840, PlSqlParser.RULE_extended_attribute_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8962;
+            this.match(PlSqlParser.ATTRIBUTE);
+            this.state = 8963;
+            this.identifier();
+            this.state = 8969;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 8964;
+                    this.match(PlSqlParser.LEVEL);
+                    this.state = 8965;
+                    this.identifier();
+                    this.state = 8966;
+                    this.match(PlSqlParser.DETERMINES);
+                    this.state = 8967;
+                    this.column_one_or_more_sub_clause();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 8971;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 990, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_one_or_more_sub_clause(): Column_one_or_more_sub_clauseContext {
+        let localContext = new Column_one_or_more_sub_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 842, PlSqlParser.RULE_column_one_or_more_sub_clause);
+        let _la: number;
+        try {
+            this.state = 8985;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 8973;
+                this.column_name();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 8974;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 8975;
+                this.column_name();
+                this.state = 8980;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 8976;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 8977;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 8982;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 8983;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_view(): Alter_viewContext {
+        let localContext = new Alter_viewContext(this.context, this.state);
+        this.enterRule(localContext, 844, PlSqlParser.RULE_alter_view);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 8987;
+            this.match(PlSqlParser.ALTER);
+            this.state = 8988;
+            this.match(PlSqlParser.VIEW);
+            this.state = 8989;
+            this.tableview_name();
+            this.state = 9022;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 996, this.context) ) {
+            case 1:
+                {
+                this.state = 8990;
+                this.match(PlSqlParser.ADD);
+                this.state = 8991;
+                this.out_of_line_constraint();
+                }
+                break;
+            case 2:
+                {
+                this.state = 8992;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 8993;
+                this.match(PlSqlParser.CONSTRAINT);
+                this.state = 8994;
+                this.constraint_name();
+                this.state = 8995;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1172 || _la === 1556)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 8997;
+                this.match(PlSqlParser.DROP);
+                this.state = 9014;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CONSTRAINT:
+                    {
+                    this.state = 8998;
+                    this.match(PlSqlParser.CONSTRAINT);
+                    this.state = 8999;
+                    this.constraint_name();
+                    }
+                    break;
+                case PlSqlParser.PRIMARY:
+                    {
+                    this.state = 9000;
+                    this.match(PlSqlParser.PRIMARY);
+                    this.state = 9001;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                case PlSqlParser.UNIQUE:
+                    {
+                    this.state = 9002;
+                    this.match(PlSqlParser.UNIQUE);
+                    this.state = 9003;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 9004;
+                    this.column_name();
+                    this.state = 9009;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 9005;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9006;
+                        this.column_name();
+                        }
+                        }
+                        this.state = 9011;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 9012;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 4:
+                {
+                this.state = 9016;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            case 5:
+                {
+                this.state = 9017;
+                this.match(PlSqlParser.READ);
+                this.state = 9018;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1260 || _la === 2315)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 6:
+                {
+                this.state = 9020;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 995, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9019;
+                    this.alter_view_editionable();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_view_editionable(): Alter_view_editionableContext {
+        let localContext = new Alter_view_editionableContext(this.context, this.state);
+        this.enterRule(localContext, 846, PlSqlParser.RULE_alter_view_editionable);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9024;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            this.state = 9025;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 482 || _la === 1133)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_view(): Create_viewContext {
+        let localContext = new Create_viewContext(this.context, this.state);
+        this.enterRule(localContext, 848, PlSqlParser.RULE_create_view);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9027;
+            this.match(PlSqlParser.CREATE);
+            this.state = 9030;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 9028;
+                this.match(PlSqlParser.OR);
+                this.state = 9029;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 9036;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617 || _la === 1139) {
+                {
+                this.state = 9033;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 9032;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 9035;
+                this.match(PlSqlParser.FORCE);
+                }
+            }
+
+            this.state = 9039;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 482 || _la === 484 || _la === 1133) {
+                {
+                this.state = 9038;
+                this.editioning_clause();
+                }
+            }
+
+            this.state = 9041;
+            this.match(PlSqlParser.VIEW);
+            this.state = 9045;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1001, this.context) ) {
+            case 1:
+                {
+                this.state = 9042;
+                this.schema_name();
+                this.state = 9043;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 9047;
+            localContext._v = this.id_expression();
+            this.state = 9051;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 692) {
+                {
+                this.state = 9048;
+                this.match(PlSqlParser.IF);
+                this.state = 9049;
+                this.match(PlSqlParser.NOT);
+                this.state = 9050;
+                this.match(PlSqlParser.EXISTS);
+                }
+            }
+
+            this.state = 9063;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1683) {
+                {
+                this.state = 9053;
+                this.match(PlSqlParser.SHARING);
+                this.state = 9054;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 9061;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.METADATA:
+                    {
+                    this.state = 9055;
+                    this.match(PlSqlParser.METADATA);
+                    }
+                    break;
+                case PlSqlParser.DATA:
+                case PlSqlParser.EXTENDED:
+                    {
+                    this.state = 9057;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2378) {
+                        {
+                        this.state = 9056;
+                        this.match(PlSqlParser.EXTENDED);
+                        }
+                    }
+
+                    this.state = 9059;
+                    this.match(PlSqlParser.DATA);
+                    }
+                    break;
+                case PlSqlParser.NONE:
+                    {
+                    this.state = 9060;
+                    this.match(PlSqlParser.NONE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+            }
+
+            this.state = 9066;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1248 || _la === 2449) {
+                {
+                this.state = 9065;
+                this.view_options();
+                }
+            }
+
+            this.state = 9071;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389) {
+                {
+                this.state = 9068;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 9069;
+                this.match(PlSqlParser.COLLATION);
+                this.state = 9070;
+                localContext._cn = this.id_expression();
+                }
+            }
+
+            this.state = 9075;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 117) {
+                {
+                this.state = 9073;
+                this.match(PlSqlParser.BEQUEATH);
+                this.state = 9074;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 341 || _la === 398)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 9077;
+            this.match(PlSqlParser.AS);
+            this.state = 9078;
+            this.select_only_statement();
+            this.state = 9080;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1009, this.context) ) {
+            case 1:
+                {
+                this.state = 9079;
+                this.subquery_restriction_clause();
+                }
+                break;
+            }
+            this.state = 9083;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1010, this.context) ) {
+            case 1:
+                {
+                this.state = 9082;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 291 || _la === 293)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public editioning_clause(): Editioning_clauseContext {
+        let localContext = new Editioning_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 850, PlSqlParser.RULE_editioning_clause);
+        let _la: number;
+        try {
+            this.state = 9091;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.EDITIONING:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9085;
+                this.match(PlSqlParser.EDITIONING);
+                }
+                break;
+            case PlSqlParser.EDITIONABLE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9086;
+                this.match(PlSqlParser.EDITIONABLE);
+                this.state = 9088;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 484) {
+                    {
+                    this.state = 9087;
+                    this.match(PlSqlParser.EDITIONING);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.NONEDITIONABLE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9090;
+                this.match(PlSqlParser.NONEDITIONABLE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public view_options(): View_optionsContext {
+        let localContext = new View_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 852, PlSqlParser.RULE_view_options);
+        try {
+            this.state = 9096;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1013, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9093;
+                this.view_alias_constraint();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9094;
+                this.object_view_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9095;
+                this.xmltype_view_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public view_alias_constraint(): View_alias_constraintContext {
+        let localContext = new View_alias_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 854, PlSqlParser.RULE_view_alias_constraint);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9098;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 9112;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 9100;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 9099;
+                    this.match(PlSqlParser.COMMA);
+                    }
+                }
+
+                this.state = 9110;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1016, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9102;
+                    this.table_alias();
+                    this.state = 9106;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1015, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 9103;
+                            this.inline_constraint();
+                            }
+                            }
+                        }
+                        this.state = 9108;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1015, this.context);
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 9109;
+                    this.out_of_line_constraint();
+                    }
+                    break;
+                }
+                }
+                }
+                this.state = 9114;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967293) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 4093640703) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || ((((_la - 2455)) & ~0x1F) === 0 && ((1 << (_la - 2455)) & 138412033) !== 0));
+            this.state = 9116;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_view_clause(): Object_view_clauseContext {
+        let localContext = new Object_view_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 856, PlSqlParser.RULE_object_view_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9118;
+            this.match(PlSqlParser.OF);
+            this.state = 9122;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1018, this.context) ) {
+            case 1:
+                {
+                this.state = 9119;
+                this.schema_name();
+                this.state = 9120;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 9124;
+            localContext._tn = this.id_expression();
+            this.state = 9148;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.WITH:
+                {
+                this.state = 9125;
+                this.match(PlSqlParser.WITH);
+                this.state = 9126;
+                this.match(PlSqlParser.OBJECT);
+                this.state = 9127;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 687 || _la === 690)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 9139;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DEFAULT:
+                    {
+                    this.state = 9128;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 9129;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 9130;
+                    this.match(PlSqlParser.REGULAR_ID);
+                    this.state = 9135;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 9131;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9132;
+                        this.match(PlSqlParser.REGULAR_ID);
+                        }
+                        }
+                        this.state = 9137;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 9138;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.UNDER:
+                {
+                this.state = 9141;
+                this.match(PlSqlParser.UNDER);
+                this.state = 9145;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1021, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9142;
+                    this.schema_name();
+                    this.state = 9143;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 9147;
+                localContext._sv = this.id_expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 9167;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2449) {
+                {
+                {
+                this.state = 9150;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9159;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 9152;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 9151;
+                        this.match(PlSqlParser.COMMA);
+                        }
+                    }
+
+                    this.state = 9157;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.CHECK:
+                    case PlSqlParser.CONSTRAINT:
+                    case PlSqlParser.CONSTRAINTS:
+                    case PlSqlParser.FOREIGN:
+                    case PlSqlParser.PRIMARY:
+                    case PlSqlParser.UNIQUE:
+                        {
+                        this.state = 9154;
+                        this.out_of_line_constraint();
+                        }
+                        break;
+                    case PlSqlParser.REGULAR_ID:
+                        {
+                        this.state = 9155;
+                        this.match(PlSqlParser.REGULAR_ID);
+                        this.state = 9156;
+                        this.inline_constraint();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    }
+                    this.state = 9161;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 200 || _la === 286 || _la === 287 || _la === 619 || _la === 1453 || _la === 2185 || _la === 2455 || _la === 2482);
+                this.state = 9163;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                }
+                this.state = 9169;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inline_constraint(): Inline_constraintContext {
+        let localContext = new Inline_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 858, PlSqlParser.RULE_inline_constraint);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9172;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 286) {
+                {
+                this.state = 9170;
+                this.match(PlSqlParser.CONSTRAINT);
+                this.state = 9171;
+                this.constraint_name();
+                }
+            }
+
+            this.state = 9183;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOT:
+            case PlSqlParser.NULL_:
+                {
+                this.state = 9175;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 9174;
+                    this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 9177;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.UNIQUE:
+                {
+                this.state = 9178;
+                this.match(PlSqlParser.UNIQUE);
+                }
+                break;
+            case PlSqlParser.PRIMARY:
+                {
+                this.state = 9179;
+                this.match(PlSqlParser.PRIMARY);
+                this.state = 9180;
+                this.match(PlSqlParser.KEY);
+                }
+                break;
+            case PlSqlParser.REFERENCES:
+                {
+                this.state = 9181;
+                this.references_clause();
+                }
+                break;
+            case PlSqlParser.CHECK:
+                {
+                this.state = 9182;
+                this.check_constraint();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 9186;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1030, this.context) ) {
+            case 1:
+                {
+                this.state = 9185;
+                this.constraint_state();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inline_ref_constraint(): Inline_ref_constraintContext {
+        let localContext = new Inline_ref_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 860, PlSqlParser.RULE_inline_ref_constraint);
+        let _la: number;
+        try {
+            this.state = 9201;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SCOPE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9188;
+                this.match(PlSqlParser.SCOPE);
+                this.state = 9189;
+                this.match(PlSqlParser.IS);
+                this.state = 9190;
+                this.tableview_name();
+                }
+                break;
+            case PlSqlParser.WITH:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9191;
+                this.match(PlSqlParser.WITH);
+                this.state = 9192;
+                this.match(PlSqlParser.ROWID);
+                }
+                break;
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.REFERENCES:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9195;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 286) {
+                    {
+                    this.state = 9193;
+                    this.match(PlSqlParser.CONSTRAINT);
+                    this.state = 9194;
+                    this.constraint_name();
+                    }
+                }
+
+                this.state = 9197;
+                this.references_clause();
+                this.state = 9199;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1032, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9198;
+                    this.constraint_state();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public out_of_line_ref_constraint(): Out_of_line_ref_constraintContext {
+        let localContext = new Out_of_line_ref_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 862, PlSqlParser.RULE_out_of_line_ref_constraint);
+        let _la: number;
+        try {
+            this.state = 9238;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SCOPE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9203;
+                this.match(PlSqlParser.SCOPE);
+                this.state = 9204;
+                this.match(PlSqlParser.FOR);
+                this.state = 9205;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9206;
+                localContext._ref_col_or_attr = this.regular_id();
+                this.state = 9207;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 9208;
+                this.match(PlSqlParser.IS);
+                this.state = 9209;
+                this.tableview_name();
+                }
+                break;
+            case PlSqlParser.REF:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9211;
+                this.match(PlSqlParser.REF);
+                this.state = 9212;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9213;
+                localContext._ref_col_or_attr = this.regular_id();
+                this.state = 9214;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 9215;
+                this.match(PlSqlParser.WITH);
+                this.state = 9216;
+                this.match(PlSqlParser.ROWID);
+                }
+                break;
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.FOREIGN:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9220;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 286) {
+                    {
+                    this.state = 9218;
+                    this.match(PlSqlParser.CONSTRAINT);
+                    this.state = 9219;
+                    this.constraint_name();
+                    }
+                }
+
+                this.state = 9222;
+                this.match(PlSqlParser.FOREIGN);
+                this.state = 9223;
+                this.match(PlSqlParser.KEY);
+                this.state = 9224;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9229;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 9226;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 9225;
+                        this.match(PlSqlParser.COMMA);
+                        }
+                    }
+
+                    this.state = 9228;
+                    localContext._ref_col_or_attr = this.regular_id();
+                    }
+                    }
+                    this.state = 9231;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 142606335) !== 0) || _la === 2455 || _la === 2482);
+                this.state = 9233;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 9234;
+                this.references_clause();
+                this.state = 9236;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1037, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9235;
+                    this.constraint_state();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext {
+        let localContext = new Out_of_line_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 864, PlSqlParser.RULE_out_of_line_constraint);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            {
+            this.state = 9242;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 286 || _la === 287) {
+                {
+                this.state = 9240;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 286 || _la === 287)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 9241;
+                this.constraint_name();
+                }
+            }
+
+            this.state = 9275;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNIQUE:
+                {
+                this.state = 9244;
+                this.match(PlSqlParser.UNIQUE);
+                this.state = 9245;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9246;
+                this.column_name();
+                this.state = 9251;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 9247;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 9248;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 9253;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 9254;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.PRIMARY:
+                {
+                this.state = 9256;
+                this.match(PlSqlParser.PRIMARY);
+                this.state = 9257;
+                this.match(PlSqlParser.KEY);
+                this.state = 9258;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9259;
+                this.column_name();
+                this.state = 9264;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 9260;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 9261;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 9266;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 9267;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.FOREIGN:
+                {
+                this.state = 9269;
+                this.foreign_key_clause();
+                }
+                break;
+            case PlSqlParser.CHECK:
+                {
+                this.state = 9270;
+                this.match(PlSqlParser.CHECK);
+                this.state = 9271;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9272;
+                this.condition();
+                this.state = 9273;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+            this.state = 9278;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1043, this.context) ) {
+            case 1:
+                {
+                this.state = 9277;
+                this.constraint_state();
+                }
+                break;
+            }
+            this.state = 9281;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1044, this.context) ) {
+            case 1:
+                {
+                this.state = 9280;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public constraint_state(): Constraint_stateContext {
+        let localContext = new Constraint_stateContext(this.context, this.state);
+        this.enterRule(localContext, 866, PlSqlParser.RULE_constraint_state);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9293;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 9293;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.DEFERRABLE:
+                    case PlSqlParser.NOT:
+                        {
+                        this.state = 9284;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 1206) {
+                            {
+                            this.state = 9283;
+                            this.match(PlSqlParser.NOT);
+                            }
+                        }
+
+                        this.state = 9286;
+                        this.match(PlSqlParser.DEFERRABLE);
+                        }
+                        break;
+                    case PlSqlParser.INITIALLY:
+                        {
+                        this.state = 9287;
+                        this.match(PlSqlParser.INITIALLY);
+                        this.state = 9288;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 395 || _la === 699)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.NORELY:
+                    case PlSqlParser.RELY:
+                        {
+                        this.state = 9289;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 1172 || _la === 1556)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.DISABLE:
+                    case PlSqlParser.ENABLE:
+                        {
+                        this.state = 9290;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 429 || _la === 499)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.NOVALIDATE:
+                    case PlSqlParser.VALIDATE:
+                        {
+                        this.state = 9291;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 1217 || _la === 2255)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.USING:
+                        {
+                        this.state = 9292;
+                        this.using_index_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 9295;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1047, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmltype_view_clause(): Xmltype_view_clauseContext {
+        let localContext = new Xmltype_view_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 868, PlSqlParser.RULE_xmltype_view_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9297;
+            this.match(PlSqlParser.OF);
+            this.state = 9298;
+            this.match(PlSqlParser.XMLTYPE);
+            this.state = 9300;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 486 || _la === 2347) {
+                {
+                this.state = 9299;
+                this.xml_schema_spec();
+                }
+            }
+
+            this.state = 9302;
+            this.match(PlSqlParser.WITH);
+            this.state = 9303;
+            this.match(PlSqlParser.OBJECT);
+            this.state = 9304;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 687 || _la === 690)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 9317;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DEFAULT:
+                {
+                this.state = 9305;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 9306;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9307;
+                this.expression();
+                this.state = 9312;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 9308;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 9309;
+                    this.expression();
+                    }
+                    }
+                    this.state = 9314;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 9315;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_schema_spec(): Xml_schema_specContext {
+        let localContext = new Xml_schema_specContext(this.context, this.state);
+        this.enterRule(localContext, 870, PlSqlParser.RULE_xml_schema_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9321;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2347) {
+                {
+                this.state = 9319;
+                this.match(PlSqlParser.XMLSCHEMA);
+                this.state = 9320;
+                this.xml_schema_url();
+                }
+            }
+
+            this.state = 9323;
+            this.match(PlSqlParser.ELEMENT);
+            this.state = 9329;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1052, this.context) ) {
+            case 1:
+                {
+                this.state = 9324;
+                this.element();
+                }
+                break;
+            case 2:
+                {
+                this.state = 9325;
+                this.xml_schema_url();
+                this.state = 9326;
+                this.match(PlSqlParser.HASH_OP);
+                this.state = 9327;
+                this.element();
+                }
+                break;
+            }
+            this.state = 9336;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1765) {
+                {
+                this.state = 9331;
+                this.match(PlSqlParser.STORE);
+                this.state = 9332;
+                this.match(PlSqlParser.ALL);
+                this.state = 9333;
+                this.match(PlSqlParser.VARRAYS);
+                this.state = 9334;
+                this.match(PlSqlParser.AS);
+                this.state = 9335;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 872 || _la === 2083)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 9341;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1054, this.context) ) {
+            case 1:
+                {
+                this.state = 9338;
+                this.allow_or_disallow();
+                this.state = 9339;
+                this.match(PlSqlParser.NONSCHEMA);
+                }
+                break;
+            }
+            this.state = 9346;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 40 || _la === 435) {
+                {
+                this.state = 9343;
+                this.allow_or_disallow();
+                this.state = 9344;
+                this.match(PlSqlParser.ANYSCHEMA);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_schema_url(): Xml_schema_urlContext {
+        let localContext = new Xml_schema_urlContext(this.context, this.state);
+        this.enterRule(localContext, 872, PlSqlParser.RULE_xml_schema_url);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9348;
+            this.match(PlSqlParser.DELIMITED_ID);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public element(): ElementContext {
+        let localContext = new ElementContext(this.context, this.state);
+        this.enterRule(localContext, 874, PlSqlParser.RULE_element);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9350;
+            this.match(PlSqlParser.DELIMITED_ID);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_tablespace(): Alter_tablespaceContext {
+        let localContext = new Alter_tablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 876, PlSqlParser.RULE_alter_tablespace);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9352;
+            this.match(PlSqlParser.ALTER);
+            this.state = 9353;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 9354;
+            this.tablespace();
+            this.state = 9387;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1059, this.context) ) {
+            case 1:
+                {
+                this.state = 9355;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 9357;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1056, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9356;
+                    this.table_compression();
+                    }
+                    break;
+                }
+                this.state = 9360;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1057, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9359;
+                    this.storage_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 9362;
+                this.match(PlSqlParser.MINIMUM);
+                this.state = 9363;
+                this.match(PlSqlParser.EXTENT);
+                this.state = 9364;
+                this.size_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 9365;
+                this.match(PlSqlParser.RESIZE);
+                this.state = 9366;
+                this.size_clause();
+                }
+                break;
+            case 4:
+                {
+                this.state = 9367;
+                this.match(PlSqlParser.COALESCE);
+                }
+                break;
+            case 5:
+                {
+                this.state = 9368;
+                this.match(PlSqlParser.SHRINK);
+                this.state = 9369;
+                this.match(PlSqlParser.SPACE_KEYWORD);
+                this.state = 9372;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1058, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9370;
+                    this.match(PlSqlParser.KEEP);
+                    this.state = 9371;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 6:
+                {
+                this.state = 9374;
+                this.match(PlSqlParser.RENAME);
+                this.state = 9375;
+                this.match(PlSqlParser.TO);
+                this.state = 9376;
+                this.new_tablespace_name();
+                }
+                break;
+            case 7:
+                {
+                this.state = 9377;
+                this.begin_or_end();
+                this.state = 9378;
+                this.match(PlSqlParser.BACKUP);
+                }
+                break;
+            case 8:
+                {
+                this.state = 9380;
+                this.datafile_tempfile_clauses();
+                }
+                break;
+            case 9:
+                {
+                this.state = 9381;
+                this.tablespace_logging_clauses();
+                }
+                break;
+            case 10:
+                {
+                this.state = 9382;
+                this.tablespace_group_clause();
+                }
+                break;
+            case 11:
+                {
+                this.state = 9383;
+                this.tablespace_state_clauses();
+                }
+                break;
+            case 12:
+                {
+                this.state = 9384;
+                this.autoextend_clause();
+                }
+                break;
+            case 13:
+                {
+                this.state = 9385;
+                this.flashback_mode_clause();
+                }
+                break;
+            case 14:
+                {
+                this.state = 9386;
+                this.tablespace_retention_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public datafile_tempfile_clauses(): Datafile_tempfile_clausesContext {
+        let localContext = new Datafile_tempfile_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 878, PlSqlParser.RULE_datafile_tempfile_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 9435;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9389;
+                this.match(PlSqlParser.ADD);
+                this.state = 9392;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DATAFILE:
+                    {
+                    this.state = 9390;
+                    this.datafile_specification();
+                    }
+                    break;
+                case PlSqlParser.TEMPFILE:
+                    {
+                    this.state = 9391;
+                    this.tempfile_specification();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9394;
+                this.match(PlSqlParser.DROP);
+                this.state = 9395;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 352 || _la === 2091)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 9398;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 9396;
+                    this.filename();
+                    }
+                    break;
+                case PlSqlParser.UNSIGNED_INTEGER:
+                    {
+                    this.state = 9397;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 9402;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1062, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9400;
+                    this.match(PlSqlParser.KEEP);
+                    this.state = 9401;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.SHRINK:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9404;
+                this.match(PlSqlParser.SHRINK);
+                this.state = 9405;
+                this.match(PlSqlParser.TEMPFILE);
+                this.state = 9408;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 9406;
+                    this.filename();
+                    }
+                    break;
+                case PlSqlParser.UNSIGNED_INTEGER:
+                    {
+                    this.state = 9407;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 9412;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1064, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9410;
+                    this.match(PlSqlParser.KEEP);
+                    this.state = 9411;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 9414;
+                this.match(PlSqlParser.RENAME);
+                this.state = 9415;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 9416;
+                this.filename();
+                this.state = 9421;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 9417;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 9418;
+                    this.filename();
+                    }
+                    }
+                    this.state = 9423;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 9424;
+                this.match(PlSqlParser.TO);
+                this.state = 9425;
+                this.filename();
+                this.state = 9430;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1066, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 9426;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9427;
+                        this.filename();
+                        }
+                        }
+                    }
+                    this.state = 9432;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1066, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.TEMPFILE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 9433;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 352 || _la === 2091)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                {
+                this.state = 9434;
+                this.online_or_offline();
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_logging_clauses(): Tablespace_logging_clausesContext {
+        let localContext = new Tablespace_logging_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 880, PlSqlParser.RULE_tablespace_logging_clauses);
+        let _la: number;
+        try {
+            this.state = 9443;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.NOLOGGING:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9437;
+                this.logging_clause();
+                }
+                break;
+            case PlSqlParser.FORCE:
+            case PlSqlParser.NO:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9439;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 9438;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 9441;
+                this.match(PlSqlParser.FORCE);
+                this.state = 9442;
+                this.match(PlSqlParser.LOGGING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_group_clause(): Tablespace_group_clauseContext {
+        let localContext = new Tablespace_group_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 882, PlSqlParser.RULE_tablespace_group_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9445;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 9446;
+            this.match(PlSqlParser.GROUP);
+            this.state = 9449;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 9447;
+                this.tablespace_group_name();
+                }
+                break;
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 9448;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_group_name(): Tablespace_group_nameContext {
+        let localContext = new Tablespace_group_nameContext(this.context, this.state);
+        this.enterRule(localContext, 884, PlSqlParser.RULE_tablespace_group_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9451;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_state_clauses(): Tablespace_state_clausesContext {
+        let localContext = new Tablespace_state_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 886, PlSqlParser.RULE_tablespace_state_clauses);
+        let _la: number;
+        try {
+            this.state = 9462;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ONLINE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9453;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            case PlSqlParser.OFFLINE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9454;
+                this.match(PlSqlParser.OFFLINE);
+                this.state = 9456;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1071, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9455;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 699 || _la === 1180 || _la === 2094)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.READ:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9458;
+                this.match(PlSqlParser.READ);
+                this.state = 9459;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1260 || _la === 2315)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.PERMANENT:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 9460;
+                this.match(PlSqlParser.PERMANENT);
+                }
+                break;
+            case PlSqlParser.TEMPORARY:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 9461;
+                this.match(PlSqlParser.TEMPORARY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public flashback_mode_clause(): Flashback_mode_clauseContext {
+        let localContext = new Flashback_mode_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 888, PlSqlParser.RULE_flashback_mode_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9464;
+            this.match(PlSqlParser.FLASHBACK);
+            this.state = 9465;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1246 || _la === 1261)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public new_tablespace_name(): New_tablespace_nameContext {
+        let localContext = new New_tablespace_nameContext(this.context, this.state);
+        this.enterRule(localContext, 890, PlSqlParser.RULE_new_tablespace_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9467;
+            this.tablespace();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_tablespace(): Create_tablespaceContext {
+        let localContext = new Create_tablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 892, PlSqlParser.RULE_create_tablespace);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9469;
+            this.match(PlSqlParser.CREATE);
+            this.state = 9471;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 122 || _la === 1707) {
+                {
+                this.state = 9470;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 122 || _la === 1707)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 9476;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TABLESPACE:
+                {
+                this.state = 9473;
+                this.permanent_tablespace_clause();
+                }
+                break;
+            case PlSqlParser.TEMPORARY:
+                {
+                this.state = 9474;
+                this.temporary_tablespace_clause();
+                }
+                break;
+            case PlSqlParser.UNDO:
+                {
+                this.state = 9475;
+                this.undo_tablespace_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public permanent_tablespace_clause(): Permanent_tablespace_clauseContext {
+        let localContext = new Permanent_tablespace_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 894, PlSqlParser.RULE_permanent_tablespace_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9478;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 9479;
+            this.id_expression();
+            this.state = 9483;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1075, this.context) ) {
+            case 1:
+                {
+                this.state = 9480;
+                this.match(PlSqlParser.IF);
+                this.state = 9481;
+                this.match(PlSqlParser.NOT);
+                this.state = 9482;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 9486;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1076, this.context) ) {
+            case 1:
+                {
+                this.state = 9485;
+                this.datafile_specification();
+                }
+                break;
+            }
+            this.state = 9505;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1078, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 9503;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.MINIMUM:
+                        {
+                        this.state = 9488;
+                        this.match(PlSqlParser.MINIMUM);
+                        this.state = 9489;
+                        this.match(PlSqlParser.EXTENT);
+                        this.state = 9490;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.BLOCKSIZE:
+                        {
+                        this.state = 9491;
+                        this.match(PlSqlParser.BLOCKSIZE);
+                        this.state = 9492;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.NOLOGGING:
+                        {
+                        this.state = 9493;
+                        this.logging_clause();
+                        }
+                        break;
+                    case PlSqlParser.FORCE:
+                        {
+                        this.state = 9494;
+                        this.match(PlSqlParser.FORCE);
+                        this.state = 9495;
+                        this.match(PlSqlParser.LOGGING);
+                        }
+                        break;
+                    case PlSqlParser.OFFLINE:
+                    case PlSqlParser.ONLINE:
+                        {
+                        this.state = 9496;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 1245 || _la === 1258)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.ENCRYPTION:
+                        {
+                        this.state = 9497;
+                        this.match(PlSqlParser.ENCRYPTION);
+                        this.state = 9498;
+                        this.tablespace_encryption_spec();
+                        }
+                        break;
+                    case PlSqlParser.DEFAULT:
+                        {
+                        this.state = 9499;
+                        this.match(PlSqlParser.DEFAULT);
+                        }
+                        break;
+                    case PlSqlParser.EXTENT:
+                        {
+                        this.state = 9500;
+                        this.extent_management_clause();
+                        }
+                        break;
+                    case PlSqlParser.SEGMENT:
+                        {
+                        this.state = 9501;
+                        this.segment_management_clause();
+                        }
+                        break;
+                    case PlSqlParser.FLASHBACK:
+                        {
+                        this.state = 9502;
+                        this.flashback_mode_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 9507;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1078, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_encryption_spec(): Tablespace_encryption_specContext {
+        let localContext = new Tablespace_encryption_specContext(this.context, this.state);
+        this.enterRule(localContext, 896, PlSqlParser.RULE_tablespace_encryption_spec);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9508;
+            this.match(PlSqlParser.USING);
+            this.state = 9509;
+            localContext._encrypt_algorithm = this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public logging_clause(): Logging_clauseContext {
+        let localContext = new Logging_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 898, PlSqlParser.RULE_logging_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9511;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 594 || _la === 885 || _la === 1120)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public extent_management_clause(): Extent_management_clauseContext {
+        let localContext = new Extent_management_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 900, PlSqlParser.RULE_extent_management_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9513;
+            this.match(PlSqlParser.EXTENT);
+            this.state = 9514;
+            this.match(PlSqlParser.MANAGEMENT);
+            this.state = 9515;
+            this.match(PlSqlParser.LOCAL);
+            this.state = 9522;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1080, this.context) ) {
+            case 1:
+                {
+                this.state = 9516;
+                this.match(PlSqlParser.AUTOALLOCATE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 9517;
+                this.match(PlSqlParser.UNIFORM);
+                this.state = 9520;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1079, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9518;
+                    this.match(PlSqlParser.SIZE);
+                    this.state = 9519;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public segment_management_clause(): Segment_management_clauseContext {
+        let localContext = new Segment_management_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 902, PlSqlParser.RULE_segment_management_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9524;
+            this.match(PlSqlParser.SEGMENT);
+            this.state = 9525;
+            this.match(PlSqlParser.SPACE_KEYWORD);
+            this.state = 9526;
+            this.match(PlSqlParser.MANAGEMENT);
+            this.state = 9527;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 91 || _la === 910)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public temporary_tablespace_clause(): Temporary_tablespace_clauseContext {
+        let localContext = new Temporary_tablespace_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 904, PlSqlParser.RULE_temporary_tablespace_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9529;
+            this.match(PlSqlParser.TEMPORARY);
+            this.state = 9530;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 9531;
+            localContext._tablespace_name = this.id_expression();
+            this.state = 9535;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1081, this.context) ) {
+            case 1:
+                {
+                this.state = 9532;
+                this.match(PlSqlParser.IF);
+                this.state = 9533;
+                this.match(PlSqlParser.NOT);
+                this.state = 9534;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 9538;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1082, this.context) ) {
+            case 1:
+                {
+                this.state = 9537;
+                this.tempfile_specification();
+                }
+                break;
+            }
+            this.state = 9541;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1083, this.context) ) {
+            case 1:
+                {
+                this.state = 9540;
+                this.tablespace_group_clause();
+                }
+                break;
+            }
+            this.state = 9544;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1084, this.context) ) {
+            case 1:
+                {
+                this.state = 9543;
+                this.extent_management_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public undo_tablespace_clause(): Undo_tablespace_clauseContext {
+        let localContext = new Undo_tablespace_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 906, PlSqlParser.RULE_undo_tablespace_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9546;
+            this.match(PlSqlParser.UNDO);
+            this.state = 9547;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 9548;
+            localContext._tablespace_name = this.id_expression();
+            this.state = 9552;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1085, this.context) ) {
+            case 1:
+                {
+                this.state = 9549;
+                this.match(PlSqlParser.IF);
+                this.state = 9550;
+                this.match(PlSqlParser.NOT);
+                this.state = 9551;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 9555;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1086, this.context) ) {
+            case 1:
+                {
+                this.state = 9554;
+                this.datafile_specification();
+                }
+                break;
+            }
+            this.state = 9558;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1087, this.context) ) {
+            case 1:
+                {
+                this.state = 9557;
+                this.extent_management_clause();
+                }
+                break;
+            }
+            this.state = 9561;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1088, this.context) ) {
+            case 1:
+                {
+                this.state = 9560;
+                this.tablespace_retention_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_retention_clause(): Tablespace_retention_clauseContext {
+        let localContext = new Tablespace_retention_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 908, PlSqlParser.RULE_tablespace_retention_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9563;
+            this.match(PlSqlParser.RETENTION);
+            this.state = 9564;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 656 || _la === 1109)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_tablespace_set(): Create_tablespace_setContext {
+        let localContext = new Create_tablespace_setContext(this.context, this.state);
+        this.enterRule(localContext, 910, PlSqlParser.RULE_create_tablespace_set);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9566;
+            this.match(PlSqlParser.CREATE);
+            this.state = 9567;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 9568;
+            this.match(PlSqlParser.SET);
+            this.state = 9569;
+            localContext._tss = this.id_expression();
+            this.state = 9573;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1089, this.context) ) {
+            case 1:
+                {
+                this.state = 9570;
+                this.match(PlSqlParser.IN);
+                this.state = 9571;
+                this.match(PlSqlParser.SHARDSPACE);
+                this.state = 9572;
+                localContext._ss = this.id_expression();
+                }
+                break;
+            }
+            this.state = 9596;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1093, this.context) ) {
+            case 1:
+                {
+                this.state = 9575;
+                this.match(PlSqlParser.USING);
+                this.state = 9576;
+                this.match(PlSqlParser.TEMPLATE);
+                this.state = 9577;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9587;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 352) {
+                    {
+                    this.state = 9578;
+                    this.match(PlSqlParser.DATAFILE);
+                    this.state = 9579;
+                    this.file_specification();
+                    this.state = 9584;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 9580;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9581;
+                        this.file_specification();
+                        }
+                        }
+                        this.state = 9586;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                }
+
+                this.state = 9590;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 9589;
+                    this.permanent_tablespace_attrs();
+                    }
+                    }
+                    this.state = 9592;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 146 || _la === 389 || _la === 429 || _la === 499 || _la === 506 || _la === 559 || ((((_la - 594)) & ~0x1F) === 0 && ((1 << (_la - 594)) & 8392705) !== 0) || _la === 885 || _la === 955 || _la === 1120 || _la === 1245 || _la === 1258 || _la === 1560 || _la === 1647 || _la === 1792);
+                this.state = 9594;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public permanent_tablespace_attrs(): Permanent_tablespace_attrsContext {
+        let localContext = new Permanent_tablespace_attrsContext(this.context, this.state);
+        this.enterRule(localContext, 912, PlSqlParser.RULE_permanent_tablespace_attrs);
+        let _la: number;
+        try {
+            this.state = 9617;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MINIMUM:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9598;
+                this.match(PlSqlParser.MINIMUM);
+                this.state = 9599;
+                this.match(PlSqlParser.EXTENT);
+                this.state = 9600;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.BLOCKSIZE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9601;
+                this.match(PlSqlParser.BLOCKSIZE);
+                this.state = 9602;
+                this.numeric();
+                this.state = 9604;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 813) {
+                    {
+                    this.state = 9603;
+                    this.match(PlSqlParser.K_LETTER);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.NOLOGGING:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 9606;
+                this.logging_clause();
+                }
+                break;
+            case PlSqlParser.FORCE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 9607;
+                this.match(PlSqlParser.FORCE);
+                this.state = 9608;
+                this.match(PlSqlParser.LOGGING);
+                }
+                break;
+            case PlSqlParser.ENCRYPTION:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 9609;
+                this.tablespace_encryption_clause();
+                }
+                break;
+            case PlSqlParser.DEFAULT:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 9610;
+                this.default_tablespace_params();
+                }
+                break;
+            case PlSqlParser.ONLINE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 9611;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            case PlSqlParser.OFFLINE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 9612;
+                this.match(PlSqlParser.OFFLINE);
+                }
+                break;
+            case PlSqlParser.EXTENT:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 9613;
+                this.extent_management_clause();
+                }
+                break;
+            case PlSqlParser.SEGMENT:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 9614;
+                this.segment_management_clause();
+                }
+                break;
+            case PlSqlParser.FLASHBACK:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 9615;
+                this.flashback_mode_clause();
+                }
+                break;
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.SUSPEND:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 9616;
+                this.lost_write_protection();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_encryption_clause(): Tablespace_encryption_clauseContext {
+        let localContext = new Tablespace_encryption_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 914, PlSqlParser.RULE_tablespace_encryption_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9619;
+            this.match(PlSqlParser.ENCRYPTION);
+            this.state = 9625;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.USING:
+                {
+                this.state = 9621;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2248) {
+                    {
+                    this.state = 9620;
+                    this.tablespace_encryption_spec();
+                    }
+                }
+
+                this.state = 9623;
+                this.match(PlSqlParser.ENCRYPT);
+                }
+                break;
+            case PlSqlParser.DECRYPT:
+                {
+                this.state = 9624;
+                this.match(PlSqlParser.DECRYPT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_tablespace_params(): Default_tablespace_paramsContext {
+        let localContext = new Default_tablespace_paramsContext(this.context, this.state);
+        this.enterRule(localContext, 916, PlSqlParser.RULE_default_tablespace_params);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9627;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 9629;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1098, this.context) ) {
+            case 1:
+                {
+                this.state = 9628;
+                this.default_table_compression();
+                }
+                break;
+            }
+            this.state = 9632;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1099, this.context) ) {
+            case 1:
+                {
+                this.state = 9631;
+                this.default_index_compression();
+                }
+                break;
+            }
+            this.state = 9635;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1100, this.context) ) {
+            case 1:
+                {
+                this.state = 9634;
+                this.inmmemory_clause();
+                }
+                break;
+            }
+            this.state = 9638;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1101, this.context) ) {
+            case 1:
+                {
+                this.state = 9637;
+                this.ilm_clause();
+                }
+                break;
+            }
+            this.state = 9641;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1102, this.context) ) {
+            case 1:
+                {
+                this.state = 9640;
+                this.storage_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_table_compression(): Default_table_compressionContext {
+        let localContext = new Default_table_compressionContext(this.context, this.state);
+        this.enterRule(localContext, 918, PlSqlParser.RULE_default_table_compression);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9643;
+            this.match(PlSqlParser.TABLE);
+            this.state = 9654;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPRESS:
+                {
+                this.state = 9644;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 9645;
+                this.match(PlSqlParser.FOR);
+                this.state = 9651;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.OLTP:
+                    {
+                    this.state = 9646;
+                    this.match(PlSqlParser.OLTP);
+                    }
+                    break;
+                case PlSqlParser.QUERY:
+                    {
+                    this.state = 9647;
+                    this.match(PlSqlParser.QUERY);
+                    this.state = 9648;
+                    this.low_high();
+                    }
+                    break;
+                case PlSqlParser.ARCHIVE:
+                    {
+                    this.state = 9649;
+                    this.match(PlSqlParser.ARCHIVE);
+                    this.state = 9650;
+                    this.low_high();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.NOCOMPRESS:
+                {
+                this.state = 9653;
+                this.match(PlSqlParser.NOCOMPRESS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public low_high(): Low_highContext {
+        let localContext = new Low_highContext(this.context, this.state);
+        this.enterRule(localContext, 920, PlSqlParser.RULE_low_high);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9656;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 676 || _la === 898)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_index_compression(): Default_index_compressionContext {
+        let localContext = new Default_index_compressionContext(this.context, this.state);
+        this.enterRule(localContext, 922, PlSqlParser.RULE_default_index_compression);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9658;
+            this.match(PlSqlParser.INDEX);
+            this.state = 9663;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPRESS:
+                {
+                this.state = 9659;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 9660;
+                this.match(PlSqlParser.ADVANCED);
+                this.state = 9661;
+                this.low_high();
+                }
+                break;
+            case PlSqlParser.NOCOMPRESS:
+                {
+                this.state = 9662;
+                this.match(PlSqlParser.NOCOMPRESS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmmemory_clause(): Inmmemory_clauseContext {
+        let localContext = new Inmmemory_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 924, PlSqlParser.RULE_inmmemory_clause);
+        try {
+            let alternative: number;
+            this.state = 9697;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INMEMORY:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9665;
+                this.match(PlSqlParser.INMEMORY);
+                this.state = 9667;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1106, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9666;
+                    this.inmemory_attributes();
+                    }
+                    break;
+                }
+                this.state = 9693;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1110, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9669;
+                    this.match(PlSqlParser.TEXT);
+                    this.state = 9691;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1109, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 9670;
+                        this.column_name();
+                        this.state = 9675;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1107, this.context);
+                        while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                            if (alternative === 1) {
+                                {
+                                {
+                                this.state = 9671;
+                                this.match(PlSqlParser.COMMA);
+                                this.state = 9672;
+                                this.column_name();
+                                }
+                                }
+                            }
+                            this.state = 9677;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1107, this.context);
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 9678;
+                        this.column_name();
+                        this.state = 9679;
+                        this.match(PlSqlParser.USING);
+                        this.state = 9680;
+                        this.policy_name();
+                        this.state = 9688;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1108, this.context);
+                        while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                            if (alternative === 1) {
+                                {
+                                {
+                                this.state = 9681;
+                                this.match(PlSqlParser.COMMA);
+                                this.state = 9682;
+                                this.column_name();
+                                this.state = 9683;
+                                this.match(PlSqlParser.USING);
+                                this.state = 9684;
+                                this.policy_name();
+                                }
+                                }
+                            }
+                            this.state = 9690;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1108, this.context);
+                        }
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.NO:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9695;
+                this.match(PlSqlParser.NO);
+                this.state = 9696;
+                this.match(PlSqlParser.INMEMORY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public datafile_specification(): Datafile_specificationContext {
+        let localContext = new Datafile_specificationContext(this.context, this.state);
+        this.enterRule(localContext, 926, PlSqlParser.RULE_datafile_specification);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9699;
+            this.match(PlSqlParser.DATAFILE);
+            {
+            this.state = 9701;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1112, this.context) ) {
+            case 1:
+                {
+                this.state = 9700;
+                this.match(PlSqlParser.COMMA);
+                }
+                break;
+            }
+            this.state = 9703;
+            this.datafile_tempfile_spec();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tempfile_specification(): Tempfile_specificationContext {
+        let localContext = new Tempfile_specificationContext(this.context, this.state);
+        this.enterRule(localContext, 928, PlSqlParser.RULE_tempfile_specification);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9705;
+            this.match(PlSqlParser.TEMPFILE);
+            {
+            this.state = 9707;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1113, this.context) ) {
+            case 1:
+                {
+                this.state = 9706;
+                this.match(PlSqlParser.COMMA);
+                }
+                break;
+            }
+            this.state = 9709;
+            this.datafile_tempfile_spec();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public datafile_tempfile_spec(): Datafile_tempfile_specContext {
+        let localContext = new Datafile_tempfile_specContext(this.context, this.state);
+        this.enterRule(localContext, 930, PlSqlParser.RULE_datafile_tempfile_spec);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9712;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1114, this.context) ) {
+            case 1:
+                {
+                this.state = 9711;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            this.state = 9716;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1115, this.context) ) {
+            case 1:
+                {
+                this.state = 9714;
+                this.match(PlSqlParser.SIZE);
+                this.state = 9715;
+                this.size_clause();
+                }
+                break;
+            }
+            this.state = 9719;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1116, this.context) ) {
+            case 1:
+                {
+                this.state = 9718;
+                this.match(PlSqlParser.REUSE);
+                }
+                break;
+            }
+            this.state = 9722;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1117, this.context) ) {
+            case 1:
+                {
+                this.state = 9721;
+                this.autoextend_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public redo_log_file_spec(): Redo_log_file_specContext {
+        let localContext = new Redo_log_file_specContext(this.context, this.state);
+        this.enterRule(localContext, 932, PlSqlParser.RULE_redo_log_file_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9736;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 9724;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 9725;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9726;
+                this.filename();
+                this.state = 9731;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 9727;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 9728;
+                    this.filename();
+                    }
+                    }
+                    this.state = 9733;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 9734;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 9740;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1120, this.context) ) {
+            case 1:
+                {
+                this.state = 9738;
+                this.match(PlSqlParser.SIZE);
+                this.state = 9739;
+                this.size_clause();
+                }
+                break;
+            }
+            this.state = 9744;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1121, this.context) ) {
+            case 1:
+                {
+                this.state = 9742;
+                this.match(PlSqlParser.BLOCKSIZE);
+                this.state = 9743;
+                this.size_clause();
+                }
+                break;
+            }
+            this.state = 9747;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1122, this.context) ) {
+            case 1:
+                {
+                this.state = 9746;
+                this.match(PlSqlParser.REUSE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public autoextend_clause(): Autoextend_clauseContext {
+        let localContext = new Autoextend_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 934, PlSqlParser.RULE_autoextend_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9749;
+            this.match(PlSqlParser.AUTOEXTEND);
+            this.state = 9759;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.OFF:
+                {
+                this.state = 9750;
+                this.match(PlSqlParser.OFF);
+                }
+                break;
+            case PlSqlParser.ON:
+                {
+                this.state = 9751;
+                this.match(PlSqlParser.ON);
+                this.state = 9754;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1123, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9752;
+                    this.match(PlSqlParser.NEXT);
+                    this.state = 9753;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                this.state = 9757;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1124, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9756;
+                    this.maxsize_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public maxsize_clause(): Maxsize_clauseContext {
+        let localContext = new Maxsize_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 936, PlSqlParser.RULE_maxsize_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9761;
+            this.match(PlSqlParser.MAXSIZE);
+            this.state = 9764;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNLIMITED:
+                {
+                this.state = 9762;
+                this.match(PlSqlParser.UNLIMITED);
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 9763;
+                this.size_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public build_clause(): Build_clauseContext {
+        let localContext = new Build_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 938, PlSqlParser.RULE_build_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9766;
+            this.match(PlSqlParser.BUILD);
+            this.state = 9767;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 395 || _la === 699)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parallel_clause(): Parallel_clauseContext {
+        let localContext = new Parallel_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 940, PlSqlParser.RULE_parallel_clause);
+        let _la: number;
+        try {
+            this.state = 9784;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOPARALLEL:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 9769;
+                this.match(PlSqlParser.NOPARALLEL);
+                }
+                break;
+            case PlSqlParser.PARALLEL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 9770;
+                this.match(PlSqlParser.PARALLEL);
+                this.state = 9782;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1129, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9771;
+                    localContext._parallel_count = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 9773;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1127, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 9772;
+                        this.parallel_instances_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 9775;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 9776;
+                    this.match(PlSqlParser.DEGREE);
+                    this.state = 9777;
+                    localContext._parallel_count = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 9779;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 761) {
+                        {
+                        this.state = 9778;
+                        this.parallel_instances_clause();
+                        }
+                    }
+
+                    this.state = 9781;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parallel_instances_clause(): Parallel_instances_clauseContext {
+        let localContext = new Parallel_instances_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 942, PlSqlParser.RULE_parallel_instances_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9786;
+            this.match(PlSqlParser.INSTANCES);
+            this.state = 9787;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 389 || _la === 2443)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_materialized_view(): Alter_materialized_viewContext {
+        let localContext = new Alter_materialized_viewContext(this.context, this.state);
+        this.enterRule(localContext, 944, PlSqlParser.RULE_alter_materialized_view);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9789;
+            this.match(PlSqlParser.ALTER);
+            this.state = 9790;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 9791;
+            this.match(PlSqlParser.VIEW);
+            this.state = 9792;
+            this.tableview_name();
+            this.state = 9818;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1133, this.context) ) {
+            case 1:
+                {
+                this.state = 9793;
+                this.physical_attributes_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 9794;
+                this.modify_mv_column_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 9795;
+                this.table_compression();
+                }
+                break;
+            case 4:
+                {
+                this.state = 9796;
+                this.lob_storage_clause();
+                this.state = 9801;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1131, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 9797;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9798;
+                        this.lob_storage_clause();
+                        }
+                        }
+                    }
+                    this.state = 9803;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1131, this.context);
+                }
+                }
+                break;
+            case 5:
+                {
+                this.state = 9804;
+                this.modify_lob_storage_clause();
+                this.state = 9809;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1132, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 9805;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9806;
+                        this.modify_lob_storage_clause();
+                        }
+                        }
+                    }
+                    this.state = 9811;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1132, this.context);
+                }
+                }
+                break;
+            case 6:
+                {
+                this.state = 9812;
+                this.parallel_clause();
+                }
+                break;
+            case 7:
+                {
+                this.state = 9813;
+                this.logging_clause();
+                }
+                break;
+            case 8:
+                {
+                this.state = 9814;
+                this.allocate_extent_clause();
+                }
+                break;
+            case 9:
+                {
+                this.state = 9815;
+                this.deallocate_unused_clause();
+                }
+                break;
+            case 10:
+                {
+                this.state = 9816;
+                this.shrink_clause();
+                }
+                break;
+            case 11:
+                {
+                {
+                this.state = 9817;
+                this.cache_or_nocache();
+                }
+                }
+                break;
+            }
+            this.state = 9821;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1134, this.context) ) {
+            case 1:
+                {
+                this.state = 9820;
+                this.alter_iot_clauses();
+                }
+                break;
+            }
+            this.state = 9826;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1135, this.context) ) {
+            case 1:
+                {
+                this.state = 9823;
+                this.match(PlSqlParser.USING);
+                this.state = 9824;
+                this.match(PlSqlParser.INDEX);
+                this.state = 9825;
+                this.physical_attributes_clause();
+                }
+                break;
+            }
+            this.state = 9829;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1136, this.context) ) {
+            case 1:
+                {
+                this.state = 9828;
+                this.alter_mv_option1();
+                }
+                break;
+            }
+            this.state = 9838;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1137, this.context) ) {
+            case 1:
+                {
+                this.state = 9831;
+                this.enable_or_disable();
+                this.state = 9832;
+                this.match(PlSqlParser.QUERY);
+                this.state = 9833;
+                this.match(PlSqlParser.REWRITE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 9835;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            case 3:
+                {
+                this.state = 9836;
+                this.match(PlSqlParser.CONSIDER);
+                this.state = 9837;
+                this.match(PlSqlParser.FRESH);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_mv_option1(): Alter_mv_option1Context {
+        let localContext = new Alter_mv_option1Context(this.context, this.state);
+        this.enterRule(localContext, 946, PlSqlParser.RULE_alter_mv_option1);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9840;
+            this.alter_mv_refresh();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_mv_refresh(): Alter_mv_refreshContext {
+        let localContext = new Alter_mv_refreshContext(this.context, this.state);
+        this.enterRule(localContext, 948, PlSqlParser.RULE_alter_mv_refresh);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9842;
+            this.match(PlSqlParser.REFRESH);
+            this.state = 9869;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 9869;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1140, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 9843;
+                        this.match(PlSqlParser.FAST);
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 9844;
+                        this.match(PlSqlParser.COMPLETE);
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 9845;
+                        this.match(PlSqlParser.FORCE);
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 9846;
+                        this.match(PlSqlParser.ON);
+                        this.state = 9847;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 242 || _la === 406)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 9848;
+                        this.match(PlSqlParser.START);
+                        this.state = 9849;
+                        this.match(PlSqlParser.WITH);
+                        this.state = 9850;
+                        this.expression();
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 9851;
+                        this.match(PlSqlParser.NEXT);
+                        this.state = 9852;
+                        this.expression();
+                        }
+                        break;
+                    case 7:
+                        {
+                        this.state = 9853;
+                        this.match(PlSqlParser.WITH);
+                        this.state = 9854;
+                        this.match(PlSqlParser.PRIMARY);
+                        this.state = 9855;
+                        this.match(PlSqlParser.KEY);
+                        }
+                        break;
+                    case 8:
+                        {
+                        this.state = 9856;
+                        this.match(PlSqlParser.USING);
+                        this.state = 9858;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 389) {
+                            {
+                            this.state = 9857;
+                            this.match(PlSqlParser.DEFAULT);
+                            }
+                        }
+
+                        this.state = 9860;
+                        this.match(PlSqlParser.MASTER);
+                        this.state = 9861;
+                        this.match(PlSqlParser.ROLLBACK);
+                        this.state = 9862;
+                        this.match(PlSqlParser.SEGMENT);
+                        this.state = 9864;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1139, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 9863;
+                            this.rollback_segment();
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case 9:
+                        {
+                        this.state = 9866;
+                        this.match(PlSqlParser.USING);
+                        this.state = 9867;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 511 || _la === 2163)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 9868;
+                        this.match(PlSqlParser.CONSTRAINTS);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 9871;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1141, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rollback_segment(): Rollback_segmentContext {
+        let localContext = new Rollback_segmentContext(this.context, this.state);
+        this.enterRule(localContext, 950, PlSqlParser.RULE_rollback_segment);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9873;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_mv_column_clause(): Modify_mv_column_clauseContext {
+        let localContext = new Modify_mv_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 952, PlSqlParser.RULE_modify_mv_column_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9875;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 9876;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 9877;
+            this.column_name();
+            this.state = 9881;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ENCRYPT:
+                {
+                this.state = 9878;
+                this.match(PlSqlParser.ENCRYPT);
+                this.state = 9879;
+                this.encryption_spec();
+                }
+                break;
+            case PlSqlParser.DECRYPT:
+                {
+                this.state = 9880;
+                this.match(PlSqlParser.DECRYPT);
+                }
+                break;
+            case PlSqlParser.RIGHT_PAREN:
+                break;
+            default:
+                break;
+            }
+            this.state = 9883;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_materialized_view_log(): Alter_materialized_view_logContext {
+        let localContext = new Alter_materialized_view_logContext(this.context, this.state);
+        this.enterRule(localContext, 954, PlSqlParser.RULE_alter_materialized_view_log);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9885;
+            this.match(PlSqlParser.ALTER);
+            this.state = 9886;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 9887;
+            this.match(PlSqlParser.VIEW);
+            this.state = 9888;
+            this.match(PlSqlParser.LOG);
+            this.state = 9890;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 617) {
+                {
+                this.state = 9889;
+                this.match(PlSqlParser.FORCE);
+                }
+            }
+
+            this.state = 9892;
+            this.match(PlSqlParser.ON);
+            this.state = 9893;
+            this.tableview_name();
+            this.state = 9902;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1144, this.context) ) {
+            case 1:
+                {
+                this.state = 9894;
+                this.physical_attributes_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 9895;
+                this.add_mv_log_column_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 9896;
+                this.parallel_clause();
+                }
+                break;
+            case 4:
+                {
+                this.state = 9897;
+                this.logging_clause();
+                }
+                break;
+            case 5:
+                {
+                this.state = 9898;
+                this.allocate_extent_clause();
+                }
+                break;
+            case 6:
+                {
+                this.state = 9899;
+                this.shrink_clause();
+                }
+                break;
+            case 7:
+                {
+                this.state = 9900;
+                this.move_mv_log_clause();
+                }
+                break;
+            case 8:
+                {
+                this.state = 9901;
+                this.cache_or_nocache();
+                }
+                break;
+            }
+            this.state = 9905;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1145, this.context) ) {
+            case 1:
+                {
+                this.state = 9904;
+                this.mv_log_augmentation();
+                }
+                break;
+            }
+            this.state = 9908;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1146, this.context) ) {
+            case 1:
+                {
+                this.state = 9907;
+                this.mv_log_purge_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_mv_log_column_clause(): Add_mv_log_column_clauseContext {
+        let localContext = new Add_mv_log_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 956, PlSqlParser.RULE_add_mv_log_column_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9910;
+            this.match(PlSqlParser.ADD);
+            this.state = 9911;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 9912;
+            this.column_name();
+            this.state = 9913;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public move_mv_log_clause(): Move_mv_log_clauseContext {
+        let localContext = new Move_mv_log_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 958, PlSqlParser.RULE_move_mv_log_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9915;
+            this.match(PlSqlParser.MOVE);
+            this.state = 9916;
+            this.segment_attributes_clause();
+            this.state = 9918;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1147, this.context) ) {
+            case 1:
+                {
+                this.state = 9917;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public mv_log_augmentation(): Mv_log_augmentationContext {
+        let localContext = new Mv_log_augmentationContext(this.context, this.state);
+        this.enterRule(localContext, 960, PlSqlParser.RULE_mv_log_augmentation);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9920;
+            this.match(PlSqlParser.ADD);
+            this.state = 9953;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.SEQUENCE:
+                {
+                this.state = 9927;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.OBJECT:
+                    {
+                    this.state = 9921;
+                    this.match(PlSqlParser.OBJECT);
+                    this.state = 9922;
+                    this.match(PlSqlParser.ID);
+                    }
+                    break;
+                case PlSqlParser.PRIMARY:
+                    {
+                    this.state = 9923;
+                    this.match(PlSqlParser.PRIMARY);
+                    this.state = 9924;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                case PlSqlParser.ROWID:
+                    {
+                    this.state = 9925;
+                    this.match(PlSqlParser.ROWID);
+                    }
+                    break;
+                case PlSqlParser.SEQUENCE:
+                    {
+                    this.state = 9926;
+                    this.match(PlSqlParser.SEQUENCE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 9940;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1150, this.context) ) {
+                case 1:
+                    {
+                    this.state = 9929;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 9930;
+                    this.column_name();
+                    this.state = 9935;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 9931;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 9932;
+                        this.column_name();
+                        }
+                        }
+                        this.state = 9937;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 9938;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 9942;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 9943;
+                this.column_name();
+                this.state = 9948;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 9944;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 9945;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 9950;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 9951;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 9956;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1153, this.context) ) {
+            case 1:
+                {
+                this.state = 9955;
+                this.new_values_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_materialized_view_log(): Create_materialized_view_logContext {
+        let localContext = new Create_materialized_view_logContext(this.context, this.state);
+        this.enterRule(localContext, 962, PlSqlParser.RULE_create_materialized_view_log);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 9958;
+            this.match(PlSqlParser.CREATE);
+            this.state = 9959;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 9960;
+            this.match(PlSqlParser.VIEW);
+            this.state = 9961;
+            this.match(PlSqlParser.LOG);
+            this.state = 9962;
+            this.match(PlSqlParser.ON);
+            this.state = 9963;
+            this.tableview_name();
+            this.state = 9973;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1156, this.context) ) {
+            case 1:
+                {
+                this.state = 9969;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 9969;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.COMPUTE:
+                        case PlSqlParser.INITRANS:
+                        case PlSqlParser.MAXTRANS:
+                        case PlSqlParser.PCTFREE:
+                        case PlSqlParser.PCTUSED:
+                        case PlSqlParser.STORAGE:
+                            {
+                            this.state = 9964;
+                            this.physical_attributes_clause();
+                            }
+                            break;
+                        case PlSqlParser.TABLESPACE:
+                            {
+                            this.state = 9965;
+                            this.match(PlSqlParser.TABLESPACE);
+                            this.state = 9966;
+                            localContext._tablespace_name = this.id_expression();
+                            }
+                            break;
+                        case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                        case PlSqlParser.LOGGING:
+                        case PlSqlParser.NOLOGGING:
+                            {
+                            this.state = 9967;
+                            this.logging_clause();
+                            }
+                            break;
+                        case PlSqlParser.CACHE:
+                        case PlSqlParser.NOCACHE:
+                            {
+                            this.state = 9968;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 166 || _la === 1067)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 9971;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1155, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            }
+            this.state = 9976;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1157, this.context) ) {
+            case 1:
+                {
+                this.state = 9975;
+                this.parallel_clause();
+                }
+                break;
+            }
+            this.state = 10018;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1166, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 9978;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 9994;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1160, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 9980;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 2455) {
+                                {
+                                this.state = 9979;
+                                this.match(PlSqlParser.COMMA);
+                                }
+                            }
+
+                            this.state = 9990;
+                            this.errorHandler.sync(this);
+                            switch (this.tokenStream.LA(1)) {
+                            case PlSqlParser.OBJECT:
+                                {
+                                this.state = 9982;
+                                this.match(PlSqlParser.OBJECT);
+                                this.state = 9983;
+                                this.match(PlSqlParser.ID);
+                                }
+                                break;
+                            case PlSqlParser.PRIMARY:
+                                {
+                                this.state = 9984;
+                                this.match(PlSqlParser.PRIMARY);
+                                this.state = 9985;
+                                this.match(PlSqlParser.KEY);
+                                }
+                                break;
+                            case PlSqlParser.ROWID:
+                                {
+                                this.state = 9986;
+                                this.match(PlSqlParser.ROWID);
+                                }
+                                break;
+                            case PlSqlParser.SEQUENCE:
+                                {
+                                this.state = 9987;
+                                this.match(PlSqlParser.SEQUENCE);
+                                }
+                                break;
+                            case PlSqlParser.COMMIT:
+                                {
+                                this.state = 9988;
+                                this.match(PlSqlParser.COMMIT);
+                                this.state = 9989;
+                                this.match(PlSqlParser.SCN);
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                            }
+                            }
+                            }
+                        }
+                        this.state = 9996;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1160, this.context);
+                    }
+                    this.state = 10008;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1163, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 9997;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 10002;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        do {
+                            {
+                            {
+                            this.state = 9999;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 2455) {
+                                {
+                                this.state = 9998;
+                                this.match(PlSqlParser.COMMA);
+                                }
+                            }
+
+                            this.state = 10001;
+                            this.regular_id();
+                            }
+                            }
+                            this.state = 10004;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 142606335) !== 0) || _la === 2455 || _la === 2482);
+                        this.state = 10006;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    }
+                    this.state = 10011;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1164, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 10010;
+                        this.new_values_clause();
+                        }
+                        break;
+                    }
+                    this.state = 10014;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1165, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 10013;
+                        this.mv_log_purge_clause();
+                        }
+                        break;
+                    }
+                    }
+                    }
+                }
+                this.state = 10020;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1166, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public new_values_clause(): New_values_clauseContext {
+        let localContext = new New_values_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 964, PlSqlParser.RULE_new_values_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10021;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 540 || _la === 706)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 10022;
+            this.match(PlSqlParser.NEW);
+            this.state = 10023;
+            this.match(PlSqlParser.VALUES);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public mv_log_purge_clause(): Mv_log_purge_clauseContext {
+        let localContext = new Mv_log_purge_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 966, PlSqlParser.RULE_mv_log_purge_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10025;
+            this.match(PlSqlParser.PURGE);
+            {
+            this.state = 10026;
+            this.match(PlSqlParser.IMMEDIATE);
+            this.state = 10028;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1167, this.context) ) {
+            case 1:
+                {
+                this.state = 10027;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 79 || _la === 1796)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_materialized_zonemap(): Create_materialized_zonemapContext {
+        let localContext = new Create_materialized_zonemapContext(this.context, this.state);
+        this.enterRule(localContext, 968, PlSqlParser.RULE_create_materialized_zonemap);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10030;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10031;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 10032;
+            this.match(PlSqlParser.ZONEMAP);
+            this.state = 10033;
+            this.zonemap_name();
+            this.state = 10038;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 10034;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 10035;
+                this.column_list();
+                this.state = 10036;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 10041;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 166 || _la === 1067 || _la === 1371 || _la === 1374 || _la === 1622 || _la === 2082) {
+                {
+                this.state = 10040;
+                this.zonemap_attributes();
+                }
+            }
+
+            this.state = 10044;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1533) {
+                {
+                this.state = 10043;
+                this.zonemap_refresh_clause();
+                }
+            }
+
+            this.state = 10048;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 429 || _la === 499) {
+                {
+                this.state = 10046;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10047;
+                this.match(PlSqlParser.PRUNING);
+                }
+            }
+
+            this.state = 10052;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ON:
+                {
+                this.state = 10050;
+                this.create_zonemap_on_table();
+                }
+                break;
+            case PlSqlParser.AS:
+                {
+                this.state = 10051;
+                this.create_zonemap_as_subquery();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_materialized_zonemap(): Alter_materialized_zonemapContext {
+        let localContext = new Alter_materialized_zonemapContext(this.context, this.state);
+        this.enterRule(localContext, 970, PlSqlParser.RULE_alter_materialized_zonemap);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10054;
+            this.match(PlSqlParser.ALTER);
+            this.state = 10055;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 10056;
+            this.match(PlSqlParser.ZONEMAP);
+            this.state = 10057;
+            this.zonemap_name();
+            this.state = 10065;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CACHE:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.TABLESPACE:
+                {
+                this.state = 10058;
+                this.zonemap_attributes();
+                }
+                break;
+            case PlSqlParser.REFRESH:
+                {
+                this.state = 10059;
+                this.zonemap_refresh_clause();
+                }
+                break;
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+                {
+                this.state = 10060;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10061;
+                this.match(PlSqlParser.PRUNING);
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 10062;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            case PlSqlParser.REBUILD:
+                {
+                this.state = 10063;
+                this.match(PlSqlParser.REBUILD);
+                }
+                break;
+            case PlSqlParser.UNUSABLE:
+                {
+                this.state = 10064;
+                this.match(PlSqlParser.UNUSABLE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_materialized_zonemap(): Drop_materialized_zonemapContext {
+        let localContext = new Drop_materialized_zonemapContext(this.context, this.state);
+        this.enterRule(localContext, 972, PlSqlParser.RULE_drop_materialized_zonemap);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10067;
+            this.match(PlSqlParser.DROP);
+            this.state = 10068;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 10069;
+            this.match(PlSqlParser.ZONEMAP);
+            this.state = 10070;
+            this.zonemap_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public zonemap_refresh_clause(): Zonemap_refresh_clauseContext {
+        let localContext = new Zonemap_refresh_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 974, PlSqlParser.RULE_zonemap_refresh_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10072;
+            this.match(PlSqlParser.REFRESH);
+            this.state = 10074;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1174, this.context) ) {
+            case 1:
+                {
+                this.state = 10073;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 249 || _la === 579 || _la === 617)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 10087;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1176, this.context) ) {
+            case 1:
+                {
+                this.state = 10076;
+                this.match(PlSqlParser.ON);
+                this.state = 10085;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1175, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10077;
+                    this.match(PlSqlParser.DEMAND);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10078;
+                    this.match(PlSqlParser.COMMIT);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 10079;
+                    this.match(PlSqlParser.LOAD);
+                    }
+                    break;
+                case 4:
+                    {
+                    this.state = 10080;
+                    this.match(PlSqlParser.DATA);
+                    this.state = 10081;
+                    this.match(PlSqlParser.MOVEMENT);
+                    }
+                    break;
+                case 5:
+                    {
+                    this.state = 10082;
+                    this.match(PlSqlParser.LOAD);
+                    this.state = 10083;
+                    this.match(PlSqlParser.DATA);
+                    this.state = 10084;
+                    this.match(PlSqlParser.MOVEMENT);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public zonemap_attributes(): Zonemap_attributesContext {
+        let localContext = new Zonemap_attributesContext(this.context, this.state);
+        this.enterRule(localContext, 976, PlSqlParser.RULE_zonemap_attributes);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10098;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 10098;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.PCTFREE:
+                        {
+                        this.state = 10089;
+                        this.match(PlSqlParser.PCTFREE);
+                        this.state = 10090;
+                        this.numeric();
+                        }
+                        break;
+                    case PlSqlParser.PCTUSED:
+                        {
+                        this.state = 10091;
+                        this.match(PlSqlParser.PCTUSED);
+                        this.state = 10092;
+                        this.numeric();
+                        }
+                        break;
+                    case PlSqlParser.SCALE:
+                        {
+                        this.state = 10093;
+                        this.match(PlSqlParser.SCALE);
+                        this.state = 10094;
+                        this.numeric();
+                        }
+                        break;
+                    case PlSqlParser.TABLESPACE:
+                        {
+                        this.state = 10095;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 10096;
+                        this.tablespace();
+                        }
+                        break;
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.NOCACHE:
+                        {
+                        this.state = 10097;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 166 || _la === 1067)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 10100;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1178, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public zonemap_name(): Zonemap_nameContext {
+        let localContext = new Zonemap_nameContext(this.context, this.state);
+        this.enterRule(localContext, 978, PlSqlParser.RULE_zonemap_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10102;
+            this.identifier();
+            this.state = 10105;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1179, this.context) ) {
+            case 1:
+                {
+                this.state = 10103;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 10104;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public operator_name(): Operator_nameContext {
+        let localContext = new Operator_nameContext(this.context, this.state);
+        this.enterRule(localContext, 980, PlSqlParser.RULE_operator_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10107;
+            this.identifier();
+            this.state = 10110;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1180, this.context) ) {
+            case 1:
+                {
+                this.state = 10108;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 10109;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public operator_function_name(): Operator_function_nameContext {
+        let localContext = new Operator_function_nameContext(this.context, this.state);
+        this.enterRule(localContext, 982, PlSqlParser.RULE_operator_function_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10112;
+            this.identifier();
+            this.state = 10117;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1181, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 10113;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 10114;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 10119;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1181, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_zonemap_on_table(): Create_zonemap_on_tableContext {
+        let localContext = new Create_zonemap_on_tableContext(this.context, this.state);
+        this.enterRule(localContext, 984, PlSqlParser.RULE_create_zonemap_on_table);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10120;
+            this.match(PlSqlParser.ON);
+            this.state = 10121;
+            this.tableview_name();
+            this.state = 10122;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10123;
+            this.column_list();
+            this.state = 10124;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_zonemap_as_subquery(): Create_zonemap_as_subqueryContext {
+        let localContext = new Create_zonemap_as_subqueryContext(this.context, this.state);
+        this.enterRule(localContext, 986, PlSqlParser.RULE_create_zonemap_as_subquery);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10126;
+            this.match(PlSqlParser.AS);
+            this.state = 10127;
+            this.subquery();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_operator(): Alter_operatorContext {
+        let localContext = new Alter_operatorContext(this.context, this.state);
+        this.enterRule(localContext, 988, PlSqlParser.RULE_alter_operator);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10129;
+            this.match(PlSqlParser.ALTER);
+            this.state = 10130;
+            this.match(PlSqlParser.OPERATOR);
+            this.state = 10131;
+            this.operator_name();
+            this.state = 10135;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                {
+                this.state = 10132;
+                this.add_binding_clause();
+                }
+                break;
+            case PlSqlParser.DROP:
+                {
+                this.state = 10133;
+                this.drop_binding_clause();
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 10134;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_operator(): Drop_operatorContext {
+        let localContext = new Drop_operatorContext(this.context, this.state);
+        this.enterRule(localContext, 990, PlSqlParser.RULE_drop_operator);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10137;
+            this.match(PlSqlParser.DROP);
+            this.state = 10138;
+            this.match(PlSqlParser.OPERATOR);
+            this.state = 10139;
+            this.operator_name();
+            this.state = 10141;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1183, this.context) ) {
+            case 1:
+                {
+                this.state = 10140;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_operator(): Create_operatorContext {
+        let localContext = new Create_operatorContext(this.context, this.state);
+        this.enterRule(localContext, 992, PlSqlParser.RULE_create_operator);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10143;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10146;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 10144;
+                this.match(PlSqlParser.OR);
+                this.state = 10145;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 10148;
+            this.match(PlSqlParser.OPERATOR);
+            this.state = 10149;
+            this.operator_name();
+            this.state = 10150;
+            this.match(PlSqlParser.BINDING);
+            this.state = 10151;
+            this.binding_clause();
+            this.state = 10156;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1185, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 10152;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 10153;
+                    this.binding_clause();
+                    }
+                    }
+                }
+                this.state = 10158;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1185, this.context);
+            }
+            this.state = 10162;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1186, this.context) ) {
+            case 1:
+                {
+                this.state = 10159;
+                this.match(PlSqlParser.SHARING);
+                this.state = 10160;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 10161;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 949 || _la === 1134)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public binding_clause(): Binding_clauseContext {
+        let localContext = new Binding_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 994, PlSqlParser.RULE_binding_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10164;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10165;
+            this.datatype();
+            this.state = 10170;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 10166;
+                this.match(PlSqlParser.COMMA);
+                this.state = 10167;
+                this.datatype();
+                }
+                }
+                this.state = 10172;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 10173;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 10174;
+            this.match(PlSqlParser.RETURN);
+            this.state = 10176;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 10175;
+                this.match(PlSqlParser.LEFT_PAREN);
+                }
+            }
+
+            this.state = 10178;
+            this.datatype();
+            this.state = 10180;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2450) {
+                {
+                this.state = 10179;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 10183;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 48 || _la === 2310) {
+                {
+                this.state = 10182;
+                this.implementation_clause();
+                }
+            }
+
+            this.state = 10185;
+            this.using_function_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_binding_clause(): Add_binding_clauseContext {
+        let localContext = new Add_binding_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 996, PlSqlParser.RULE_add_binding_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10187;
+            this.match(PlSqlParser.ADD);
+            this.state = 10188;
+            this.match(PlSqlParser.BINDING);
+            this.state = 10189;
+            this.binding_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public implementation_clause(): Implementation_clauseContext {
+        let localContext = new Implementation_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 998, PlSqlParser.RULE_implementation_clause);
+        try {
+            this.state = 10195;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ANCILLARY:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10191;
+                this.match(PlSqlParser.ANCILLARY);
+                this.state = 10192;
+                this.match(PlSqlParser.TO);
+                this.state = 10193;
+                this.primary_operator_list();
+                }
+                break;
+            case PlSqlParser.WITH:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10194;
+                this.operator_context_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public primary_operator_list(): Primary_operator_listContext {
+        let localContext = new Primary_operator_listContext(this.context, this.state);
+        this.enterRule(localContext, 1000, PlSqlParser.RULE_primary_operator_list);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10197;
+            this.primary_operator_item();
+            this.state = 10202;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 10198;
+                this.match(PlSqlParser.COMMA);
+                this.state = 10199;
+                this.primary_operator_item();
+                }
+                }
+                this.state = 10204;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public primary_operator_item(): Primary_operator_itemContext {
+        let localContext = new Primary_operator_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1002, PlSqlParser.RULE_primary_operator_item);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10205;
+            this.schema_object_name();
+            this.state = 10206;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10207;
+            this.datatype();
+            this.state = 10212;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 10208;
+                this.match(PlSqlParser.COMMA);
+                this.state = 10209;
+                this.datatype();
+                }
+                }
+                this.state = 10214;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 10215;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public operator_context_clause(): Operator_context_clauseContext {
+        let localContext = new Operator_context_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1004, PlSqlParser.RULE_operator_context_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10217;
+            this.match(PlSqlParser.WITH);
+            this.state = 10218;
+            this.match(PlSqlParser.INDEX);
+            this.state = 10219;
+            this.match(PlSqlParser.CONTEXT);
+            this.state = 10220;
+            this.match(PlSqlParser.COMMA);
+            this.state = 10221;
+            this.match(PlSqlParser.SCAN);
+            this.state = 10222;
+            this.match(PlSqlParser.CONTEXT);
+            this.state = 10223;
+            this.implementation_type_name();
+            this.state = 10227;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 260) {
+                {
+                this.state = 10224;
+                this.match(PlSqlParser.COMPUTE);
+                this.state = 10225;
+                this.match(PlSqlParser.ANCILLARY);
+                this.state = 10226;
+                this.match(PlSqlParser.DATA);
+                }
+            }
+
+            this.state = 10232;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2310) {
+                {
+                this.state = 10229;
+                this.match(PlSqlParser.WITH);
+                this.state = 10230;
+                this.match(PlSqlParser.COLUMN);
+                this.state = 10231;
+                this.match(PlSqlParser.CONTEXT);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_function_clause(): Using_function_clauseContext {
+        let localContext = new Using_function_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1006, PlSqlParser.RULE_using_function_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10234;
+            this.match(PlSqlParser.USING);
+            this.state = 10235;
+            this.operator_function_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_binding_clause(): Drop_binding_clauseContext {
+        let localContext = new Drop_binding_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1008, PlSqlParser.RULE_drop_binding_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10237;
+            this.match(PlSqlParser.DROP);
+            this.state = 10238;
+            this.match(PlSqlParser.BINDING);
+            this.state = 10239;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10240;
+            this.datatype();
+            this.state = 10245;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 10241;
+                this.match(PlSqlParser.COMMA);
+                this.state = 10242;
+                this.datatype();
+                }
+                }
+                this.state = 10247;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 10248;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 10250;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1197, this.context) ) {
+            case 1:
+                {
+                this.state = 10249;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_materialized_view(): Create_materialized_viewContext {
+        let localContext = new Create_materialized_viewContext(this.context, this.state);
+        this.enterRule(localContext, 1010, PlSqlParser.RULE_create_materialized_view);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10252;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10253;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 10254;
+            this.match(PlSqlParser.VIEW);
+            this.state = 10258;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1198, this.context) ) {
+            case 1:
+                {
+                this.state = 10255;
+                this.match(PlSqlParser.IF);
+                this.state = 10256;
+                this.match(PlSqlParser.NOT);
+                this.state = 10257;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 10260;
+            this.tableview_name();
+            this.state = 10263;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1248) {
+                {
+                this.state = 10261;
+                this.match(PlSqlParser.OF);
+                this.state = 10262;
+                this.type_name();
+                }
+            }
+
+            this.state = 10282;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 10265;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 10268;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1200, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10266;
+                    this.scoped_table_ref_constraint();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10267;
+                    this.mv_column_alias();
+                    }
+                    break;
+                }
+                this.state = 10277;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 10270;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 10273;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1201, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 10271;
+                        this.scoped_table_ref_constraint();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 10272;
+                        this.mv_column_alias();
+                        }
+                        break;
+                    }
+                    }
+                    }
+                    this.state = 10279;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 10280;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 10304;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ON:
+                {
+                this.state = 10284;
+                this.match(PlSqlParser.ON);
+                this.state = 10285;
+                this.match(PlSqlParser.PREBUILT);
+                this.state = 10286;
+                this.match(PlSqlParser.TABLE);
+                this.state = 10290;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2308 || _la === 2310) {
+                    {
+                    this.state = 10287;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2308 || _la === 2310)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 10288;
+                    this.match(PlSqlParser.REDUCED);
+                    this.state = 10289;
+                    this.match(PlSqlParser.PRECISION);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.ANNOTATIONS:
+            case PlSqlParser.AS:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.ILM:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NO:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PCTFREE:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.ROW:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.USING:
+                {
+                this.state = 10293;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 220 || _la === 237 || _la === 258 || _la === 260 || _la === 561 || _la === 594 || _la === 698 || _la === 744 || _la === 747 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1139 || _la === 1308 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1647 || _la === 1764 || _la === 2082) {
+                    {
+                    this.state = 10292;
+                    this.physical_properties();
+                    }
+                }
+
+                this.state = 10296;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 166 || _la === 1067) {
+                    {
+                    this.state = 10295;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 166 || _la === 1067)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 10299;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1150 || _la === 1335) {
+                    {
+                    this.state = 10298;
+                    this.parallel_clause();
+                    }
+                }
+
+                this.state = 10302;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 158) {
+                    {
+                    this.state = 10301;
+                    this.build_clause();
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 10323;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1213, this.context) ) {
+            case 1:
+                {
+                this.state = 10306;
+                this.match(PlSqlParser.USING);
+                this.state = 10307;
+                this.match(PlSqlParser.INDEX);
+                this.state = 10317;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 260 || _la === 744 || _la === 932 || _la === 1371 || _la === 1374 || _la === 1764 || _la === 2082) {
+                    {
+                    {
+                    this.state = 10311;
+                    this.errorHandler.sync(this);
+                    alternative = 1;
+                    do {
+                        switch (alternative) {
+                        case 1:
+                            {
+                            this.state = 10311;
+                            this.errorHandler.sync(this);
+                            switch (this.tokenStream.LA(1)) {
+                            case PlSqlParser.COMPUTE:
+                            case PlSqlParser.INITRANS:
+                            case PlSqlParser.MAXTRANS:
+                            case PlSqlParser.PCTFREE:
+                            case PlSqlParser.PCTUSED:
+                            case PlSqlParser.STORAGE:
+                                {
+                                this.state = 10308;
+                                this.physical_attributes_clause();
+                                }
+                                break;
+                            case PlSqlParser.TABLESPACE:
+                                {
+                                this.state = 10309;
+                                this.match(PlSqlParser.TABLESPACE);
+                                this.state = 10310;
+                                localContext._mv_tablespace = this.id_expression();
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 10313;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1211, this.context);
+                    } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                    }
+                    }
+                    this.state = 10319;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 10320;
+                this.match(PlSqlParser.USING);
+                this.state = 10321;
+                this.match(PlSqlParser.NO);
+                this.state = 10322;
+                this.match(PlSqlParser.INDEX);
+                }
+                break;
+            }
+            this.state = 10326;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1021 || _la === 1533) {
+                {
+                this.state = 10325;
+                this.create_mv_refresh();
+                }
+            }
+
+            this.state = 10329;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 530) {
+                {
+                this.state = 10328;
+                this.evaluation_edition_clause();
+                }
+            }
+
+            this.state = 10335;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1216, this.context) ) {
+            case 1:
+                {
+                this.state = 10331;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10332;
+                this.match(PlSqlParser.ON);
+                this.state = 10333;
+                this.match(PlSqlParser.QUERY);
+                this.state = 10334;
+                this.match(PlSqlParser.COMPUTATION);
+                }
+                break;
+            }
+            this.state = 10338;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1217, this.context) ) {
+            case 1:
+                {
+                this.state = 10337;
+                this.query_rewrite_clause();
+                }
+                break;
+            }
+            this.state = 10343;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 429 || _la === 499) {
+                {
+                this.state = 10340;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10341;
+                this.match(PlSqlParser.CONCURRENT);
+                this.state = 10342;
+                this.match(PlSqlParser.REFRESH);
+                }
+            }
+
+            this.state = 10346;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 51) {
+                {
+                this.state = 10345;
+                this.annotations_clause();
+                }
+            }
+
+            this.state = 10348;
+            this.match(PlSqlParser.AS);
+            this.state = 10349;
+            this.select_only_statement();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public scoped_table_ref_constraint(): Scoped_table_ref_constraintContext {
+        let localContext = new Scoped_table_ref_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 1012, PlSqlParser.RULE_scoped_table_ref_constraint);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10351;
+            this.match(PlSqlParser.SCOPE);
+            this.state = 10352;
+            this.match(PlSqlParser.FOR);
+            this.state = 10353;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10354;
+            localContext._ref_column_or_attribute = this.identifier();
+            this.state = 10355;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 10356;
+            this.match(PlSqlParser.IS);
+            this.state = 10360;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1220, this.context) ) {
+            case 1:
+                {
+                this.state = 10357;
+                this.schema_name();
+                this.state = 10358;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 10362;
+            localContext._scope_table_name_or_c_alias = this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public mv_column_alias(): Mv_column_aliasContext {
+        let localContext = new Mv_column_aliasContext(this.context, this.state);
+        this.enterRule(localContext, 1014, PlSqlParser.RULE_mv_column_alias);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10366;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 10364;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 10365;
+                this.quoted_string();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 10370;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 505) {
+                {
+                this.state = 10368;
+                this.match(PlSqlParser.ENCRYPT);
+                this.state = 10369;
+                this.encryption_spec();
+                }
+            }
+
+            this.state = 10374;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ANNOTATIONS:
+                {
+                this.state = 10372;
+                this.annotations_clause();
+                }
+                break;
+            case PlSqlParser.SCOPE:
+                {
+                this.state = 10373;
+                this.scoped_table_ref_constraint();
+                }
+                break;
+            case PlSqlParser.RIGHT_PAREN:
+            case PlSqlParser.COMMA:
+                break;
+            default:
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_mv_refresh(): Create_mv_refreshContext {
+        let localContext = new Create_mv_refreshContext(this.context, this.state);
+        this.enterRule(localContext, 1016, PlSqlParser.RULE_create_mv_refresh);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10416;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NEVER:
+                {
+                this.state = 10376;
+                this.match(PlSqlParser.NEVER);
+                this.state = 10377;
+                this.match(PlSqlParser.REFRESH);
+                }
+                break;
+            case PlSqlParser.REFRESH:
+                {
+                this.state = 10378;
+                this.match(PlSqlParser.REFRESH);
+                this.state = 10412;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    this.state = 10412;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1229, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 10379;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 250 || _la === 579 || _la === 617)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 10380;
+                        this.match(PlSqlParser.ON);
+                        this.state = 10381;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 242 || _la === 406 || _la === 1745)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 10385;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.START:
+                            {
+                            this.state = 10382;
+                            this.match(PlSqlParser.START);
+                            this.state = 10383;
+                            this.match(PlSqlParser.WITH);
+                            }
+                            break;
+                        case PlSqlParser.NEXT:
+                            {
+                            this.state = 10384;
+                            this.match(PlSqlParser.NEXT);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 10387;
+                        this.expression();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 10388;
+                        this.match(PlSqlParser.WITH);
+                        this.state = 10392;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.PRIMARY:
+                            {
+                            this.state = 10389;
+                            this.match(PlSqlParser.PRIMARY);
+                            this.state = 10390;
+                            this.match(PlSqlParser.KEY);
+                            }
+                            break;
+                        case PlSqlParser.ROWID:
+                            {
+                            this.state = 10391;
+                            this.match(PlSqlParser.ROWID);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 10394;
+                        this.match(PlSqlParser.USING);
+                        this.state = 10407;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.DEFAULT:
+                            {
+                            this.state = 10395;
+                            this.match(PlSqlParser.DEFAULT);
+                            this.state = 10397;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 874 || _la === 914) {
+                                {
+                                this.state = 10396;
+                                _la = this.tokenStream.LA(1);
+                                if(!(_la === 874 || _la === 914)) {
+                                this.errorHandler.recoverInline(this);
+                                }
+                                else {
+                                    this.errorHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                                }
+                            }
+
+                            this.state = 10399;
+                            this.match(PlSqlParser.ROLLBACK);
+                            this.state = 10400;
+                            this.match(PlSqlParser.SEGMENT);
+                            }
+                            break;
+                        case PlSqlParser.LOCAL:
+                        case PlSqlParser.MASTER:
+                        case PlSqlParser.ROLLBACK:
+                            {
+                            this.state = 10402;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 874 || _la === 914) {
+                                {
+                                this.state = 10401;
+                                _la = this.tokenStream.LA(1);
+                                if(!(_la === 874 || _la === 914)) {
+                                this.errorHandler.recoverInline(this);
+                                }
+                                else {
+                                    this.errorHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                                }
+                            }
+
+                            this.state = 10404;
+                            this.match(PlSqlParser.ROLLBACK);
+                            this.state = 10405;
+                            this.match(PlSqlParser.SEGMENT);
+                            this.state = 10406;
+                            this.rollback_segment_name();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 10409;
+                        this.match(PlSqlParser.USING);
+                        this.state = 10410;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 511 || _la === 2163)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 10411;
+                        this.match(PlSqlParser.CONSTRAINTS);
+                        }
+                        break;
+                    }
+                    }
+                    this.state = 10414;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 250 || _la === 579 || _la === 617 || _la === 1026 || _la === 1261 || _la === 1739 || _la === 2248 || _la === 2310);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public query_rewrite_clause(): Query_rewrite_clauseContext {
+        let localContext = new Query_rewrite_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1018, PlSqlParser.RULE_query_rewrite_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10418;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 429 || _la === 499)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 10419;
+            this.match(PlSqlParser.QUERY);
+            this.state = 10420;
+            this.match(PlSqlParser.REWRITE);
+            this.state = 10422;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2205) {
+                {
+                this.state = 10421;
+                this.unusable_editions_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unusable_editions_clause(): Unusable_editions_clauseContext {
+        let localContext = new Unusable_editions_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1020, PlSqlParser.RULE_unusable_editions_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10424;
+            this.match(PlSqlParser.UNUSABLE);
+            this.state = 10443;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1235, this.context) ) {
+            case 1:
+                {
+                this.state = 10428;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.BEFORE:
+                    {
+                    this.state = 10425;
+                    this.match(PlSqlParser.BEFORE);
+                    }
+                    break;
+                case PlSqlParser.BEGINNING:
+                    {
+                    this.state = 10426;
+                    this.match(PlSqlParser.BEGINNING);
+                    this.state = 10427;
+                    this.match(PlSqlParser.WITH);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 10430;
+                this.match(PlSqlParser.CURRENT);
+                this.state = 10431;
+                this.match(PlSqlParser.EDITION);
+                }
+                break;
+            case 2:
+                {
+                this.state = 10435;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.BEFORE:
+                    {
+                    this.state = 10432;
+                    this.match(PlSqlParser.BEFORE);
+                    }
+                    break;
+                case PlSqlParser.BEGINNING:
+                    {
+                    this.state = 10433;
+                    this.match(PlSqlParser.BEGINNING);
+                    this.state = 10434;
+                    this.match(PlSqlParser.WITH);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 10437;
+                this.match(PlSqlParser.EDITION);
+                this.state = 10438;
+                this.edition_name();
+                }
+                break;
+            case 3:
+                {
+                this.state = 10439;
+                this.match(PlSqlParser.BEGINNING);
+                this.state = 10440;
+                this.match(PlSqlParser.WITH);
+                this.state = 10441;
+                this.match(PlSqlParser.NULL_);
+                this.state = 10442;
+                this.match(PlSqlParser.EDITION);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_materialized_view(): Drop_materialized_viewContext {
+        let localContext = new Drop_materialized_viewContext(this.context, this.state);
+        this.enterRule(localContext, 1022, PlSqlParser.RULE_drop_materialized_view);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10445;
+            this.match(PlSqlParser.DROP);
+            this.state = 10446;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 10447;
+            this.match(PlSqlParser.VIEW);
+            this.state = 10448;
+            this.tableview_name();
+            this.state = 10451;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1236, this.context) ) {
+            case 1:
+                {
+                this.state = 10449;
+                this.match(PlSqlParser.PRESERVE);
+                this.state = 10450;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_materialized_view_log(): Drop_materialized_view_logContext {
+        let localContext = new Drop_materialized_view_logContext(this.context, this.state);
+        this.enterRule(localContext, 1024, PlSqlParser.RULE_drop_materialized_view_log);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10453;
+            this.match(PlSqlParser.DROP);
+            this.state = 10454;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 10455;
+            this.match(PlSqlParser.VIEW);
+            this.state = 10456;
+            this.match(PlSqlParser.LOG);
+            this.state = 10459;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 692) {
+                {
+                this.state = 10457;
+                this.match(PlSqlParser.IF);
+                this.state = 10458;
+                this.match(PlSqlParser.EXISTS);
+                }
+            }
+
+            this.state = 10461;
+            this.match(PlSqlParser.ON);
+            this.state = 10462;
+            this.tableview_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_context(): Create_contextContext {
+        let localContext = new Create_contextContext(this.context, this.state);
+        this.enterRule(localContext, 1026, PlSqlParser.RULE_create_context);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10464;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10467;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 10465;
+                this.match(PlSqlParser.OR);
+                this.state = 10466;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 10469;
+            this.match(PlSqlParser.CONTEXT);
+            this.state = 10470;
+            this.oracle_namespace();
+            this.state = 10471;
+            this.match(PlSqlParser.USING);
+            this.state = 10475;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1239, this.context) ) {
+            case 1:
+                {
+                this.state = 10472;
+                this.schema_object_name();
+                this.state = 10473;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 10477;
+            this.package_name();
+            this.state = 10482;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1240, this.context) ) {
+            case 1:
+                {
+                this.state = 10478;
+                this.match(PlSqlParser.INITIALIZED);
+                this.state = 10479;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 562 || _la === 644)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 10480;
+                this.match(PlSqlParser.ACCESSED);
+                this.state = 10481;
+                this.match(PlSqlParser.GLOBALLY);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public oracle_namespace(): Oracle_namespaceContext {
+        let localContext = new Oracle_namespaceContext(this.context, this.state);
+        this.enterRule(localContext, 1028, PlSqlParser.RULE_oracle_namespace);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10484;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_cluster(): Create_clusterContext {
+        let localContext = new Create_clusterContext(this.context, this.state);
+        this.enterRule(localContext, 1030, PlSqlParser.RULE_create_cluster);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10486;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10487;
+            this.match(PlSqlParser.CLUSTER);
+            this.state = 10488;
+            this.cluster_name();
+            this.state = 10489;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10490;
+            this.column_name();
+            this.state = 10491;
+            this.datatype();
+            this.state = 10493;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1711) {
+                {
+                this.state = 10492;
+                this.match(PlSqlParser.SORT);
+                }
+            }
+
+            this.state = 10503;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 10495;
+                this.match(PlSqlParser.COMMA);
+                this.state = 10496;
+                this.column_name();
+                this.state = 10497;
+                this.datatype();
+                this.state = 10499;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1711) {
+                    {
+                    this.state = 10498;
+                    this.match(PlSqlParser.SORT);
+                    }
+                }
+
+                }
+                }
+                this.state = 10505;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 10506;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 10526;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1247, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 10524;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.PCTFREE:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 10507;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case PlSqlParser.SIZE:
+                        {
+                        this.state = 10508;
+                        this.match(PlSqlParser.SIZE);
+                        this.state = 10509;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.TABLESPACE:
+                        {
+                        this.state = 10510;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 10511;
+                        this.tablespace();
+                        }
+                        break;
+                    case PlSqlParser.INDEX:
+                        {
+                        this.state = 10512;
+                        this.match(PlSqlParser.INDEX);
+                        }
+                        break;
+                    case PlSqlParser.HASHKEYS:
+                    case PlSqlParser.SINGLE:
+                        {
+                        this.state = 10515;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 1697) {
+                            {
+                            this.state = 10513;
+                            this.match(PlSqlParser.SINGLE);
+                            this.state = 10514;
+                            this.match(PlSqlParser.TABLE);
+                            }
+                        }
+
+                        this.state = 10517;
+                        this.match(PlSqlParser.HASHKEYS);
+                        this.state = 10518;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        this.state = 10522;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1245, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 10519;
+                            this.match(PlSqlParser.HASH);
+                            this.state = 10520;
+                            this.match(PlSqlParser.IS);
+                            this.state = 10521;
+                            this.expression();
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 10528;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1247, this.context);
+            }
+            this.state = 10530;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1248, this.context) ) {
+            case 1:
+                {
+                this.state = 10529;
+                this.parallel_clause();
+                }
+                break;
+            }
+            this.state = 10533;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1249, this.context) ) {
+            case 1:
+                {
+                this.state = 10532;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1182 || _la === 1601)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 10536;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1250, this.context) ) {
+            case 1:
+                {
+                this.state = 10535;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 166 || _la === 1067)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_profile(): Create_profileContext {
+        let localContext = new Create_profileContext(this.context, this.state);
+        this.enterRule(localContext, 1032, PlSqlParser.RULE_create_profile);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10538;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10540;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 909) {
+                {
+                this.state = 10539;
+                this.match(PlSqlParser.MANDATORY);
+                }
+            }
+
+            this.state = 10542;
+            this.match(PlSqlParser.PROFILE);
+            this.state = 10543;
+            localContext._p = this.id_expression();
+            this.state = 10544;
+            this.match(PlSqlParser.LIMIT);
+            this.state = 10547;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 10547;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COMPOSITE_LIMIT:
+                    case PlSqlParser.CONNECT_TIME:
+                    case PlSqlParser.CPU_PER_CALL:
+                    case PlSqlParser.CPU_PER_SESSION:
+                    case PlSqlParser.IDLE_TIME:
+                    case PlSqlParser.LOGICAL_READS_PER_CALL:
+                    case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                    case PlSqlParser.PRIVATE_SGA:
+                    case PlSqlParser.SESSIONS_PER_USER:
+                        {
+                        this.state = 10545;
+                        this.resource_parameters();
+                        }
+                        break;
+                    case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                    case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                    case PlSqlParser.PASSWORD_GRACE_TIME:
+                    case PlSqlParser.PASSWORD_LIFE_TIME:
+                    case PlSqlParser.PASSWORD_LOCK_TIME:
+                    case PlSqlParser.PASSWORD_REUSE_MAX:
+                    case PlSqlParser.PASSWORD_REUSE_TIME:
+                    case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                    case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                        {
+                        this.state = 10546;
+                        this.password_parameters();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 10549;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1253, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            this.state = 10552;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1254, this.context) ) {
+            case 1:
+                {
+                this.state = 10551;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public resource_parameters(): Resource_parametersContext {
+        let localContext = new Resource_parametersContext(this.context, this.state);
+        this.enterRule(localContext, 1034, PlSqlParser.RULE_resource_parameters);
+        let _la: number;
+        try {
+            this.state = 10562;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10554;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 256 || _la === 281 || _la === 318 || _la === 319 || _la === 691 || _la === 887 || _la === 888 || _la === 1670)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10555;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 389 || _la === 2187 || _la === 2443)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.PRIVATE_SGA:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10556;
+                this.match(PlSqlParser.PRIVATE_SGA);
+                this.state = 10560;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNSIGNED_INTEGER:
+                    {
+                    this.state = 10557;
+                    this.size_clause();
+                    }
+                    break;
+                case PlSqlParser.UNLIMITED:
+                    {
+                    this.state = 10558;
+                    this.match(PlSqlParser.UNLIMITED);
+                    }
+                    break;
+                case PlSqlParser.DEFAULT:
+                    {
+                    this.state = 10559;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public password_parameters(): Password_parametersContext {
+        let localContext = new Password_parametersContext(this.context, this.state);
+        this.enterRule(localContext, 1036, PlSqlParser.RULE_password_parameters);
+        let _la: number;
+        try {
+            this.state = 10581;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10564;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 572 || _la === 703 || ((((_la - 1355)) & ~0x1F) === 0 && ((1 << (_la - 1355)) & 55) !== 0))) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10568;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1257, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10565;
+                    this.expression();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10566;
+                    this.match(PlSqlParser.UNLIMITED);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 10567;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10570;
+                this.match(PlSqlParser.PASSWORD_VERIFY_FUNCTION);
+                this.state = 10574;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.INTRODUCER:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 10571;
+                    this.function_name();
+                    }
+                    break;
+                case PlSqlParser.NULL_:
+                    {
+                    this.state = 10572;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                    break;
+                case PlSqlParser.DEFAULT:
+                    {
+                    this.state = 10573;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 10576;
+                this.match(PlSqlParser.PASSWORD_ROLLOVER_TIME);
+                this.state = 10579;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1259, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10577;
+                    this.expression();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10578;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_lockdown_profile(): Create_lockdown_profileContext {
+        let localContext = new Create_lockdown_profileContext(this.context, this.state);
+        this.enterRule(localContext, 1038, PlSqlParser.RULE_create_lockdown_profile);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10583;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10584;
+            this.match(PlSqlParser.LOCKDOWN);
+            this.state = 10585;
+            this.match(PlSqlParser.PROFILE);
+            this.state = 10586;
+            this.id_expression();
+            this.state = 10589;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1261, this.context) ) {
+            case 1:
+                {
+                this.state = 10587;
+                this.static_base_profile();
+                }
+                break;
+            case 2:
+                {
+                this.state = 10588;
+                this.dynamic_base_profile();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public static_base_profile(): Static_base_profileContext {
+        let localContext = new Static_base_profileContext(this.context, this.state);
+        this.enterRule(localContext, 1040, PlSqlParser.RULE_static_base_profile);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10591;
+            this.match(PlSqlParser.FROM);
+            this.state = 10592;
+            localContext._bp = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dynamic_base_profile(): Dynamic_base_profileContext {
+        let localContext = new Dynamic_base_profileContext(this.context, this.state);
+        this.enterRule(localContext, 1042, PlSqlParser.RULE_dynamic_base_profile);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10594;
+            this.match(PlSqlParser.INCLUDING);
+            this.state = 10595;
+            localContext._bp = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_outline(): Create_outlineContext {
+        let localContext = new Create_outlineContext(this.context, this.state);
+        this.enterRule(localContext, 1044, PlSqlParser.RULE_create_outline);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10597;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10600;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 10598;
+                this.match(PlSqlParser.OR);
+                this.state = 10599;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 10603;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1457 || _la === 1475) {
+                {
+                this.state = 10602;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1457 || _la === 1475)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 10605;
+            this.match(PlSqlParser.OUTLINE);
+            this.state = 10607;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1264, this.context) ) {
+            case 1:
+                {
+                this.state = 10606;
+                localContext._o = this.id_expression();
+                }
+                break;
+            }
+            this.state = 10614;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1266, this.context) ) {
+            case 1:
+                {
+                this.state = 10609;
+                this.match(PlSqlParser.FROM);
+                this.state = 10611;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1265, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10610;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1457 || _la === 1475)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 10613;
+                localContext._so = this.id_expression();
+                }
+                break;
+            }
+            this.state = 10619;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1267, this.context) ) {
+            case 1:
+                {
+                this.state = 10616;
+                this.match(PlSqlParser.FOR);
+                this.state = 10617;
+                this.match(PlSqlParser.CATEGORY);
+                this.state = 10618;
+                localContext._c = this.id_expression();
+                }
+                break;
+            }
+            this.state = 10623;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1268, this.context) ) {
+            case 1:
+                {
+                this.state = 10621;
+                this.match(PlSqlParser.ON);
+                this.state = 10622;
+                this.statement();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_restore_point(): Create_restore_pointContext {
+        let localContext = new Create_restore_pointContext(this.context, this.state);
+        this.enterRule(localContext, 1046, PlSqlParser.RULE_create_restore_point);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10625;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10627;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 210) {
+                {
+                this.state = 10626;
+                this.match(PlSqlParser.CLEAN);
+                }
+            }
+
+            this.state = 10629;
+            this.match(PlSqlParser.RESTORE);
+            this.state = 10630;
+            this.match(PlSqlParser.POINT);
+            this.state = 10631;
+            localContext._rp = this.id_expression();
+            this.state = 10636;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1270, this.context) ) {
+            case 1:
+                {
+                this.state = 10632;
+                this.match(PlSqlParser.FOR);
+                this.state = 10633;
+                this.match(PlSqlParser.PLUGGABLE);
+                this.state = 10634;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 10635;
+                localContext._pdb = this.id_expression();
+                }
+                break;
+            }
+            this.state = 10642;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1271, this.context) ) {
+            case 1:
+                {
+                this.state = 10638;
+                this.match(PlSqlParser.AS);
+                this.state = 10639;
+                this.match(PlSqlParser.OF);
+                this.state = 10640;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1629 || _la === 2110)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10641;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 10648;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1272, this.context) ) {
+            case 1:
+                {
+                this.state = 10644;
+                this.match(PlSqlParser.PRESERVE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 10645;
+                this.match(PlSqlParser.GUARANTEE);
+                this.state = 10646;
+                this.match(PlSqlParser.FLASHBACK);
+                this.state = 10647;
+                this.match(PlSqlParser.DATABASE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_role(): Create_roleContext {
+        let localContext = new Create_roleContext(this.context, this.state);
+        this.enterRule(localContext, 1048, PlSqlParser.RULE_create_role);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10650;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10651;
+            this.match(PlSqlParser.ROLE);
+            this.state = 10652;
+            this.role_name();
+            this.state = 10654;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1273, this.context) ) {
+            case 1:
+                {
+                this.state = 10653;
+                this.role_identified_clause();
+                }
+                break;
+            }
+            this.state = 10657;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1274, this.context) ) {
+            case 1:
+                {
+                this.state = 10656;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_table(): Create_tableContext {
+        let localContext = new Create_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1050, PlSqlParser.RULE_create_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10659;
+            this.match(PlSqlParser.CREATE);
+            this.state = 10669;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1276, this.context) ) {
+            case 1:
+                {
+                this.state = 10660;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 643 || _la === 1457)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10661;
+                this.match(PlSqlParser.TEMPORARY);
+                }
+                break;
+            case 2:
+                {
+                this.state = 10662;
+                this.match(PlSqlParser.SHARDED);
+                }
+                break;
+            case 3:
+                {
+                this.state = 10663;
+                this.match(PlSqlParser.DUPLICATED);
+                }
+                break;
+            case 4:
+                {
+                this.state = 10665;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2381) {
+                    {
+                    this.state = 10664;
+                    this.match(PlSqlParser.IMMUTABLE);
+                    }
+                }
+
+                this.state = 10667;
+                this.match(PlSqlParser.BLOCKCHAIN);
+                }
+                break;
+            case 5:
+                {
+                this.state = 10668;
+                this.match(PlSqlParser.IMMUTABLE);
+                }
+                break;
+            }
+            this.state = 10671;
+            this.match(PlSqlParser.TABLE);
+            this.state = 10675;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1277, this.context) ) {
+            case 1:
+                {
+                this.state = 10672;
+                this.schema_name();
+                this.state = 10673;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 10677;
+            this.table_name();
+            this.state = 10681;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1278, this.context) ) {
+            case 1:
+                {
+                this.state = 10678;
+                this.match(PlSqlParser.IF);
+                this.state = 10679;
+                this.match(PlSqlParser.NOT);
+                this.state = 10680;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 10693;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1281, this.context) ) {
+            case 1:
+                {
+                this.state = 10683;
+                this.match(PlSqlParser.SHARING);
+                this.state = 10684;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 10691;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.METADATA:
+                    {
+                    this.state = 10685;
+                    this.match(PlSqlParser.METADATA);
+                    }
+                    break;
+                case PlSqlParser.DATA:
+                case PlSqlParser.EXTENDED:
+                    {
+                    this.state = 10687;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2378) {
+                        {
+                        this.state = 10686;
+                        this.match(PlSqlParser.EXTENDED);
+                        }
+                    }
+
+                    this.state = 10689;
+                    this.match(PlSqlParser.DATA);
+                    }
+                    break;
+                case PlSqlParser.NONE:
+                    {
+                    this.state = 10690;
+                    this.match(PlSqlParser.NONE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 10698;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1282, this.context) ) {
+            case 1:
+                {
+                this.state = 10695;
+                this.relational_table();
+                }
+                break;
+            case 2:
+                {
+                this.state = 10696;
+                this.xmltype_table();
+                }
+                break;
+            case 3:
+                {
+                this.state = 10697;
+                this.object_table();
+                }
+                break;
+            }
+            this.state = 10701;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1283, this.context) ) {
+            case 1:
+                {
+                this.state = 10700;
+                this.memoptimize_read_write_clause();
+                }
+                break;
+            }
+            this.state = 10705;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1284, this.context) ) {
+            case 1:
+                {
+                this.state = 10703;
+                this.match(PlSqlParser.PARENT);
+                this.state = 10704;
+                this.tableview_name();
+                }
+                break;
+            }
+            this.state = 10709;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1285, this.context) ) {
+            case 1:
+                {
+                this.state = 10707;
+                this.match(PlSqlParser.USAGE);
+                this.state = 10708;
+                this.match(PlSqlParser.QUEUE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmltype_table(): Xmltype_tableContext {
+        let localContext = new Xmltype_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1052, PlSqlParser.RULE_xmltype_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10711;
+            this.match(PlSqlParser.OF);
+            this.state = 10712;
+            this.match(PlSqlParser.XMLTYPE);
+            this.state = 10717;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1286, this.context) ) {
+            case 1:
+                {
+                this.state = 10713;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 10714;
+                this.object_properties();
+                this.state = 10715;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 10721;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1287, this.context) ) {
+            case 1:
+                {
+                this.state = 10719;
+                this.match(PlSqlParser.XMLTYPE);
+                this.state = 10720;
+                this.xmltype_storage();
+                }
+                break;
+            }
+            this.state = 10724;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1288, this.context) ) {
+            case 1:
+                {
+                this.state = 10723;
+                this.xmlschema_spec();
+                }
+                break;
+            }
+            this.state = 10727;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1289, this.context) ) {
+            case 1:
+                {
+                this.state = 10726;
+                this.xmltype_virtual_columns();
+                }
+                break;
+            }
+            this.state = 10733;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1290, this.context) ) {
+            case 1:
+                {
+                this.state = 10729;
+                this.match(PlSqlParser.ON);
+                this.state = 10730;
+                this.match(PlSqlParser.COMMIT);
+                this.state = 10731;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 403 || _la === 1449)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10732;
+                this.match(PlSqlParser.ROWS);
+                }
+                break;
+            }
+            this.state = 10736;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1291, this.context) ) {
+            case 1:
+                {
+                this.state = 10735;
+                this.oid_clause();
+                }
+                break;
+            }
+            this.state = 10739;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1292, this.context) ) {
+            case 1:
+                {
+                this.state = 10738;
+                this.oid_index_clause();
+                }
+                break;
+            }
+            this.state = 10742;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1293, this.context) ) {
+            case 1:
+                {
+                this.state = 10741;
+                this.physical_properties();
+                }
+                break;
+            }
+            this.state = 10745;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1294, this.context) ) {
+            case 1:
+                {
+                this.state = 10744;
+                this.table_properties();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmltype_virtual_columns(): Xmltype_virtual_columnsContext {
+        let localContext = new Xmltype_virtual_columnsContext(this.context, this.state);
+        this.enterRule(localContext, 1054, PlSqlParser.RULE_xmltype_virtual_columns);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10747;
+            this.match(PlSqlParser.VIRTUAL);
+            this.state = 10748;
+            this.match(PlSqlParser.COLUMNS);
+            this.state = 10749;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10750;
+            this.column_name();
+            this.state = 10751;
+            this.match(PlSqlParser.AS);
+            this.state = 10752;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10753;
+            this.expression();
+            this.state = 10754;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 10764;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 10755;
+                this.match(PlSqlParser.COMMA);
+                this.state = 10756;
+                this.column_name();
+                this.state = 10757;
+                this.match(PlSqlParser.AS);
+                this.state = 10758;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 10759;
+                this.expression();
+                this.state = 10760;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                }
+                this.state = 10766;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 10767;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmltype_column_properties(): Xmltype_column_propertiesContext {
+        let localContext = new Xmltype_column_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1056, PlSqlParser.RULE_xmltype_column_properties);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10769;
+            this.match(PlSqlParser.XMLTYPE);
+            this.state = 10771;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1296, this.context) ) {
+            case 1:
+                {
+                this.state = 10770;
+                this.match(PlSqlParser.COLUMN);
+                }
+                break;
+            }
+            this.state = 10773;
+            this.column_name();
+            this.state = 10775;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1297, this.context) ) {
+            case 1:
+                {
+                this.state = 10774;
+                this.xmltype_storage();
+                }
+                break;
+            }
+            this.state = 10778;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1298, this.context) ) {
+            case 1:
+                {
+                this.state = 10777;
+                this.xmlschema_spec();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmltype_storage(): Xmltype_storageContext {
+        let localContext = new Xmltype_storageContext(this.context, this.state);
+        this.enterRule(localContext, 1058, PlSqlParser.RULE_xmltype_storage);
+        let _la: number;
+        try {
+            this.state = 10811;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1304, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10780;
+                this.match(PlSqlParser.STORE);
+                this.state = 10781;
+                this.match(PlSqlParser.AS);
+                this.state = 10805;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.OBJECT:
+                    {
+                    this.state = 10782;
+                    this.match(PlSqlParser.OBJECT);
+                    this.state = 10783;
+                    this.match(PlSqlParser.RELATIONAL);
+                    }
+                    break;
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.SECUREFILE:
+                    {
+                    this.state = 10785;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 107 || _la === 1642) {
+                        {
+                        this.state = 10784;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 107 || _la === 1642)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 10790;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.CLOB:
+                        {
+                        this.state = 10787;
+                        this.match(PlSqlParser.CLOB);
+                        }
+                        break;
+                    case PlSqlParser.BINARY:
+                        {
+                        this.state = 10788;
+                        this.match(PlSqlParser.BINARY);
+                        this.state = 10789;
+                        this.match(PlSqlParser.XML);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 10803;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1302, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 10792;
+                        this.lob_segname();
+                        this.state = 10797;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1301, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 10793;
+                            this.match(PlSqlParser.LEFT_PAREN);
+                            this.state = 10794;
+                            this.lob_parameters();
+                            this.state = 10795;
+                            this.match(PlSqlParser.RIGHT_PAREN);
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 10799;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 10800;
+                        this.lob_parameters();
+                        this.state = 10801;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10807;
+                this.match(PlSqlParser.STORE);
+                this.state = 10808;
+                this.match(PlSqlParser.VARRAYS);
+                this.state = 10809;
+                this.match(PlSqlParser.AS);
+                this.state = 10810;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 872 || _la === 2083)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlschema_spec(): Xmlschema_specContext {
+        let localContext = new Xmlschema_specContext(this.context, this.state);
+        this.enterRule(localContext, 1060, PlSqlParser.RULE_xmlschema_spec);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10819;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1306, this.context) ) {
+            case 1:
+                {
+                this.state = 10815;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2347) {
+                    {
+                    this.state = 10813;
+                    this.match(PlSqlParser.XMLSCHEMA);
+                    this.state = 10814;
+                    this.match(PlSqlParser.DELIMITED_ID);
+                    }
+                }
+
+                this.state = 10817;
+                this.match(PlSqlParser.ELEMENT);
+                this.state = 10818;
+                this.id_expression();
+                }
+                break;
+            }
+            this.state = 10826;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1307, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 10821;
+                    this.allow_or_disallow();
+                    this.state = 10822;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 56 || _la === 1140)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    }
+                }
+                this.state = 10828;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1307, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_table(): Object_tableContext {
+        let localContext = new Object_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1062, PlSqlParser.RULE_object_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10829;
+            this.match(PlSqlParser.OF);
+            this.state = 10833;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1308, this.context) ) {
+            case 1:
+                {
+                this.state = 10830;
+                this.schema_name();
+                this.state = 10831;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 10835;
+            this.object_type();
+            this.state = 10837;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1309, this.context) ) {
+            case 1:
+                {
+                this.state = 10836;
+                this.object_table_substitution();
+                }
+                break;
+            }
+            this.state = 10850;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1311, this.context) ) {
+            case 1:
+                {
+                this.state = 10839;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 10840;
+                this.object_properties();
+                this.state = 10845;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 10841;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 10842;
+                    this.object_properties();
+                    }
+                    }
+                    this.state = 10847;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 10848;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 10856;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1312, this.context) ) {
+            case 1:
+                {
+                this.state = 10852;
+                this.match(PlSqlParser.ON);
+                this.state = 10853;
+                this.match(PlSqlParser.COMMIT);
+                this.state = 10854;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 403 || _la === 1449)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 10855;
+                this.match(PlSqlParser.ROWS);
+                }
+                break;
+            }
+            this.state = 10859;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1313, this.context) ) {
+            case 1:
+                {
+                this.state = 10858;
+                this.oid_clause();
+                }
+                break;
+            }
+            this.state = 10862;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1314, this.context) ) {
+            case 1:
+                {
+                this.state = 10861;
+                this.oid_index_clause();
+                }
+                break;
+            }
+            this.state = 10865;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1315, this.context) ) {
+            case 1:
+                {
+                this.state = 10864;
+                this.physical_properties();
+                }
+                break;
+            }
+            this.state = 10868;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1316, this.context) ) {
+            case 1:
+                {
+                this.state = 10867;
+                this.table_properties();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_type(): Object_typeContext {
+        let localContext = new Object_typeContext(this.context, this.state);
+        this.enterRule(localContext, 1064, PlSqlParser.RULE_object_type);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10870;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public oid_index_clause(): Oid_index_clauseContext {
+        let localContext = new Oid_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1066, PlSqlParser.RULE_oid_index_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10872;
+            this.match(PlSqlParser.OIDINDEX);
+            this.state = 10874;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                this.state = 10873;
+                this.index_name();
+                }
+            }
+
+            this.state = 10876;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 10880;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                this.state = 10880;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.PCTFREE:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.STORAGE:
+                    {
+                    this.state = 10877;
+                    this.physical_attributes_clause();
+                    }
+                    break;
+                case PlSqlParser.TABLESPACE:
+                    {
+                    this.state = 10878;
+                    this.match(PlSqlParser.TABLESPACE);
+                    this.state = 10879;
+                    this.tablespace();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 10882;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 260 || _la === 744 || _la === 932 || _la === 1371 || _la === 1374 || _la === 1764 || _la === 2082);
+            this.state = 10884;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public oid_clause(): Oid_clauseContext {
+        let localContext = new Oid_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1068, PlSqlParser.RULE_oid_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10886;
+            this.match(PlSqlParser.OBJECT);
+            this.state = 10887;
+            this.match(PlSqlParser.IDENTIFIER);
+            this.state = 10888;
+            this.match(PlSqlParser.IS);
+            this.state = 10893;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SYSTEM:
+                {
+                this.state = 10889;
+                this.match(PlSqlParser.SYSTEM);
+                this.state = 10890;
+                this.match(PlSqlParser.GENERATED);
+                }
+                break;
+            case PlSqlParser.PRIMARY:
+                {
+                this.state = 10891;
+                this.match(PlSqlParser.PRIMARY);
+                this.state = 10892;
+                this.match(PlSqlParser.KEY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_properties(): Object_propertiesContext {
+        let localContext = new Object_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1070, PlSqlParser.RULE_object_properties);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 10917;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1325, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10897;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1321, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10895;
+                    this.column_name();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10896;
+                    this.attribute_name();
+                    }
+                    break;
+                }
+                this.state = 10901;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 389) {
+                    {
+                    this.state = 10899;
+                    this.match(PlSqlParser.DEFAULT);
+                    this.state = 10900;
+                    this.expression();
+                    }
+                }
+
+                this.state = 10912;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1324, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10903;
+                    this.inline_constraint();
+                    this.state = 10908;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1323, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 10904;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 10905;
+                            this.inline_constraint();
+                            }
+                            }
+                        }
+                        this.state = 10910;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1323, this.context);
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10911;
+                    this.inline_ref_constraint();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10914;
+                this.out_of_line_constraint();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 10915;
+                this.out_of_line_ref_constraint();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 10916;
+                this.supplemental_logging_props();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_table_substitution(): Object_table_substitutionContext {
+        let localContext = new Object_table_substitutionContext(this.context, this.state);
+        this.enterRule(localContext, 1072, PlSqlParser.RULE_object_table_substitution);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10920;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 10919;
+                this.match(PlSqlParser.NOT);
+                }
+            }
+
+            this.state = 10922;
+            this.match(PlSqlParser.SUBSTITUTABLE);
+            this.state = 10923;
+            this.match(PlSqlParser.AT);
+            this.state = 10924;
+            this.match(PlSqlParser.ALL);
+            this.state = 10925;
+            this.match(PlSqlParser.LEVELS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public relational_table(): Relational_tableContext {
+        let localContext = new Relational_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1074, PlSqlParser.RULE_relational_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10938;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1328, this.context) ) {
+            case 1:
+                {
+                this.state = 10927;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 10928;
+                this.relational_property();
+                this.state = 10933;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 10929;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 10930;
+                    this.relational_property();
+                    }
+                    }
+                    this.state = 10935;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 10936;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 10941;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1329, this.context) ) {
+            case 1:
+                {
+                this.state = 10940;
+                this.relational_table_properties();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public relational_table_properties(): Relational_table_propertiesContext {
+        let localContext = new Relational_table_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1076, PlSqlParser.RULE_relational_table_properties);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10944;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 10943;
+                    this.relational_table_property();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 10946;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1330, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public relational_table_property(): Relational_table_propertyContext {
+        let localContext = new Relational_table_propertyContext(this.context, this.state);
+        this.enterRule(localContext, 1078, PlSqlParser.RULE_relational_table_property);
+        let _la: number;
+        try {
+            this.state = 10963;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1332, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10948;
+                this.immutable_table_clauses();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10949;
+                this.blockchain_table_clauses();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 10950;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 10951;
+                this.match(PlSqlParser.COLLATION);
+                this.state = 10952;
+                this.collation_name();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 10953;
+                this.match(PlSqlParser.ON);
+                this.state = 10954;
+                this.match(PlSqlParser.COMMIT);
+                this.state = 10959;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1331, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10955;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 469 || _la === 1449)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 10956;
+                    this.match(PlSqlParser.DEFINITION);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 10957;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 403 || _la === 1449)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 10958;
+                    this.match(PlSqlParser.ROWS);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 10961;
+                this.physical_properties();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 10962;
+                this.table_properties();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public immutable_table_clauses(): Immutable_table_clausesContext {
+        let localContext = new Immutable_table_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1080, PlSqlParser.RULE_immutable_table_clauses);
+        try {
+            this.state = 10967;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1333, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 10965;
+                this.immutable_table_no_drop_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 10966;
+                this.immutable_table_no_delete_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public immutable_table_no_drop_clause(): Immutable_table_no_drop_clauseContext {
+        let localContext = new Immutable_table_no_drop_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1082, PlSqlParser.RULE_immutable_table_no_drop_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10969;
+            this.match(PlSqlParser.NO);
+            this.state = 10970;
+            this.match(PlSqlParser.DROP);
+            this.state = 10976;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1334, this.context) ) {
+            case 1:
+                {
+                this.state = 10971;
+                this.match(PlSqlParser.UNTIL);
+                this.state = 10972;
+                this.numeric();
+                this.state = 10973;
+                this.match(PlSqlParser.DAYS);
+                this.state = 10974;
+                this.match(PlSqlParser.IDLE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public immutable_table_no_delete_clause(): Immutable_table_no_delete_clauseContext {
+        let localContext = new Immutable_table_no_delete_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1084, PlSqlParser.RULE_immutable_table_no_delete_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10978;
+            this.match(PlSqlParser.NO);
+            this.state = 10979;
+            this.match(PlSqlParser.DELETE);
+            this.state = 10991;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1337, this.context) ) {
+            case 1:
+                {
+                this.state = 10981;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1335, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10980;
+                    this.match(PlSqlParser.LOCKED);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 10983;
+                this.match(PlSqlParser.UNTIL);
+                this.state = 10984;
+                this.numeric();
+                this.state = 10985;
+                this.match(PlSqlParser.DAYS);
+                this.state = 10986;
+                this.match(PlSqlParser.AFTER);
+                this.state = 10987;
+                this.match(PlSqlParser.INSERT);
+                this.state = 10989;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1336, this.context) ) {
+                case 1:
+                    {
+                    this.state = 10988;
+                    this.match(PlSqlParser.LOCKED);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public blockchain_table_clauses(): Blockchain_table_clausesContext {
+        let localContext = new Blockchain_table_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1086, PlSqlParser.RULE_blockchain_table_clauses);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10993;
+            this.blockchain_drop_table_clause();
+            this.state = 10994;
+            this.blockchain_row_retention_clause();
+            this.state = 10995;
+            this.blockchain_hash_and_data_format_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public blockchain_drop_table_clause(): Blockchain_drop_table_clauseContext {
+        let localContext = new Blockchain_drop_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1088, PlSqlParser.RULE_blockchain_drop_table_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 10997;
+            this.match(PlSqlParser.NO);
+            this.state = 10998;
+            this.match(PlSqlParser.DROP);
+            this.state = 11004;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2204) {
+                {
+                this.state = 10999;
+                this.match(PlSqlParser.UNTIL);
+                this.state = 11000;
+                this.numeric();
+                this.state = 11001;
+                this.match(PlSqlParser.DAYS);
+                this.state = 11002;
+                this.match(PlSqlParser.IDLE);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public blockchain_row_retention_clause(): Blockchain_row_retention_clauseContext {
+        let localContext = new Blockchain_row_retention_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1090, PlSqlParser.RULE_blockchain_row_retention_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11006;
+            this.match(PlSqlParser.NO);
+            this.state = 11007;
+            this.match(PlSqlParser.DELETE);
+            this.state = 11019;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.HASHING:
+                {
+                this.state = 11009;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 880) {
+                    {
+                    this.state = 11008;
+                    this.match(PlSqlParser.LOCKED);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.UNTIL:
+                {
+                this.state = 11011;
+                this.match(PlSqlParser.UNTIL);
+                this.state = 11012;
+                this.numeric();
+                this.state = 11013;
+                this.match(PlSqlParser.DAYS);
+                this.state = 11014;
+                this.match(PlSqlParser.AFTER);
+                this.state = 11015;
+                this.match(PlSqlParser.INSERT);
+                this.state = 11017;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 880) {
+                    {
+                    this.state = 11016;
+                    this.match(PlSqlParser.LOCKED);
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public blockchain_hash_and_data_format_clause(): Blockchain_hash_and_data_format_clauseContext {
+        let localContext = new Blockchain_hash_and_data_format_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1092, PlSqlParser.RULE_blockchain_hash_and_data_format_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11021;
+            this.match(PlSqlParser.HASHING);
+            this.state = 11022;
+            this.match(PlSqlParser.USING);
+            this.state = 11023;
+            this.match(PlSqlParser.SHA2_512_Q);
+            this.state = 11024;
+            this.match(PlSqlParser.VERSION);
+            this.state = 11025;
+            this.match(PlSqlParser.V1_Q);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public collation_name(): Collation_nameContext {
+        let localContext = new Collation_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1094, PlSqlParser.RULE_collation_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11027;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_properties(): Table_propertiesContext {
+        let localContext = new Table_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1096, PlSqlParser.RULE_table_properties);
+        let _la: number;
+        try {
+            this.state = 11059;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1343, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11029;
+                this.column_properties();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11030;
+                this.read_only_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 11031;
+                this.indexing_clause();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 11032;
+                this.table_partitioning_clauses();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 11033;
+                this.attribute_clustering_clause();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 11034;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 166 || _la === 1067)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 11035;
+                this.result_cache_clause();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 11036;
+                this.parallel_clause();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 11037;
+                this.monitoring_nomonitoring();
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 11038;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1182 || _la === 1601)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 11039;
+                this.enable_disable_clause();
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 11040;
+                this.row_movement_clause();
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 11041;
+                this.logical_replication_clause();
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 11042;
+                this.flashback_archive_clause();
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 11043;
+                this.physical_properties();
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 11044;
+                this.match(PlSqlParser.ROW);
+                this.state = 11045;
+                this.match(PlSqlParser.ARCHIVAL);
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 11046;
+                this.match(PlSqlParser.AS);
+                this.state = 11047;
+                this.select_only_statement();
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 11048;
+                this.match(PlSqlParser.FOR);
+                this.state = 11049;
+                this.match(PlSqlParser.EXCHANGE);
+                this.state = 11050;
+                this.match(PlSqlParser.WITH);
+                this.state = 11051;
+                this.match(PlSqlParser.TABLE);
+                this.state = 11055;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1342, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11052;
+                    this.schema_name();
+                    this.state = 11053;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 11057;
+                this.table_name();
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 11058;
+                this.annotations_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public read_only_clause(): Read_only_clauseContext {
+        let localContext = new Read_only_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1098, PlSqlParser.RULE_read_only_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11061;
+            this.match(PlSqlParser.READ);
+            this.state = 11062;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1260 || _la === 2315)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public indexing_clause(): Indexing_clauseContext {
+        let localContext = new Indexing_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1100, PlSqlParser.RULE_indexing_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11064;
+            this.match(PlSqlParser.INDEXING);
+            this.state = 11065;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1246 || _la === 1261)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public attribute_clustering_clause(): Attribute_clustering_clauseContext {
+        let localContext = new Attribute_clustering_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1102, PlSqlParser.RULE_attribute_clustering_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11067;
+            this.match(PlSqlParser.CLUSTERING);
+            this.state = 11069;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                this.state = 11068;
+                this.clustering_join();
+                }
+            }
+
+            this.state = 11071;
+            this.cluster_clause();
+            this.state = 11077;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1346, this.context) ) {
+            case 1:
+                {
+                this.state = 11073;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139 || _la === 2362) {
+                    {
+                    this.state = 11072;
+                    this.yes_no();
+                    }
+                }
+
+                this.state = 11075;
+                this.match(PlSqlParser.ON);
+                this.state = 11076;
+                this.match(PlSqlParser.LOAD);
+                }
+                break;
+            }
+            this.state = 11085;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1348, this.context) ) {
+            case 1:
+                {
+                this.state = 11080;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139 || _la === 2362) {
+                    {
+                    this.state = 11079;
+                    this.yes_no();
+                    }
+                }
+
+                this.state = 11082;
+                this.match(PlSqlParser.ON);
+                this.state = 11083;
+                this.match(PlSqlParser.DATA);
+                this.state = 11084;
+                this.match(PlSqlParser.MOVEMENT);
+                }
+                break;
+            }
+            this.state = 11088;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1349, this.context) ) {
+            case 1:
+                {
+                this.state = 11087;
+                this.zonemap_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public clustering_join(): Clustering_joinContext {
+        let localContext = new Clustering_joinContext(this.context, this.state);
+        this.enterRule(localContext, 1104, PlSqlParser.RULE_clustering_join);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11093;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1350, this.context) ) {
+            case 1:
+                {
+                this.state = 11090;
+                this.schema_name();
+                this.state = 11091;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 11095;
+            this.table_name();
+            this.state = 11096;
+            this.clustering_join_item();
+            this.state = 11101;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11097;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11098;
+                this.clustering_join_item();
+                }
+                }
+                this.state = 11103;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public clustering_join_item(): Clustering_join_itemContext {
+        let localContext = new Clustering_join_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1106, PlSqlParser.RULE_clustering_join_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11104;
+            this.match(PlSqlParser.JOIN);
+            this.state = 11108;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1352, this.context) ) {
+            case 1:
+                {
+                this.state = 11105;
+                this.schema_name();
+                this.state = 11106;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 11110;
+            this.table_name();
+            this.state = 11111;
+            this.match(PlSqlParser.ON);
+            this.state = 11112;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11113;
+            this.equijoin_condition();
+            this.state = 11114;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public equijoin_condition(): Equijoin_conditionContext {
+        let localContext = new Equijoin_conditionContext(this.context, this.state);
+        this.enterRule(localContext, 1108, PlSqlParser.RULE_equijoin_condition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11116;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cluster_clause(): Cluster_clauseContext {
+        let localContext = new Cluster_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1110, PlSqlParser.RULE_cluster_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11118;
+            this.match(PlSqlParser.BY);
+            this.state = 11120;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 771 || _la === 860) {
+                {
+                this.state = 11119;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 771 || _la === 860)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 11122;
+            this.match(PlSqlParser.ORDER);
+            this.state = 11123;
+            this.clustering_columns();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public clustering_columns(): Clustering_columnsContext {
+        let localContext = new Clustering_columnsContext(this.context, this.state);
+        this.enterRule(localContext, 1112, PlSqlParser.RULE_clustering_columns);
+        let _la: number;
+        try {
+            this.state = 11137;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1355, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11125;
+                this.clustering_column_group();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11126;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11127;
+                this.clustering_column_group();
+                this.state = 11132;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11128;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11129;
+                    this.clustering_column_group();
+                    }
+                    }
+                    this.state = 11134;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 11135;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public clustering_column_group(): Clustering_column_groupContext {
+        let localContext = new Clustering_column_groupContext(this.context, this.state);
+        this.enterRule(localContext, 1114, PlSqlParser.RULE_clustering_column_group);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11139;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11140;
+            this.column_name();
+            this.state = 11145;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11141;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11142;
+                this.column_name();
+                }
+                }
+                this.state = 11147;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11148;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public yes_no(): Yes_noContext {
+        let localContext = new Yes_noContext(this.context, this.state);
+        this.enterRule(localContext, 1116, PlSqlParser.RULE_yes_no);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11150;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1139 || _la === 2362)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public zonemap_clause(): Zonemap_clauseContext {
+        let localContext = new Zonemap_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1118, PlSqlParser.RULE_zonemap_clause);
+        try {
+            this.state = 11164;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.WITH:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11152;
+                this.match(PlSqlParser.WITH);
+                this.state = 11153;
+                this.match(PlSqlParser.MATERIALIZED);
+                this.state = 11154;
+                this.match(PlSqlParser.ZONEMAP);
+                this.state = 11159;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1357, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11155;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11156;
+                    this.zonemap_name();
+                    this.state = 11157;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.WITHOUT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11161;
+                this.match(PlSqlParser.WITHOUT);
+                this.state = 11162;
+                this.match(PlSqlParser.MATERIALIZED);
+                this.state = 11163;
+                this.match(PlSqlParser.ZONEMAP);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public logical_replication_clause(): Logical_replication_clauseContext {
+        let localContext = new Logical_replication_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1120, PlSqlParser.RULE_logical_replication_clause);
+        let _la: number;
+        try {
+            this.state = 11185;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DISABLE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11166;
+                this.match(PlSqlParser.DISABLE);
+                this.state = 11167;
+                this.match(PlSqlParser.LOGICAL);
+                this.state = 11168;
+                this.match(PlSqlParser.REPLICATION);
+                }
+                break;
+            case PlSqlParser.ENABLE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11169;
+                this.match(PlSqlParser.ENABLE);
+                this.state = 11170;
+                this.match(PlSqlParser.LOGICAL);
+                this.state = 11171;
+                this.match(PlSqlParser.REPLICATION);
+                this.state = 11183;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1361, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11175;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.ALL:
+                        {
+                        this.state = 11172;
+                        this.match(PlSqlParser.ALL);
+                        }
+                        break;
+                    case PlSqlParser.ALLOW:
+                        {
+                        this.state = 11173;
+                        this.match(PlSqlParser.ALLOW);
+                        this.state = 11174;
+                        this.match(PlSqlParser.NOVALIDATE);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 11177;
+                    this.match(PlSqlParser.KEYS);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 11179;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1139) {
+                        {
+                        this.state = 11178;
+                        this.match(PlSqlParser.NO);
+                        }
+                    }
+
+                    this.state = 11181;
+                    this.match(PlSqlParser.PARTIAL);
+                    this.state = 11182;
+                    this.match(PlSqlParser.JSON);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_name(): Table_nameContext {
+        let localContext = new Table_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1122, PlSqlParser.RULE_table_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11187;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public relational_property(): Relational_propertyContext {
+        let localContext = new Relational_propertyContext(this.context, this.state);
+        this.enterRule(localContext, 1124, PlSqlParser.RULE_relational_property);
+        try {
+            this.state = 11195;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1363, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11189;
+                this.out_of_line_constraint();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11190;
+                this.out_of_line_ref_constraint();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 11191;
+                this.column_definition();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 11192;
+                this.virtual_column_definition();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 11193;
+                this.period_definition();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 11194;
+                this.supplemental_logging_props();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_partitioning_clauses(): Table_partitioning_clausesContext {
+        let localContext = new Table_partitioning_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1126, PlSqlParser.RULE_table_partitioning_clauses);
+        try {
+            this.state = 11205;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1364, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11197;
+                this.range_partitions();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11198;
+                this.list_partitions();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 11199;
+                this.hash_partitions();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 11200;
+                this.composite_range_partitions();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 11201;
+                this.composite_list_partitions();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 11202;
+                this.composite_hash_partitions();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 11203;
+                this.reference_partitioning();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 11204;
+                this.system_partitioning();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public range_partitions(): Range_partitionsContext {
+        let localContext = new Range_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1128, PlSqlParser.RULE_range_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11207;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11208;
+            this.match(PlSqlParser.BY);
+            this.state = 11209;
+            this.match(PlSqlParser.RANGE);
+            this.state = 11210;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11211;
+            this.column_name();
+            this.state = 11216;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11212;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11213;
+                this.column_name();
+                }
+                }
+                this.state = 11218;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11219;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11239;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 777) {
+                {
+                this.state = 11220;
+                this.match(PlSqlParser.INTERVAL);
+                this.state = 11221;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11222;
+                this.expression();
+                this.state = 11223;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 11237;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1765) {
+                    {
+                    this.state = 11224;
+                    this.match(PlSqlParser.STORE);
+                    this.state = 11225;
+                    this.match(PlSqlParser.IN);
+                    this.state = 11226;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11227;
+                    this.tablespace();
+                    this.state = 11232;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11228;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11229;
+                        this.tablespace();
+                        }
+                        }
+                        this.state = 11234;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 11235;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                }
+            }
+
+            this.state = 11241;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11242;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11244;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 11243;
+                this.partition_name();
+                }
+            }
+
+            this.state = 11246;
+            this.range_values_clause();
+            this.state = 11247;
+            this.table_partition_description();
+            this.state = 11258;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11248;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11249;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 11251;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                    {
+                    this.state = 11250;
+                    this.partition_name();
+                    }
+                }
+
+                this.state = 11253;
+                this.range_values_clause();
+                this.state = 11254;
+                this.table_partition_description();
+                }
+                }
+                this.state = 11260;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11261;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public list_partitions(): List_partitionsContext {
+        let localContext = new List_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1130, PlSqlParser.RULE_list_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11263;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11264;
+            this.match(PlSqlParser.BY);
+            this.state = 11265;
+            this.match(PlSqlParser.LIST);
+            this.state = 11266;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11267;
+            this.column_name();
+            this.state = 11268;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11285;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1374, this.context) ) {
+            case 1:
+                {
+                this.state = 11269;
+                this.match(PlSqlParser.AUTOMATIC);
+                this.state = 11283;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1373, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11270;
+                    this.match(PlSqlParser.STORE);
+                    this.state = 11271;
+                    this.match(PlSqlParser.IN);
+                    this.state = 11272;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11273;
+                    this.tablespace();
+                    this.state = 11278;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11274;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11275;
+                        this.tablespace();
+                        }
+                        }
+                        this.state = 11280;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 11281;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 11309;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1378, this.context) ) {
+            case 1:
+                {
+                this.state = 11287;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11288;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 11290;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                    {
+                    this.state = 11289;
+                    this.partition_name();
+                    }
+                }
+
+                this.state = 11292;
+                this.list_values_clause();
+                this.state = 11293;
+                this.table_partition_description();
+                this.state = 11304;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11294;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11295;
+                    this.match(PlSqlParser.PARTITION);
+                    this.state = 11297;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                        {
+                        this.state = 11296;
+                        this.partition_name();
+                        }
+                    }
+
+                    this.state = 11299;
+                    this.list_values_clause();
+                    this.state = 11300;
+                    this.table_partition_description();
+                    }
+                    }
+                    this.state = 11306;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 11307;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hash_partitions(): Hash_partitionsContext {
+        let localContext = new Hash_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1132, PlSqlParser.RULE_hash_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11311;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11312;
+            this.match(PlSqlParser.BY);
+            this.state = 11313;
+            this.match(PlSqlParser.HASH);
+            this.state = 11314;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11315;
+            this.column_name();
+            this.state = 11320;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11316;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11317;
+                this.column_name();
+                }
+                }
+                this.state = 11322;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11323;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11326;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 11324;
+                this.individual_hash_partitions();
+                }
+                break;
+            case PlSqlParser.PARTITIONS:
+                {
+                this.state = 11325;
+                this.hash_partitions_by_quantity();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public individual_hash_partitions(): Individual_hash_partitionsContext {
+        let localContext = new Individual_hash_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1134, PlSqlParser.RULE_individual_hash_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11328;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11329;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11331;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1381, this.context) ) {
+            case 1:
+                {
+                this.state = 11330;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 11334;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 237 || _la === 258 || _la === 747 || _la === 869 || _la === 1075 || _la === 1139 || _la === 1322 || _la === 1608 || _la === 2082 || _la === 2269) {
+                {
+                this.state = 11333;
+                this.partitioning_storage_clause();
+                }
+            }
+
+            this.state = 11346;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11336;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11337;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 11339;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1383, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11338;
+                    this.partition_name();
+                    }
+                    break;
+                }
+                this.state = 11342;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 237 || _la === 258 || _la === 747 || _la === 869 || _la === 1075 || _la === 1139 || _la === 1322 || _la === 1608 || _la === 2082 || _la === 2269) {
+                    {
+                    this.state = 11341;
+                    this.partitioning_storage_clause();
+                    }
+                }
+
+                }
+                }
+                this.state = 11348;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11349;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hash_partitions_by_quantity(): Hash_partitions_by_quantityContext {
+        let localContext = new Hash_partitions_by_quantityContext(this.context, this.state);
+        this.enterRule(localContext, 1136, PlSqlParser.RULE_hash_partitions_by_quantity);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11351;
+            this.match(PlSqlParser.PARTITIONS);
+            this.state = 11352;
+            this.hash_partition_quantity();
+            this.state = 11366;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1387, this.context) ) {
+            case 1:
+                {
+                this.state = 11353;
+                this.match(PlSqlParser.STORE);
+                this.state = 11354;
+                this.match(PlSqlParser.IN);
+                this.state = 11355;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11356;
+                this.tablespace();
+                this.state = 11361;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11357;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11358;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 11363;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 11364;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 11370;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1388, this.context) ) {
+            case 1:
+                {
+                this.state = 11368;
+                this.table_compression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 11369;
+                this.key_compression();
+                }
+                break;
+            }
+            this.state = 11386;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1390, this.context) ) {
+            case 1:
+                {
+                this.state = 11372;
+                this.match(PlSqlParser.OVERFLOW_);
+                this.state = 11373;
+                this.match(PlSqlParser.STORE);
+                this.state = 11374;
+                this.match(PlSqlParser.IN);
+                this.state = 11375;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11376;
+                this.tablespace();
+                this.state = 11381;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11377;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11378;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 11383;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 11384;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hash_partition_quantity(): Hash_partition_quantityContext {
+        let localContext = new Hash_partition_quantityContext(this.context, this.state);
+        this.enterRule(localContext, 1138, PlSqlParser.RULE_hash_partition_quantity);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11388;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public composite_range_partitions(): Composite_range_partitionsContext {
+        let localContext = new Composite_range_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1140, PlSqlParser.RULE_composite_range_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11390;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11391;
+            this.match(PlSqlParser.BY);
+            this.state = 11392;
+            this.match(PlSqlParser.RANGE);
+            this.state = 11393;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11394;
+            this.column_name();
+            this.state = 11399;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11395;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11396;
+                this.column_name();
+                }
+                }
+                this.state = 11401;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11402;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11422;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 777) {
+                {
+                this.state = 11403;
+                this.match(PlSqlParser.INTERVAL);
+                this.state = 11404;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11405;
+                this.expression();
+                this.state = 11406;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 11420;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1765) {
+                    {
+                    this.state = 11407;
+                    this.match(PlSqlParser.STORE);
+                    this.state = 11408;
+                    this.match(PlSqlParser.IN);
+                    this.state = 11409;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11410;
+                    this.tablespace();
+                    this.state = 11415;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11411;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11412;
+                        this.tablespace();
+                        }
+                        }
+                        this.state = 11417;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 11418;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                }
+            }
+
+            this.state = 11427;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1395, this.context) ) {
+            case 1:
+                {
+                this.state = 11424;
+                this.subpartition_by_range();
+                }
+                break;
+            case 2:
+                {
+                this.state = 11425;
+                this.subpartition_by_list();
+                }
+                break;
+            case 3:
+                {
+                this.state = 11426;
+                this.subpartition_by_hash();
+                }
+                break;
+            }
+            this.state = 11429;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11430;
+            this.range_partition_desc();
+            this.state = 11435;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11431;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11432;
+                this.range_partition_desc();
+                }
+                }
+                this.state = 11437;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11438;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public composite_list_partitions(): Composite_list_partitionsContext {
+        let localContext = new Composite_list_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1142, PlSqlParser.RULE_composite_list_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11440;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11441;
+            this.match(PlSqlParser.BY);
+            this.state = 11442;
+            this.match(PlSqlParser.LIST);
+            this.state = 11443;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11444;
+            this.column_name();
+            this.state = 11445;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11449;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1397, this.context) ) {
+            case 1:
+                {
+                this.state = 11446;
+                this.subpartition_by_range();
+                }
+                break;
+            case 2:
+                {
+                this.state = 11447;
+                this.subpartition_by_list();
+                }
+                break;
+            case 3:
+                {
+                this.state = 11448;
+                this.subpartition_by_hash();
+                }
+                break;
+            }
+            this.state = 11451;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11452;
+            this.list_partition_desc();
+            this.state = 11457;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11453;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11454;
+                this.list_partition_desc();
+                }
+                }
+                this.state = 11459;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11460;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public composite_hash_partitions(): Composite_hash_partitionsContext {
+        let localContext = new Composite_hash_partitionsContext(this.context, this.state);
+        this.enterRule(localContext, 1144, PlSqlParser.RULE_composite_hash_partitions);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11462;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11463;
+            this.match(PlSqlParser.BY);
+            this.state = 11464;
+            this.match(PlSqlParser.HASH);
+            this.state = 11465;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11468;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 11466;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11467;
+                this.column_name();
+                }
+                }
+                this.state = 11470;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2455);
+            this.state = 11472;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11476;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1400, this.context) ) {
+            case 1:
+                {
+                this.state = 11473;
+                this.subpartition_by_range();
+                }
+                break;
+            case 2:
+                {
+                this.state = 11474;
+                this.subpartition_by_list();
+                }
+                break;
+            case 3:
+                {
+                this.state = 11475;
+                this.subpartition_by_hash();
+                }
+                break;
+            }
+            this.state = 11480;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 11478;
+                this.individual_hash_partitions();
+                }
+                break;
+            case PlSqlParser.PARTITIONS:
+                {
+                this.state = 11479;
+                this.hash_partitions_by_quantity();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public reference_partitioning(): Reference_partitioningContext {
+        let localContext = new Reference_partitioningContext(this.context, this.state);
+        this.enterRule(localContext, 1146, PlSqlParser.RULE_reference_partitioning);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11482;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11483;
+            this.match(PlSqlParser.BY);
+            this.state = 11484;
+            this.match(PlSqlParser.REFERENCE);
+            this.state = 11485;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11486;
+            this.constraint_name();
+            this.state = 11487;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11499;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1403, this.context) ) {
+            case 1:
+                {
+                this.state = 11488;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11489;
+                this.reference_partition_desc();
+                this.state = 11494;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11490;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11491;
+                    this.reference_partition_desc();
+                    }
+                    }
+                    this.state = 11496;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 11497;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public reference_partition_desc(): Reference_partition_descContext {
+        let localContext = new Reference_partition_descContext(this.context, this.state);
+        this.enterRule(localContext, 1148, PlSqlParser.RULE_reference_partition_desc);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11501;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11503;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1404, this.context) ) {
+            case 1:
+                {
+                this.state = 11502;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 11505;
+            this.table_partition_description();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public system_partitioning(): System_partitioningContext {
+        let localContext = new System_partitioningContext(this.context, this.state);
+        this.enterRule(localContext, 1150, PlSqlParser.RULE_system_partitioning);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11507;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11508;
+            this.match(PlSqlParser.BY);
+            this.state = 11509;
+            this.match(PlSqlParser.SYSTEM);
+            this.state = 11520;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1406, this.context) ) {
+            case 1:
+                {
+                this.state = 11510;
+                this.match(PlSqlParser.PARTITIONS);
+                this.state = 11511;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case 2:
+                {
+                this.state = 11512;
+                this.reference_partition_desc();
+                this.state = 11517;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1405, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 11513;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11514;
+                        this.reference_partition_desc();
+                        }
+                        }
+                    }
+                    this.state = 11519;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1405, this.context);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public range_partition_desc(): Range_partition_descContext {
+        let localContext = new Range_partition_descContext(this.context, this.state);
+        this.enterRule(localContext, 1152, PlSqlParser.RULE_range_partition_desc);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11522;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11524;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1407, this.context) ) {
+            case 1:
+                {
+                this.state = 11523;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 11527;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1408, this.context) ) {
+            case 1:
+                {
+                this.state = 11526;
+                this.range_values_clause();
+                }
+                break;
+            }
+            this.state = 11529;
+            this.table_partition_description();
+            this.state = 11562;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1414, this.context) ) {
+            case 1:
+                {
+                this.state = 11560;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 11530;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11555;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1412, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11531;
+                        this.range_subpartition_desc();
+                        this.state = 11536;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        while (_la === 2455) {
+                            {
+                            {
+                            this.state = 11532;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 11533;
+                            this.range_subpartition_desc();
+                            }
+                            }
+                            this.state = 11538;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 11539;
+                        this.list_subpartition_desc();
+                        this.state = 11544;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        while (_la === 2455) {
+                            {
+                            {
+                            this.state = 11540;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 11541;
+                            this.list_subpartition_desc();
+                            }
+                            }
+                            this.state = 11546;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        }
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 11547;
+                        this.individual_hash_subparts();
+                        this.state = 11552;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        while (_la === 2455) {
+                            {
+                            {
+                            this.state = 11548;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 11549;
+                            this.individual_hash_subparts();
+                            }
+                            }
+                            this.state = 11554;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        }
+                        }
+                        break;
+                    }
+                    this.state = 11557;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case PlSqlParser.SUBPARTITIONS:
+                    {
+                    this.state = 11559;
+                    this.hash_subparts_by_quantity();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public list_partition_desc(): List_partition_descContext {
+        let localContext = new List_partition_descContext(this.context, this.state);
+        this.enterRule(localContext, 1154, PlSqlParser.RULE_list_partition_desc);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11564;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 11566;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1415, this.context) ) {
+            case 1:
+                {
+                this.state = 11565;
+                this.partition_name();
+                }
+                break;
+            }
+            this.state = 11569;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1416, this.context) ) {
+            case 1:
+                {
+                this.state = 11568;
+                this.list_values_clause();
+                }
+                break;
+            }
+            this.state = 11571;
+            this.table_partition_description();
+            this.state = 11604;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1422, this.context) ) {
+            case 1:
+                {
+                this.state = 11602;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 11572;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11597;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1420, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11573;
+                        this.range_subpartition_desc();
+                        this.state = 11578;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        while (_la === 2455) {
+                            {
+                            {
+                            this.state = 11574;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 11575;
+                            this.range_subpartition_desc();
+                            }
+                            }
+                            this.state = 11580;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 11581;
+                        this.list_subpartition_desc();
+                        this.state = 11586;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        while (_la === 2455) {
+                            {
+                            {
+                            this.state = 11582;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 11583;
+                            this.list_subpartition_desc();
+                            }
+                            }
+                            this.state = 11588;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        }
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 11589;
+                        this.individual_hash_subparts();
+                        this.state = 11594;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        while (_la === 2455) {
+                            {
+                            {
+                            this.state = 11590;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 11591;
+                            this.individual_hash_subparts();
+                            }
+                            }
+                            this.state = 11596;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                        }
+                        }
+                        break;
+                    }
+                    this.state = 11599;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case PlSqlParser.SUBPARTITIONS:
+                    {
+                    this.state = 11601;
+                    this.hash_subparts_by_quantity();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_template(): Subpartition_templateContext {
+        let localContext = new Subpartition_templateContext(this.context, this.state);
+        this.enterRule(localContext, 1156, PlSqlParser.RULE_subpartition_template);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11606;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11607;
+            this.match(PlSqlParser.TEMPLATE);
+            {
+            this.state = 11638;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 11608;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11633;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1426, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11609;
+                    this.range_subpartition_desc();
+                    this.state = 11614;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11610;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11611;
+                        this.range_subpartition_desc();
+                        }
+                        }
+                        this.state = 11616;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 11617;
+                    this.list_subpartition_desc();
+                    this.state = 11622;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11618;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11619;
+                        this.list_subpartition_desc();
+                        }
+                        }
+                        this.state = 11624;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 11625;
+                    this.individual_hash_subparts();
+                    this.state = 11630;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11626;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11627;
+                        this.individual_hash_subparts();
+                        }
+                        }
+                        this.state = 11632;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                }
+                this.state = 11635;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 11637;
+                this.hash_subpartition_quantity();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hash_subpartition_quantity(): Hash_subpartition_quantityContext {
+        let localContext = new Hash_subpartition_quantityContext(this.context, this.state);
+        this.enterRule(localContext, 1158, PlSqlParser.RULE_hash_subpartition_quantity);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11640;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_by_range(): Subpartition_by_rangeContext {
+        let localContext = new Subpartition_by_rangeContext(this.context, this.state);
+        this.enterRule(localContext, 1160, PlSqlParser.RULE_subpartition_by_range);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11642;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11643;
+            this.match(PlSqlParser.BY);
+            this.state = 11644;
+            this.match(PlSqlParser.RANGE);
+            this.state = 11645;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11646;
+            this.column_name();
+            this.state = 11651;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11647;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11648;
+                this.column_name();
+                }
+                }
+                this.state = 11653;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11654;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11656;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1777) {
+                {
+                this.state = 11655;
+                this.subpartition_template();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_by_list(): Subpartition_by_listContext {
+        let localContext = new Subpartition_by_listContext(this.context, this.state);
+        this.enterRule(localContext, 1162, PlSqlParser.RULE_subpartition_by_list);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11658;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11659;
+            this.match(PlSqlParser.BY);
+            this.state = 11660;
+            this.match(PlSqlParser.LIST);
+            this.state = 11661;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11662;
+            this.column_name();
+            this.state = 11663;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11665;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1777) {
+                {
+                this.state = 11664;
+                this.subpartition_template();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_by_hash(): Subpartition_by_hashContext {
+        let localContext = new Subpartition_by_hashContext(this.context, this.state);
+        this.enterRule(localContext, 1164, PlSqlParser.RULE_subpartition_by_hash);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11667;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11668;
+            this.match(PlSqlParser.BY);
+            this.state = 11669;
+            this.match(PlSqlParser.HASH);
+            this.state = 11670;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11671;
+            this.column_name();
+            this.state = 11676;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 11672;
+                this.match(PlSqlParser.COMMA);
+                this.state = 11673;
+                this.column_name();
+                }
+                }
+                this.state = 11678;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 11679;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11698;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SUBPARTITIONS:
+                {
+                this.state = 11680;
+                this.match(PlSqlParser.SUBPARTITIONS);
+                this.state = 11681;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 11695;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1765) {
+                    {
+                    this.state = 11682;
+                    this.match(PlSqlParser.STORE);
+                    this.state = 11683;
+                    this.match(PlSqlParser.IN);
+                    this.state = 11684;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11685;
+                    this.tablespace();
+                    this.state = 11690;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 11686;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 11687;
+                        this.tablespace();
+                        }
+                        }
+                        this.state = 11692;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 11693;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 11697;
+                this.subpartition_template();
+                }
+                break;
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.LEFT_PAREN:
+                break;
+            default:
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_name(): Subpartition_nameContext {
+        let localContext = new Subpartition_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1166, PlSqlParser.RULE_subpartition_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11700;
+            this.partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public range_subpartition_desc(): Range_subpartition_descContext {
+        let localContext = new Range_subpartition_descContext(this.context, this.state);
+        this.enterRule(localContext, 1168, PlSqlParser.RULE_range_subpartition_desc);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11702;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11704;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 11703;
+                this.subpartition_name();
+                }
+            }
+
+            this.state = 11706;
+            this.range_values_clause();
+            this.state = 11708;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1436, this.context) ) {
+            case 1:
+                {
+                this.state = 11707;
+                this.partitioning_storage_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public list_subpartition_desc(): List_subpartition_descContext {
+        let localContext = new List_subpartition_descContext(this.context, this.state);
+        this.enterRule(localContext, 1170, PlSqlParser.RULE_list_subpartition_desc);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11710;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11712;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 11711;
+                this.subpartition_name();
+                }
+            }
+
+            this.state = 11714;
+            this.list_values_clause();
+            this.state = 11716;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 237 || _la === 258 || _la === 747 || _la === 869 || _la === 1075 || _la === 1139 || _la === 1322 || _la === 1608 || _la === 2082 || _la === 2269) {
+                {
+                this.state = 11715;
+                this.partitioning_storage_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public individual_hash_subparts(): Individual_hash_subpartsContext {
+        let localContext = new Individual_hash_subpartsContext(this.context, this.state);
+        this.enterRule(localContext, 1172, PlSqlParser.RULE_individual_hash_subparts);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11718;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 11720;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1439, this.context) ) {
+            case 1:
+                {
+                this.state = 11719;
+                this.subpartition_name();
+                }
+                break;
+            }
+            this.state = 11723;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 237 || _la === 258 || _la === 747 || _la === 869 || _la === 1075 || _la === 1139 || _la === 1322 || _la === 1608 || _la === 2082 || _la === 2269) {
+                {
+                this.state = 11722;
+                this.partitioning_storage_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hash_subparts_by_quantity(): Hash_subparts_by_quantityContext {
+        let localContext = new Hash_subparts_by_quantityContext(this.context, this.state);
+        this.enterRule(localContext, 1174, PlSqlParser.RULE_hash_subparts_by_quantity);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11725;
+            this.match(PlSqlParser.SUBPARTITIONS);
+            this.state = 11726;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            this.state = 11740;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1442, this.context) ) {
+            case 1:
+                {
+                this.state = 11727;
+                this.match(PlSqlParser.STORE);
+                this.state = 11728;
+                this.match(PlSqlParser.IN);
+                this.state = 11729;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11730;
+                this.tablespace();
+                this.state = 11735;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11731;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11732;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 11737;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 11738;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public range_values_clause(): Range_values_clauseContext {
+        let localContext = new Range_values_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1176, PlSqlParser.RULE_range_values_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11742;
+            this.match(PlSqlParser.VALUES);
+            this.state = 11743;
+            this.match(PlSqlParser.LESS);
+            this.state = 11744;
+            this.match(PlSqlParser.THAN);
+            this.state = 11745;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11746;
+            this.range_values_list();
+            this.state = 11747;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public range_values_list(): Range_values_listContext {
+        let localContext = new Range_values_listContext(this.context, this.state);
+        this.enterRule(localContext, 1178, PlSqlParser.RULE_range_values_list);
+        let _la: number;
+        try {
+            this.state = 11767;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHR:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.DECODE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.MINUS_SIGN:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11749;
+                this.literal();
+                this.state = 11754;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11750;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11751;
+                    this.literal();
+                    }
+                    }
+                    this.state = 11756;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11757;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 11758;
+                this.literal();
+                this.state = 11764;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11759;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11760;
+                    this.match(PlSqlParser.TIMESTAMP);
+                    this.state = 11761;
+                    this.literal();
+                    }
+                    }
+                    this.state = 11766;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public list_values_clause(): List_values_clauseContext {
+        let localContext = new List_values_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1180, PlSqlParser.RULE_list_values_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11769;
+            this.match(PlSqlParser.VALUES);
+            this.state = 11770;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11790;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHR:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.DECODE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.MINUS_SIGN:
+                {
+                this.state = 11771;
+                this.literal();
+                this.state = 11776;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11772;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11773;
+                    this.literal();
+                    }
+                    }
+                    this.state = 11778;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                {
+                this.state = 11779;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 11780;
+                this.literal();
+                this.state = 11786;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 11781;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 11782;
+                    this.match(PlSqlParser.TIMESTAMP);
+                    this.state = 11783;
+                    this.literal();
+                    }
+                    }
+                    this.state = 11788;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.DEFAULT:
+                {
+                this.state = 11789;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 11792;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_partition_description(): Table_partition_descriptionContext {
+        let localContext = new Table_partition_descriptionContext(this.context, this.state);
+        this.enterRule(localContext, 1182, PlSqlParser.RULE_table_partition_description);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11795;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1449, this.context) ) {
+            case 1:
+                {
+                this.state = 11794;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 561 || _la === 779)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 11798;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1450, this.context) ) {
+            case 1:
+                {
+                this.state = 11797;
+                this.deferred_segment_creation();
+                }
+                break;
+            }
+            this.state = 11801;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1451, this.context) ) {
+            case 1:
+                {
+                this.state = 11800;
+                this.read_only_clause();
+                }
+                break;
+            }
+            this.state = 11804;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1452, this.context) ) {
+            case 1:
+                {
+                this.state = 11803;
+                this.indexing_clause();
+                }
+                break;
+            }
+            this.state = 11807;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1453, this.context) ) {
+            case 1:
+                {
+                this.state = 11806;
+                this.segment_attributes_clause();
+                }
+                break;
+            }
+            this.state = 11811;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1454, this.context) ) {
+            case 1:
+                {
+                this.state = 11809;
+                this.table_compression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 11810;
+                this.key_compression();
+                }
+                break;
+            }
+            this.state = 11814;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1455, this.context) ) {
+            case 1:
+                {
+                this.state = 11813;
+                this.inmemory_table_clause();
+                }
+                break;
+            }
+            this.state = 11817;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1456, this.context) ) {
+            case 1:
+                {
+                this.state = 11816;
+                this.ilm_clause();
+                }
+                break;
+            }
+            this.state = 11823;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1458, this.context) ) {
+            case 1:
+                {
+                this.state = 11819;
+                this.match(PlSqlParser.OVERFLOW_);
+                this.state = 11821;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1457, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11820;
+                    this.segment_attributes_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 11830;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1460, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 11828;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.LOB:
+                        {
+                        this.state = 11825;
+                        this.lob_storage_clause();
+                        }
+                        break;
+                    case PlSqlParser.VARRAY:
+                        {
+                        this.state = 11826;
+                        this.varray_col_properties();
+                        }
+                        break;
+                    case PlSqlParser.NESTED:
+                        {
+                        this.state = 11827;
+                        this.nested_table_col_properties();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 11832;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1460, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partitioning_storage_clause(): Partitioning_storage_clauseContext {
+        let localContext = new Partitioning_storage_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1184, PlSqlParser.RULE_partitioning_storage_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11854;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 11854;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1463, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11833;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 11834;
+                        this.tablespace();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 11835;
+                        this.match(PlSqlParser.OVERFLOW_);
+                        this.state = 11838;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1461, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 11836;
+                            this.match(PlSqlParser.TABLESPACE);
+                            this.state = 11837;
+                            this.tablespace();
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 11840;
+                        this.table_compression();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 11841;
+                        this.key_compression();
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 11842;
+                        this.inmemory_table_clause();
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 11843;
+                        this.lob_partitioning_storage();
+                        }
+                        break;
+                    case 7:
+                        {
+                        this.state = 11844;
+                        this.match(PlSqlParser.VARRAY);
+                        this.state = 11845;
+                        this.varray_item();
+                        this.state = 11846;
+                        this.match(PlSqlParser.STORE);
+                        this.state = 11847;
+                        this.match(PlSqlParser.AS);
+                        this.state = 11849;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 107 || _la === 1642) {
+                            {
+                            this.state = 11848;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 107 || _la === 1642)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                        }
+
+                        this.state = 11851;
+                        this.match(PlSqlParser.LOB);
+                        this.state = 11852;
+                        this.lob_segname();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 11856;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1464, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_partitioning_storage(): Lob_partitioning_storageContext {
+        let localContext = new Lob_partitioning_storageContext(this.context, this.state);
+        this.enterRule(localContext, 1186, PlSqlParser.RULE_lob_partitioning_storage);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11858;
+            this.match(PlSqlParser.LOB);
+            this.state = 11859;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 11860;
+            this.lob_item();
+            this.state = 11861;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 11862;
+            this.match(PlSqlParser.STORE);
+            this.state = 11863;
+            this.match(PlSqlParser.AS);
+            this.state = 11865;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1465, this.context) ) {
+            case 1:
+                {
+                this.state = 11864;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 107 || _la === 1642)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 11880;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 11867;
+                this.lob_segname();
+                this.state = 11873;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1466, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11868;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 11869;
+                    this.match(PlSqlParser.TABLESPACE);
+                    this.state = 11870;
+                    this.tablespace();
+                    this.state = 11871;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 11875;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 11876;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 11877;
+                this.tablespace();
+                this.state = 11878;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public size_clause(): Size_clauseContext {
+        let localContext = new Size_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1188, PlSqlParser.RULE_size_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11882;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            this.state = 11884;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1468, this.context) ) {
+            case 1:
+                {
+                this.state = 11883;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 480 || _la === 636 || _la === 813 || _la === 902 || _la === 1330 || _la === 2079)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_compression(): Table_compressionContext {
+        let localContext = new Table_compressionContext(this.context, this.state);
+        this.enterRule(localContext, 1190, PlSqlParser.RULE_table_compression);
+        let _la: number;
+        try {
+            this.state = 11927;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPRESS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11886;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 11900;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1471, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11887;
+                    this.match(PlSqlParser.BASIC);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 11888;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 11898;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.OLTP:
+                        {
+                        this.state = 11889;
+                        this.match(PlSqlParser.OLTP);
+                        }
+                        break;
+                    case PlSqlParser.ARCHIVE:
+                    case PlSqlParser.QUERY:
+                        {
+                        this.state = 11890;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 64 || _la === 1486)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 11892;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1469, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 11891;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 676 || _la === 898)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case PlSqlParser.ALL:
+                        {
+                        this.state = 11894;
+                        this.match(PlSqlParser.ALL);
+                        this.state = 11895;
+                        this.match(PlSqlParser.OPERATIONS);
+                        }
+                        break;
+                    case PlSqlParser.DIRECT_LOAD:
+                        {
+                        this.state = 11896;
+                        this.match(PlSqlParser.DIRECT_LOAD);
+                        this.state = 11897;
+                        this.match(PlSqlParser.OPERATIONS);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.ROW:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11902;
+                this.match(PlSqlParser.ROW);
+                this.state = 11903;
+                this.match(PlSqlParser.STORE);
+                this.state = 11904;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 11906;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1472, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11905;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 29 || _la === 106)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.COLUMN:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 11908;
+                this.match(PlSqlParser.COLUMN);
+                this.state = 11909;
+                this.match(PlSqlParser.STORE);
+                this.state = 11910;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 11916;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1474, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11911;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 11912;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 64 || _la === 1486)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 11914;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1473, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11913;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 676 || _la === 898)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                this.state = 11924;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1476, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11919;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1139) {
+                        {
+                        this.state = 11918;
+                        this.match(PlSqlParser.NO);
+                        }
+                    }
+
+                    this.state = 11921;
+                    this.match(PlSqlParser.ROW);
+                    this.state = 11922;
+                    this.match(PlSqlParser.LEVEL);
+                    this.state = 11923;
+                    this.match(PlSqlParser.LOCKING);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.NOCOMPRESS:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 11926;
+                this.match(PlSqlParser.NOCOMPRESS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext {
+        let localContext = new Inmemory_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1192, PlSqlParser.RULE_inmemory_table_clause);
+        try {
+            let alternative: number;
+            this.state = 11948;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1482, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11930;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 11929;
+                        this.inmemory_column_clause();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 11932;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1478, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11940;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.INMEMORY:
+                    {
+                    this.state = 11934;
+                    this.match(PlSqlParser.INMEMORY);
+                    this.state = 11936;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1479, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11935;
+                        this.inmemory_attributes();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.NO:
+                    {
+                    this.state = 11938;
+                    this.match(PlSqlParser.NO);
+                    this.state = 11939;
+                    this.match(PlSqlParser.INMEMORY);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 11945;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1481, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 11942;
+                        this.inmemory_column_clause();
+                        }
+                        }
+                    }
+                    this.state = 11947;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1481, this.context);
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_attributes(): Inmemory_attributesContext {
+        let localContext = new Inmemory_attributesContext(this.context, this.state);
+        this.enterRule(localContext, 1194, PlSqlParser.RULE_inmemory_attributes);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11954;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 11954;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1483, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11950;
+                        this.inmemory_memcompress();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 11951;
+                        this.inmemory_priority();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 11952;
+                        this.inmemory_distribute();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 11953;
+                        this.inmemory_duplicate();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 11956;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1484, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_memcompress(): Inmemory_memcompressContext {
+        let localContext = new Inmemory_memcompressContext(this.context, this.state);
+        this.enterRule(localContext, 1196, PlSqlParser.RULE_inmemory_memcompress);
+        let _la: number;
+        try {
+            this.state = 11969;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MEMCOMPRESS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11958;
+                this.match(PlSqlParser.MEMCOMPRESS);
+                this.state = 11959;
+                this.match(PlSqlParser.FOR);
+                this.state = 11965;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DML:
+                    {
+                    this.state = 11960;
+                    this.match(PlSqlParser.DML);
+                    }
+                    break;
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.QUERY:
+                    {
+                    this.state = 11961;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 176 || _la === 1486)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 11963;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1485, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 11962;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 676 || _la === 898)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.NO:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11967;
+                this.match(PlSqlParser.NO);
+                this.state = 11968;
+                this.match(PlSqlParser.MEMCOMPRESS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_priority(): Inmemory_priorityContext {
+        let localContext = new Inmemory_priorityContext(this.context, this.state);
+        this.enterRule(localContext, 1198, PlSqlParser.RULE_inmemory_priority);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11971;
+            this.match(PlSqlParser.PRIORITY);
+            this.state = 11972;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 326 || _la === 676 || _la === 898 || _la === 936 || _la === 1134)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_distribute(): Inmemory_distributeContext {
+        let localContext = new Inmemory_distributeContext(this.context, this.state);
+        this.enterRule(localContext, 1200, PlSqlParser.RULE_inmemory_distribute);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 11974;
+            this.match(PlSqlParser.DISTRIBUTE);
+            this.state = 11983;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1489, this.context) ) {
+            case 1:
+                {
+                this.state = 11975;
+                this.match(PlSqlParser.AUTO);
+                }
+                break;
+            case 2:
+                {
+                this.state = 11976;
+                this.match(PlSqlParser.BY);
+                this.state = 11981;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ROWID:
+                    {
+                    this.state = 11977;
+                    this.match(PlSqlParser.ROWID);
+                    this.state = 11978;
+                    this.match(PlSqlParser.RANGE);
+                    }
+                    break;
+                case PlSqlParser.PARTITION:
+                    {
+                    this.state = 11979;
+                    this.match(PlSqlParser.PARTITION);
+                    }
+                    break;
+                case PlSqlParser.SUBPARTITION:
+                    {
+                    this.state = 11980;
+                    this.match(PlSqlParser.SUBPARTITION);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 11993;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1491, this.context) ) {
+            case 1:
+                {
+                this.state = 11985;
+                this.match(PlSqlParser.FOR);
+                this.state = 11986;
+                this.match(PlSqlParser.SERVICE);
+                this.state = 11991;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1490, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11987;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 11988;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 11989;
+                    this.identifier();
+                    }
+                    break;
+                case 4:
+                    {
+                    this.state = 11990;
+                    this.match(PlSqlParser.NONE);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_duplicate(): Inmemory_duplicateContext {
+        let localContext = new Inmemory_duplicateContext(this.context, this.state);
+        this.enterRule(localContext, 1202, PlSqlParser.RULE_inmemory_duplicate);
+        try {
+            this.state = 12001;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DUPLICATE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 11995;
+                this.match(PlSqlParser.DUPLICATE);
+                this.state = 11997;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1492, this.context) ) {
+                case 1:
+                    {
+                    this.state = 11996;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.NO:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 11999;
+                this.match(PlSqlParser.NO);
+                this.state = 12000;
+                this.match(PlSqlParser.DUPLICATE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inmemory_column_clause(): Inmemory_column_clauseContext {
+        let localContext = new Inmemory_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1204, PlSqlParser.RULE_inmemory_column_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12009;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INMEMORY:
+                {
+                this.state = 12003;
+                this.match(PlSqlParser.INMEMORY);
+                this.state = 12005;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 942 || _la === 1139) {
+                    {
+                    this.state = 12004;
+                    this.inmemory_memcompress();
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.NO:
+                {
+                this.state = 12007;
+                this.match(PlSqlParser.NO);
+                this.state = 12008;
+                this.match(PlSqlParser.INMEMORY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 12011;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 12012;
+            this.column_list();
+            this.state = 12013;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext {
+        let localContext = new Physical_attributes_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1206, PlSqlParser.RULE_physical_attributes_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12025;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 12025;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.PCTFREE:
+                        {
+                        this.state = 12015;
+                        this.match(PlSqlParser.PCTFREE);
+                        this.state = 12016;
+                        localContext._pctfree = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.PCTUSED:
+                        {
+                        this.state = 12017;
+                        this.match(PlSqlParser.PCTUSED);
+                        this.state = 12018;
+                        localContext._pctused = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.INITRANS:
+                        {
+                        this.state = 12019;
+                        this.match(PlSqlParser.INITRANS);
+                        this.state = 12020;
+                        localContext._inittrans = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.MAXTRANS:
+                        {
+                        this.state = 12021;
+                        this.match(PlSqlParser.MAXTRANS);
+                        this.state = 12022;
+                        localContext._maxtrans = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 12023;
+                        this.storage_clause();
+                        }
+                        break;
+                    case PlSqlParser.COMPUTE:
+                        {
+                        this.state = 12024;
+                        this.compute_clauses();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 12027;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1497, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public storage_clause(): Storage_clauseContext {
+        let localContext = new Storage_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1208, PlSqlParser.RULE_storage_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12029;
+            this.match(PlSqlParser.STORAGE);
+            this.state = 12030;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 12058;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                this.state = 12058;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.INITIAL:
+                    {
+                    this.state = 12031;
+                    this.match(PlSqlParser.INITIAL);
+                    this.state = 12032;
+                    localContext._initial_size = this.size_clause();
+                    }
+                    break;
+                case PlSqlParser.NEXT:
+                    {
+                    this.state = 12033;
+                    this.match(PlSqlParser.NEXT);
+                    this.state = 12034;
+                    localContext._next_size = this.size_clause();
+                    }
+                    break;
+                case PlSqlParser.MINEXTENTS:
+                    {
+                    this.state = 12035;
+                    this.match(PlSqlParser.MINEXTENTS);
+                    this.state = 12036;
+                    localContext._minextents = this.tokenStream.LT(1);
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2187 || _la === 2443)) {
+                        localContext._minextents = this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.MAXEXTENTS:
+                    {
+                    this.state = 12037;
+                    this.match(PlSqlParser.MAXEXTENTS);
+                    this.state = 12038;
+                    localContext._minextents = this.tokenStream.LT(1);
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2187 || _la === 2443)) {
+                        localContext._minextents = this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.PCTINCREASE:
+                    {
+                    this.state = 12039;
+                    this.match(PlSqlParser.PCTINCREASE);
+                    this.state = 12040;
+                    localContext._pctincrease = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case PlSqlParser.FREELISTS:
+                    {
+                    this.state = 12041;
+                    this.match(PlSqlParser.FREELISTS);
+                    this.state = 12042;
+                    localContext._freelists = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case PlSqlParser.FREELIST:
+                    {
+                    this.state = 12043;
+                    this.match(PlSqlParser.FREELIST);
+                    this.state = 12044;
+                    this.match(PlSqlParser.GROUPS);
+                    this.state = 12045;
+                    localContext._freelist_groups = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case PlSqlParser.OPTIMAL:
+                    {
+                    this.state = 12046;
+                    this.match(PlSqlParser.OPTIMAL);
+                    this.state = 12049;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                        {
+                        this.state = 12047;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.NULL_:
+                        {
+                        this.state = 12048;
+                        this.match(PlSqlParser.NULL_);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                case PlSqlParser.BUFFER_POOL:
+                    {
+                    this.state = 12051;
+                    this.match(PlSqlParser.BUFFER_POOL);
+                    this.state = 12052;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 389 || _la === 815 || _la === 1521)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.FLASH_CACHE:
+                    {
+                    this.state = 12053;
+                    this.match(PlSqlParser.FLASH_CACHE);
+                    this.state = 12054;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 389 || _la === 815 || _la === 1134)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.CELL_FLASH_CACHE:
+                    {
+                    this.state = 12055;
+                    this.match(PlSqlParser.CELL_FLASH_CACHE);
+                    this.state = 12056;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 389 || _la === 815 || _la === 1134)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.ENCRYPT:
+                    {
+                    this.state = 12057;
+                    this.match(PlSqlParser.ENCRYPT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 12060;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 157 || _la === 186 || _la === 505 || ((((_la - 607)) & ~0x1F) === 0 && ((1 << (_la - 607)) & 786433) !== 0) || _la === 741 || _la === 924 || _la === 953 || _la === 1026 || _la === 1270 || _la === 1372);
+            this.state = 12062;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public deferred_segment_creation(): Deferred_segment_creationContext {
+        let localContext = new Deferred_segment_creationContext(this.context, this.state);
+        this.enterRule(localContext, 1210, PlSqlParser.RULE_deferred_segment_creation);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12064;
+            this.match(PlSqlParser.SEGMENT);
+            this.state = 12065;
+            this.match(PlSqlParser.CREATION);
+            this.state = 12066;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 395 || _la === 699)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext {
+        let localContext = new Segment_attributes_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1212, PlSqlParser.RULE_segment_attributes_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12079;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 12079;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.PCTFREE:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 12068;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case PlSqlParser.TABLESPACE:
+                        {
+                        this.state = 12069;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 12075;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1502, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 12070;
+                            localContext._tablespace_name = this.id_expression();
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 12072;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 1501, this.context) ) {
+                            case 1:
+                                {
+                                this.state = 12071;
+                                this.match(PlSqlParser.SET);
+                                }
+                                break;
+                            }
+                            this.state = 12074;
+                            this.identifier();
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case PlSqlParser.COLUMN:
+                    case PlSqlParser.COMPRESS:
+                    case PlSqlParser.NOCOMPRESS:
+                    case PlSqlParser.ROW:
+                        {
+                        this.state = 12077;
+                        this.table_compression();
+                        }
+                        break;
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.NOLOGGING:
+                        {
+                        this.state = 12078;
+                        this.logging_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 12081;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1504, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public physical_properties(): Physical_propertiesContext {
+        let localContext = new Physical_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1214, PlSqlParser.RULE_physical_properties);
+        let _la: number;
+        try {
+            this.state = 12126;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1511, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12083;
+                this.deferred_segment_creation();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12084;
+                this.segment_attributes_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12085;
+                this.table_compression();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 12086;
+                this.inmemory_table_clause();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 12087;
+                this.ilm_clause();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 12088;
+                this.match(PlSqlParser.ORGANIZATION);
+                this.state = 12103;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.HEAP:
+                    {
+                    this.state = 12089;
+                    this.match(PlSqlParser.HEAP);
+                    this.state = 12091;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1505, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12090;
+                        this.segment_attributes_clause();
+                        }
+                        break;
+                    }
+                    this.state = 12093;
+                    this.heap_org_table_clause();
+                    }
+                    break;
+                case PlSqlParser.INDEX:
+                    {
+                    this.state = 12094;
+                    this.match(PlSqlParser.INDEX);
+                    this.state = 12096;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1506, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12095;
+                        this.segment_attributes_clause();
+                        }
+                        break;
+                    }
+                    this.state = 12099;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1507, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12098;
+                        this.index_org_table_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.EXTERNAL:
+                    {
+                    this.state = 12101;
+                    this.match(PlSqlParser.EXTERNAL);
+                    this.state = 12102;
+                    this.external_table_clause();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 12105;
+                this.match(PlSqlParser.EXTERNAL);
+                this.state = 12106;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 12107;
+                this.match(PlSqlParser.ATTRIBUTES);
+                this.state = 12108;
+                this.external_table_clause();
+                this.state = 12111;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1509, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12109;
+                    this.match(PlSqlParser.REJECT);
+                    this.state = 12110;
+                    this.match(PlSqlParser.LIMIT);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 12113;
+                this.match(PlSqlParser.CLUSTER);
+                this.state = 12114;
+                this.cluster_name();
+                this.state = 12115;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12116;
+                this.column_name();
+                this.state = 12121;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12117;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12118;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 12123;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 12124;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_clause(): Ilm_clauseContext {
+        let localContext = new Ilm_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1216, PlSqlParser.RULE_ilm_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12128;
+            this.match(PlSqlParser.ILM);
+            this.state = 12138;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                {
+                this.state = 12129;
+                this.match(PlSqlParser.ADD);
+                this.state = 12130;
+                this.match(PlSqlParser.POLICY);
+                this.state = 12131;
+                this.ilm_policy_clause();
+                }
+                break;
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+                {
+                this.state = 12132;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 403 || _la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12133;
+                this.match(PlSqlParser.POLICY);
+                this.state = 12134;
+                this.ilm_policy_clause();
+                }
+                break;
+            case PlSqlParser.DELETE_ALL:
+                {
+                this.state = 12135;
+                this.match(PlSqlParser.DELETE_ALL);
+                }
+                break;
+            case PlSqlParser.ENABLE_ALL:
+                {
+                this.state = 12136;
+                this.match(PlSqlParser.ENABLE_ALL);
+                }
+                break;
+            case PlSqlParser.DISABLE_ALL:
+                {
+                this.state = 12137;
+                this.match(PlSqlParser.DISABLE_ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_policy_clause(): Ilm_policy_clauseContext {
+        let localContext = new Ilm_policy_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1218, PlSqlParser.RULE_ilm_policy_clause);
+        try {
+            this.state = 12143;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.ROW:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12140;
+                this.ilm_compression_policy();
+                }
+                break;
+            case PlSqlParser.TIER:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12141;
+                this.ilm_tiering_policy();
+                }
+                break;
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.NO:
+            case PlSqlParser.SET:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12142;
+                this.ilm_inmemory_policy();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_compression_policy(): Ilm_compression_policyContext {
+        let localContext = new Ilm_compression_policyContext(this.context, this.state);
+        this.enterRule(localContext, 1220, PlSqlParser.RULE_ilm_compression_policy);
+        let _la: number;
+        try {
+            this.state = 12164;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1515, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12145;
+                this.table_compression();
+                this.state = 12146;
+                this.segment_group();
+                this.state = 12147;
+                this.ilm_after_on();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                {
+                this.state = 12149;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 237 || _la === 1608)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12150;
+                this.match(PlSqlParser.STORE);
+                this.state = 12151;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 12155;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ADVANCED:
+                    {
+                    this.state = 12152;
+                    this.match(PlSqlParser.ADVANCED);
+                    }
+                    break;
+                case PlSqlParser.FOR:
+                    {
+                    this.state = 12153;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 12154;
+                    this.match(PlSqlParser.QUERY);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 12157;
+                this.match(PlSqlParser.ROW);
+                this.state = 12158;
+                this.match(PlSqlParser.AFTER);
+                this.state = 12159;
+                this.ilm_time_period();
+                this.state = 12160;
+                this.match(PlSqlParser.OF);
+                this.state = 12161;
+                this.match(PlSqlParser.NO);
+                this.state = 12162;
+                this.match(PlSqlParser.MODIFICATION);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_tiering_policy(): Ilm_tiering_policyContext {
+        let localContext = new Ilm_tiering_policyContext(this.context, this.state);
+        this.enterRule(localContext, 1222, PlSqlParser.RULE_ilm_tiering_policy);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12166;
+            this.match(PlSqlParser.TIER);
+            this.state = 12167;
+            this.match(PlSqlParser.TO);
+            this.state = 12168;
+            this.tablespace();
+            this.state = 12182;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1519, this.context) ) {
+            case 1:
+                {
+                this.state = 12170;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1516, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12169;
+                    this.segment_group();
+                    }
+                    break;
+                }
+                this.state = 12174;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1517, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12172;
+                    this.match(PlSqlParser.ON);
+                    this.state = 12173;
+                    this.function_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 12176;
+                this.match(PlSqlParser.READ);
+                this.state = 12177;
+                this.match(PlSqlParser.ONLY);
+                this.state = 12179;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 650 || _la === 1647) {
+                    {
+                    this.state = 12178;
+                    this.segment_group();
+                    }
+                }
+
+                this.state = 12181;
+                this.ilm_after_on();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_after_on(): Ilm_after_onContext {
+        let localContext = new Ilm_after_onContext(this.context, this.state);
+        this.enterRule(localContext, 1224, PlSqlParser.RULE_ilm_after_on);
+        let _la: number;
+        try {
+            this.state = 12194;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.AFTER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12184;
+                this.match(PlSqlParser.AFTER);
+                this.state = 12185;
+                this.ilm_time_period();
+                this.state = 12186;
+                this.match(PlSqlParser.OF);
+                this.state = 12190;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NO:
+                    {
+                    this.state = 12187;
+                    this.match(PlSqlParser.NO);
+                    this.state = 12188;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 4 || _la === 979)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.CREATION:
+                    {
+                    this.state = 12189;
+                    this.match(PlSqlParser.CREATION);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.ON:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12192;
+                this.match(PlSqlParser.ON);
+                this.state = 12193;
+                this.function_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public segment_group(): Segment_groupContext {
+        let localContext = new Segment_groupContext(this.context, this.state);
+        this.enterRule(localContext, 1226, PlSqlParser.RULE_segment_group);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12196;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 650 || _la === 1647)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_inmemory_policy(): Ilm_inmemory_policyContext {
+        let localContext = new Ilm_inmemory_policyContext(this.context, this.state);
+        this.enterRule(localContext, 1228, PlSqlParser.RULE_ilm_inmemory_policy);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12208;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SET:
+                {
+                this.state = 12198;
+                this.match(PlSqlParser.SET);
+                this.state = 12199;
+                this.match(PlSqlParser.INMEMORY);
+                this.state = 12201;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 448 || _la === 475 || _la === 942 || _la === 1139 || _la === 1455) {
+                    {
+                    this.state = 12200;
+                    this.inmemory_attributes();
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                {
+                this.state = 12203;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 12204;
+                this.match(PlSqlParser.INMEMORY);
+                this.state = 12205;
+                this.inmemory_memcompress();
+                }
+                break;
+            case PlSqlParser.NO:
+                {
+                this.state = 12206;
+                this.match(PlSqlParser.NO);
+                this.state = 12207;
+                this.match(PlSqlParser.INMEMORY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 12211;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1647) {
+                {
+                this.state = 12210;
+                this.match(PlSqlParser.SEGMENT);
+                }
+            }
+
+            this.state = 12213;
+            this.ilm_after_on();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ilm_time_period(): Ilm_time_periodContext {
+        let localContext = new Ilm_time_periodContext(this.context, this.state);
+        this.enterRule(localContext, 1230, PlSqlParser.RULE_ilm_time_period);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12215;
+            this.numeric();
+            this.state = 12216;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 365 || _la === 366 || _la === 986 || _la === 988 || _la === 2359 || _la === 2360)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public heap_org_table_clause(): Heap_org_table_clauseContext {
+        let localContext = new Heap_org_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1232, PlSqlParser.RULE_heap_org_table_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12219;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1525, this.context) ) {
+            case 1:
+                {
+                this.state = 12218;
+                this.table_compression();
+                }
+                break;
+            }
+            this.state = 12222;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1526, this.context) ) {
+            case 1:
+                {
+                this.state = 12221;
+                this.inmemory_table_clause();
+                }
+                break;
+            }
+            this.state = 12225;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1527, this.context) ) {
+            case 1:
+                {
+                this.state = 12224;
+                this.ilm_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_clause(): External_table_clauseContext {
+        let localContext = new External_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1234, PlSqlParser.RULE_external_table_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12227;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 12230;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2168) {
+                {
+                this.state = 12228;
+                this.match(PlSqlParser.TYPE);
+                this.state = 12229;
+                this.access_driver_type();
+                }
+            }
+
+            this.state = 12232;
+            this.external_table_data_props();
+            this.state = 12233;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 12235;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1529, this.context) ) {
+            case 1:
+                {
+                this.state = 12234;
+                this.parallel_clause();
+                }
+                break;
+            }
+            this.state = 12243;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1531, this.context) ) {
+            case 1:
+                {
+                this.state = 12237;
+                this.match(PlSqlParser.REJECT);
+                this.state = 12238;
+                this.match(PlSqlParser.LIMIT);
+                this.state = 12241;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNSIGNED_INTEGER:
+                case PlSqlParser.APPROXIMATE_NUM_LIT:
+                    {
+                    this.state = 12239;
+                    this.numeric();
+                    }
+                    break;
+                case PlSqlParser.UNLIMITED:
+                    {
+                    this.state = 12240;
+                    this.match(PlSqlParser.UNLIMITED);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 12246;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1532, this.context) ) {
+            case 1:
+                {
+                this.state = 12245;
+                this.inmemory_table_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public access_driver_type(): Access_driver_typeContext {
+        let localContext = new Access_driver_typeContext(this.context, this.state);
+        this.enterRule(localContext, 1236, PlSqlParser.RULE_access_driver_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12248;
+            _la = this.tokenStream.LA(1);
+            if(!(((((_la - 2382)) & ~0x1F) === 0 && ((1 << (_la - 2382)) & 15) !== 0))) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_data_props(): External_table_data_propsContext {
+        let localContext = new External_table_data_propsContext(this.context, this.state);
+        this.enterRule(localContext, 1238, PlSqlParser.RULE_external_table_data_props);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12253;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389) {
+                {
+                this.state = 12250;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 12251;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 12252;
+                this.external_table_directory();
+                }
+            }
+
+            this.state = 12273;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 4) {
+                {
+                this.state = 12255;
+                this.match(PlSqlParser.ACCESS);
+                this.state = 12256;
+                this.match(PlSqlParser.PARAMETERS);
+                this.state = 12271;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1535, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12257;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 12258;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 12259;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 12260;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 12262;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    do {
+                        {
+                        {
+                        this.state = 12261;
+                        this.external_table_data_format();
+                        }
+                        }
+                        this.state = 12264;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000575) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209087) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578605) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963199) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4219469791) !== 0) || ((((_la - 451)) & ~0x1F) === 0 && ((1 << (_la - 451)) & 4286314527) !== 0) || ((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & 4127192319) !== 0) || ((((_la - 515)) & ~0x1F) === 0 && ((1 << (_la - 515)) & 4227856383) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 4294967295) !== 0) || ((((_la - 579)) & ~0x1F) === 0 && ((1 << (_la - 579)) & 4278190079) !== 0) || ((((_la - 611)) & ~0x1F) === 0 && ((1 << (_la - 611)) & 4294704127) !== 0) || ((((_la - 643)) & ~0x1F) === 0 && ((1 << (_la - 643)) & 2145386319) !== 0) || ((((_la - 675)) & ~0x1F) === 0 && ((1 << (_la - 675)) & 4294440959) !== 0) || ((((_la - 707)) & ~0x1F) === 0 && ((1 << (_la - 707)) & 4294965247) !== 0) || ((((_la - 740)) & ~0x1F) === 0 && ((1 << (_la - 740)) & 4294828031) !== 0) || ((((_la - 772)) & ~0x1F) === 0 && ((1 << (_la - 772)) & 4294950639) !== 0) || ((((_la - 804)) & ~0x1F) === 0 && ((1 << (_la - 804)) & 2113929215) !== 0) || ((((_la - 836)) & ~0x1F) === 0 && ((1 << (_la - 836)) & 3485466623) !== 0) || ((((_la - 868)) & ~0x1F) === 0 && ((1 << (_la - 868)) & 4294950907) !== 0) || ((((_la - 901)) & ~0x1F) === 0 && ((1 << (_la - 901)) & 4294967295) !== 0) || ((((_la - 933)) & ~0x1F) === 0 && ((1 << (_la - 933)) & 4278190079) !== 0) || ((((_la - 965)) & ~0x1F) === 0 && ((1 << (_la - 965)) & 4294959103) !== 0) || ((((_la - 997)) & ~0x1F) === 0 && ((1 << (_la - 997)) & 4294966783) !== 0) || ((((_la - 1029)) & ~0x1F) === 0 && ((1 << (_la - 1029)) & 4294967295) !== 0) || ((((_la - 1061)) & ~0x1F) === 0 && ((1 << (_la - 1061)) & 4026515327) !== 0) || ((((_la - 1093)) & ~0x1F) === 0 && ((1 << (_la - 1093)) & 4294967039) !== 0) || ((((_la - 1125)) & ~0x1F) === 0 && ((1 << (_la - 1125)) & 4294965247) !== 0) || ((((_la - 1157)) & ~0x1F) === 0 && ((1 << (_la - 1157)) & 4227858431) !== 0) || ((((_la - 1190)) & ~0x1F) === 0 && ((1 << (_la - 1190)) & 2147385343) !== 0) || ((((_la - 1222)) & ~0x1F) === 0 && ((1 << (_la - 1222)) & 4227858175) !== 0) || ((((_la - 1254)) & ~0x1F) === 0 && ((1 << (_la - 1254)) & 2681208671) !== 0) || ((((_la - 1286)) & ~0x1F) === 0 && ((1 << (_la - 1286)) & 4286054399) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4294967295) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4290772991) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4261150711) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482);
+                    this.state = 12266;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 12268;
+                    this.match(PlSqlParser.USING);
+                    this.state = 12269;
+                    this.match(PlSqlParser.CLOB);
+                    this.state = 12270;
+                    this.select_only_statement();
+                    }
+                    break;
+                }
+                }
+            }
+
+            this.state = 12287;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 877) {
+                {
+                this.state = 12275;
+                this.match(PlSqlParser.LOCATION);
+                this.state = 12276;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12277;
+                this.external_table_directory();
+                this.state = 12282;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12278;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12279;
+                    this.external_table_directory();
+                    }
+                    }
+                    this.state = 12284;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 12285;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_data_format(): External_table_data_formatContext {
+        let localContext = new External_table_data_formatContext(this.context, this.state);
+        this.enterRule(localContext, 1240, PlSqlParser.RULE_external_table_data_format);
+        let _la: number;
+        try {
+            this.state = 12310;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1540, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12289;
+                this.match(PlSqlParser.RECORDS);
+                this.state = 12290;
+                this.match(PlSqlParser.DELIMITED);
+                this.state = 12291;
+                this.match(PlSqlParser.BY);
+                this.state = 12292;
+                this.match(PlSqlParser.NEWLINE_);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12293;
+                this.match(PlSqlParser.COLUMN);
+                this.state = 12294;
+                this.match(PlSqlParser.TRANSFORMS);
+                this.state = 12295;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12296;
+                this.external_table_transform();
+                this.state = 12301;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12297;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12298;
+                    this.external_table_transform();
+                    }
+                    }
+                    this.state = 12303;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 12304;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12306;
+                this.external_table_records();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 12307;
+                this.external_table_fields();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 12308;
+                this.external_table_datapump();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 12309;
+                this.external_table_hive();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_transform(): External_table_transformContext {
+        let localContext = new External_table_transformContext(this.context, this.state);
+        this.enterRule(localContext, 1242, PlSqlParser.RULE_external_table_transform);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12312;
+            this.column_name();
+            this.state = 12313;
+            this.match(PlSqlParser.FROM);
+            this.state = 12348;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NULL_:
+                {
+                this.state = 12314;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.CONSTANT:
+                {
+                this.state = 12315;
+                this.match(PlSqlParser.CONSTANT);
+                this.state = 12316;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.LOBFILE:
+                {
+                this.state = 12317;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 262 || _la === 870)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12321;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1541, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12318;
+                    this.external_table_field();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 12319;
+                    this.match(PlSqlParser.CONSTANT);
+                    this.state = 12320;
+                    this.quoted_string();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.BLOB:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.FROM:
+                {
+                this.state = 12340;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.FROM:
+                    {
+                    this.state = 12323;
+                    this.match(PlSqlParser.FROM);
+                    this.state = 12324;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 12325;
+                    this.external_table_directory();
+                    this.state = 12330;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 12326;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 12327;
+                        this.external_table_directory();
+                        }
+                        }
+                        this.state = 12332;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 12333;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case PlSqlParser.CLOB:
+                    {
+                    this.state = 12335;
+                    this.match(PlSqlParser.CLOB);
+                    }
+                    break;
+                case PlSqlParser.BLOB:
+                    {
+                    this.state = 12336;
+                    this.match(PlSqlParser.BLOB);
+                    }
+                    break;
+                case PlSqlParser.CHARACTERSET:
+                    {
+                    this.state = 12337;
+                    this.match(PlSqlParser.CHARACTERSET);
+                    this.state = 12338;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 12339;
+                    this.char_set_name();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.STARTOF:
+                {
+                this.state = 12342;
+                this.match(PlSqlParser.STARTOF);
+                this.state = 12343;
+                this.external_table_field_list();
+                this.state = 12344;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12345;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 12346;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_field(): External_table_fieldContext {
+        let localContext = new External_table_fieldContext(this.context, this.state);
+        this.enterRule(localContext, 1244, PlSqlParser.RULE_external_table_field);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12350;
+            this.column_name();
+            this.state = 12352;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1545, this.context) ) {
+            case 1:
+                {
+                this.state = 12351;
+                this.type_name();
+                }
+                break;
+            }
+            this.state = 12356;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 12354;
+                this.match(PlSqlParser.NOT);
+                this.state = 12355;
+                this.match(PlSqlParser.NULL_);
+                }
+            }
+
+            this.state = 12359;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389 || _la === 2459) {
+                {
+                this.state = 12358;
+                this.default_value_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_field_list(): External_table_field_listContext {
+        let localContext = new External_table_field_listContext(this.context, this.state);
+        this.enterRule(localContext, 1246, PlSqlParser.RULE_external_table_field_list);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12361;
+            this.external_table_fields_clause();
+            this.state = 12366;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 12362;
+                this.match(PlSqlParser.COMMA);
+                this.state = 12363;
+                this.external_table_fields_clause();
+                }
+                }
+                this.state = 12368;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_fields_clause(): External_table_fields_clauseContext {
+        let localContext = new External_table_fields_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1248, PlSqlParser.RULE_external_table_fields_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12369;
+            this.external_table_field();
+            this.state = 12376;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1550, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 12374;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.POSITION:
+                    case PlSqlParser.LEFT_PAREN:
+                        {
+                        this.state = 12370;
+                        this.external_table_position_clause();
+                        }
+                        break;
+                    case PlSqlParser.BINARY_DOUBLE:
+                    case PlSqlParser.BINARY_FLOAT:
+                    case PlSqlParser.CHAR:
+                    case PlSqlParser.DECIMAL:
+                    case PlSqlParser.DOUBLE:
+                    case PlSqlParser.FLOAT:
+                    case PlSqlParser.INTEGER:
+                    case PlSqlParser.ORACLE_DATE:
+                    case PlSqlParser.ORACLE_NUMBER:
+                    case PlSqlParser.RAW:
+                    case PlSqlParser.UNSIGNED:
+                    case PlSqlParser.VARCHAR:
+                    case PlSqlParser.VARCHARC:
+                    case PlSqlParser.VARRAW:
+                    case PlSqlParser.VARRAWC:
+                    case PlSqlParser.ZONED:
+                        {
+                        this.state = 12371;
+                        this.external_table_datatype_clause();
+                        }
+                        break;
+                    case PlSqlParser.DEFAULTIF:
+                    case PlSqlParser.NULLIF:
+                        {
+                        this.state = 12372;
+                        this.external_table_init_clause();
+                        }
+                        break;
+                    case PlSqlParser.LLS:
+                        {
+                        this.state = 12373;
+                        this.external_table_lls_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 12378;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1550, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_position_clause(): External_table_position_clauseContext {
+        let localContext = new External_table_position_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1250, PlSqlParser.RULE_external_table_position_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12380;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1420) {
+                {
+                this.state = 12379;
+                this.match(PlSqlParser.POSITION);
+                }
+            }
+
+            this.state = 12382;
+            this.match(PlSqlParser.LEFT_PAREN);
+            {
+            this.state = 12384;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2452) {
+                {
+                this.state = 12383;
+                this.match(PlSqlParser.ASTERISK);
+                }
+            }
+
+            this.state = 12387;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2453 || _la === 2454) {
+                {
+                this.state = 12386;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2453 || _la === 2454)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 12390;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2443) {
+                {
+                this.state = 12389;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+            }
+
+            }
+            this.state = 12398;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.BINDVAR:
+                {
+                this.state = 12392;
+                this.match(PlSqlParser.BINDVAR);
+                }
+                break;
+            case PlSqlParser.COLON:
+                {
+                {
+                this.state = 12393;
+                this.match(PlSqlParser.COLON);
+                this.state = 12395;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2453 || _la === 2454) {
+                    {
+                    this.state = 12394;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2453 || _la === 2454)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 12397;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 12400;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_datatype_clause(): External_table_datatype_clauseContext {
+        let localContext = new External_table_datatype_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1252, PlSqlParser.RULE_external_table_datatype_clause);
+        let _la: number;
+        try {
+            this.state = 12491;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.UNSIGNED:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12403;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2202) {
+                    {
+                    this.state = 12402;
+                    this.match(PlSqlParser.UNSIGNED);
+                    }
+                }
+
+                this.state = 12405;
+                this.match(PlSqlParser.INTEGER);
+                this.state = 12407;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1558, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12406;
+                    this.match(PlSqlParser.EXTERNAL);
+                    }
+                    break;
+                }
+                this.state = 12410;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2443) {
+                    {
+                    this.state = 12409;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                }
+
+                this.state = 12413;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1560, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12412;
+                    this.external_table_delimit_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.ZONED:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12415;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 381 || _la === 2366)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12432;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 12416;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 12417;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 12420;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 12418;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 12419;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                    }
+
+                    this.state = 12422;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case PlSqlParser.EXTERNAL:
+                    {
+                    this.state = 12423;
+                    this.match(PlSqlParser.EXTERNAL);
+                    this.state = 12427;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1562, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12424;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 12425;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        this.state = 12426;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    }
+                    this.state = 12430;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1563, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12429;
+                        this.external_table_delimit_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.ORACLE_DATE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12434;
+                this.match(PlSqlParser.ORACLE_DATE);
+                }
+                break;
+            case PlSqlParser.ORACLE_NUMBER:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 12435;
+                this.match(PlSqlParser.ORACLE_NUMBER);
+                this.state = 12437;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1565, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12436;
+                    this.match(PlSqlParser.COUNTED);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.FLOAT:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 12439;
+                this.match(PlSqlParser.FLOAT);
+                this.state = 12441;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1566, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12440;
+                    this.match(PlSqlParser.EXTERNAL);
+                    }
+                    break;
+                }
+                this.state = 12444;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2443) {
+                    {
+                    this.state = 12443;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                }
+
+                this.state = 12447;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1568, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12446;
+                    this.external_table_delimit_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.DOUBLE:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 12449;
+                this.match(PlSqlParser.DOUBLE);
+                }
+                break;
+            case PlSqlParser.BINARY_FLOAT:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 12450;
+                this.match(PlSqlParser.BINARY_FLOAT);
+                this.state = 12452;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1569, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12451;
+                    this.match(PlSqlParser.EXTERNAL);
+                    }
+                    break;
+                }
+                this.state = 12455;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2443) {
+                    {
+                    this.state = 12454;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                }
+
+                this.state = 12458;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1571, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12457;
+                    this.external_table_delimit_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.BINARY_DOUBLE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 12460;
+                this.match(PlSqlParser.BINARY_DOUBLE);
+                }
+                break;
+            case PlSqlParser.RAW:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 12461;
+                this.match(PlSqlParser.RAW);
+                this.state = 12463;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2443) {
+                    {
+                    this.state = 12462;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.CHAR:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 12465;
+                this.match(PlSqlParser.CHAR);
+                this.state = 12467;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1573, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12466;
+                    this.match(PlSqlParser.EXTERNAL);
+                    }
+                    break;
+                }
+                this.state = 12472;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1574, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12469;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 12470;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 12471;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                this.state = 12475;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1575, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12474;
+                    this.external_table_delimit_clause();
+                    }
+                    break;
+                }
+                this.state = 12478;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1576, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12477;
+                    this.external_table_trim_clause();
+                    }
+                    break;
+                }
+                this.state = 12481;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1577, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12480;
+                    this.external_table_date_format_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARCHARC:
+            case PlSqlParser.VARRAW:
+            case PlSqlParser.VARRAWC:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 12483;
+                _la = this.tokenStream.LA(1);
+                if(!(((((_la - 2262)) & ~0x1F) === 0 && ((1 << (_la - 2262)) & 27) !== 0))) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12484;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12487;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1578, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12485;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 12486;
+                    this.match(PlSqlParser.COMMA);
+                    }
+                    break;
+                }
+                this.state = 12489;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 12490;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_delimit_clause(): External_table_delimit_clauseContext {
+        let localContext = new External_table_delimit_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1254, PlSqlParser.RULE_external_table_delimit_clause);
+        let _la: number;
+        try {
+            this.state = 12518;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ENCLOSED:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12493;
+                this.match(PlSqlParser.ENCLOSED);
+                this.state = 12494;
+                this.match(PlSqlParser.BY);
+                this.state = 12495;
+                this.quoted_string();
+                this.state = 12498;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 49) {
+                    {
+                    this.state = 12496;
+                    this.match(PlSqlParser.AND);
+                    this.state = 12497;
+                    this.quoted_string();
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.TERMINATED:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12500;
+                this.match(PlSqlParser.TERMINATED);
+                this.state = 12501;
+                this.match(PlSqlParser.BY);
+                this.state = 12504;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 12502;
+                    this.quoted_string();
+                    }
+                    break;
+                case PlSqlParser.WHITESPACE:
+                    {
+                    this.state = 12503;
+                    this.match(PlSqlParser.WHITESPACE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 12516;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1584, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12507;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1275) {
+                        {
+                        this.state = 12506;
+                        this.match(PlSqlParser.OPTIONALLY);
+                        }
+                    }
+
+                    this.state = 12509;
+                    this.match(PlSqlParser.ENCLOSED);
+                    this.state = 12510;
+                    this.match(PlSqlParser.BY);
+                    this.state = 12511;
+                    this.quoted_string();
+                    this.state = 12514;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 49) {
+                        {
+                        this.state = 12512;
+                        this.match(PlSqlParser.AND);
+                        this.state = 12513;
+                        this.quoted_string();
+                        }
+                    }
+
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_trim_clause(): External_table_trim_clauseContext {
+        let localContext = new External_table_trim_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1256, PlSqlParser.RULE_external_table_trim_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12520;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 835 || _la === 900 || _la === 901 || _la === 1205 || _la === 1611)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_date_format_clause(): External_table_date_format_clauseContext {
+        let localContext = new External_table_date_format_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1258, PlSqlParser.RULE_external_table_date_format_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12523;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 363) {
+                {
+                this.state = 12522;
+                this.match(PlSqlParser.DATE_FORMAT);
+                }
+            }
+
+            this.state = 12539;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DATE:
+                {
+                this.state = 12525;
+                this.match(PlSqlParser.DATE);
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                {
+                this.state = 12526;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 12533;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2310) {
+                    {
+                    this.state = 12527;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 12529;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 874) {
+                        {
+                        this.state = 12528;
+                        this.match(PlSqlParser.LOCAL);
+                        }
+                    }
+
+                    this.state = 12531;
+                    this.match(PlSqlParser.TIME);
+                    this.state = 12532;
+                    this.match(PlSqlParser.ZONE);
+                    }
+                }
+
+                this.state = 12535;
+                this.match(PlSqlParser.MASK);
+                this.state = 12536;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.INTERVAL:
+                {
+                this.state = 12537;
+                this.match(PlSqlParser.INTERVAL);
+                this.state = 12538;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 367 || _la === 2361)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_init_clause(): External_table_init_clauseContext {
+        let localContext = new External_table_init_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1260, PlSqlParser.RULE_external_table_init_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12541;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 390 || _la === 1229)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 12542;
+            this.external_table_condition_clause(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public external_table_condition_clause(): External_table_condition_clauseContext;
+    public external_table_condition_clause(_p: number): External_table_condition_clauseContext;
+    public external_table_condition_clause(_p?: number): External_table_condition_clauseContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new External_table_condition_clauseContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 1262;
+        this.enterRecursionRule(localContext, 1262, PlSqlParser.RULE_external_table_condition_clause, _p);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            {
+            this.state = 12550;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 12545;
+                this.field_spec();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 12546;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12547;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 12548;
+                this.match(PlSqlParser.BINDVAR);
+                this.state = 12549;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 12552;
+            this.relational_operator();
+            this.state = 12556;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 12553;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.HEX_STRING_LIT:
+                {
+                this.state = 12554;
+                this.match(PlSqlParser.HEX_STRING_LIT);
+                }
+                break;
+            case PlSqlParser.BLANKS:
+                {
+                this.state = 12555;
+                this.match(PlSqlParser.BLANKS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 12563;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1592, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    {
+                    localContext = new External_table_condition_clauseContext(parentContext, parentState);
+                    this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_external_table_condition_clause);
+                    this.state = 12558;
+                    if (!(this.precpred(this.context, 1))) {
+                        throw this.createFailedPredicateException("this.precpred(this.context, 1)");
+                    }
+                    this.state = 12559;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 49 || _la === 1309)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 12560;
+                    this.external_table_condition_clause(2);
+                    }
+                    }
+                }
+                this.state = 12565;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1592, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+    public external_table_lls_clause(): External_table_lls_clauseContext {
+        let localContext = new External_table_lls_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1264, PlSqlParser.RULE_external_table_lls_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12566;
+            this.match(PlSqlParser.LLS);
+            this.state = 12567;
+            this.external_table_directory();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_records(): External_table_recordsContext {
+        let localContext = new External_table_recordsContext(this.context, this.state);
+        this.enterRule(localContext, 1266, PlSqlParser.RULE_external_table_records);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 12611;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RECORDS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12569;
+                this.match(PlSqlParser.RECORDS);
+                this.state = 12598;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.FIXED:
+                    {
+                    this.state = 12570;
+                    this.match(PlSqlParser.FIXED);
+                    this.state = 12571;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case PlSqlParser.VARIABLE:
+                    {
+                    this.state = 12572;
+                    this.match(PlSqlParser.VARIABLE);
+                    this.state = 12573;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case PlSqlParser.DELIMITED:
+                    {
+                    this.state = 12574;
+                    this.match(PlSqlParser.DELIMITED);
+                    this.state = 12575;
+                    this.match(PlSqlParser.BY);
+                    this.state = 12581;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.DETECTED:
+                    case PlSqlParser.NEWLINE_:
+                        {
+                        this.state = 12577;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 418) {
+                            {
+                            this.state = 12576;
+                            this.match(PlSqlParser.DETECTED);
+                            }
+                        }
+
+                        this.state = 12579;
+                        this.match(PlSqlParser.NEWLINE_);
+                        }
+                        break;
+                    case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                    case PlSqlParser.CHAR_STRING:
+                        {
+                        this.state = 12580;
+                        this.quoted_string();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                case PlSqlParser.XMLTAG:
+                    {
+                    this.state = 12583;
+                    this.match(PlSqlParser.XMLTAG);
+                    this.state = 12585;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2449) {
+                        {
+                        this.state = 12584;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        }
+                    }
+
+                    this.state = 12587;
+                    this.id_expression();
+                    this.state = 12592;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 12588;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 12589;
+                        this.id_expression();
+                        }
+                        }
+                        this.state = 12594;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 12596;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1597, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12595;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 12603;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1599, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 12600;
+                        this.external_table_record_options_clause();
+                        }
+                        }
+                    }
+                    this.state = 12605;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1599, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.BADFILE:
+            case PlSqlParser.BYTEORDERMARK:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATE_CACHE:
+            case PlSqlParser.DISABLE_DIRECTORY_LINK_CHECK:
+            case PlSqlParser.DISCARDFILE:
+            case PlSqlParser.DNFS_DISABLE:
+            case PlSqlParser.DNFS_ENABLE:
+            case PlSqlParser.DNFS_READBUFFERS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.IO_OPTIONS:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.NOBADFILE:
+            case PlSqlParser.NODISCARDFILE:
+            case PlSqlParser.NOLOGFILE:
+            case PlSqlParser.PREPROCESSOR:
+            case PlSqlParser.READSIZE:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.STRING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12607;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 12606;
+                        this.external_table_record_options_clause();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 12609;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1600, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_record_options_clause(): External_table_record_options_clauseContext {
+        let localContext = new External_table_record_options_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1268, PlSqlParser.RULE_external_table_record_options_clause);
+        let _la: number;
+        try {
+            this.state = 12650;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHARACTERSET:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12613;
+                this.match(PlSqlParser.CHARACTERSET);
+                this.state = 12614;
+                this.char_set_name();
+                }
+                break;
+            case PlSqlParser.EXTERNAL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12615;
+                this.match(PlSqlParser.EXTERNAL);
+                this.state = 12616;
+                this.match(PlSqlParser.VARIABLE);
+                this.state = 12617;
+                this.match(PlSqlParser.DATA);
+                }
+                break;
+            case PlSqlParser.PREPROCESSOR:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12618;
+                this.match(PlSqlParser.PREPROCESSOR);
+                this.state = 12619;
+                this.external_table_directory();
+                }
+                break;
+            case PlSqlParser.DATA:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 12620;
+                this.match(PlSqlParser.DATA);
+                this.state = 12621;
+                this.match(PlSqlParser.IS);
+                this.state = 12622;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 121 || _la === 864)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12623;
+                this.match(PlSqlParser.ENDIAN);
+                }
+                break;
+            case PlSqlParser.BYTEORDERMARK:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 12624;
+                this.match(PlSqlParser.BYTEORDERMARK);
+                this.state = 12625;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 200 || _la === 1068)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.STRING:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 12626;
+                this.match(PlSqlParser.STRING);
+                this.state = 12627;
+                this.match(PlSqlParser.SIZES);
+                this.state = 12628;
+                this.match(PlSqlParser.ARE);
+                this.state = 12629;
+                this.match(PlSqlParser.IN);
+                this.state = 12630;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 164 || _la === 194)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.LOAD:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 12631;
+                this.match(PlSqlParser.LOAD);
+                this.state = 12632;
+                this.match(PlSqlParser.WHEN);
+                this.state = 12633;
+                this.external_table_condition_clause(0);
+                }
+                break;
+            case PlSqlParser.BADFILE:
+            case PlSqlParser.DISCARDFILE:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.NOBADFILE:
+            case PlSqlParser.NODISCARDFILE:
+            case PlSqlParser.NOLOGFILE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 12634;
+                this.external_table_output_files();
+                }
+                break;
+            case PlSqlParser.READSIZE:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 12635;
+                this.match(PlSqlParser.READSIZE);
+                this.state = 12637;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2474) {
+                    {
+                    this.state = 12636;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    }
+                }
+
+                this.state = 12639;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.DISABLE_DIRECTORY_LINK_CHECK:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 12640;
+                this.match(PlSqlParser.DISABLE_DIRECTORY_LINK_CHECK);
+                }
+                break;
+            case PlSqlParser.DATE_CACHE:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 12641;
+                this.match(PlSqlParser.DATE_CACHE);
+                this.state = 12642;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.SKIP_:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 12643;
+                this.match(PlSqlParser.SKIP_);
+                this.state = 12644;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.IO_OPTIONS:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 12645;
+                this.match(PlSqlParser.IO_OPTIONS);
+                this.state = 12646;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 424 || _la === 1089)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.DNFS_DISABLE:
+            case PlSqlParser.DNFS_ENABLE:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 12647;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 451 || _la === 452)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.DNFS_READBUFFERS:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 12648;
+                this.match(PlSqlParser.DNFS_READBUFFERS);
+                this.state = 12649;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_output_files(): External_table_output_filesContext {
+        let localContext = new External_table_output_filesContext(this.context, this.state);
+        this.enterRule(localContext, 1270, PlSqlParser.RULE_external_table_output_files);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12658;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOBADFILE:
+            case PlSqlParser.NODISCARDFILE:
+            case PlSqlParser.NOLOGFILE:
+                {
+                this.state = 12652;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1061 || _la === 1090 || _la === 1119)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.BADFILE:
+            case PlSqlParser.DISCARDFILE:
+            case PlSqlParser.LOGFILE:
+                {
+                this.state = 12653;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 105 || _la === 438 || _la === 883)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12655;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1604, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12654;
+                    this.external_table_directory();
+                    }
+                    break;
+                }
+                this.state = 12657;
+                this.filename();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_fields(): External_table_fieldsContext {
+        let localContext = new External_table_fieldsContext(this.context, this.state);
+        this.enterRule(localContext, 1272, PlSqlParser.RULE_external_table_fields);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12660;
+            this.match(PlSqlParser.FIELDS);
+            this.state = 12662;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 694) {
+                {
+                this.state = 12661;
+                this.match(PlSqlParser.IGNORE_CHARS_AFTER_EOR);
+                }
+            }
+
+            this.state = 12667;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1607, this.context) ) {
+            case 1:
+                {
+                this.state = 12664;
+                this.match(PlSqlParser.CSV);
+                this.state = 12665;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2308 || _la === 2310)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12666;
+                this.match(PlSqlParser.EMBEDDED);
+                }
+                break;
+            }
+            this.state = 12670;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1608, this.context) ) {
+            case 1:
+                {
+                this.state = 12669;
+                this.external_table_delimit_clause();
+                }
+                break;
+            }
+            this.state = 12673;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1609, this.context) ) {
+            case 1:
+                {
+                this.state = 12672;
+                this.external_table_trim_clause();
+                }
+                break;
+            }
+            this.state = 12680;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 38) {
+                {
+                this.state = 12675;
+                this.match(PlSqlParser.ALL);
+                this.state = 12676;
+                this.match(PlSqlParser.FIELDS);
+                this.state = 12677;
+                this.match(PlSqlParser.OVERRIDE);
+                this.state = 12678;
+                this.match(PlSqlParser.THESE);
+                this.state = 12679;
+                this.match(PlSqlParser.FIELDS);
+                }
+            }
+
+            this.state = 12687;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1611, this.context) ) {
+            case 1:
+                {
+                this.state = 12682;
+                this.match(PlSqlParser.MISSING);
+                this.state = 12683;
+                this.match(PlSqlParser.FIELD);
+                this.state = 12684;
+                this.match(PlSqlParser.VALUES);
+                this.state = 12685;
+                this.match(PlSqlParser.ARE);
+                this.state = 12686;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            }
+            this.state = 12695;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1612, this.context) ) {
+            case 1:
+                {
+                this.state = 12689;
+                this.match(PlSqlParser.REJECT);
+                this.state = 12690;
+                this.match(PlSqlParser.ROWS);
+                this.state = 12691;
+                this.match(PlSqlParser.WITH);
+                this.state = 12692;
+                this.match(PlSqlParser.ALL);
+                this.state = 12693;
+                this.match(PlSqlParser.NULL_);
+                this.state = 12694;
+                this.match(PlSqlParser.FIELDS);
+                }
+                break;
+            }
+            this.state = 12701;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1613, this.context) ) {
+            case 1:
+                {
+                this.state = 12697;
+                this.match(PlSqlParser.DATE_FORMAT);
+                this.state = 12698;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 361 || _la === 2110)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12699;
+                this.match(PlSqlParser.MASK);
+                this.state = 12700;
+                this.quoted_string();
+                }
+                break;
+            }
+            this.state = 12711;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1615, this.context) ) {
+            case 1:
+                {
+                this.state = 12703;
+                this.match(PlSqlParser.NULLIF);
+                this.state = 12704;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2465 || _la === 2474)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12708;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 12705;
+                    this.quoted_string();
+                    }
+                    break;
+                case PlSqlParser.HEX_STRING_LIT:
+                    {
+                    this.state = 12706;
+                    this.match(PlSqlParser.HEX_STRING_LIT);
+                    }
+                    break;
+                case PlSqlParser.BLANKS:
+                    {
+                    this.state = 12707;
+                    this.match(PlSqlParser.BLANKS);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 12710;
+                this.match(PlSqlParser.NONULLIF);
+                }
+                break;
+            }
+            this.state = 12714;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 12713;
+                this.match(PlSqlParser.LEFT_PAREN);
+                }
+            }
+
+            this.state = 12717;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1617, this.context) ) {
+            case 1:
+                {
+                this.state = 12716;
+                this.external_table_field_list();
+                }
+                break;
+            }
+            this.state = 12720;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1618, this.context) ) {
+            case 1:
+                {
+                this.state = 12719;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_datapump(): External_table_datapumpContext {
+        let localContext = new External_table_datapumpContext(this.context, this.state);
+        this.enterRule(localContext, 1274, PlSqlParser.RULE_external_table_datapump);
+        let _la: number;
+        try {
+            this.state = 12778;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ENCRYPTION:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12722;
+                this.match(PlSqlParser.ENCRYPTION);
+                this.state = 12723;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 430 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.NOLOGFILE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12724;
+                this.match(PlSqlParser.NOLOGFILE);
+                }
+                break;
+            case PlSqlParser.LOGFILE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12725;
+                this.match(PlSqlParser.LOGFILE);
+                this.state = 12727;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1619, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12726;
+                    this.external_table_directory();
+                    }
+                    break;
+                }
+                this.state = 12729;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.COMPRESSION:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 12730;
+                this.match(PlSqlParser.COMPRESSION);
+                this.state = 12736;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1621, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12731;
+                    this.match(PlSqlParser.ENABLED);
+                    this.state = 12733;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1620, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 12732;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 106 || _la === 676 || _la === 898 || _la === 936)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 12735;
+                    this.match(PlSqlParser.DISABLED);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.HADOOP_TRAILERS:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 12738;
+                this.match(PlSqlParser.HADOOP_TRAILERS);
+                this.state = 12739;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 430 || _la === 500)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 12740;
+                this.match(PlSqlParser.VERSION);
+                this.state = 12744;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.COMPATIBLE:
+                    {
+                    this.state = 12741;
+                    this.match(PlSqlParser.COMPATIBLE);
+                    }
+                    break;
+                case PlSqlParser.LATEST:
+                    {
+                    this.state = 12742;
+                    this.match(PlSqlParser.LATEST);
+                    }
+                    break;
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 12743;
+                    this.quoted_string();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.NOLOG:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 12746;
+                this.match(PlSqlParser.NOLOG);
+                }
+                break;
+            case PlSqlParser.DEBUG:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 12747;
+                this.match(PlSqlParser.DEBUG);
+                this.state = 12748;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 12749;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12750;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 12751;
+                this.match(PlSqlParser.COMMA);
+                this.state = 12752;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 12753;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.DATAPUMP:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 12754;
+                this.match(PlSqlParser.DATAPUMP);
+                this.state = 12755;
+                this.match(PlSqlParser.INTERNAL);
+                this.state = 12756;
+                this.match(PlSqlParser.TABLE);
+                this.state = 12757;
+                this.tableview_name();
+                }
+                break;
+            case PlSqlParser.TEMPLATE_TABLE:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 12758;
+                this.match(PlSqlParser.TEMPLATE_TABLE);
+                this.state = 12759;
+                this.tableview_name();
+                }
+                break;
+            case PlSqlParser.JOB:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 12760;
+                this.match(PlSqlParser.JOB);
+                this.state = 12761;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 12762;
+                this.schema_name();
+                this.state = 12763;
+                this.match(PlSqlParser.COMMA);
+                this.state = 12764;
+                this.tableview_name();
+                this.state = 12765;
+                this.match(PlSqlParser.COMMA);
+                this.state = 12766;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 12767;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.WORKERID:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 12769;
+                this.match(PlSqlParser.WORKERID);
+                this.state = 12770;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.PARALLEL:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 12771;
+                this.match(PlSqlParser.PARALLEL);
+                this.state = 12772;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.VERSION:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 12773;
+                this.match(PlSqlParser.VERSION);
+                this.state = 12774;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.ENCRYPTPASSWORDISNULL:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 12775;
+                this.match(PlSqlParser.ENCRYPTPASSWORDISNULL);
+                }
+                break;
+            case PlSqlParser.DBLINK:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 12776;
+                this.match(PlSqlParser.DBLINK);
+                this.state = 12777;
+                this.quoted_string();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_hive(): External_table_hiveContext {
+        let localContext = new External_table_hiveContext(this.context, this.state);
+        this.enterRule(localContext, 1276, PlSqlParser.RULE_external_table_hive);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12780;
+            this.id_expression();
+            this.state = 12785;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2442) {
+                {
+                {
+                this.state = 12781;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 12782;
+                this.id_expression();
+                }
+                }
+                this.state = 12787;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 12788;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 2471 || _la === 2474)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 12872;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1633, this.context) ) {
+            case 1:
+                {
+                this.state = 12789;
+                this.tableview_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 12790;
+                this.external_table_hive_parameter_map();
+                }
+                break;
+            case 3:
+                {
+                this.state = 12791;
+                this.match(PlSqlParser.LEFT_BRACKET);
+                this.state = 12792;
+                this.external_table_hive_parameter_map();
+                this.state = 12797;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12793;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12794;
+                    this.external_table_hive_parameter_map();
+                    }
+                    }
+                    this.state = 12799;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 12800;
+                this.match(PlSqlParser.RIGHT_BRACKET);
+                }
+                break;
+            case 4:
+                {
+                this.state = 12802;
+                this.external_table_field();
+                this.state = 12803;
+                this.datatype();
+                this.state = 12806;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1626, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12804;
+                    this.match(PlSqlParser.COMMENT);
+                    this.state = 12805;
+                    this.quoted_string();
+                    }
+                    break;
+                }
+                this.state = 12813;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12808;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12809;
+                    this.match(PlSqlParser.COMMENT);
+                    this.state = 12810;
+                    this.quoted_string();
+                    }
+                    }
+                    this.state = 12815;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 5:
+                {
+                this.state = 12816;
+                this.match(PlSqlParser.SEQUENCEFILE);
+                }
+                break;
+            case 6:
+                {
+                this.state = 12817;
+                this.match(PlSqlParser.TEXTFILE);
+                }
+                break;
+            case 7:
+                {
+                this.state = 12818;
+                this.match(PlSqlParser.RCFILE);
+                }
+                break;
+            case 8:
+                {
+                this.state = 12819;
+                this.match(PlSqlParser.ORC);
+                }
+                break;
+            case 9:
+                {
+                this.state = 12820;
+                this.match(PlSqlParser.PARQUET);
+                }
+                break;
+            case 10:
+                {
+                this.state = 12821;
+                this.match(PlSqlParser.INPUTFORMAT);
+                this.state = 12822;
+                this.quoted_string();
+                this.state = 12823;
+                this.match(PlSqlParser.OUTPUTFORMAT);
+                this.state = 12824;
+                this.quoted_string();
+                }
+                break;
+            case 11:
+                {
+                this.state = 12826;
+                this.external_table_directory();
+                }
+                break;
+            case 12:
+                {
+                this.state = 12828;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 405) {
+                    {
+                    this.state = 12827;
+                    this.match(PlSqlParser.DELIMITED);
+                    }
+                }
+
+                this.state = 12851;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.FIELDS:
+                    {
+                    this.state = 12830;
+                    this.match(PlSqlParser.FIELDS);
+                    this.state = 12831;
+                    this.match(PlSqlParser.TERMINATED);
+                    this.state = 12832;
+                    this.match(PlSqlParser.BY);
+                    this.state = 12833;
+                    this.match(PlSqlParser.CHARACTER);
+                    {
+                    this.state = 12834;
+                    this.match(PlSqlParser.ESCAPED);
+                    this.state = 12835;
+                    this.match(PlSqlParser.BY);
+                    this.state = 12836;
+                    this.match(PlSqlParser.CHARACTER);
+                    }
+                    }
+                    break;
+                case PlSqlParser.COLLECTION:
+                case PlSqlParser.LINES:
+                case PlSqlParser.MAP:
+                    {
+                    this.state = 12842;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COLLECTION:
+                        {
+                        this.state = 12837;
+                        this.match(PlSqlParser.COLLECTION);
+                        this.state = 12838;
+                        this.match(PlSqlParser.ITEMS);
+                        }
+                        break;
+                    case PlSqlParser.MAP:
+                        {
+                        this.state = 12839;
+                        this.match(PlSqlParser.MAP);
+                        this.state = 12840;
+                        this.match(PlSqlParser.KEYS);
+                        }
+                        break;
+                    case PlSqlParser.LINES:
+                        {
+                        this.state = 12841;
+                        this.match(PlSqlParser.LINES);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 12844;
+                    this.match(PlSqlParser.TERMINATED);
+                    this.state = 12845;
+                    this.match(PlSqlParser.BY);
+                    this.state = 12846;
+                    this.match(PlSqlParser.CHARACTER);
+                    }
+                    break;
+                case PlSqlParser.NULL_:
+                    {
+                    this.state = 12847;
+                    this.match(PlSqlParser.NULL_);
+                    this.state = 12848;
+                    this.match(PlSqlParser.DEFINED);
+                    this.state = 12849;
+                    this.match(PlSqlParser.AS);
+                    this.state = 12850;
+                    this.match(PlSqlParser.CHARACTER);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 13:
+                {
+                this.state = 12853;
+                this.match(PlSqlParser.SERDE);
+                this.state = 12854;
+                this.quoted_string();
+                this.state = 12870;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2310) {
+                    {
+                    this.state = 12855;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 12856;
+                    this.match(PlSqlParser.SERDEPROPERTIES);
+                    {
+                    this.state = 12857;
+                    this.quoted_string();
+                    this.state = 12858;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 12859;
+                    this.quoted_string();
+                    this.state = 12867;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 12860;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 12861;
+                        this.quoted_string();
+                        this.state = 12862;
+                        this.match(PlSqlParser.EQUALS_OP);
+                        this.state = 12863;
+                        this.quoted_string();
+                        }
+                        }
+                        this.state = 12869;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    }
+                }
+
+                }
+                break;
+            }
+            this.state = 12875;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1634, this.context) ) {
+            case 1:
+                {
+                this.state = 12874;
+                this.external_table_hive();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_hive_parameter_map(): External_table_hive_parameter_mapContext {
+        let localContext = new External_table_hive_parameter_mapContext(this.context, this.state);
+        this.enterRule(localContext, 1278, PlSqlParser.RULE_external_table_hive_parameter_map);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12877;
+            this.match(PlSqlParser.LEFT_CURLY_PAREN);
+            {
+            this.state = 12878;
+            this.external_table_hive_parameter_map_entry();
+            this.state = 12883;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 12879;
+                this.match(PlSqlParser.COMMA);
+                this.state = 12880;
+                this.external_table_hive_parameter_map_entry();
+                }
+                }
+                this.state = 12885;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+            this.state = 12886;
+            this.match(PlSqlParser.RIGHT_CURLY_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_hive_parameter_map_entry(): External_table_hive_parameter_map_entryContext {
+        let localContext = new External_table_hive_parameter_map_entryContext(this.context, this.state);
+        this.enterRule(localContext, 1280, PlSqlParser.RULE_external_table_hive_parameter_map_entry);
+        let _la: number;
+        try {
+            this.state = 12915;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1638, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12888;
+                this.id_expression();
+                this.state = 12889;
+                this.match(PlSqlParser.BINDVAR);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12891;
+                this.id_expression();
+                this.state = 12892;
+                this.match(PlSqlParser.COLON);
+                this.state = 12893;
+                this.match(PlSqlParser.LEFT_BRACKET);
+                this.state = 12894;
+                this.id_expression();
+                this.state = 12899;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12895;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12896;
+                    this.id_expression();
+                    }
+                    }
+                    this.state = 12901;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 12902;
+                this.match(PlSqlParser.RIGHT_BRACKET);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12904;
+                this.match(PlSqlParser.LEFT_BRACKET);
+                this.state = 12905;
+                this.id_expression();
+                this.state = 12910;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 12906;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 12907;
+                    this.id_expression();
+                    }
+                    }
+                    this.state = 12912;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 12913;
+                this.match(PlSqlParser.RIGHT_BRACKET);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public external_table_directory(): External_table_directoryContext {
+        let localContext = new External_table_directoryContext(this.context, this.state);
+        this.enterRule(localContext, 1282, PlSqlParser.RULE_external_table_directory);
+        let _la: number;
+        try {
+            this.state = 12932;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1641, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12917;
+                this.directory_name();
+                this.state = 12918;
+                this.match(PlSqlParser.COLON);
+                this.state = 12919;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12927;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 142606335) !== 0) || _la === 2482) {
+                    {
+                    this.state = 12921;
+                    this.directory_name();
+                    this.state = 12923;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                        {
+                        this.state = 12922;
+                        this.object_name();
+                        }
+                    }
+
+                    this.state = 12925;
+                    this.match(PlSqlParser.COLON);
+                    }
+                }
+
+                this.state = 12929;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 12930;
+                this.quoted_string();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 12931;
+                this.variable_name();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public row_movement_clause(): Row_movement_clauseContext {
+        let localContext = new Row_movement_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1284, PlSqlParser.RULE_row_movement_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12935;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 429 || _la === 499) {
+                {
+                this.state = 12934;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 429 || _la === 499)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 12937;
+            this.match(PlSqlParser.ROW);
+            this.state = 12938;
+            this.match(PlSqlParser.MOVEMENT);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public flashback_archive_clause(): Flashback_archive_clauseContext {
+        let localContext = new Flashback_archive_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1286, PlSqlParser.RULE_flashback_archive_clause);
+        try {
+            this.state = 12948;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.FLASHBACK:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12940;
+                this.match(PlSqlParser.FLASHBACK);
+                this.state = 12941;
+                this.match(PlSqlParser.ARCHIVE);
+                this.state = 12943;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1643, this.context) ) {
+                case 1:
+                    {
+                    this.state = 12942;
+                    localContext._fa = this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.NO:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12945;
+                this.match(PlSqlParser.NO);
+                this.state = 12946;
+                this.match(PlSqlParser.FLASHBACK);
+                this.state = 12947;
+                this.match(PlSqlParser.ARCHIVE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public log_grp(): Log_grpContext {
+        let localContext = new Log_grpContext(this.context, this.state);
+        this.enterRule(localContext, 1288, PlSqlParser.RULE_log_grp);
+        try {
+            this.state = 12952;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNSIGNED_INTEGER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12950;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12951;
+                this.identifier();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public supplemental_table_logging(): Supplemental_table_loggingContext {
+        let localContext = new Supplemental_table_loggingContext(this.context, this.state);
+        this.enterRule(localContext, 1290, PlSqlParser.RULE_supplemental_table_logging);
+        try {
+            let alternative: number;
+            this.state = 12994;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 12954;
+                this.match(PlSqlParser.ADD);
+                this.state = 12955;
+                this.match(PlSqlParser.SUPPLEMENTAL);
+                this.state = 12956;
+                this.match(PlSqlParser.LOG);
+                this.state = 12959;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.GROUP:
+                    {
+                    this.state = 12957;
+                    this.supplemental_log_grp_clause();
+                    }
+                    break;
+                case PlSqlParser.DATA:
+                    {
+                    this.state = 12958;
+                    this.supplemental_id_key_clause();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 12970;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1648, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 12961;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 12962;
+                        this.match(PlSqlParser.SUPPLEMENTAL);
+                        this.state = 12963;
+                        this.match(PlSqlParser.LOG);
+                        this.state = 12966;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.GROUP:
+                            {
+                            this.state = 12964;
+                            this.supplemental_log_grp_clause();
+                            }
+                            break;
+                        case PlSqlParser.DATA:
+                            {
+                            this.state = 12965;
+                            this.supplemental_id_key_clause();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        }
+                    }
+                    this.state = 12972;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1648, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 12973;
+                this.match(PlSqlParser.DROP);
+                this.state = 12974;
+                this.match(PlSqlParser.SUPPLEMENTAL);
+                this.state = 12975;
+                this.match(PlSqlParser.LOG);
+                this.state = 12979;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DATA:
+                    {
+                    this.state = 12976;
+                    this.supplemental_id_key_clause();
+                    }
+                    break;
+                case PlSqlParser.GROUP:
+                    {
+                    this.state = 12977;
+                    this.match(PlSqlParser.GROUP);
+                    this.state = 12978;
+                    this.log_grp();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 12991;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1651, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 12981;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 12982;
+                        this.match(PlSqlParser.SUPPLEMENTAL);
+                        this.state = 12983;
+                        this.match(PlSqlParser.LOG);
+                        this.state = 12987;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.DATA:
+                            {
+                            this.state = 12984;
+                            this.supplemental_id_key_clause();
+                            }
+                            break;
+                        case PlSqlParser.GROUP:
+                            {
+                            this.state = 12985;
+                            this.match(PlSqlParser.GROUP);
+                            this.state = 12986;
+                            this.log_grp();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        }
+                    }
+                    this.state = 12993;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1651, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public supplemental_log_grp_clause(): Supplemental_log_grp_clauseContext {
+        let localContext = new Supplemental_log_grp_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1292, PlSqlParser.RULE_supplemental_log_grp_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 12996;
+            this.match(PlSqlParser.GROUP);
+            this.state = 12997;
+            this.log_grp();
+            this.state = 12998;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 12999;
+            this.column_name();
+            this.state = 13002;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1139) {
+                {
+                this.state = 13000;
+                this.match(PlSqlParser.NO);
+                this.state = 13001;
+                this.match(PlSqlParser.LOG);
+                }
+            }
+
+            this.state = 13012;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 13004;
+                this.match(PlSqlParser.COMMA);
+                this.state = 13005;
+                this.column_name();
+                this.state = 13008;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 13006;
+                    this.match(PlSqlParser.NO);
+                    this.state = 13007;
+                    this.match(PlSqlParser.LOG);
+                    }
+                }
+
+                }
+                }
+                this.state = 13014;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 13015;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 13017;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1656, this.context) ) {
+            case 1:
+                {
+                this.state = 13016;
+                this.match(PlSqlParser.ALWAYS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public supplemental_id_key_clause(): Supplemental_id_key_clauseContext {
+        let localContext = new Supplemental_id_key_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1294, PlSqlParser.RULE_supplemental_id_key_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13019;
+            this.match(PlSqlParser.DATA);
+            this.state = 13020;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 13035;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 13022;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 13021;
+                    this.match(PlSqlParser.COMMA);
+                    }
+                }
+
+                this.state = 13033;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ALL:
+                    {
+                    this.state = 13024;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                case PlSqlParser.PRIMARY:
+                    {
+                    this.state = 13025;
+                    this.match(PlSqlParser.PRIMARY);
+                    this.state = 13026;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                case PlSqlParser.UNIQUE:
+                    {
+                    this.state = 13027;
+                    this.match(PlSqlParser.UNIQUE);
+                    this.state = 13029;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 718) {
+                        {
+                        this.state = 13028;
+                        this.match(PlSqlParser.INDEX);
+                        }
+                    }
+
+                    }
+                    break;
+                case PlSqlParser.FOREIGN:
+                    {
+                    this.state = 13031;
+                    this.match(PlSqlParser.FOREIGN);
+                    this.state = 13032;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                }
+                this.state = 13037;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 38 || _la === 619 || _la === 1453 || _la === 2185 || _la === 2455);
+            this.state = 13039;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 13040;
+            this.match(PlSqlParser.COLUMNS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext {
+        let localContext = new Allocate_extent_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1296, PlSqlParser.RULE_allocate_extent_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13042;
+            this.match(PlSqlParser.ALLOCATE);
+            this.state = 13043;
+            this.match(PlSqlParser.EXTENT);
+            this.state = 13056;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1663, this.context) ) {
+            case 1:
+                {
+                this.state = 13044;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 13051;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    this.state = 13051;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.SIZE:
+                        {
+                        this.state = 13045;
+                        this.match(PlSqlParser.SIZE);
+                        this.state = 13046;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.DATAFILE:
+                        {
+                        this.state = 13047;
+                        this.match(PlSqlParser.DATAFILE);
+                        this.state = 13048;
+                        localContext._datafile = this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        break;
+                    case PlSqlParser.INSTANCE:
+                        {
+                        this.state = 13049;
+                        this.match(PlSqlParser.INSTANCE);
+                        this.state = 13050;
+                        localContext._inst_num = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    this.state = 13053;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 352 || _la === 760 || _la === 1701);
+                this.state = 13055;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext {
+        let localContext = new Deallocate_unused_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1298, PlSqlParser.RULE_deallocate_unused_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13058;
+            this.match(PlSqlParser.DEALLOCATE);
+            this.state = 13059;
+            this.match(PlSqlParser.UNUSED);
+            this.state = 13062;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1664, this.context) ) {
+            case 1:
+                {
+                this.state = 13060;
+                this.match(PlSqlParser.KEEP);
+                this.state = 13061;
+                this.size_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public shrink_clause(): Shrink_clauseContext {
+        let localContext = new Shrink_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1300, PlSqlParser.RULE_shrink_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13064;
+            this.match(PlSqlParser.SHRINK);
+            this.state = 13065;
+            this.match(PlSqlParser.SPACE_KEYWORD);
+            this.state = 13067;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1665, this.context) ) {
+            case 1:
+                {
+                this.state = 13066;
+                this.match(PlSqlParser.COMPACT);
+                }
+                break;
+            }
+            this.state = 13070;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1666, this.context) ) {
+            case 1:
+                {
+                this.state = 13069;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            this.state = 13073;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1667, this.context) ) {
+            case 1:
+                {
+                this.state = 13072;
+                this.match(PlSqlParser.CHECK);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public records_per_block_clause(): Records_per_block_clauseContext {
+        let localContext = new Records_per_block_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1302, PlSqlParser.RULE_records_per_block_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13076;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 954 || _la === 1124) {
+                {
+                this.state = 13075;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 954 || _la === 1124)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 13078;
+            this.match(PlSqlParser.RECORDS_PER_BLOCK);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public upgrade_table_clause(): Upgrade_table_clauseContext {
+        let localContext = new Upgrade_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1304, PlSqlParser.RULE_upgrade_table_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13080;
+            this.match(PlSqlParser.UPGRADE);
+            {
+            this.state = 13082;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 13081;
+                this.match(PlSqlParser.NOT);
+                }
+            }
+
+            this.state = 13084;
+            this.match(PlSqlParser.INCLUDING);
+            this.state = 13085;
+            this.match(PlSqlParser.DATA);
+            }
+            this.state = 13087;
+            this.column_properties();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public truncate_table(): Truncate_tableContext {
+        let localContext = new Truncate_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1306, PlSqlParser.RULE_truncate_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13089;
+            this.match(PlSqlParser.TRUNCATE);
+            this.state = 13090;
+            this.match(PlSqlParser.TABLE);
+            this.state = 13091;
+            this.tableview_name();
+            this.state = 13098;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1671, this.context) ) {
+            case 1:
+                {
+                this.state = 13092;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1449 || _la === 1477)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 13096;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1670, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13093;
+                    this.match(PlSqlParser.MATERIALIZED);
+                    this.state = 13094;
+                    this.match(PlSqlParser.VIEW);
+                    this.state = 13095;
+                    this.match(PlSqlParser.LOG);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 13108;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1674, this.context) ) {
+            case 1:
+                {
+                this.state = 13105;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DROP:
+                    {
+                    this.state = 13100;
+                    this.match(PlSqlParser.DROP);
+                    this.state = 13102;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 38) {
+                        {
+                        this.state = 13101;
+                        this.match(PlSqlParser.ALL);
+                        }
+                    }
+
+                    }
+                    break;
+                case PlSqlParser.REUSE:
+                    {
+                    this.state = 13104;
+                    this.match(PlSqlParser.REUSE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 13107;
+                this.match(PlSqlParser.STORAGE);
+                }
+                break;
+            }
+            this.state = 13111;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1675, this.context) ) {
+            case 1:
+                {
+                this.state = 13110;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_table(): Drop_tableContext {
+        let localContext = new Drop_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1308, PlSqlParser.RULE_drop_table);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13113;
+            this.match(PlSqlParser.DROP);
+            this.state = 13114;
+            this.match(PlSqlParser.TABLE);
+            this.state = 13115;
+            this.tableview_name();
+            this.state = 13118;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1676, this.context) ) {
+            case 1:
+                {
+                this.state = 13116;
+                this.match(PlSqlParser.IF);
+                this.state = 13117;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 13122;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1677, this.context) ) {
+            case 1:
+                {
+                this.state = 13120;
+                this.match(PlSqlParser.AS);
+                this.state = 13121;
+                this.tableview_name();
+                }
+                break;
+            }
+            this.state = 13126;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1678, this.context) ) {
+            case 1:
+                {
+                this.state = 13124;
+                this.match(PlSqlParser.CASCADE);
+                this.state = 13125;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 286 || _la === 287)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 13129;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1679, this.context) ) {
+            case 1:
+                {
+                this.state = 13128;
+                this.match(PlSqlParser.PURGE);
+                }
+                break;
+            }
+            this.state = 13133;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1680, this.context) ) {
+            case 1:
+                {
+                this.state = 13131;
+                this.match(PlSqlParser.AS);
+                this.state = 13132;
+                this.table_alias();
+                }
+                break;
+            }
+            this.state = 13136;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1681, this.context) ) {
+            case 1:
+                {
+                this.state = 13135;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_tablespace(): Drop_tablespaceContext {
+        let localContext = new Drop_tablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 1310, PlSqlParser.RULE_drop_tablespace);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13138;
+            this.match(PlSqlParser.DROP);
+            this.state = 13139;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 13140;
+            localContext._ts = this.id_expression();
+            this.state = 13143;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1682, this.context) ) {
+            case 1:
+                {
+                this.state = 13141;
+                this.match(PlSqlParser.IF);
+                this.state = 13142;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 13149;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1684, this.context) ) {
+            case 1:
+                {
+                this.state = 13145;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 469 || _la === 815)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 13147;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1683, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13146;
+                    this.match(PlSqlParser.QUOTA);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 13152;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1685, this.context) ) {
+            case 1:
+                {
+                this.state = 13151;
+                this.including_contents_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_tablespace_set(): Drop_tablespace_setContext {
+        let localContext = new Drop_tablespace_setContext(this.context, this.state);
+        this.enterRule(localContext, 1312, PlSqlParser.RULE_drop_tablespace_set);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13154;
+            this.match(PlSqlParser.DROP);
+            this.state = 13155;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 13156;
+            this.match(PlSqlParser.SET);
+            this.state = 13157;
+            localContext._tss = this.id_expression();
+            this.state = 13159;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1686, this.context) ) {
+            case 1:
+                {
+                this.state = 13158;
+                this.including_contents_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public including_contents_clause(): Including_contents_clauseContext {
+        let localContext = new Including_contents_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1314, PlSqlParser.RULE_including_contents_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13161;
+            this.match(PlSqlParser.INCLUDING);
+            this.state = 13162;
+            this.match(PlSqlParser.CONTENTS);
+            this.state = 13165;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1687, this.context) ) {
+            case 1:
+                {
+                this.state = 13163;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 49 || _la === 815)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 13164;
+                this.match(PlSqlParser.DATAFILES);
+                }
+                break;
+            }
+            this.state = 13169;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1688, this.context) ) {
+            case 1:
+                {
+                this.state = 13167;
+                this.match(PlSqlParser.CASCADE);
+                this.state = 13168;
+                this.match(PlSqlParser.CONSTRAINTS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_view(): Drop_viewContext {
+        let localContext = new Drop_viewContext(this.context, this.state);
+        this.enterRule(localContext, 1316, PlSqlParser.RULE_drop_view);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13171;
+            this.match(PlSqlParser.DROP);
+            this.state = 13172;
+            this.match(PlSqlParser.VIEW);
+            this.state = 13173;
+            this.tableview_name();
+            this.state = 13176;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1689, this.context) ) {
+            case 1:
+                {
+                this.state = 13174;
+                this.match(PlSqlParser.IF);
+                this.state = 13175;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            }
+            this.state = 13180;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1690, this.context) ) {
+            case 1:
+                {
+                this.state = 13178;
+                this.match(PlSqlParser.CASCADE);
+                this.state = 13179;
+                this.match(PlSqlParser.CONSTRAINT);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public comment_on_column(): Comment_on_columnContext {
+        let localContext = new Comment_on_columnContext(this.context, this.state);
+        this.enterRule(localContext, 1318, PlSqlParser.RULE_comment_on_column);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13182;
+            this.match(PlSqlParser.COMMENT);
+            this.state = 13183;
+            this.match(PlSqlParser.ON);
+            this.state = 13184;
+            this.match(PlSqlParser.COLUMN);
+            this.state = 13185;
+            this.column_name();
+            this.state = 13186;
+            this.match(PlSqlParser.IS);
+            this.state = 13187;
+            this.quoted_string();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public enable_or_disable(): Enable_or_disableContext {
+        let localContext = new Enable_or_disableContext(this.context, this.state);
+        this.enterRule(localContext, 1320, PlSqlParser.RULE_enable_or_disable);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13189;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 429 || _la === 499)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public allow_or_disallow(): Allow_or_disallowContext {
+        let localContext = new Allow_or_disallowContext(this.context, this.state);
+        this.enterRule(localContext, 1322, PlSqlParser.RULE_allow_or_disallow);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13191;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 40 || _la === 435)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_synonym(): Alter_synonymContext {
+        let localContext = new Alter_synonymContext(this.context, this.state);
+        this.enterRule(localContext, 1324, PlSqlParser.RULE_alter_synonym);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13193;
+            this.match(PlSqlParser.ALTER);
+            this.state = 13195;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1475) {
+                {
+                this.state = 13194;
+                this.match(PlSqlParser.PUBLIC);
+                }
+            }
+
+            this.state = 13197;
+            this.match(PlSqlParser.SYNONYM);
+            this.state = 13201;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1692, this.context) ) {
+            case 1:
+                {
+                this.state = 13198;
+                this.schema_name();
+                this.state = 13199;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13203;
+            this.synonym_name();
+            this.state = 13204;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 249 || _la === 482 || _la === 1133)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_synonym(): Create_synonymContext {
+        let localContext = new Create_synonymContext(this.context, this.state);
+        this.enterRule(localContext, 1326, PlSqlParser.RULE_create_synonym);
+        let _la: number;
+        try {
+            this.state = 13253;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1701, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 13206;
+                this.match(PlSqlParser.CREATE);
+                this.state = 13209;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1309) {
+                    {
+                    this.state = 13207;
+                    this.match(PlSqlParser.OR);
+                    this.state = 13208;
+                    this.match(PlSqlParser.REPLACE);
+                    }
+                }
+
+                this.state = 13211;
+                this.match(PlSqlParser.PUBLIC);
+                this.state = 13212;
+                this.match(PlSqlParser.SYNONYM);
+                this.state = 13213;
+                this.synonym_name();
+                this.state = 13214;
+                this.match(PlSqlParser.FOR);
+                this.state = 13218;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1694, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13215;
+                    this.schema_name();
+                    this.state = 13216;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 13220;
+                this.schema_object_name();
+                this.state = 13223;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1695, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13221;
+                    this.match(PlSqlParser.AT_SIGN);
+                    this.state = 13222;
+                    this.link_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 13225;
+                this.match(PlSqlParser.CREATE);
+                this.state = 13228;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1309) {
+                    {
+                    this.state = 13226;
+                    this.match(PlSqlParser.OR);
+                    this.state = 13227;
+                    this.match(PlSqlParser.REPLACE);
+                    }
+                }
+
+                this.state = 13230;
+                this.match(PlSqlParser.SYNONYM);
+                this.state = 13234;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1697, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13231;
+                    this.schema_name();
+                    this.state = 13232;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 13236;
+                this.synonym_name();
+                this.state = 13237;
+                this.match(PlSqlParser.FOR);
+                this.state = 13241;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1698, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13238;
+                    this.schema_name();
+                    this.state = 13239;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 13243;
+                this.schema_object_name();
+                this.state = 13251;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1700, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13244;
+                    this.match(PlSqlParser.AT_SIGN);
+                    this.state = 13248;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1699, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 13245;
+                        this.schema_name();
+                        this.state = 13246;
+                        this.match(PlSqlParser.PERIOD);
+                        }
+                        break;
+                    }
+                    this.state = 13250;
+                    this.link_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_synonym(): Drop_synonymContext {
+        let localContext = new Drop_synonymContext(this.context, this.state);
+        this.enterRule(localContext, 1328, PlSqlParser.RULE_drop_synonym);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13255;
+            this.match(PlSqlParser.DROP);
+            this.state = 13257;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1475) {
+                {
+                this.state = 13256;
+                this.match(PlSqlParser.PUBLIC);
+                }
+            }
+
+            this.state = 13259;
+            this.match(PlSqlParser.SYNONYM);
+            this.state = 13263;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1703, this.context) ) {
+            case 1:
+                {
+                this.state = 13260;
+                this.schema_name();
+                this.state = 13261;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13265;
+            this.synonym_name();
+            this.state = 13267;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1704, this.context) ) {
+            case 1:
+                {
+                this.state = 13266;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_spfile(): Create_spfileContext {
+        let localContext = new Create_spfileContext(this.context, this.state);
+        this.enterRule(localContext, 1330, PlSqlParser.RULE_create_spfile);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13269;
+            this.match(PlSqlParser.CREATE);
+            this.state = 13270;
+            this.match(PlSqlParser.SPFILE);
+            this.state = 13273;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2474) {
+                {
+                this.state = 13271;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 13272;
+                this.spfile_name();
+                }
+            }
+
+            this.state = 13275;
+            this.match(PlSqlParser.FROM);
+            this.state = 13286;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PFILE:
+                {
+                this.state = 13276;
+                this.match(PlSqlParser.PFILE);
+                this.state = 13279;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1706, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13277;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 13278;
+                    this.pfile_name();
+                    }
+                    break;
+                }
+                this.state = 13283;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1707, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13281;
+                    this.match(PlSqlParser.AS);
+                    this.state = 13282;
+                    this.match(PlSqlParser.COPY);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.MEMORY:
+                {
+                this.state = 13285;
+                this.match(PlSqlParser.MEMORY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public spfile_name(): Spfile_nameContext {
+        let localContext = new Spfile_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1332, PlSqlParser.RULE_spfile_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13288;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pfile_name(): Pfile_nameContext {
+        let localContext = new Pfile_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1334, PlSqlParser.RULE_pfile_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13290;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public comment_on_table(): Comment_on_tableContext {
+        let localContext = new Comment_on_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1336, PlSqlParser.RULE_comment_on_table);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13292;
+            this.match(PlSqlParser.COMMENT);
+            this.state = 13293;
+            this.match(PlSqlParser.ON);
+            this.state = 13294;
+            this.match(PlSqlParser.TABLE);
+            this.state = 13295;
+            this.tableview_name();
+            this.state = 13296;
+            this.match(PlSqlParser.IS);
+            this.state = 13297;
+            this.quoted_string();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public comment_on_materialized(): Comment_on_materializedContext {
+        let localContext = new Comment_on_materializedContext(this.context, this.state);
+        this.enterRule(localContext, 1338, PlSqlParser.RULE_comment_on_materialized);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13299;
+            this.match(PlSqlParser.COMMENT);
+            this.state = 13300;
+            this.match(PlSqlParser.ON);
+            this.state = 13301;
+            this.match(PlSqlParser.MATERIALIZED);
+            this.state = 13302;
+            this.match(PlSqlParser.VIEW);
+            this.state = 13303;
+            this.tableview_name();
+            this.state = 13304;
+            this.match(PlSqlParser.IS);
+            this.state = 13305;
+            this.quoted_string();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_analytic_view(): Alter_analytic_viewContext {
+        let localContext = new Alter_analytic_viewContext(this.context, this.state);
+        this.enterRule(localContext, 1340, PlSqlParser.RULE_alter_analytic_view);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13307;
+            this.match(PlSqlParser.ALTER);
+            this.state = 13308;
+            this.match(PlSqlParser.ANALYTIC);
+            this.state = 13309;
+            this.match(PlSqlParser.VIEW);
+            this.state = 13313;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1709, this.context) ) {
+            case 1:
+                {
+                this.state = 13310;
+                this.schema_name();
+                this.state = 13311;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13315;
+            localContext._av = this.id_expression();
+            this.state = 13322;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RENAME:
+                {
+                this.state = 13316;
+                this.match(PlSqlParser.RENAME);
+                this.state = 13317;
+                this.match(PlSqlParser.TO);
+                this.state = 13318;
+                this.id_expression();
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 13319;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            case PlSqlParser.ADD:
+                {
+                this.state = 13320;
+                this.alter_add_cache_clause();
+                }
+                break;
+            case PlSqlParser.DROP:
+                {
+                this.state = 13321;
+                this.alter_drop_cache_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_add_cache_clause(): Alter_add_cache_clauseContext {
+        let localContext = new Alter_add_cache_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1342, PlSqlParser.RULE_alter_add_cache_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13324;
+            this.match(PlSqlParser.ADD);
+            this.state = 13325;
+            this.match(PlSqlParser.CACHE);
+            this.state = 13326;
+            this.match(PlSqlParser.MEASURE);
+            this.state = 13327;
+            this.match(PlSqlParser.GROUP);
+            this.state = 13328;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 13331;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALL:
+                {
+                this.state = 13329;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 13330;
+                this.measure_list();
+                }
+                break;
+            case PlSqlParser.RIGHT_PAREN:
+                break;
+            default:
+                break;
+            }
+            this.state = 13333;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 13334;
+            this.match(PlSqlParser.LEVELS);
+            this.state = 13335;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 13336;
+            this.levels_item();
+            this.state = 13341;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 13337;
+                this.match(PlSqlParser.COMMA);
+                this.state = 13338;
+                this.levels_item();
+                }
+                }
+                this.state = 13343;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 13344;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public levels_item(): Levels_itemContext {
+        let localContext = new Levels_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1344, PlSqlParser.RULE_levels_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13354;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1714, this.context) ) {
+            case 1:
+                {
+                this.state = 13349;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1713, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13346;
+                    localContext._d = this.id_expression();
+                    this.state = 13347;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                this.state = 13351;
+                localContext._h = this.id_expression();
+                this.state = 13352;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13356;
+            localContext._l = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public measure_list(): Measure_listContext {
+        let localContext = new Measure_listContext(this.context, this.state);
+        this.enterRule(localContext, 1346, PlSqlParser.RULE_measure_list);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13358;
+            this.id_expression();
+            this.state = 13363;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 13359;
+                this.match(PlSqlParser.COMMA);
+                this.state = 13360;
+                this.id_expression();
+                }
+                }
+                this.state = 13365;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_drop_cache_clause(): Alter_drop_cache_clauseContext {
+        let localContext = new Alter_drop_cache_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1348, PlSqlParser.RULE_alter_drop_cache_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13366;
+            this.match(PlSqlParser.DROP);
+            this.state = 13367;
+            this.match(PlSqlParser.CACHE);
+            this.state = 13368;
+            this.match(PlSqlParser.MEASURE);
+            this.state = 13369;
+            this.match(PlSqlParser.GROUP);
+            this.state = 13370;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 13373;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALL:
+                {
+                this.state = 13371;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 13372;
+                this.measure_list();
+                }
+                break;
+            case PlSqlParser.RIGHT_PAREN:
+                break;
+            default:
+                break;
+            }
+            this.state = 13375;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 13376;
+            this.match(PlSqlParser.LEVELS);
+            this.state = 13377;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 13378;
+            this.levels_item();
+            this.state = 13383;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 13379;
+                this.match(PlSqlParser.COMMA);
+                this.state = 13380;
+                this.levels_item();
+                }
+                }
+                this.state = 13385;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 13386;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_attribute_dimension(): Alter_attribute_dimensionContext {
+        let localContext = new Alter_attribute_dimensionContext(this.context, this.state);
+        this.enterRule(localContext, 1350, PlSqlParser.RULE_alter_attribute_dimension);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13388;
+            this.match(PlSqlParser.ALTER);
+            this.state = 13389;
+            this.match(PlSqlParser.ATTRIBUTE);
+            this.state = 13390;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 13394;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1718, this.context) ) {
+            case 1:
+                {
+                this.state = 13391;
+                this.schema_name();
+                this.state = 13392;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13396;
+            localContext._ad = this.id_expression();
+            this.state = 13401;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RENAME:
+                {
+                this.state = 13397;
+                this.match(PlSqlParser.RENAME);
+                this.state = 13398;
+                this.match(PlSqlParser.TO);
+                this.state = 13399;
+                localContext._nad = this.id_expression();
+                }
+                break;
+            case PlSqlParser.COMPILE:
+                {
+                this.state = 13400;
+                this.match(PlSqlParser.COMPILE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_audit_policy(): Alter_audit_policyContext {
+        let localContext = new Alter_audit_policyContext(this.context, this.state);
+        this.enterRule(localContext, 1352, PlSqlParser.RULE_alter_audit_policy);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13403;
+            this.match(PlSqlParser.ALTER);
+            this.state = 13404;
+            this.match(PlSqlParser.AUDIT);
+            this.state = 13405;
+            this.match(PlSqlParser.POLICY);
+            this.state = 13406;
+            localContext._p = this.id_expression();
+            this.state = 13408;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1720, this.context) ) {
+            case 1:
+                {
+                this.state = 13407;
+                this.match(PlSqlParser.ADD);
+                }
+                break;
+            }
+            this.state = 13423;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1725, this.context) ) {
+            case 1:
+                {
+                this.state = 13411;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1721, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13410;
+                    this.privilege_audit_clause();
+                    }
+                    break;
+                }
+                this.state = 13414;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1722, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13413;
+                    this.action_audit_clause();
+                    }
+                    break;
+                }
+                this.state = 13417;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1723, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13416;
+                    this.role_audit_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 13421;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1724, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13419;
+                    this.match(PlSqlParser.ONLY);
+                    this.state = 13420;
+                    this.match(PlSqlParser.TOPLEVEL);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 13426;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1726, this.context) ) {
+            case 1:
+                {
+                this.state = 13425;
+                this.match(PlSqlParser.DROP);
+                }
+                break;
+            }
+            this.state = 13441;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1731, this.context) ) {
+            case 1:
+                {
+                this.state = 13429;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1727, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13428;
+                    this.privilege_audit_clause();
+                    }
+                    break;
+                }
+                this.state = 13432;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1728, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13431;
+                    this.action_audit_clause();
+                    }
+                    break;
+                }
+                this.state = 13435;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1729, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13434;
+                    this.role_audit_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 13439;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1730, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13437;
+                    this.match(PlSqlParser.ONLY);
+                    this.state = 13438;
+                    this.match(PlSqlParser.TOPLEVEL);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 13451;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1733, this.context) ) {
+            case 1:
+                {
+                this.state = 13443;
+                this.match(PlSqlParser.CONDITION);
+                this.state = 13449;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DROP:
+                    {
+                    this.state = 13444;
+                    this.match(PlSqlParser.DROP);
+                    }
+                    break;
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 13445;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 13446;
+                    this.match(PlSqlParser.EVALUATE);
+                    this.state = 13447;
+                    this.match(PlSqlParser.PER);
+                    this.state = 13448;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 760 || _la === 1669 || _la === 1745)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_cluster(): Alter_clusterContext {
+        let localContext = new Alter_clusterContext(this.context, this.state);
+        this.enterRule(localContext, 1354, PlSqlParser.RULE_alter_cluster);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13453;
+            this.match(PlSqlParser.ALTER);
+            this.state = 13454;
+            this.match(PlSqlParser.CLUSTER);
+            this.state = 13455;
+            this.cluster_name();
+            this.state = 13462;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 13462;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.PCTFREE:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 13456;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case PlSqlParser.SIZE:
+                        {
+                        this.state = 13457;
+                        this.match(PlSqlParser.SIZE);
+                        this.state = 13458;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.ALLOCATE:
+                        {
+                        this.state = 13459;
+                        this.allocate_extent_clause();
+                        }
+                        break;
+                    case PlSqlParser.DEALLOCATE:
+                        {
+                        this.state = 13460;
+                        this.deallocate_unused_clause();
+                        }
+                        break;
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.NOCACHE:
+                        {
+                        this.state = 13461;
+                        this.cache_or_nocache();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 13464;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1735, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            this.state = 13467;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1736, this.context) ) {
+            case 1:
+                {
+                this.state = 13466;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_analytic_view(): Drop_analytic_viewContext {
+        let localContext = new Drop_analytic_viewContext(this.context, this.state);
+        this.enterRule(localContext, 1356, PlSqlParser.RULE_drop_analytic_view);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13469;
+            this.match(PlSqlParser.DROP);
+            this.state = 13470;
+            this.match(PlSqlParser.ANALYTIC);
+            this.state = 13471;
+            this.match(PlSqlParser.VIEW);
+            this.state = 13475;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1737, this.context) ) {
+            case 1:
+                {
+                this.state = 13472;
+                this.schema_name();
+                this.state = 13473;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13477;
+            localContext._av = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_attribute_dimension(): Drop_attribute_dimensionContext {
+        let localContext = new Drop_attribute_dimensionContext(this.context, this.state);
+        this.enterRule(localContext, 1358, PlSqlParser.RULE_drop_attribute_dimension);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13479;
+            this.match(PlSqlParser.DROP);
+            this.state = 13480;
+            this.match(PlSqlParser.ATTRIBUTE);
+            this.state = 13481;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 13485;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1738, this.context) ) {
+            case 1:
+                {
+                this.state = 13482;
+                this.schema_name();
+                this.state = 13483;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 13487;
+            localContext._ad = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_audit_policy(): Drop_audit_policyContext {
+        let localContext = new Drop_audit_policyContext(this.context, this.state);
+        this.enterRule(localContext, 1360, PlSqlParser.RULE_drop_audit_policy);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13489;
+            this.match(PlSqlParser.DROP);
+            this.state = 13490;
+            this.match(PlSqlParser.AUDIT);
+            this.state = 13491;
+            this.match(PlSqlParser.POLICY);
+            this.state = 13492;
+            localContext._p = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_flashback_archive(): Drop_flashback_archiveContext {
+        let localContext = new Drop_flashback_archiveContext(this.context, this.state);
+        this.enterRule(localContext, 1362, PlSqlParser.RULE_drop_flashback_archive);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13494;
+            this.match(PlSqlParser.DROP);
+            this.state = 13495;
+            this.match(PlSqlParser.FLASHBACK);
+            this.state = 13496;
+            this.match(PlSqlParser.ARCHIVE);
+            this.state = 13497;
+            localContext._fa = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_cluster(): Drop_clusterContext {
+        let localContext = new Drop_clusterContext(this.context, this.state);
+        this.enterRule(localContext, 1364, PlSqlParser.RULE_drop_cluster);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13499;
+            this.match(PlSqlParser.DROP);
+            this.state = 13500;
+            this.match(PlSqlParser.CLUSTER);
+            this.state = 13501;
+            this.cluster_name();
+            this.state = 13508;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1740, this.context) ) {
+            case 1:
+                {
+                this.state = 13502;
+                this.match(PlSqlParser.INCLUDING);
+                this.state = 13503;
+                this.match(PlSqlParser.TABLES);
+                this.state = 13506;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1739, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13504;
+                    this.match(PlSqlParser.CASCADE);
+                    this.state = 13505;
+                    this.match(PlSqlParser.CONSTRAINTS);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_context(): Drop_contextContext {
+        let localContext = new Drop_contextContext(this.context, this.state);
+        this.enterRule(localContext, 1366, PlSqlParser.RULE_drop_context);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13510;
+            this.match(PlSqlParser.DROP);
+            this.state = 13511;
+            this.match(PlSqlParser.CONTEXT);
+            this.state = 13512;
+            localContext._ns = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_directory(): Drop_directoryContext {
+        let localContext = new Drop_directoryContext(this.context, this.state);
+        this.enterRule(localContext, 1368, PlSqlParser.RULE_drop_directory);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13514;
+            this.match(PlSqlParser.DROP);
+            this.state = 13515;
+            this.match(PlSqlParser.DIRECTORY);
+            this.state = 13516;
+            localContext._dn = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_diskgroup(): Drop_diskgroupContext {
+        let localContext = new Drop_diskgroupContext(this.context, this.state);
+        this.enterRule(localContext, 1370, PlSqlParser.RULE_drop_diskgroup);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13518;
+            this.match(PlSqlParser.DROP);
+            this.state = 13519;
+            this.match(PlSqlParser.DISKGROUP);
+            this.state = 13520;
+            localContext._dgn = this.id_expression();
+            this.state = 13529;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1743, this.context) ) {
+            case 1:
+                {
+                this.state = 13526;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.FORCE:
+                case PlSqlParser.INCLUDING:
+                    {
+                    this.state = 13522;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 617) {
+                        {
+                        this.state = 13521;
+                        this.match(PlSqlParser.FORCE);
+                        }
+                    }
+
+                    this.state = 13524;
+                    this.match(PlSqlParser.INCLUDING);
+                    }
+                    break;
+                case PlSqlParser.EXCLUDING:
+                    {
+                    this.state = 13525;
+                    this.match(PlSqlParser.EXCLUDING);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 13528;
+                this.match(PlSqlParser.CONTENTS);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_edition(): Drop_editionContext {
+        let localContext = new Drop_editionContext(this.context, this.state);
+        this.enterRule(localContext, 1372, PlSqlParser.RULE_drop_edition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13531;
+            this.match(PlSqlParser.DROP);
+            this.state = 13532;
+            this.match(PlSqlParser.EDITION);
+            this.state = 13533;
+            localContext._e = this.id_expression();
+            this.state = 13535;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1744, this.context) ) {
+            case 1:
+                {
+                this.state = 13534;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public truncate_cluster(): Truncate_clusterContext {
+        let localContext = new Truncate_clusterContext(this.context, this.state);
+        this.enterRule(localContext, 1374, PlSqlParser.RULE_truncate_cluster);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13537;
+            this.match(PlSqlParser.TRUNCATE);
+            this.state = 13538;
+            this.match(PlSqlParser.CLUSTER);
+            this.state = 13539;
+            this.cluster_name();
+            this.state = 13542;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1745, this.context) ) {
+            case 1:
+                {
+                this.state = 13540;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 469 || _la === 1589)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 13541;
+                this.match(PlSqlParser.STORAGE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cache_or_nocache(): Cache_or_nocacheContext {
+        let localContext = new Cache_or_nocacheContext(this.context, this.state);
+        this.enterRule(localContext, 1376, PlSqlParser.RULE_cache_or_nocache);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13544;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 166 || _la === 1067)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public database_name(): Database_nameContext {
+        let localContext = new Database_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1378, PlSqlParser.RULE_database_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13546;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_database(): Alter_databaseContext {
+        let localContext = new Alter_databaseContext(this.context, this.state);
+        this.enterRule(localContext, 1380, PlSqlParser.RULE_alter_database);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13548;
+            this.match(PlSqlParser.ALTER);
+            this.state = 13549;
+            this.database_clause();
+            this.state = 13565;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1746, this.context) ) {
+            case 1:
+                {
+                this.state = 13550;
+                this.startup_clauses();
+                }
+                break;
+            case 2:
+                {
+                this.state = 13551;
+                this.recovery_clauses();
+                }
+                break;
+            case 3:
+                {
+                this.state = 13552;
+                this.database_file_clauses();
+                }
+                break;
+            case 4:
+                {
+                this.state = 13553;
+                this.logfile_clauses();
+                }
+                break;
+            case 5:
+                {
+                this.state = 13554;
+                this.controlfile_clauses();
+                }
+                break;
+            case 6:
+                {
+                this.state = 13555;
+                this.standby_database_clauses();
+                }
+                break;
+            case 7:
+                {
+                this.state = 13556;
+                this.default_settings_clause();
+                }
+                break;
+            case 8:
+                {
+                this.state = 13557;
+                this.instance_clauses();
+                }
+                break;
+            case 9:
+                {
+                this.state = 13558;
+                this.security_clause();
+                }
+                break;
+            case 10:
+                {
+                this.state = 13559;
+                this.prepare_clause();
+                }
+                break;
+            case 11:
+                {
+                this.state = 13560;
+                this.drop_mirror_clause();
+                }
+                break;
+            case 12:
+                {
+                this.state = 13561;
+                this.lost_write_protection();
+                }
+                break;
+            case 13:
+                {
+                this.state = 13562;
+                this.cdb_fleet_clauses();
+                }
+                break;
+            case 14:
+                {
+                this.state = 13563;
+                this.property_clauses();
+                }
+                break;
+            case 15:
+                {
+                this.state = 13564;
+                this.replay_upgrade_clauses();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public database_clause(): Database_clauseContext {
+        let localContext = new Database_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1382, PlSqlParser.RULE_database_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13568;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1411) {
+                {
+                this.state = 13567;
+                this.match(PlSqlParser.PLUGGABLE);
+                }
+            }
+
+            this.state = 13570;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 13572;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1748, this.context) ) {
+            case 1:
+                {
+                this.state = 13571;
+                this.database_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public startup_clauses(): Startup_clausesContext {
+        let localContext = new Startup_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1384, PlSqlParser.RULE_startup_clauses);
+        let _la: number;
+        try {
+            this.state = 13593;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1753, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 13574;
+                this.match(PlSqlParser.MOUNT);
+                this.state = 13577;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1749, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13575;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 216 || _la === 1736)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 13576;
+                    this.match(PlSqlParser.DATABASE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 13579;
+                this.match(PlSqlParser.OPEN);
+                this.state = 13582;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1750, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13580;
+                    this.match(PlSqlParser.READ);
+                    this.state = 13581;
+                    this.match(PlSqlParser.WRITE);
+                    }
+                    break;
+                }
+                this.state = 13585;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1751, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13584;
+                    this.resetlogs_or_noresetlogs();
+                    }
+                    break;
+                }
+                this.state = 13588;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1752, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13587;
+                    this.upgrade_or_downgrade();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 13590;
+                this.match(PlSqlParser.OPEN);
+                this.state = 13591;
+                this.match(PlSqlParser.READ);
+                this.state = 13592;
+                this.match(PlSqlParser.ONLY);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public resetlogs_or_noresetlogs(): Resetlogs_or_noresetlogsContext {
+        let localContext = new Resetlogs_or_noresetlogsContext(this.context, this.state);
+        this.enterRule(localContext, 1386, PlSqlParser.RULE_resetlogs_or_noresetlogs);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13595;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1175 || _la === 1567)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public upgrade_or_downgrade(): Upgrade_or_downgradeContext {
+        let localContext = new Upgrade_or_downgradeContext(this.context, this.state);
+        this.enterRule(localContext, 1388, PlSqlParser.RULE_upgrade_or_downgrade);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13597;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 466 || _la === 2213)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public recovery_clauses(): Recovery_clausesContext {
+        let localContext = new Recovery_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1390, PlSqlParser.RULE_recovery_clauses);
+        try {
+            this.state = 13604;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1754, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 13599;
+                this.general_recovery();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 13600;
+                this.managed_standby_recovery();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 13601;
+                this.begin_or_end();
+                this.state = 13602;
+                this.match(PlSqlParser.BACKUP);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public begin_or_end(): Begin_or_endContext {
+        let localContext = new Begin_or_endContext(this.context, this.state);
+        this.enterRule(localContext, 1392, PlSqlParser.RULE_begin_or_end);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13606;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 113 || _la === 508)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public general_recovery(): General_recoveryContext {
+        let localContext = new General_recoveryContext(this.context, this.state);
+        this.enterRule(localContext, 1394, PlSqlParser.RULE_general_recovery);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13608;
+            this.match(PlSqlParser.RECOVER);
+            this.state = 13610;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1755, this.context) ) {
+            case 1:
+                {
+                this.state = 13609;
+                this.match(PlSqlParser.AUTOMATIC);
+                }
+                break;
+            }
+            this.state = 13614;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1756, this.context) ) {
+            case 1:
+                {
+                this.state = 13612;
+                this.match(PlSqlParser.FROM);
+                this.state = 13613;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            this.state = 13638;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1762, this.context) ) {
+            case 1:
+                {
+                this.state = 13620;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1757, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13616;
+                    this.full_database_recovery();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 13617;
+                    this.partial_database_recovery();
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 13618;
+                    this.match(PlSqlParser.LOGFILE);
+                    this.state = 13619;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    break;
+                }
+                this.state = 13631;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1760, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13627;
+                    this.errorHandler.sync(this);
+                    alternative = 1;
+                    do {
+                        switch (alternative) {
+                        case 1:
+                            {
+                            this.state = 13627;
+                            this.errorHandler.sync(this);
+                            switch (this.tokenStream.LA(1)) {
+                            case PlSqlParser.TEST:
+                                {
+                                this.state = 13622;
+                                this.match(PlSqlParser.TEST);
+                                }
+                                break;
+                            case PlSqlParser.ALLOW:
+                                {
+                                this.state = 13623;
+                                this.match(PlSqlParser.ALLOW);
+                                this.state = 13624;
+                                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                                this.state = 13625;
+                                this.match(PlSqlParser.CORRUPTION);
+                                }
+                                break;
+                            case PlSqlParser.NOPARALLEL:
+                            case PlSqlParser.PARALLEL:
+                                {
+                                this.state = 13626;
+                                this.parallel_clause();
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 13629;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1759, this.context);
+                    } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 13633;
+                this.match(PlSqlParser.CONTINUE);
+                this.state = 13635;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1761, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13634;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 13637;
+                this.match(PlSqlParser.CANCEL);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public full_database_recovery(): Full_database_recoveryContext {
+        let localContext = new Full_database_recoveryContext(this.context, this.state);
+        this.enterRule(localContext, 1396, PlSqlParser.RULE_full_database_recovery);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13641;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1736) {
+                {
+                this.state = 13640;
+                this.match(PlSqlParser.STANDBY);
+                }
+            }
+
+            this.state = 13643;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 13663;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1767, this.context) ) {
+            case 1:
+                {
+                this.state = 13659;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 13659;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.UNTIL:
+                            {
+                            this.state = 13644;
+                            this.match(PlSqlParser.UNTIL);
+                            this.state = 13651;
+                            this.errorHandler.sync(this);
+                            switch (this.tokenStream.LA(1)) {
+                            case PlSqlParser.CANCEL:
+                                {
+                                this.state = 13645;
+                                this.match(PlSqlParser.CANCEL);
+                                }
+                                break;
+                            case PlSqlParser.TIME:
+                                {
+                                this.state = 13646;
+                                this.match(PlSqlParser.TIME);
+                                this.state = 13647;
+                                this.match(PlSqlParser.CHAR_STRING);
+                                }
+                                break;
+                            case PlSqlParser.CHANGE:
+                                {
+                                this.state = 13648;
+                                this.match(PlSqlParser.CHANGE);
+                                this.state = 13649;
+                                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                                }
+                                break;
+                            case PlSqlParser.CONSISTENT:
+                                {
+                                this.state = 13650;
+                                this.match(PlSqlParser.CONSISTENT);
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                            }
+                            }
+                            break;
+                        case PlSqlParser.USING:
+                            {
+                            this.state = 13653;
+                            this.match(PlSqlParser.USING);
+                            this.state = 13654;
+                            this.match(PlSqlParser.BACKUP);
+                            this.state = 13655;
+                            this.match(PlSqlParser.CONTROLFILE);
+                            }
+                            break;
+                        case PlSqlParser.SNAPSHOT:
+                            {
+                            this.state = 13656;
+                            this.match(PlSqlParser.SNAPSHOT);
+                            this.state = 13657;
+                            this.match(PlSqlParser.TIME);
+                            this.state = 13658;
+                            this.match(PlSqlParser.CHAR_STRING);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 13661;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1766, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partial_database_recovery(): Partial_database_recoveryContext {
+        let localContext = new Partial_database_recoveryContext(this.context, this.state);
+        this.enterRule(localContext, 1398, PlSqlParser.RULE_partial_database_recovery);
+        try {
+            let alternative: number;
+            this.state = 13686;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1771, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 13665;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 13666;
+                this.tablespace();
+                this.state = 13671;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1768, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 13667;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 13668;
+                        this.tablespace();
+                        }
+                        }
+                    }
+                    this.state = 13673;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1768, this.context);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 13674;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 13675;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 13676;
+                this.filenumber();
+                this.state = 13682;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1770, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        this.state = 13680;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.COMMA:
+                            {
+                            this.state = 13677;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 13678;
+                            this.match(PlSqlParser.CHAR_STRING);
+                            }
+                            break;
+                        case PlSqlParser.UNSIGNED_INTEGER:
+                            {
+                            this.state = 13679;
+                            this.filenumber();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                    }
+                    this.state = 13684;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1770, this.context);
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 13685;
+                this.partial_database_recovery_10g();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partial_database_recovery_10g(): Partial_database_recovery_10gContext {
+        let localContext = new Partial_database_recovery_10gContext(this.context, this.state);
+        this.enterRule(localContext, 1400, PlSqlParser.RULE_partial_database_recovery_10g);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13688;
+            if (!(this.isVersion10())) {
+                throw this.createFailedPredicateException("this.isVersion10()");
+            }
+            this.state = 13689;
+            this.match(PlSqlParser.STANDBY);
+            this.state = 13710;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TABLESPACE:
+                {
+                this.state = 13690;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 13691;
+                this.tablespace();
+                this.state = 13696;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 13692;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 13693;
+                    this.tablespace();
+                    }
+                    }
+                    this.state = 13698;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case PlSqlParser.DATAFILE:
+                {
+                this.state = 13699;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 13700;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 13701;
+                this.filenumber();
+                this.state = 13707;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2443 || _la === 2455) {
+                    {
+                    this.state = 13705;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COMMA:
+                        {
+                        this.state = 13702;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 13703;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        break;
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                        {
+                        this.state = 13704;
+                        this.filenumber();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    this.state = 13709;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 13712;
+            this.match(PlSqlParser.UNTIL);
+            this.state = 13715;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 283) {
+                {
+                this.state = 13713;
+                this.match(PlSqlParser.CONSISTENT);
+                this.state = 13714;
+                this.match(PlSqlParser.WITH);
+                }
+            }
+
+            this.state = 13717;
+            this.match(PlSqlParser.CONTROLFILE);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public managed_standby_recovery(): Managed_standby_recoveryContext {
+        let localContext = new Managed_standby_recoveryContext(this.context, this.state);
+        this.enterRule(localContext, 1402, PlSqlParser.RULE_managed_standby_recovery);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13719;
+            this.match(PlSqlParser.RECOVER);
+            this.state = 13754;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MANAGED:
+                {
+                this.state = 13720;
+                this.match(PlSqlParser.MANAGED);
+                this.state = 13721;
+                this.match(PlSqlParser.STANDBY);
+                this.state = 13722;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 13744;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1780, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13738;
+                    this.errorHandler.sync(this);
+                    alternative = 1;
+                    do {
+                        switch (alternative) {
+                        case 1:
+                            {
+                            this.state = 13738;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 1778, this.context) ) {
+                            case 1:
+                                {
+                                this.state = 13723;
+                                this.match(PlSqlParser.USING);
+                                this.state = 13724;
+                                this.match(PlSqlParser.CURRENT);
+                                this.state = 13725;
+                                this.match(PlSqlParser.LOGFILE);
+                                }
+                                break;
+                            case 2:
+                                {
+                                this.state = 13726;
+                                this.match(PlSqlParser.DISCONNECT);
+                                this.state = 13729;
+                                this.errorHandler.sync(this);
+                                switch (this.interpreter.adaptivePredict(this.tokenStream, 1777, this.context) ) {
+                                case 1:
+                                    {
+                                    this.state = 13727;
+                                    this.match(PlSqlParser.FROM);
+                                    this.state = 13728;
+                                    this.match(PlSqlParser.SESSION);
+                                    }
+                                    break;
+                                }
+                                }
+                                break;
+                            case 3:
+                                {
+                                this.state = 13731;
+                                this.match(PlSqlParser.NODELAY);
+                                }
+                                break;
+                            case 4:
+                                {
+                                this.state = 13732;
+                                this.match(PlSqlParser.UNTIL);
+                                this.state = 13733;
+                                this.match(PlSqlParser.CHANGE);
+                                this.state = 13734;
+                                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                                }
+                                break;
+                            case 5:
+                                {
+                                this.state = 13735;
+                                this.match(PlSqlParser.UNTIL);
+                                this.state = 13736;
+                                this.match(PlSqlParser.CONSISTENT);
+                                }
+                                break;
+                            case 6:
+                                {
+                                this.state = 13737;
+                                this.parallel_clause();
+                                }
+                                break;
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 13740;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1779, this.context);
+                    } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 13742;
+                    this.match(PlSqlParser.FINISH);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 13743;
+                    this.match(PlSqlParser.CANCEL);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.TO:
+                {
+                this.state = 13746;
+                this.match(PlSqlParser.TO);
+                this.state = 13747;
+                this.match(PlSqlParser.LOGICAL);
+                this.state = 13748;
+                this.match(PlSqlParser.STANDBY);
+                this.state = 13752;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1781, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13749;
+                    this.db_name();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 13750;
+                    this.match(PlSqlParser.KEEP);
+                    this.state = 13751;
+                    this.match(PlSqlParser.IDENTITY);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public db_name(): Db_nameContext {
+        let localContext = new Db_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1404, PlSqlParser.RULE_db_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13756;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public database_file_clauses(): Database_file_clausesContext {
+        let localContext = new Database_file_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1406, PlSqlParser.RULE_database_file_clauses);
+        let _la: number;
+        try {
+            this.state = 13775;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 13758;
+                this.match(PlSqlParser.RENAME);
+                this.state = 13759;
+                this.match(PlSqlParser.FILE);
+                this.state = 13760;
+                this.filename();
+                this.state = 13765;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 13761;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 13762;
+                    this.filename();
+                    }
+                    }
+                    this.state = 13767;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 13768;
+                this.match(PlSqlParser.TO);
+                this.state = 13769;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.CREATE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 13771;
+                this.create_datafile_clause();
+                }
+                break;
+            case PlSqlParser.DATAFILE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 13772;
+                this.alter_datafile_clause();
+                }
+                break;
+            case PlSqlParser.TEMPFILE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 13773;
+                this.alter_tempfile_clause();
+                }
+                break;
+            case PlSqlParser.MOVE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 13774;
+                this.move_datafile_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_datafile_clause(): Create_datafile_clauseContext {
+        let localContext = new Create_datafile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1408, PlSqlParser.RULE_create_datafile_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13777;
+            this.match(PlSqlParser.CREATE);
+            this.state = 13778;
+            this.match(PlSqlParser.DATAFILE);
+            this.state = 13781;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 13779;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 13780;
+                this.filenumber();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 13790;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1787, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 13783;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 13786;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.CHAR_STRING:
+                        {
+                        this.state = 13784;
+                        this.filename();
+                        }
+                        break;
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                        {
+                        this.state = 13785;
+                        this.filenumber();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    }
+                }
+                this.state = 13792;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1787, this.context);
+            }
+            this.state = 13795;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1788, this.context) ) {
+            case 1:
+                {
+                this.state = 13793;
+                this.match(PlSqlParser.AS);
+                {
+                this.state = 13794;
+                this.match(PlSqlParser.NEW);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_datafile_clause(): Alter_datafile_clauseContext {
+        let localContext = new Alter_datafile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1410, PlSqlParser.RULE_alter_datafile_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13797;
+            this.match(PlSqlParser.DATAFILE);
+            this.state = 13800;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 13798;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 13799;
+                this.filenumber();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 13809;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 13802;
+                this.match(PlSqlParser.COMMA);
+                this.state = 13805;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 13803;
+                    this.filename();
+                    }
+                    break;
+                case PlSqlParser.UNSIGNED_INTEGER:
+                    {
+                    this.state = 13804;
+                    this.filenumber();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                }
+                this.state = 13811;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 13823;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ONLINE:
+                {
+                this.state = 13812;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            case PlSqlParser.OFFLINE:
+                {
+                this.state = 13813;
+                this.match(PlSqlParser.OFFLINE);
+                this.state = 13816;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1792, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13814;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 13815;
+                    this.match(PlSqlParser.DROP);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.RESIZE:
+                {
+                this.state = 13818;
+                this.match(PlSqlParser.RESIZE);
+                this.state = 13819;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.AUTOEXTEND:
+                {
+                this.state = 13820;
+                this.autoextend_clause();
+                }
+                break;
+            case PlSqlParser.END:
+                {
+                this.state = 13821;
+                this.match(PlSqlParser.END);
+                this.state = 13822;
+                this.match(PlSqlParser.BACKUP);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_tempfile_clause(): Alter_tempfile_clauseContext {
+        let localContext = new Alter_tempfile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1412, PlSqlParser.RULE_alter_tempfile_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13825;
+            this.match(PlSqlParser.TEMPFILE);
+            this.state = 13828;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 13826;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 13827;
+                this.filenumber();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 13837;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 13830;
+                this.match(PlSqlParser.COMMA);
+                this.state = 13833;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 13831;
+                    this.filename();
+                    }
+                    break;
+                case PlSqlParser.UNSIGNED_INTEGER:
+                    {
+                    this.state = 13832;
+                    this.filenumber();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                }
+                this.state = 13839;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 13848;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.RESIZE:
+                {
+                this.state = 13840;
+                this.match(PlSqlParser.RESIZE);
+                this.state = 13841;
+                this.size_clause();
+                }
+                break;
+            case PlSqlParser.AUTOEXTEND:
+                {
+                this.state = 13842;
+                this.autoextend_clause();
+                }
+                break;
+            case PlSqlParser.DROP:
+                {
+                this.state = 13843;
+                this.match(PlSqlParser.DROP);
+                {
+                this.state = 13844;
+                this.match(PlSqlParser.INCLUDING);
+                this.state = 13845;
+                this.match(PlSqlParser.DATAFILES);
+                }
+                }
+                break;
+            case PlSqlParser.ONLINE:
+                {
+                this.state = 13846;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            case PlSqlParser.OFFLINE:
+                {
+                this.state = 13847;
+                this.match(PlSqlParser.OFFLINE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public move_datafile_clause(): Move_datafile_clauseContext {
+        let localContext = new Move_datafile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1414, PlSqlParser.RULE_move_datafile_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13850;
+            this.match(PlSqlParser.MOVE);
+            this.state = 13851;
+            this.match(PlSqlParser.DATAFILE);
+            this.state = 13854;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHAR_STRING:
+                {
+                this.state = 13852;
+                this.filename();
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+                {
+                this.state = 13853;
+                this.filenumber();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 13863;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1800, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 13856;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 13859;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.CHAR_STRING:
+                        {
+                        this.state = 13857;
+                        this.filename();
+                        }
+                        break;
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                        {
+                        this.state = 13858;
+                        this.filenumber();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    }
+                }
+                this.state = 13865;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1800, this.context);
+            }
+            this.state = 13868;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1801, this.context) ) {
+            case 1:
+                {
+                this.state = 13866;
+                this.match(PlSqlParser.TO);
+                this.state = 13867;
+                this.filename();
+                }
+                break;
+            }
+            this.state = 13871;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1802, this.context) ) {
+            case 1:
+                {
+                this.state = 13870;
+                this.match(PlSqlParser.REUSE);
+                }
+                break;
+            }
+            this.state = 13874;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1803, this.context) ) {
+            case 1:
+                {
+                this.state = 13873;
+                this.match(PlSqlParser.KEEP);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public logfile_clauses(): Logfile_clausesContext {
+        let localContext = new Logfile_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1416, PlSqlParser.RULE_logfile_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 13932;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1812, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 13881;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ARCHIVELOG:
+                    {
+                    this.state = 13876;
+                    this.match(PlSqlParser.ARCHIVELOG);
+                    this.state = 13878;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1804, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 13877;
+                        this.match(PlSqlParser.MANUAL);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.NOARCHIVELOG:
+                    {
+                    this.state = 13880;
+                    this.match(PlSqlParser.NOARCHIVELOG);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 13884;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 13883;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 13886;
+                this.match(PlSqlParser.FORCE);
+                this.state = 13887;
+                this.match(PlSqlParser.LOGGING);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 13888;
+                this.match(PlSqlParser.SET);
+                this.state = 13889;
+                this.match(PlSqlParser.STANDBY);
+                this.state = 13890;
+                this.match(PlSqlParser.NOLOGGING);
+                this.state = 13891;
+                this.match(PlSqlParser.FOR);
+                this.state = 13896;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DATA:
+                    {
+                    this.state = 13892;
+                    this.match(PlSqlParser.DATA);
+                    this.state = 13893;
+                    this.match(PlSqlParser.AVAILABILITY);
+                    }
+                    break;
+                case PlSqlParser.LOAD:
+                    {
+                    this.state = 13894;
+                    this.match(PlSqlParser.LOAD);
+                    this.state = 13895;
+                    this.match(PlSqlParser.PERFORMANCE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 13898;
+                this.match(PlSqlParser.RENAME);
+                this.state = 13899;
+                this.match(PlSqlParser.FILE);
+                this.state = 13900;
+                this.filename();
+                this.state = 13905;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 13901;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 13902;
+                    this.filename();
+                    }
+                    }
+                    this.state = 13907;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 13908;
+                this.match(PlSqlParser.TO);
+                this.state = 13909;
+                this.filename();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 13911;
+                this.match(PlSqlParser.CLEAR);
+                this.state = 13913;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2175) {
+                    {
+                    this.state = 13912;
+                    this.match(PlSqlParser.UNARCHIVED);
+                    }
+                }
+
+                this.state = 13915;
+                this.match(PlSqlParser.LOGFILE);
+                this.state = 13916;
+                this.logfile_descriptor();
+                this.state = 13921;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1810, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 13917;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 13918;
+                        this.logfile_descriptor();
+                        }
+                        }
+                    }
+                    this.state = 13923;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1810, this.context);
+                }
+                this.state = 13926;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1811, this.context) ) {
+                case 1:
+                    {
+                    this.state = 13924;
+                    this.match(PlSqlParser.UNRECOVERABLE);
+                    this.state = 13925;
+                    this.match(PlSqlParser.DATAFILE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 13928;
+                this.add_logfile_clauses();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 13929;
+                this.drop_logfile_clauses();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 13930;
+                this.switch_logfile_clause();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 13931;
+                this.supplemental_db_logging();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_logfile_clauses(): Add_logfile_clausesContext {
+        let localContext = new Add_logfile_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1418, PlSqlParser.RULE_add_logfile_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13934;
+            this.match(PlSqlParser.ADD);
+            this.state = 13936;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1736) {
+                {
+                this.state = 13935;
+                this.match(PlSqlParser.STANDBY);
+                }
+            }
+
+            this.state = 13938;
+            this.match(PlSqlParser.LOGFILE);
+            this.state = 13974;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.GROUP:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 13943;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.INSTANCE:
+                    {
+                    this.state = 13939;
+                    this.match(PlSqlParser.INSTANCE);
+                    this.state = 13940;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    break;
+                case PlSqlParser.THREAD:
+                    {
+                    this.state = 13941;
+                    this.match(PlSqlParser.THREAD);
+                    this.state = 13942;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case PlSqlParser.GROUP:
+                case PlSqlParser.CHAR_STRING:
+                case PlSqlParser.LEFT_PAREN:
+                    break;
+                default:
+                    break;
+                }
+                this.state = 13946;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 13945;
+                        this.group_redo_logfile();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 13948;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1815, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.MEMBER:
+                {
+                this.state = 13950;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 13951;
+                this.filename();
+                this.state = 13953;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1589) {
+                    {
+                    this.state = 13952;
+                    this.match(PlSqlParser.REUSE);
+                    }
+                }
+
+                this.state = 13962;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 13955;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 13956;
+                    this.filename();
+                    this.state = 13958;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1589) {
+                        {
+                        this.state = 13957;
+                        this.match(PlSqlParser.REUSE);
+                        }
+                    }
+
+                    }
+                    }
+                    this.state = 13964;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 13965;
+                this.match(PlSqlParser.TO);
+                this.state = 13966;
+                this.logfile_descriptor();
+                this.state = 13971;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1819, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 13967;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 13968;
+                        this.logfile_descriptor();
+                        }
+                        }
+                    }
+                    this.state = 13973;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1819, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public group_redo_logfile(): Group_redo_logfileContext {
+        let localContext = new Group_redo_logfileContext(this.context, this.state);
+        this.enterRule(localContext, 1420, PlSqlParser.RULE_group_redo_logfile);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13978;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 650) {
+                {
+                this.state = 13976;
+                this.match(PlSqlParser.GROUP);
+                this.state = 13977;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+            }
+
+            this.state = 13980;
+            this.redo_log_file_spec();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_logfile_clauses(): Drop_logfile_clausesContext {
+        let localContext = new Drop_logfile_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1422, PlSqlParser.RULE_drop_logfile_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 13982;
+            this.match(PlSqlParser.DROP);
+            this.state = 13984;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1736) {
+                {
+                this.state = 13983;
+                this.match(PlSqlParser.STANDBY);
+                }
+            }
+
+            this.state = 13986;
+            this.match(PlSqlParser.LOGFILE);
+            this.state = 14004;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.GROUP:
+            case PlSqlParser.CHAR_STRING:
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 13987;
+                this.logfile_descriptor();
+                this.state = 13992;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1823, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 13988;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 13989;
+                        this.logfile_descriptor();
+                        }
+                        }
+                    }
+                    this.state = 13994;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1823, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.MEMBER:
+                {
+                this.state = 13995;
+                this.match(PlSqlParser.MEMBER);
+                this.state = 13996;
+                this.filename();
+                this.state = 14001;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1824, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 13997;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 13998;
+                        this.filename();
+                        }
+                        }
+                    }
+                    this.state = 14003;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1824, this.context);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public switch_logfile_clause(): Switch_logfile_clauseContext {
+        let localContext = new Switch_logfile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1424, PlSqlParser.RULE_switch_logfile_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14006;
+            this.match(PlSqlParser.SWITCH);
+            this.state = 14007;
+            this.match(PlSqlParser.ALL);
+            this.state = 14008;
+            this.match(PlSqlParser.LOGFILES);
+            this.state = 14009;
+            this.match(PlSqlParser.TO);
+            this.state = 14010;
+            this.match(PlSqlParser.BLOCKSIZE);
+            this.state = 14011;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public supplemental_db_logging(): Supplemental_db_loggingContext {
+        let localContext = new Supplemental_db_loggingContext(this.context, this.state);
+        this.enterRule(localContext, 1426, PlSqlParser.RULE_supplemental_db_logging);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14013;
+            this.add_or_drop();
+            this.state = 14014;
+            this.match(PlSqlParser.SUPPLEMENTAL);
+            this.state = 14015;
+            this.match(PlSqlParser.LOG);
+            this.state = 14019;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1826, this.context) ) {
+            case 1:
+                {
+                this.state = 14016;
+                this.match(PlSqlParser.DATA);
+                }
+                break;
+            case 2:
+                {
+                this.state = 14017;
+                this.supplemental_id_key_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 14018;
+                this.supplemental_plsql_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_or_drop(): Add_or_dropContext {
+        let localContext = new Add_or_dropContext(this.context, this.state);
+        this.enterRule(localContext, 1428, PlSqlParser.RULE_add_or_drop);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14021;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 21 || _la === 469)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public supplemental_plsql_clause(): Supplemental_plsql_clauseContext {
+        let localContext = new Supplemental_plsql_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1430, PlSqlParser.RULE_supplemental_plsql_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14023;
+            this.match(PlSqlParser.DATA);
+            this.state = 14024;
+            this.match(PlSqlParser.FOR);
+            this.state = 14025;
+            this.match(PlSqlParser.PROCEDURAL);
+            this.state = 14026;
+            this.match(PlSqlParser.REPLICATION);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public logfile_descriptor(): Logfile_descriptorContext {
+        let localContext = new Logfile_descriptorContext(this.context, this.state);
+        this.enterRule(localContext, 1432, PlSqlParser.RULE_logfile_descriptor);
+        let _la: number;
+        try {
+            this.state = 14042;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.GROUP:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14028;
+                this.match(PlSqlParser.GROUP);
+                this.state = 14029;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14030;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 14031;
+                this.filename();
+                this.state = 14036;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 14032;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 14033;
+                    this.filename();
+                    }
+                    }
+                    this.state = 14038;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 14039;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14041;
+                this.filename();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public controlfile_clauses(): Controlfile_clausesContext {
+        let localContext = new Controlfile_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1434, PlSqlParser.RULE_controlfile_clauses);
+        let _la: number;
+        try {
+            this.state = 14065;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CREATE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14044;
+                this.match(PlSqlParser.CREATE);
+                this.state = 14046;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 886 || _la === 1394) {
+                    {
+                    this.state = 14045;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 886 || _la === 1394)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 14048;
+                this.match(PlSqlParser.STANDBY);
+                this.state = 14049;
+                this.match(PlSqlParser.CONTROLFILE);
+                this.state = 14050;
+                this.match(PlSqlParser.AS);
+                this.state = 14051;
+                this.filename();
+                this.state = 14053;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1830, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14052;
+                    this.match(PlSqlParser.REUSE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.BACKUP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14055;
+                this.match(PlSqlParser.BACKUP);
+                this.state = 14056;
+                this.match(PlSqlParser.CONTROLFILE);
+                this.state = 14057;
+                this.match(PlSqlParser.TO);
+                this.state = 14063;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 14058;
+                    this.filename();
+                    this.state = 14060;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1831, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14059;
+                        this.match(PlSqlParser.REUSE);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.TRACE:
+                    {
+                    this.state = 14062;
+                    this.trace_file_clause();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public trace_file_clause(): Trace_file_clauseContext {
+        let localContext = new Trace_file_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1436, PlSqlParser.RULE_trace_file_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14067;
+            this.match(PlSqlParser.TRACE);
+            this.state = 14073;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1835, this.context) ) {
+            case 1:
+                {
+                this.state = 14068;
+                this.match(PlSqlParser.AS);
+                this.state = 14069;
+                this.filename();
+                this.state = 14071;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1834, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14070;
+                    this.match(PlSqlParser.REUSE);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 14076;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1836, this.context) ) {
+            case 1:
+                {
+                this.state = 14075;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1175 || _la === 1567)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public standby_database_clauses(): Standby_database_clausesContext {
+        let localContext = new Standby_database_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1438, PlSqlParser.RULE_standby_database_clauses);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14085;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ACTIVATE:
+                {
+                this.state = 14078;
+                this.activate_standby_db_clause();
+                }
+                break;
+            case PlSqlParser.SET:
+                {
+                this.state = 14079;
+                this.maximize_standby_db_clause();
+                }
+                break;
+            case PlSqlParser.REGISTER:
+                {
+                this.state = 14080;
+                this.register_logfile_clause();
+                }
+                break;
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.PREPARE:
+                {
+                this.state = 14081;
+                this.commit_switchover_clause();
+                }
+                break;
+            case PlSqlParser.START:
+                {
+                this.state = 14082;
+                this.start_standby_clause();
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.STOP:
+                {
+                this.state = 14083;
+                this.stop_standby_clause();
+                }
+                break;
+            case PlSqlParser.CONVERT:
+                {
+                this.state = 14084;
+                this.convert_database_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14088;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1838, this.context) ) {
+            case 1:
+                {
+                this.state = 14087;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public activate_standby_db_clause(): Activate_standby_db_clauseContext {
+        let localContext = new Activate_standby_db_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1440, PlSqlParser.RULE_activate_standby_db_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14090;
+            this.match(PlSqlParser.ACTIVATE);
+            this.state = 14092;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 886 || _la === 1394) {
+                {
+                this.state = 14091;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 886 || _la === 1394)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 14094;
+            this.match(PlSqlParser.STANDBY);
+            this.state = 14095;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14098;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1840, this.context) ) {
+            case 1:
+                {
+                this.state = 14096;
+                this.match(PlSqlParser.FINISH);
+                this.state = 14097;
+                this.match(PlSqlParser.APPLY);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public maximize_standby_db_clause(): Maximize_standby_db_clauseContext {
+        let localContext = new Maximize_standby_db_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1442, PlSqlParser.RULE_maximize_standby_db_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14100;
+            this.match(PlSqlParser.SET);
+            this.state = 14101;
+            this.match(PlSqlParser.STANDBY);
+            this.state = 14102;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14103;
+            this.match(PlSqlParser.TO);
+            this.state = 14104;
+            this.match(PlSqlParser.MAXIMIZE);
+            this.state = 14105;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 98 || _la === 1387 || _la === 1471)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public register_logfile_clause(): Register_logfile_clauseContext {
+        let localContext = new Register_logfile_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1444, PlSqlParser.RULE_register_logfile_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14107;
+            this.match(PlSqlParser.REGISTER);
+            this.state = 14110;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1309) {
+                {
+                this.state = 14108;
+                this.match(PlSqlParser.OR);
+                this.state = 14109;
+                this.match(PlSqlParser.REPLACE);
+                }
+            }
+
+            this.state = 14112;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 886 || _la === 1394)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14113;
+            this.match(PlSqlParser.LOGFILE);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public commit_switchover_clause(): Commit_switchover_clauseContext {
+        let localContext = new Commit_switchover_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1446, PlSqlParser.RULE_commit_switchover_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14115;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 242 || _la === 1443)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14116;
+            this.match(PlSqlParser.TO);
+            this.state = 14117;
+            this.match(PlSqlParser.SWITCHOVER);
+            this.state = 14146;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1849, this.context) ) {
+            case 1:
+                {
+                this.state = 14143;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.TO:
+                    {
+                    this.state = 14118;
+                    this.match(PlSqlParser.TO);
+                    this.state = 14139;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1847, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14127;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1844, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 14120;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 886 || _la === 1394) {
+                                {
+                                this.state = 14119;
+                                _la = this.tokenStream.LA(1);
+                                if(!(_la === 886 || _la === 1394)) {
+                                this.errorHandler.recoverInline(this);
+                                }
+                                else {
+                                    this.errorHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                                }
+                            }
+
+                            this.state = 14122;
+                            this.match(PlSqlParser.PRIMARY);
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 14124;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 1394) {
+                                {
+                                this.state = 14123;
+                                this.match(PlSqlParser.PHYSICAL);
+                                }
+                            }
+
+                            this.state = 14126;
+                            this.match(PlSqlParser.STANDBY);
+                            }
+                            break;
+                        }
+                        this.state = 14135;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1846, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 14130;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 2308 || _la === 2310) {
+                                {
+                                this.state = 14129;
+                                _la = this.tokenStream.LA(1);
+                                if(!(_la === 2308 || _la === 2310)) {
+                                this.errorHandler.recoverInline(this);
+                                }
+                                else {
+                                    this.errorHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                                }
+                            }
+
+                            this.state = 14132;
+                            this.match(PlSqlParser.SESSION);
+                            this.state = 14133;
+                            this.match(PlSqlParser.SHUTDOWN);
+                            this.state = 14134;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 1221 || _la === 2295)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 14137;
+                        this.match(PlSqlParser.LOGICAL);
+                        this.state = 14138;
+                        this.match(PlSqlParser.STANDBY);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.LOGICAL:
+                    {
+                    this.state = 14141;
+                    this.match(PlSqlParser.LOGICAL);
+                    this.state = 14142;
+                    this.match(PlSqlParser.STANDBY);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 14145;
+                this.match(PlSqlParser.CANCEL);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public start_standby_clause(): Start_standby_clauseContext {
+        let localContext = new Start_standby_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1448, PlSqlParser.RULE_start_standby_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14148;
+            this.match(PlSqlParser.START);
+            this.state = 14149;
+            this.match(PlSqlParser.LOGICAL);
+            this.state = 14150;
+            this.match(PlSqlParser.STANDBY);
+            this.state = 14151;
+            this.match(PlSqlParser.APPLY);
+            this.state = 14153;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1850, this.context) ) {
+            case 1:
+                {
+                this.state = 14152;
+                this.match(PlSqlParser.IMMEDIATE);
+                }
+                break;
+            }
+            this.state = 14156;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1851, this.context) ) {
+            case 1:
+                {
+                this.state = 14155;
+                this.match(PlSqlParser.NODELAY);
+                }
+                break;
+            }
+            this.state = 14169;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1853, this.context) ) {
+            case 1:
+                {
+                this.state = 14158;
+                this.match(PlSqlParser.NEW);
+                this.state = 14159;
+                this.match(PlSqlParser.PRIMARY);
+                this.state = 14160;
+                this.regular_id();
+                }
+                break;
+            case 2:
+                {
+                this.state = 14161;
+                this.match(PlSqlParser.INITIAL);
+                this.state = 14163;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1852, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14162;
+                    localContext._scn_value = this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 14165;
+                this.match(PlSqlParser.SKIP_);
+                this.state = 14166;
+                this.match(PlSqlParser.FAILED);
+                this.state = 14167;
+                this.match(PlSqlParser.TRANSACTION);
+                }
+                break;
+            case 4:
+                {
+                this.state = 14168;
+                this.match(PlSqlParser.FINISH);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public stop_standby_clause(): Stop_standby_clauseContext {
+        let localContext = new Stop_standby_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1450, PlSqlParser.RULE_stop_standby_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14171;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1 || _la === 1763)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14172;
+            this.match(PlSqlParser.LOGICAL);
+            this.state = 14173;
+            this.match(PlSqlParser.STANDBY);
+            this.state = 14174;
+            this.match(PlSqlParser.APPLY);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public convert_database_clause(): Convert_database_clauseContext {
+        let localContext = new Convert_database_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1452, PlSqlParser.RULE_convert_database_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14176;
+            this.match(PlSqlParser.CONVERT);
+            this.state = 14177;
+            this.match(PlSqlParser.TO);
+            this.state = 14178;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1394 || _la === 1709)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14179;
+            this.match(PlSqlParser.STANDBY);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_settings_clause(): Default_settings_clauseContext {
+        let localContext = new Default_settings_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1454, PlSqlParser.RULE_default_settings_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 14227;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1858, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14181;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 14182;
+                this.match(PlSqlParser.EDITION);
+                this.state = 14183;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 14184;
+                this.edition_name();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14185;
+                this.match(PlSqlParser.SET);
+                this.state = 14186;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 14187;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 122 || _la === 1707)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14188;
+                this.match(PlSqlParser.TABLESPACE);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14189;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 14190;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 14191;
+                this.tablespace();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14192;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 14193;
+                this.match(PlSqlParser.TEMPORARY);
+                this.state = 14194;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 14197;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1854, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14195;
+                    this.tablespace();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 14196;
+                    this.tablespace_group_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14199;
+                this.match(PlSqlParser.RENAME);
+                this.state = 14200;
+                this.match(PlSqlParser.GLOBAL_NAME);
+                this.state = 14201;
+                this.match(PlSqlParser.TO);
+                this.state = 14202;
+                this.database();
+                this.state = 14205;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 14203;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 14204;
+                        this.domain();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 14207;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1855, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 14209;
+                this.match(PlSqlParser.ENABLE);
+                this.state = 14210;
+                this.match(PlSqlParser.BLOCK);
+                this.state = 14211;
+                this.match(PlSqlParser.CHANGE);
+                this.state = 14212;
+                this.match(PlSqlParser.TRACKING);
+                this.state = 14219;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1857, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14213;
+                    this.match(PlSqlParser.USING);
+                    this.state = 14214;
+                    this.match(PlSqlParser.FILE);
+                    this.state = 14215;
+                    this.filename();
+                    this.state = 14217;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1856, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14216;
+                        this.match(PlSqlParser.REUSE);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 14221;
+                this.match(PlSqlParser.DISABLE);
+                this.state = 14222;
+                this.match(PlSqlParser.BLOCK);
+                this.state = 14223;
+                this.match(PlSqlParser.CHANGE);
+                this.state = 14224;
+                this.match(PlSqlParser.TRACKING);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 14225;
+                this.flashback_mode_clause();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 14226;
+                this.set_time_zone_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_time_zone_clause(): Set_time_zone_clauseContext {
+        let localContext = new Set_time_zone_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1456, PlSqlParser.RULE_set_time_zone_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14229;
+            this.match(PlSqlParser.SET);
+            this.state = 14230;
+            this.match(PlSqlParser.TIME_ZONE);
+            this.state = 14231;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 14232;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public instance_clauses(): Instance_clausesContext {
+        let localContext = new Instance_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1458, PlSqlParser.RULE_instance_clauses);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14234;
+            this.enable_or_disable();
+            this.state = 14235;
+            this.match(PlSqlParser.INSTANCE);
+            this.state = 14236;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public security_clause(): Security_clauseContext {
+        let localContext = new Security_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1460, PlSqlParser.RULE_security_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14238;
+            this.match(PlSqlParser.GUARD);
+            this.state = 14239;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 38 || _la === 1134 || _la === 1736)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public domain(): DomainContext {
+        let localContext = new DomainContext(this.context, this.state);
+        this.enterRule(localContext, 1462, PlSqlParser.RULE_domain);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14241;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public database(): DatabaseContext {
+        let localContext = new DatabaseContext(this.context, this.state);
+        this.enterRule(localContext, 1464, PlSqlParser.RULE_database);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14243;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public edition_name(): Edition_nameContext {
+        let localContext = new Edition_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1466, PlSqlParser.RULE_edition_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14245;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filenumber(): FilenumberContext {
+        let localContext = new FilenumberContext(this.context, this.state);
+        this.enterRule(localContext, 1468, PlSqlParser.RULE_filenumber);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14247;
+            this.match(PlSqlParser.UNSIGNED_INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filename(): FilenameContext {
+        let localContext = new FilenameContext(this.context, this.state);
+        this.enterRule(localContext, 1470, PlSqlParser.RULE_filename);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14249;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public prepare_clause(): Prepare_clauseContext {
+        let localContext = new Prepare_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1472, PlSqlParser.RULE_prepare_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14251;
+            this.match(PlSqlParser.PREPARE);
+            this.state = 14252;
+            this.match(PlSqlParser.MIRROR);
+            this.state = 14253;
+            this.match(PlSqlParser.COPY);
+            this.state = 14254;
+            localContext._c = this.id_expression();
+            this.state = 14258;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1859, this.context) ) {
+            case 1:
+                {
+                this.state = 14255;
+                this.match(PlSqlParser.WITH);
+                this.state = 14256;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 676 || _la === 964 || _la === 2198)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14257;
+                this.match(PlSqlParser.REDUNDANCY);
+                }
+                break;
+            }
+            this.state = 14263;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1860, this.context) ) {
+            case 1:
+                {
+                this.state = 14260;
+                this.match(PlSqlParser.FOR);
+                this.state = 14261;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 14262;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_mirror_clause(): Drop_mirror_clauseContext {
+        let localContext = new Drop_mirror_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1474, PlSqlParser.RULE_drop_mirror_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14265;
+            this.match(PlSqlParser.DROP);
+            this.state = 14266;
+            this.match(PlSqlParser.MIRROR);
+            this.state = 14267;
+            this.match(PlSqlParser.COPY);
+            this.state = 14268;
+            localContext._mn = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lost_write_protection(): Lost_write_protectionContext {
+        let localContext = new Lost_write_protectionContext(this.context, this.state);
+        this.enterRule(localContext, 1476, PlSqlParser.RULE_lost_write_protection);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14270;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 429 || _la === 499 || _la === 1560 || _la === 1792)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14271;
+            this.match(PlSqlParser.LOST);
+            this.state = 14272;
+            this.match(PlSqlParser.WRITE);
+            this.state = 14273;
+            this.match(PlSqlParser.PROTECTION);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cdb_fleet_clauses(): Cdb_fleet_clausesContext {
+        let localContext = new Cdb_fleet_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1478, PlSqlParser.RULE_cdb_fleet_clauses);
+        try {
+            this.state = 14277;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1861, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14275;
+                this.lead_cdb_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14276;
+                this.lead_cdb_uri_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lead_cdb_clause(): Lead_cdb_clauseContext {
+        let localContext = new Lead_cdb_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1480, PlSqlParser.RULE_lead_cdb_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14279;
+            this.match(PlSqlParser.SET);
+            this.state = 14280;
+            this.match(PlSqlParser.LEAD_CDB);
+            this.state = 14281;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 14282;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 576 || _la === 2160)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lead_cdb_uri_clause(): Lead_cdb_uri_clauseContext {
+        let localContext = new Lead_cdb_uri_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1482, PlSqlParser.RULE_lead_cdb_uri_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14284;
+            this.match(PlSqlParser.SET);
+            this.state = 14285;
+            this.match(PlSqlParser.LEAD_CDB_URI);
+            this.state = 14286;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 14287;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public property_clauses(): Property_clausesContext {
+        let localContext = new Property_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1484, PlSqlParser.RULE_property_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14289;
+            this.match(PlSqlParser.PROPERTY);
+            this.state = 14290;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1560 || _la === 1673)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14291;
+            this.match(PlSqlParser.DEFAULT_CREDENTIAL);
+            this.state = 14292;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 14293;
+            localContext._qcn = this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public replay_upgrade_clauses(): Replay_upgrade_clausesContext {
+        let localContext = new Replay_upgrade_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1486, PlSqlParser.RULE_replay_upgrade_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14295;
+            this.match(PlSqlParser.UPGRADE);
+            this.state = 14296;
+            this.match(PlSqlParser.SYNC);
+            this.state = 14297;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1246 || _la === 1261)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_database_link(): Alter_database_linkContext {
+        let localContext = new Alter_database_linkContext(this.context, this.state);
+        this.enterRule(localContext, 1488, PlSqlParser.RULE_alter_database_link);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14299;
+            this.match(PlSqlParser.ALTER);
+            this.state = 14301;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1681) {
+                {
+                this.state = 14300;
+                this.match(PlSqlParser.SHARED);
+                }
+            }
+
+            this.state = 14304;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1475) {
+                {
+                this.state = 14303;
+                this.match(PlSqlParser.PUBLIC);
+                }
+            }
+
+            this.state = 14306;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14307;
+            this.match(PlSqlParser.LINK);
+            this.state = 14308;
+            this.local_link_name();
+            this.state = 14319;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CONNECT:
+                {
+                this.state = 14309;
+                this.match(PlSqlParser.CONNECT);
+                this.state = 14310;
+                this.match(PlSqlParser.TO);
+                this.state = 14311;
+                this.user_object_name();
+                this.state = 14312;
+                this.match(PlSqlParser.IDENTIFIED);
+                this.state = 14313;
+                this.match(PlSqlParser.BY);
+                this.state = 14314;
+                this.password_value();
+                this.state = 14316;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1864, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14315;
+                    this.link_authentication();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.AUTHENTICATED:
+                {
+                this.state = 14318;
+                this.link_authentication();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public password_value(): Password_valueContext {
+        let localContext = new Password_valueContext(this.context, this.state);
+        this.enterRule(localContext, 1490, PlSqlParser.RULE_password_value);
+        try {
+            this.state = 14325;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14321;
+                this.id_expression();
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14322;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.VALUES:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14323;
+                this.match(PlSqlParser.VALUES);
+                this.state = 14324;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public link_authentication(): Link_authenticationContext {
+        let localContext = new Link_authenticationContext(this.context, this.state);
+        this.enterRule(localContext, 1492, PlSqlParser.RULE_link_authentication);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14327;
+            this.match(PlSqlParser.AUTHENTICATED);
+            this.state = 14328;
+            this.match(PlSqlParser.BY);
+            this.state = 14329;
+            this.user_object_name();
+            this.state = 14330;
+            this.match(PlSqlParser.IDENTIFIED);
+            this.state = 14331;
+            this.match(PlSqlParser.BY);
+            this.state = 14332;
+            this.password_value();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_schema(): Create_schemaContext {
+        let localContext = new Create_schemaContext(this.context, this.state);
+        this.enterRule(localContext, 1494, PlSqlParser.RULE_create_schema);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14334;
+            this.match(PlSqlParser.CREATE);
+            this.state = 14335;
+            this.match(PlSqlParser.SCHEMA);
+            this.state = 14336;
+            this.match(PlSqlParser.AUTHORIZATION);
+            this.state = 14337;
+            this.schema_name();
+            this.state = 14343;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1868, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 14341;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1867, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14338;
+                        this.create_table();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 14339;
+                        this.create_view();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 14340;
+                        this.grant_statement();
+                        }
+                        break;
+                    }
+                    }
+                }
+                this.state = 14345;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1868, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_database(): Create_databaseContext {
+        let localContext = new Create_databaseContext(this.context, this.state);
+        this.enterRule(localContext, 1496, PlSqlParser.RULE_create_database);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14346;
+            this.match(PlSqlParser.CREATE);
+            this.state = 14347;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14348;
+            this.database_name();
+            this.state = 14387;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 14387;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1872, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14349;
+                        this.match(PlSqlParser.USER);
+                        this.state = 14350;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 1799 || _la === 1951)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 14351;
+                        this.match(PlSqlParser.IDENTIFIED);
+                        this.state = 14352;
+                        this.match(PlSqlParser.BY);
+                        this.state = 14353;
+                        this.password_value();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 14354;
+                        this.match(PlSqlParser.CONTROLFILE);
+                        this.state = 14355;
+                        this.match(PlSqlParser.REUSE);
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 14356;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 923 || _la === 926)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 14357;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 14359;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 1002) {
+                            {
+                            this.state = 14358;
+                            this.match(PlSqlParser.NATIONAL);
+                            }
+                        }
+
+                        this.state = 14361;
+                        this.match(PlSqlParser.CHARACTER);
+                        this.state = 14362;
+                        this.match(PlSqlParser.SET);
+                        this.state = 14363;
+                        this.char_set_name();
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 14364;
+                        this.match(PlSqlParser.SET);
+                        this.state = 14365;
+                        this.match(PlSqlParser.DEFAULT);
+                        this.state = 14366;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 122 || _la === 1707)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 14367;
+                        this.match(PlSqlParser.TABLESPACE);
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 14368;
+                        this.database_logging_clauses();
+                        }
+                        break;
+                    case 7:
+                        {
+                        this.state = 14369;
+                        this.tablespace_clauses();
+                        }
+                        break;
+                    case 8:
+                        {
+                        this.state = 14370;
+                        this.set_time_zone_clause();
+                        }
+                        break;
+                    case 9:
+                        {
+                        this.state = 14372;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 122 || _la === 1707) {
+                            {
+                            this.state = 14371;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 122 || _la === 1707)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                        }
+
+                        this.state = 14374;
+                        this.match(PlSqlParser.USER_DATA);
+                        this.state = 14375;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 14376;
+                        this.tablespace_group_name();
+                        this.state = 14377;
+                        this.match(PlSqlParser.DATAFILE);
+                        this.state = 14378;
+                        this.datafile_tempfile_spec();
+                        this.state = 14383;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 1871, this.context);
+                        while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                            if (alternative === 1) {
+                                {
+                                {
+                                this.state = 14379;
+                                this.match(PlSqlParser.COMMA);
+                                this.state = 14380;
+                                this.datafile_tempfile_spec();
+                                }
+                                }
+                            }
+                            this.state = 14385;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1871, this.context);
+                        }
+                        }
+                        break;
+                    case 10:
+                        {
+                        this.state = 14386;
+                        this.enable_pluggable_database();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 14389;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1873, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public database_logging_clauses(): Database_logging_clausesContext {
+        let localContext = new Database_logging_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1498, PlSqlParser.RULE_database_logging_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 14406;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LOGFILE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14391;
+                this.match(PlSqlParser.LOGFILE);
+                this.state = 14392;
+                this.database_logging_sub_clause();
+                this.state = 14397;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1874, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 14393;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14394;
+                        this.database_logging_sub_clause();
+                        }
+                        }
+                    }
+                    this.state = 14399;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1874, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14400;
+                _la = this.tokenStream.LA(1);
+                if(!(((((_la - 927)) & ~0x1F) === 0 && ((1 << (_la - 927)) & 7) !== 0))) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14401;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.ARCHIVELOG:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14402;
+                this.match(PlSqlParser.ARCHIVELOG);
+                }
+                break;
+            case PlSqlParser.NOARCHIVELOG:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14403;
+                this.match(PlSqlParser.NOARCHIVELOG);
+                }
+                break;
+            case PlSqlParser.FORCE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14404;
+                this.match(PlSqlParser.FORCE);
+                this.state = 14405;
+                this.match(PlSqlParser.LOGGING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public database_logging_sub_clause(): Database_logging_sub_clauseContext {
+        let localContext = new Database_logging_sub_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1500, PlSqlParser.RULE_database_logging_sub_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14410;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1876, this.context) ) {
+            case 1:
+                {
+                this.state = 14408;
+                this.match(PlSqlParser.GROUP);
+                this.state = 14409;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            }
+            this.state = 14412;
+            this.file_specification();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_clauses(): Tablespace_clausesContext {
+        let localContext = new Tablespace_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1502, PlSqlParser.RULE_tablespace_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 14432;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1879, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14414;
+                this.match(PlSqlParser.EXTENT);
+                this.state = 14415;
+                this.match(PlSqlParser.MANAGEMENT);
+                this.state = 14416;
+                this.match(PlSqlParser.LOCAL);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14418;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1802) {
+                    {
+                    this.state = 14417;
+                    this.match(PlSqlParser.SYSAUX);
+                    }
+                }
+
+                this.state = 14420;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 14421;
+                this.file_specification();
+                this.state = 14426;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1878, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 14422;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14423;
+                        this.file_specification();
+                        }
+                        }
+                    }
+                    this.state = 14428;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1878, this.context);
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14429;
+                this.default_tablespace();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14430;
+                this.default_temp_tablespace();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14431;
+                this.undo_tablespace();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public enable_pluggable_database(): Enable_pluggable_databaseContext {
+        let localContext = new Enable_pluggable_databaseContext(this.context, this.state);
+        this.enterRule(localContext, 1504, PlSqlParser.RULE_enable_pluggable_database);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14434;
+            this.match(PlSqlParser.ENABLE);
+            this.state = 14435;
+            this.match(PlSqlParser.PLUGGABLE);
+            this.state = 14436;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14449;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1883, this.context) ) {
+            case 1:
+                {
+                this.state = 14437;
+                this.match(PlSqlParser.SEED);
+                this.state = 14439;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1880, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14438;
+                    this.file_name_convert();
+                    }
+                    break;
+                }
+                this.state = 14443;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1881, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14441;
+                    this.match(PlSqlParser.SYSTEM);
+                    this.state = 14442;
+                    this.tablespace_datafile_clauses();
+                    }
+                    break;
+                }
+                this.state = 14447;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1882, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14445;
+                    this.match(PlSqlParser.SYSAUX);
+                    this.state = 14446;
+                    this.tablespace_datafile_clauses();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 14452;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1884, this.context) ) {
+            case 1:
+                {
+                this.state = 14451;
+                this.undo_mode_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public file_name_convert(): File_name_convertContext {
+        let localContext = new File_name_convertContext(this.context, this.state);
+        this.enterRule(localContext, 1506, PlSqlParser.RULE_file_name_convert);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14454;
+            this.match(PlSqlParser.FILE_NAME_CONVERT);
+            this.state = 14455;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 14468;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 14456;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 14457;
+                this.filename_convert_sub_clause();
+                this.state = 14462;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 14458;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 14459;
+                    this.filename_convert_sub_clause();
+                    }
+                    }
+                    this.state = 14464;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 14465;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.NONE:
+                {
+                this.state = 14467;
+                this.match(PlSqlParser.NONE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filename_convert_sub_clause(): Filename_convert_sub_clauseContext {
+        let localContext = new Filename_convert_sub_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1508, PlSqlParser.RULE_filename_convert_sub_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14470;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 14473;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1887, this.context) ) {
+            case 1:
+                {
+                this.state = 14471;
+                this.match(PlSqlParser.COMMA);
+                this.state = 14472;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace_datafile_clauses(): Tablespace_datafile_clausesContext {
+        let localContext = new Tablespace_datafile_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1510, PlSqlParser.RULE_tablespace_datafile_clauses);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14475;
+            this.match(PlSqlParser.DATAFILES);
+            this.state = 14479;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 14479;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.SIZE:
+                        {
+                        this.state = 14476;
+                        this.match(PlSqlParser.SIZE);
+                        this.state = 14477;
+                        this.size_clause();
+                        }
+                        break;
+                    case PlSqlParser.AUTOEXTEND:
+                        {
+                        this.state = 14478;
+                        this.autoextend_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 14481;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1889, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public undo_mode_clause(): Undo_mode_clauseContext {
+        let localContext = new Undo_mode_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1512, PlSqlParser.RULE_undo_mode_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14483;
+            this.match(PlSqlParser.LOCAL);
+            this.state = 14484;
+            this.match(PlSqlParser.UNDO);
+            this.state = 14485;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1246 || _la === 1261)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_tablespace(): Default_tablespaceContext {
+        let localContext = new Default_tablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 1514, PlSqlParser.RULE_default_tablespace);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14487;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 14488;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 14489;
+            this.tablespace();
+            this.state = 14492;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1890, this.context) ) {
+            case 1:
+                {
+                this.state = 14490;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 14491;
+                this.datafile_tempfile_spec();
+                }
+                break;
+            }
+            this.state = 14495;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1891, this.context) ) {
+            case 1:
+                {
+                this.state = 14494;
+                this.extent_management_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_temp_tablespace(): Default_temp_tablespaceContext {
+        let localContext = new Default_temp_tablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 1516, PlSqlParser.RULE_default_temp_tablespace);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14498;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 122 || _la === 1707) {
+                {
+                this.state = 14497;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 122 || _la === 1707)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 14500;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 14508;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TEMPORARY:
+                {
+                this.state = 14501;
+                this.match(PlSqlParser.TEMPORARY);
+                this.state = 14502;
+                this.match(PlSqlParser.TABLESPACE);
+                }
+                break;
+            case PlSqlParser.LOCAL:
+                {
+                this.state = 14503;
+                this.match(PlSqlParser.LOCAL);
+                this.state = 14504;
+                this.match(PlSqlParser.TEMPORARY);
+                this.state = 14505;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 14506;
+                this.match(PlSqlParser.FOR);
+                this.state = 14507;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 38 || _la === 836)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14510;
+            this.tablespace();
+            this.state = 14520;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1895, this.context) ) {
+            case 1:
+                {
+                this.state = 14511;
+                this.match(PlSqlParser.TEMPFILE);
+                this.state = 14512;
+                this.file_specification();
+                this.state = 14517;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1894, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 14513;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14514;
+                        this.file_specification();
+                        }
+                        }
+                    }
+                    this.state = 14519;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1894, this.context);
+                }
+                }
+                break;
+            }
+            this.state = 14523;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1896, this.context) ) {
+            case 1:
+                {
+                this.state = 14522;
+                this.extent_management_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public undo_tablespace(): Undo_tablespaceContext {
+        let localContext = new Undo_tablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 1518, PlSqlParser.RULE_undo_tablespace);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14526;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 122 || _la === 1707) {
+                {
+                this.state = 14525;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 122 || _la === 1707)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 14528;
+            this.match(PlSqlParser.UNDO);
+            this.state = 14529;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 14530;
+            this.tablespace();
+            this.state = 14540;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1899, this.context) ) {
+            case 1:
+                {
+                this.state = 14531;
+                this.match(PlSqlParser.DATAFILE);
+                this.state = 14532;
+                this.file_specification();
+                this.state = 14537;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1898, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 14533;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14534;
+                        this.file_specification();
+                        }
+                        }
+                    }
+                    this.state = 14539;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1898, this.context);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_database(): Drop_databaseContext {
+        let localContext = new Drop_databaseContext(this.context, this.state);
+        this.enterRule(localContext, 1520, PlSqlParser.RULE_drop_database);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14542;
+            this.match(PlSqlParser.DROP);
+            this.state = 14543;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14546;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1900, this.context) ) {
+            case 1:
+                {
+                this.state = 14544;
+                this.match(PlSqlParser.INCLUDING);
+                this.state = 14545;
+                this.match(PlSqlParser.BACKUPS);
+                }
+                break;
+            }
+            this.state = 14549;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1901, this.context) ) {
+            case 1:
+                {
+                this.state = 14548;
+                this.match(PlSqlParser.NOPROMPT);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public create_database_link(): Create_database_linkContext {
+        let localContext = new Create_database_linkContext(this.context, this.state);
+        this.enterRule(localContext, 1522, PlSqlParser.RULE_create_database_link);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14551;
+            this.match(PlSqlParser.CREATE);
+            this.state = 14553;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1681) {
+                {
+                this.state = 14552;
+                this.match(PlSqlParser.SHARED);
+                }
+            }
+
+            this.state = 14556;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1475) {
+                {
+                this.state = 14555;
+                this.match(PlSqlParser.PUBLIC);
+                }
+            }
+
+            this.state = 14558;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14559;
+            this.match(PlSqlParser.LINK);
+            this.state = 14560;
+            this.link_name();
+            this.state = 14576;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1907, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 14574;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.CONNECT:
+                        {
+                        this.state = 14561;
+                        this.match(PlSqlParser.CONNECT);
+                        this.state = 14562;
+                        this.match(PlSqlParser.TO);
+                        this.state = 14571;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 1905, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 14563;
+                            this.match(PlSqlParser.CURRENT_USER);
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 14564;
+                            this.user_object_name();
+                            this.state = 14565;
+                            this.match(PlSqlParser.IDENTIFIED);
+                            this.state = 14566;
+                            this.match(PlSqlParser.BY);
+                            this.state = 14567;
+                            this.password_value();
+                            this.state = 14569;
+                            this.errorHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this.tokenStream, 1904, this.context) ) {
+                            case 1:
+                                {
+                                this.state = 14568;
+                                this.link_authentication();
+                                }
+                                break;
+                            }
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case PlSqlParser.AUTHENTICATED:
+                        {
+                        this.state = 14573;
+                        this.link_authentication();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 14578;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1907, this.context);
+            }
+            this.state = 14581;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1908, this.context) ) {
+            case 1:
+                {
+                this.state = 14579;
+                this.match(PlSqlParser.USING);
+                this.state = 14580;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_database_link(): Drop_database_linkContext {
+        let localContext = new Drop_database_linkContext(this.context, this.state);
+        this.enterRule(localContext, 1524, PlSqlParser.RULE_drop_database_link);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14583;
+            this.match(PlSqlParser.DROP);
+            this.state = 14585;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1475) {
+                {
+                this.state = 14584;
+                this.match(PlSqlParser.PUBLIC);
+                }
+            }
+
+            this.state = 14587;
+            this.match(PlSqlParser.DATABASE);
+            this.state = 14588;
+            this.match(PlSqlParser.LINK);
+            this.state = 14589;
+            this.link_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_tablespace_set(): Alter_tablespace_setContext {
+        let localContext = new Alter_tablespace_setContext(this.context, this.state);
+        this.enterRule(localContext, 1526, PlSqlParser.RULE_alter_tablespace_set);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14591;
+            this.match(PlSqlParser.ALTER);
+            this.state = 14592;
+            this.match(PlSqlParser.TABLESPACE);
+            this.state = 14593;
+            this.match(PlSqlParser.SET);
+            this.state = 14594;
+            localContext._tss = this.id_expression();
+            this.state = 14595;
+            this.alter_tablespace_attrs();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_tablespace_attrs(): Alter_tablespace_attrsContext {
+        let localContext = new Alter_tablespace_attrsContext(this.context, this.state);
+        this.enterRule(localContext, 1528, PlSqlParser.RULE_alter_tablespace_attrs);
+        let _la: number;
+        try {
+            this.state = 14624;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1911, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14597;
+                this.default_tablespace_params();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14598;
+                this.match(PlSqlParser.MINIMUM);
+                this.state = 14599;
+                this.match(PlSqlParser.EXTENT);
+                this.state = 14600;
+                this.size_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14601;
+                this.match(PlSqlParser.RESIZE);
+                this.state = 14602;
+                this.size_clause();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14603;
+                this.match(PlSqlParser.COALESCE);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14604;
+                this.match(PlSqlParser.SHRINK);
+                this.state = 14605;
+                this.match(PlSqlParser.SPACE_KEYWORD);
+                this.state = 14608;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1910, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14606;
+                    this.match(PlSqlParser.KEEP);
+                    this.state = 14607;
+                    this.size_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 14610;
+                this.match(PlSqlParser.RENAME);
+                this.state = 14611;
+                this.match(PlSqlParser.TO);
+                this.state = 14612;
+                localContext._nts = this.id_expression();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 14613;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 113 || _la === 508)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14614;
+                this.match(PlSqlParser.BACKUP);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 14615;
+                this.datafile_tempfile_clauses();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 14616;
+                this.tablespace_logging_clauses();
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 14617;
+                this.tablespace_group_clause();
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 14618;
+                this.tablespace_state_clauses();
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 14619;
+                this.autoextend_clause();
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 14620;
+                this.flashback_mode_clause();
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 14621;
+                this.tablespace_retention_clause();
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 14622;
+                this.alter_tablespace_encryption();
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 14623;
+                this.lost_write_protection();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_tablespace_encryption(): Alter_tablespace_encryptionContext {
+        let localContext = new Alter_tablespace_encryptionContext(this.context, this.state);
+        this.enterRule(localContext, 1530, PlSqlParser.RULE_alter_tablespace_encryption);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14626;
+            this.match(PlSqlParser.ENCRYPTION);
+            this.state = 14651;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.OFFLINE:
+                {
+                this.state = 14627;
+                this.match(PlSqlParser.OFFLINE);
+                this.state = 14633;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.USING:
+                    {
+                    this.state = 14629;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2248) {
+                        {
+                        this.state = 14628;
+                        this.tablespace_encryption_spec();
+                        }
+                    }
+
+                    this.state = 14631;
+                    this.match(PlSqlParser.ENCRYPT);
+                    }
+                    break;
+                case PlSqlParser.DECRYPT:
+                    {
+                    this.state = 14632;
+                    this.match(PlSqlParser.DECRYPT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.ONLINE:
+                {
+                this.state = 14635;
+                this.match(PlSqlParser.ONLINE);
+                this.state = 14641;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.USING:
+                    {
+                    this.state = 14637;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2248) {
+                        {
+                        this.state = 14636;
+                        this.tablespace_encryption_spec();
+                        }
+                    }
+
+                    this.state = 14639;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 505 || _la === 1552)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                case PlSqlParser.DECRYPT:
+                    {
+                    this.state = 14640;
+                    this.match(PlSqlParser.DECRYPT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 14644;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1916, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14643;
+                    this.ts_file_name_convert();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.FINISH:
+                {
+                this.state = 14646;
+                this.match(PlSqlParser.FINISH);
+                this.state = 14647;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 387 || _la === 505 || _la === 1552)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14649;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1917, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14648;
+                    this.ts_file_name_convert();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ts_file_name_convert(): Ts_file_name_convertContext {
+        let localContext = new Ts_file_name_convertContext(this.context, this.state);
+        this.enterRule(localContext, 1532, PlSqlParser.RULE_ts_file_name_convert);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14653;
+            this.match(PlSqlParser.FILE_NAME_CONVERT);
+            this.state = 14654;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 14655;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 14656;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 14657;
+            this.match(PlSqlParser.COMMA);
+            this.state = 14658;
+            this.match(PlSqlParser.CHAR_STRING);
+            this.state = 14665;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 14659;
+                this.match(PlSqlParser.COMMA);
+                this.state = 14660;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 14661;
+                this.match(PlSqlParser.COMMA);
+                this.state = 14662;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                }
+                this.state = 14667;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 14668;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 14670;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1920, this.context) ) {
+            case 1:
+                {
+                this.state = 14669;
+                this.match(PlSqlParser.KEEP);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_role(): Alter_roleContext {
+        let localContext = new Alter_roleContext(this.context, this.state);
+        this.enterRule(localContext, 1534, PlSqlParser.RULE_alter_role);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14672;
+            this.match(PlSqlParser.ALTER);
+            this.state = 14673;
+            this.match(PlSqlParser.ROLE);
+            this.state = 14674;
+            this.role_name();
+            this.state = 14675;
+            this.role_identified_clause();
+            this.state = 14677;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1921, this.context) ) {
+            case 1:
+                {
+                this.state = 14676;
+                this.container_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public role_identified_clause(): Role_identified_clauseContext {
+        let localContext = new Role_identified_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1536, PlSqlParser.RULE_role_identified_clause);
+        try {
+            this.state = 14698;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14679;
+                this.match(PlSqlParser.NOT);
+                this.state = 14680;
+                this.match(PlSqlParser.IDENTIFIED);
+                }
+                break;
+            case PlSqlParser.IDENTIFIED:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14681;
+                this.match(PlSqlParser.IDENTIFIED);
+                this.state = 14696;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.BY:
+                    {
+                    this.state = 14682;
+                    this.match(PlSqlParser.BY);
+                    this.state = 14683;
+                    this.identifier();
+                    }
+                    break;
+                case PlSqlParser.USING:
+                    {
+                    this.state = 14684;
+                    this.match(PlSqlParser.USING);
+                    this.state = 14685;
+                    this.identifier();
+                    this.state = 14688;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1922, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14686;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 14687;
+                        this.id_expression();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.EXTERNALLY:
+                    {
+                    this.state = 14690;
+                    this.match(PlSqlParser.EXTERNALLY);
+                    }
+                    break;
+                case PlSqlParser.GLOBALLY:
+                    {
+                    this.state = 14691;
+                    this.match(PlSqlParser.GLOBALLY);
+                    this.state = 14694;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1923, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14692;
+                        this.match(PlSqlParser.AS);
+                        this.state = 14693;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_table(): Alter_tableContext {
+        let localContext = new Alter_tableContext(this.context, this.state);
+        this.enterRule(localContext, 1538, PlSqlParser.RULE_alter_table);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14700;
+            this.match(PlSqlParser.ALTER);
+            this.state = 14701;
+            this.match(PlSqlParser.TABLE);
+            this.state = 14702;
+            this.tableview_name();
+            this.state = 14712;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1928, this.context) ) {
+            case 1:
+                {
+                this.state = 14704;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 14703;
+                        this.memoptimize_read_write_clause();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 14706;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1926, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                this.state = 14709;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1927, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14708;
+                    this.alter_table_body();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 14711;
+                this.alter_table_body();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_table_body(): Alter_table_bodyContext {
+        let localContext = new Alter_table_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 1540, PlSqlParser.RULE_alter_table_body);
+        try {
+            this.state = 14719;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1930, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14714;
+                this.alter_table_action();
+                this.state = 14716;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1929, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14715;
+                    this.enable_disable_clauses();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14718;
+                this.enable_disable_clauses();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_table_action(): Alter_table_actionContext {
+        let localContext = new Alter_table_actionContext(this.context, this.state);
+        this.enterRule(localContext, 1542, PlSqlParser.RULE_alter_table_action);
+        try {
+            this.state = 14727;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1931, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14721;
+                this.alter_table_properties();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14722;
+                this.constraint_clauses();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14723;
+                this.column_clauses();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14724;
+                this.alter_table_partitioning();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14725;
+                this.move_table_clause();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 14726;
+                this.modify_to_partitioned();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public enable_disable_clauses(): Enable_disable_clausesContext {
+        let localContext = new Enable_disable_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1544, PlSqlParser.RULE_enable_disable_clauses);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14737;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 14737;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1933, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 14729;
+                        this.enable_disable_clause();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 14730;
+                        this.enable_or_disable();
+                        this.state = 14735;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.TABLE:
+                            {
+                            this.state = 14731;
+                            this.match(PlSqlParser.TABLE);
+                            this.state = 14732;
+                            this.match(PlSqlParser.LOCK);
+                            }
+                            break;
+                        case PlSqlParser.ALL:
+                            {
+                            this.state = 14733;
+                            this.match(PlSqlParser.ALL);
+                            this.state = 14734;
+                            this.match(PlSqlParser.TRIGGERS);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 14739;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1934, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public memoptimize_read_write_clause(): Memoptimize_read_write_clauseContext {
+        let localContext = new Memoptimize_read_write_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1546, PlSqlParser.RULE_memoptimize_read_write_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14742;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1139) {
+                {
+                this.state = 14741;
+                this.match(PlSqlParser.NO);
+                }
+            }
+
+            this.state = 14744;
+            this.match(PlSqlParser.MEMOPTIMIZE);
+            this.state = 14745;
+            this.match(PlSqlParser.FOR);
+            this.state = 14746;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1507 || _la === 2315)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_table_properties(): Alter_table_propertiesContext {
+        let localContext = new Alter_table_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1548, PlSqlParser.RULE_alter_table_properties);
+        let _la: number;
+        try {
+            this.state = 14765;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1937, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14748;
+                this.alter_table_properties_1();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14749;
+                this.match(PlSqlParser.RENAME);
+                this.state = 14750;
+                this.match(PlSqlParser.TO);
+                this.state = 14751;
+                this.tableview_name();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14752;
+                this.shrink_clause();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14753;
+                this.match(PlSqlParser.READ);
+                this.state = 14754;
+                this.match(PlSqlParser.ONLY);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14755;
+                this.match(PlSqlParser.READ);
+                this.state = 14756;
+                this.match(PlSqlParser.WRITE);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 14757;
+                this.match(PlSqlParser.REKEY);
+                this.state = 14758;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 14760;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 14759;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 14762;
+                this.match(PlSqlParser.ROW);
+                this.state = 14763;
+                this.match(PlSqlParser.ARCHIVAL);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 14764;
+                this.annotations_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_table_partitioning(): Alter_table_partitioningContext {
+        let localContext = new Alter_table_partitioningContext(this.context, this.state);
+        this.enterRule(localContext, 1550, PlSqlParser.RULE_alter_table_partitioning);
+        try {
+            this.state = 14778;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 14767;
+                this.add_table_partition();
+                }
+                break;
+            case PlSqlParser.DROP:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 14768;
+                this.drop_table_partition();
+                }
+                break;
+            case PlSqlParser.MERGE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 14769;
+                this.merge_table_partition();
+                }
+                break;
+            case PlSqlParser.MODIFY:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 14770;
+                this.modify_table_partition();
+                }
+                break;
+            case PlSqlParser.SPLIT:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 14771;
+                this.split_table_partition();
+                }
+                break;
+            case PlSqlParser.TRUNCATE:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 14772;
+                this.truncate_table_partition();
+                }
+                break;
+            case PlSqlParser.EXCHANGE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 14773;
+                this.exchange_table_partition();
+                }
+                break;
+            case PlSqlParser.COALESCE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 14774;
+                this.coalesce_table_partition();
+                }
+                break;
+            case PlSqlParser.SET:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 14775;
+                this.alter_interval_partition();
+                }
+                break;
+            case PlSqlParser.MOVE:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 14776;
+                this.move_table_partition();
+                }
+                break;
+            case PlSqlParser.RENAME:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 14777;
+                this.rename_table_partition();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_table_partition(): Add_table_partitionContext {
+        let localContext = new Add_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1552, PlSqlParser.RULE_add_table_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14780;
+            this.match(PlSqlParser.ADD);
+            this.state = 14797;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1943, this.context) ) {
+            case 1:
+                {
+                this.state = 14781;
+                this.range_partition_desc();
+                }
+                break;
+            case 2:
+                {
+                this.state = 14782;
+                this.list_partition_desc();
+                }
+                break;
+            case 3:
+                {
+                this.state = 14783;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 14785;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1939, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14784;
+                    this.partition_name();
+                    }
+                    break;
+                }
+                this.state = 14789;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1940, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14787;
+                    this.match(PlSqlParser.TABLESPACE);
+                    this.state = 14788;
+                    this.tablespace();
+                    }
+                    break;
+                }
+                this.state = 14792;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1941, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14791;
+                    this.key_compression();
+                    }
+                    break;
+                }
+                this.state = 14795;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1942, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14794;
+                    this.match(PlSqlParser.UNUSABLE);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_table_partition(): Drop_table_partitionContext {
+        let localContext = new Drop_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1554, PlSqlParser.RULE_drop_table_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14799;
+            this.match(PlSqlParser.DROP);
+            this.state = 14802;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITIONS:
+                {
+                this.state = 14800;
+                this.partition_extended_names();
+                }
+                break;
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 14801;
+                this.subpartition_extended_names();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14808;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1946, this.context) ) {
+            case 1:
+                {
+                this.state = 14804;
+                this.update_index_clauses();
+                this.state = 14806;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1945, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14805;
+                    this.parallel_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_table_partition(): Merge_table_partitionContext {
+        let localContext = new Merge_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1556, PlSqlParser.RULE_merge_table_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14810;
+            this.match(PlSqlParser.MERGE);
+            this.state = 14811;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 14812;
+            this.partition_name();
+            this.state = 14813;
+            this.match(PlSqlParser.AND);
+            this.state = 14814;
+            this.partition_name();
+            this.state = 14815;
+            this.match(PlSqlParser.INTO);
+            this.state = 14816;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 14817;
+            this.partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_table_partition(): Modify_table_partitionContext {
+        let localContext = new Modify_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1558, PlSqlParser.RULE_modify_table_partition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14819;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 14820;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1350 || _la === 1777)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 14821;
+            this.partition_name();
+            this.state = 14824;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1947, this.context) ) {
+            case 1:
+                {
+                this.state = 14822;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 21 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14823;
+                this.list_values_clause();
+                }
+                break;
+            }
+            this.state = 14828;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1948, this.context) ) {
+            case 1:
+                {
+                this.state = 14826;
+                this.match(PlSqlParser.ADD);
+                this.state = 14827;
+                this.range_subpartition_desc();
+                }
+                break;
+            }
+            this.state = 14836;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1950, this.context) ) {
+            case 1:
+                {
+                this.state = 14831;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1513) {
+                    {
+                    this.state = 14830;
+                    this.match(PlSqlParser.REBUILD);
+                    }
+                }
+
+                this.state = 14833;
+                this.match(PlSqlParser.UNUSABLE);
+                this.state = 14834;
+                this.match(PlSqlParser.LOCAL);
+                this.state = 14835;
+                this.match(PlSqlParser.INDEXES);
+                }
+                break;
+            }
+            this.state = 14839;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1951, this.context) ) {
+            case 1:
+                {
+                this.state = 14838;
+                this.shrink_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public split_table_partition(): Split_table_partitionContext {
+        let localContext = new Split_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1560, PlSqlParser.RULE_split_table_partition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14841;
+            this.match(PlSqlParser.SPLIT);
+            this.state = 14842;
+            this.partition_extended_names();
+            this.state = 14888;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.AT:
+                {
+                this.state = 14843;
+                this.match(PlSqlParser.AT);
+                this.state = 14844;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 14845;
+                this.literal();
+                this.state = 14850;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 14846;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 14847;
+                    this.literal();
+                    }
+                    }
+                    this.state = 14852;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 14853;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 14854;
+                this.match(PlSqlParser.INTO);
+                this.state = 14855;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 14856;
+                this.range_partition_desc();
+                this.state = 14861;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 14857;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 14858;
+                    this.range_partition_desc();
+                    }
+                    }
+                    this.state = 14863;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 14864;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.INTO:
+                {
+                this.state = 14866;
+                this.match(PlSqlParser.INTO);
+                this.state = 14867;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 14884;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1956, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14868;
+                    this.range_partition_desc();
+                    this.state = 14873;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 14869;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14870;
+                        this.range_partition_desc();
+                        }
+                        }
+                        this.state = 14875;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 14876;
+                    this.list_partition_desc();
+                    this.state = 14881;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 14877;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14878;
+                        this.list_partition_desc();
+                        }
+                        }
+                        this.state = 14883;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                }
+                this.state = 14886;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14893;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1958, this.context) ) {
+            case 1:
+                {
+                this.state = 14890;
+                this.update_global_index_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 14891;
+                this.update_index_clauses();
+                }
+                break;
+            case 3:
+                {
+                this.state = 14892;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public truncate_table_partition(): Truncate_table_partitionContext {
+        let localContext = new Truncate_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1562, PlSqlParser.RULE_truncate_table_partition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14895;
+            this.match(PlSqlParser.TRUNCATE);
+            this.state = 14898;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITIONS:
+                {
+                this.state = 14896;
+                this.partition_extended_names();
+                }
+                break;
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 14897;
+                this.subpartition_extended_names();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14908;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1962, this.context) ) {
+            case 1:
+                {
+                this.state = 14905;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DROP:
+                    {
+                    this.state = 14900;
+                    this.match(PlSqlParser.DROP);
+                    this.state = 14902;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 38) {
+                        {
+                        this.state = 14901;
+                        this.match(PlSqlParser.ALL);
+                        }
+                    }
+
+                    }
+                    break;
+                case PlSqlParser.REUSE:
+                    {
+                    this.state = 14904;
+                    this.match(PlSqlParser.REUSE);
+                    }
+                    break;
+                case PlSqlParser.STORAGE:
+                    break;
+                default:
+                    break;
+                }
+                this.state = 14907;
+                this.match(PlSqlParser.STORAGE);
+                }
+                break;
+            }
+            this.state = 14911;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1963, this.context) ) {
+            case 1:
+                {
+                this.state = 14910;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            this.state = 14917;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1965, this.context) ) {
+            case 1:
+                {
+                this.state = 14913;
+                this.update_index_clauses();
+                this.state = 14915;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1964, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14914;
+                    this.parallel_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public exchange_table_partition(): Exchange_table_partitionContext {
+        let localContext = new Exchange_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1564, PlSqlParser.RULE_exchange_table_partition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14919;
+            this.match(PlSqlParser.EXCHANGE);
+            this.state = 14920;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 14921;
+            this.partition_name();
+            this.state = 14922;
+            this.match(PlSqlParser.WITH);
+            this.state = 14923;
+            this.match(PlSqlParser.TABLE);
+            this.state = 14924;
+            this.tableview_name();
+            this.state = 14927;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1966, this.context) ) {
+            case 1:
+                {
+                this.state = 14925;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 540 || _la === 706)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14926;
+                this.match(PlSqlParser.INDEXES);
+                }
+                break;
+            }
+            this.state = 14931;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1967, this.context) ) {
+            case 1:
+                {
+                this.state = 14929;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2308 || _la === 2310)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 14930;
+                this.match(PlSqlParser.VALIDATION);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public coalesce_table_partition(): Coalesce_table_partitionContext {
+        let localContext = new Coalesce_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1566, PlSqlParser.RULE_coalesce_table_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14933;
+            this.match(PlSqlParser.COALESCE);
+            this.state = 14934;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 14936;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1968, this.context) ) {
+            case 1:
+                {
+                this.state = 14935;
+                this.parallel_clause();
+                }
+                break;
+            }
+            this.state = 14941;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1969, this.context) ) {
+            case 1:
+                {
+                this.state = 14938;
+                this.allow_or_disallow();
+                this.state = 14939;
+                this.match(PlSqlParser.CLUSTERING);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_interval_partition(): Alter_interval_partitionContext {
+        let localContext = new Alter_interval_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1568, PlSqlParser.RULE_alter_interval_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14943;
+            this.match(PlSqlParser.SET);
+            this.state = 14944;
+            this.match(PlSqlParser.INTERVAL);
+            this.state = 14945;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 14948;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1970, this.context) ) {
+            case 1:
+                {
+                this.state = 14946;
+                this.constant();
+                }
+                break;
+            case 2:
+                {
+                this.state = 14947;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 14950;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public move_table_partition(): Move_table_partitionContext {
+        let localContext = new Move_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1570, PlSqlParser.RULE_move_table_partition);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14952;
+            this.match(PlSqlParser.MOVE);
+            this.state = 14967;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITIONS:
+                {
+                this.state = 14953;
+                this.partition_extended_names();
+                this.state = 14956;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1971, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14954;
+                    this.match(PlSqlParser.MAPPING);
+                    this.state = 14955;
+                    this.match(PlSqlParser.TABLE);
+                    }
+                    break;
+                }
+                this.state = 14958;
+                this.table_partition_description();
+                }
+                break;
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 14960;
+                this.subpartition_extended_names();
+                this.state = 14962;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1972, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14961;
+                    this.indexing_clause();
+                    }
+                    break;
+                }
+                this.state = 14965;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1973, this.context) ) {
+                case 1:
+                    {
+                    this.state = 14964;
+                    this.partitioning_storage_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14978;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 1976, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 14976;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.INCLUDING:
+                        {
+                        this.state = 14969;
+                        this.filter_condition();
+                        }
+                        break;
+                    case PlSqlParser.INVALIDATE:
+                    case PlSqlParser.UPDATE:
+                        {
+                        this.state = 14970;
+                        this.update_index_clauses();
+                        }
+                        break;
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.PARALLEL:
+                        {
+                        this.state = 14971;
+                        this.parallel_clause();
+                        }
+                        break;
+                    case PlSqlParser.ALLOW:
+                    case PlSqlParser.DISALLOW:
+                        {
+                        this.state = 14972;
+                        this.allow_or_disallow();
+                        this.state = 14973;
+                        this.match(PlSqlParser.CLUSTERING);
+                        }
+                        break;
+                    case PlSqlParser.ONLINE:
+                        {
+                        this.state = 14975;
+                        this.match(PlSqlParser.ONLINE);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 14980;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1976, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filter_condition(): Filter_conditionContext {
+        let localContext = new Filter_conditionContext(this.context, this.state);
+        this.enterRule(localContext, 1572, PlSqlParser.RULE_filter_condition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14981;
+            this.match(PlSqlParser.INCLUDING);
+            this.state = 14982;
+            this.match(PlSqlParser.ROWS);
+            this.state = 14983;
+            this.where_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rename_table_partition(): Rename_table_partitionContext {
+        let localContext = new Rename_table_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1574, PlSqlParser.RULE_rename_table_partition);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14985;
+            this.match(PlSqlParser.RENAME);
+            this.state = 14988;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITIONS:
+                {
+                this.state = 14986;
+                this.partition_extended_names();
+                }
+                break;
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 14987;
+                this.subpartition_extended_names();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 14990;
+            this.match(PlSqlParser.TO);
+            this.state = 14991;
+            this.partition_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_extended_names(): Partition_extended_namesContext {
+        let localContext = new Partition_extended_namesContext(this.context, this.state);
+        this.enterRule(localContext, 1576, PlSqlParser.RULE_partition_extended_names);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 14993;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1350 || _la === 1352)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 15028;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 14994;
+                this.partition_name();
+                this.state = 14999;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1978, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 14995;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 14996;
+                        this.partition_name();
+                        }
+                        }
+                    }
+                    this.state = 15001;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1978, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 15002;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15003;
+                this.partition_name();
+                this.state = 15008;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15004;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15005;
+                    this.partition_name();
+                    }
+                    }
+                    this.state = 15010;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15011;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.FOR:
+                {
+                this.state = 15013;
+                this.match(PlSqlParser.FOR);
+                this.state = 15015;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 15014;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    }
+                }
+
+                this.state = 15017;
+                this.partition_key_value();
+                this.state = 15022;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1981, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 15018;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 15019;
+                        this.partition_key_value();
+                        }
+                        }
+                    }
+                    this.state = 15024;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1981, this.context);
+                }
+                this.state = 15026;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1982, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15025;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subpartition_extended_names(): Subpartition_extended_namesContext {
+        let localContext = new Subpartition_extended_namesContext(this.context, this.state);
+        this.enterRule(localContext, 1578, PlSqlParser.RULE_subpartition_extended_names);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15030;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1776 || _la === 1777)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 15062;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 15031;
+                this.partition_name();
+                this.state = 15034;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1984, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15032;
+                    this.match(PlSqlParser.UPDATE);
+                    this.state = 15033;
+                    this.match(PlSqlParser.INDEXES);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 15036;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15037;
+                this.partition_name();
+                this.state = 15042;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15038;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15039;
+                    this.partition_name();
+                    }
+                    }
+                    this.state = 15044;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15045;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.FOR:
+                {
+                this.state = 15047;
+                this.match(PlSqlParser.FOR);
+                this.state = 15049;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 15048;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    }
+                }
+
+                this.state = 15051;
+                this.subpartition_key_value();
+                this.state = 15056;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1987, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 15052;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 15053;
+                        this.subpartition_key_value();
+                        }
+                        }
+                    }
+                    this.state = 15058;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1987, this.context);
+                }
+                this.state = 15060;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 1988, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15059;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_table_properties_1(): Alter_table_properties_1Context {
+        let localContext = new Alter_table_properties_1Context(this.context, this.state);
+        this.enterRule(localContext, 1580, PlSqlParser.RULE_alter_table_properties_1);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15083;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 15083;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 1990, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 15064;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 15065;
+                        this.logging_clause();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 15066;
+                        this.table_compression();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 15067;
+                        this.inmemory_table_clause();
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 15068;
+                        this.supplemental_table_logging();
+                        }
+                        break;
+                    case 6:
+                        {
+                        this.state = 15069;
+                        this.allocate_extent_clause();
+                        }
+                        break;
+                    case 7:
+                        {
+                        this.state = 15070;
+                        this.deallocate_unused_clause();
+                        }
+                        break;
+                    case 8:
+                        {
+                        this.state = 15071;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 166 || _la === 1067)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case 9:
+                        {
+                        this.state = 15072;
+                        this.match(PlSqlParser.RESULT_CACHE);
+                        this.state = 15073;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 15074;
+                        this.match(PlSqlParser.MODE);
+                        this.state = 15075;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 389 || _la === 617)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 15076;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    case 10:
+                        {
+                        this.state = 15077;
+                        this.upgrade_table_clause();
+                        }
+                        break;
+                    case 11:
+                        {
+                        this.state = 15078;
+                        this.records_per_block_clause();
+                        }
+                        break;
+                    case 12:
+                        {
+                        this.state = 15079;
+                        this.parallel_clause();
+                        }
+                        break;
+                    case 13:
+                        {
+                        this.state = 15080;
+                        this.row_movement_clause();
+                        }
+                        break;
+                    case 14:
+                        {
+                        this.state = 15081;
+                        this.logical_replication_clause();
+                        }
+                        break;
+                    case 15:
+                        {
+                        this.state = 15082;
+                        this.flashback_archive_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15085;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 1991, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            this.state = 15088;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1992, this.context) ) {
+            case 1:
+                {
+                this.state = 15087;
+                this.alter_iot_clauses();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_iot_clauses(): Alter_iot_clausesContext {
+        let localContext = new Alter_iot_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1582, PlSqlParser.RULE_alter_iot_clauses);
+        try {
+            this.state = 15094;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1993, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15090;
+                this.index_org_table_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15091;
+                this.alter_overflow_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 15092;
+                this.alter_mapping_table_clause();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 15093;
+                this.match(PlSqlParser.COALESCE);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_mapping_table_clause(): Alter_mapping_table_clauseContext {
+        let localContext = new Alter_mapping_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1584, PlSqlParser.RULE_alter_mapping_table_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15096;
+            this.match(PlSqlParser.MAPPING);
+            this.state = 15097;
+            this.match(PlSqlParser.TABLE);
+            this.state = 15100;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALLOCATE:
+                {
+                this.state = 15098;
+                this.allocate_extent_clause();
+                }
+                break;
+            case PlSqlParser.DEALLOCATE:
+                {
+                this.state = 15099;
+                this.deallocate_unused_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public alter_overflow_clause(): Alter_overflow_clauseContext {
+        let localContext = new Alter_overflow_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1586, PlSqlParser.RULE_alter_overflow_clause);
+        try {
+            let alternative: number;
+            this.state = 15112;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ADD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15102;
+                this.add_overflow_clause();
+                }
+                break;
+            case PlSqlParser.OVERFLOW_:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15103;
+                this.match(PlSqlParser.OVERFLOW_);
+                this.state = 15108;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 15108;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.COLUMN:
+                        case PlSqlParser.COMPRESS:
+                        case PlSqlParser.COMPUTE:
+                        case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                        case PlSqlParser.INITRANS:
+                        case PlSqlParser.LOGGING:
+                        case PlSqlParser.MAXTRANS:
+                        case PlSqlParser.NOCOMPRESS:
+                        case PlSqlParser.NOLOGGING:
+                        case PlSqlParser.PCTFREE:
+                        case PlSqlParser.PCTUSED:
+                        case PlSqlParser.ROW:
+                        case PlSqlParser.STORAGE:
+                        case PlSqlParser.TABLESPACE:
+                            {
+                            this.state = 15104;
+                            this.segment_attributes_clause();
+                            }
+                            break;
+                        case PlSqlParser.ALLOCATE:
+                            {
+                            this.state = 15105;
+                            this.allocate_extent_clause();
+                            }
+                            break;
+                        case PlSqlParser.SHRINK:
+                            {
+                            this.state = 15106;
+                            this.shrink_clause();
+                            }
+                            break;
+                        case PlSqlParser.DEALLOCATE:
+                            {
+                            this.state = 15107;
+                            this.deallocate_unused_clause();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 15110;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 1996, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_overflow_clause(): Add_overflow_clauseContext {
+        let localContext = new Add_overflow_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1588, PlSqlParser.RULE_add_overflow_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15114;
+            this.match(PlSqlParser.ADD);
+            this.state = 15115;
+            this.match(PlSqlParser.OVERFLOW_);
+            this.state = 15117;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1998, this.context) ) {
+            case 1:
+                {
+                this.state = 15116;
+                this.segment_attributes_clause();
+                }
+                break;
+            }
+            this.state = 15135;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2002, this.context) ) {
+            case 1:
+                {
+                this.state = 15119;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15120;
+                this.match(PlSqlParser.PARTITION);
+                this.state = 15122;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 10485761) !== 0) || _la === 594 || _la === 744 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1764 || _la === 2082) {
+                    {
+                    this.state = 15121;
+                    this.segment_attributes_clause();
+                    }
+                }
+
+                this.state = 15131;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15124;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15125;
+                    this.match(PlSqlParser.PARTITION);
+                    this.state = 15127;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (((((_la - 237)) & ~0x1F) === 0 && ((1 << (_la - 237)) & 10485761) !== 0) || _la === 594 || _la === 744 || _la === 885 || _la === 932 || _la === 1075 || _la === 1120 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1764 || _la === 2082) {
+                        {
+                        this.state = 15126;
+                        this.segment_attributes_clause();
+                        }
+                    }
+
+                    }
+                    }
+                    this.state = 15133;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15134;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_index_clauses(): Update_index_clausesContext {
+        let localContext = new Update_index_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1590, PlSqlParser.RULE_update_index_clauses);
+        try {
+            this.state = 15139;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2003, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15137;
+                this.update_global_index_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15138;
+                this.update_all_indexes_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_global_index_clause(): Update_global_index_clauseContext {
+        let localContext = new Update_global_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1592, PlSqlParser.RULE_update_global_index_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15141;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 781 || _la === 2209)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 15142;
+            this.match(PlSqlParser.GLOBAL);
+            this.state = 15143;
+            this.match(PlSqlParser.INDEXES);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_all_indexes_clause(): Update_all_indexes_clauseContext {
+        let localContext = new Update_all_indexes_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1594, PlSqlParser.RULE_update_all_indexes_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15145;
+            this.match(PlSqlParser.UPDATE);
+            this.state = 15146;
+            this.match(PlSqlParser.INDEXES);
+            this.state = 15151;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2004, this.context) ) {
+            case 1:
+                {
+                this.state = 15147;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15148;
+                this.update_all_indexes_index_clause();
+                this.state = 15149;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_all_indexes_index_clause(): Update_all_indexes_index_clauseContext {
+        let localContext = new Update_all_indexes_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1596, PlSqlParser.RULE_update_all_indexes_index_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15153;
+            this.index_name();
+            this.state = 15154;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 15157;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+                {
+                this.state = 15155;
+                this.update_index_partition();
+                }
+                break;
+            case PlSqlParser.SUBPARTITION:
+                {
+                this.state = 15156;
+                this.update_index_subpartition();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 15159;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 15164;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 15160;
+                this.match(PlSqlParser.COMMA);
+                this.state = 15161;
+                this.update_all_indexes_clause();
+                }
+                }
+                this.state = 15166;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_index_partition(): Update_index_partitionContext {
+        let localContext = new Update_index_partitionContext(this.context, this.state);
+        this.enterRule(localContext, 1598, PlSqlParser.RULE_update_index_partition);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15167;
+            this.index_partition_description();
+            this.state = 15169;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1765 || _la === 2449) {
+                {
+                this.state = 15168;
+                this.index_subpartition_clause();
+                }
+            }
+
+            this.state = 15175;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2008, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 15171;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15172;
+                    this.update_index_partition();
+                    }
+                    }
+                }
+                this.state = 15177;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2008, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_index_subpartition(): Update_index_subpartitionContext {
+        let localContext = new Update_index_subpartitionContext(this.context, this.state);
+        this.enterRule(localContext, 1600, PlSqlParser.RULE_update_index_subpartition);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15178;
+            this.match(PlSqlParser.SUBPARTITION);
+            this.state = 15180;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2009, this.context) ) {
+            case 1:
+                {
+                this.state = 15179;
+                this.subpartition_name();
+                }
+                break;
+            }
+            this.state = 15184;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2082) {
+                {
+                this.state = 15182;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 15183;
+                this.tablespace();
+                }
+            }
+
+            this.state = 15190;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2011, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 15186;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15187;
+                    this.update_index_subpartition();
+                    }
+                    }
+                }
+                this.state = 15192;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2011, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public enable_disable_clause(): Enable_disable_clauseContext {
+        let localContext = new Enable_disable_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1602, PlSqlParser.RULE_enable_disable_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15193;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 429 || _la === 499)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 15195;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1217 || _la === 2255) {
+                {
+                this.state = 15194;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1217 || _la === 2255)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 15213;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNIQUE:
+                {
+                this.state = 15197;
+                this.match(PlSqlParser.UNIQUE);
+                this.state = 15198;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15199;
+                this.column_name();
+                this.state = 15204;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15200;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15201;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 15206;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15207;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.PRIMARY:
+                {
+                this.state = 15209;
+                this.match(PlSqlParser.PRIMARY);
+                this.state = 15210;
+                this.match(PlSqlParser.KEY);
+                }
+                break;
+            case PlSqlParser.CONSTRAINT:
+                {
+                this.state = 15211;
+                this.match(PlSqlParser.CONSTRAINT);
+                this.state = 15212;
+                this.constraint_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 15216;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2015, this.context) ) {
+            case 1:
+                {
+                this.state = 15215;
+                this.using_index_clause();
+                }
+                break;
+            }
+            this.state = 15219;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2016, this.context) ) {
+            case 1:
+                {
+                this.state = 15218;
+                this.exceptions_clause();
+                }
+                break;
+            }
+            this.state = 15222;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2017, this.context) ) {
+            case 1:
+                {
+                this.state = 15221;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            this.state = 15226;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2018, this.context) ) {
+            case 1:
+                {
+                this.state = 15224;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 469 || _la === 815)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 15225;
+                this.match(PlSqlParser.INDEX);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_index_clause(): Using_index_clauseContext {
+        let localContext = new Using_index_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1604, PlSqlParser.RULE_using_index_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15228;
+            this.match(PlSqlParser.USING);
+            this.state = 15229;
+            this.match(PlSqlParser.INDEX);
+            this.state = 15236;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2019, this.context) ) {
+            case 1:
+                {
+                this.state = 15230;
+                this.index_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 15231;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15232;
+                this.create_index();
+                this.state = 15233;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                {
+                this.state = 15235;
+                this.index_properties();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_attributes(): Index_attributesContext {
+        let localContext = new Index_attributesContext(this.context, this.state);
+        this.enterRule(localContext, 1606, PlSqlParser.RULE_index_attributes);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15251;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 15251;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.PCTFREE:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.STORAGE:
+                        {
+                        this.state = 15238;
+                        this.physical_attributes_clause();
+                        }
+                        break;
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.NOLOGGING:
+                        {
+                        this.state = 15239;
+                        this.logging_clause();
+                        }
+                        break;
+                    case PlSqlParser.ONLINE:
+                        {
+                        this.state = 15240;
+                        this.match(PlSqlParser.ONLINE);
+                        }
+                        break;
+                    case PlSqlParser.TABLESPACE:
+                        {
+                        this.state = 15241;
+                        this.match(PlSqlParser.TABLESPACE);
+                        this.state = 15244;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.ABORT:
+                        case PlSqlParser.ABS:
+                        case PlSqlParser.ABSENT:
+                        case PlSqlParser.ACCESS:
+                        case PlSqlParser.ACCESSED:
+                        case PlSqlParser.ACCESSIBLE:
+                        case PlSqlParser.ACCOUNT:
+                        case PlSqlParser.ACL:
+                        case PlSqlParser.ACOS:
+                        case PlSqlParser.ACROSS:
+                        case PlSqlParser.ACTION:
+                        case PlSqlParser.ACTIONS:
+                        case PlSqlParser.ACTIVATE:
+                        case PlSqlParser.ACTIVE:
+                        case PlSqlParser.ACTIVE_COMPONENT:
+                        case PlSqlParser.ACTIVE_DATA:
+                        case PlSqlParser.ACTIVE_FUNCTION:
+                        case PlSqlParser.ACTIVE_TAG:
+                        case PlSqlParser.ACTIVITY:
+                        case PlSqlParser.ADAPTIVE_PLAN:
+                        case PlSqlParser.ADD:
+                        case PlSqlParser.ADD_COLUMN:
+                        case PlSqlParser.ADD_GROUP:
+                        case PlSqlParser.ADD_MONTHS:
+                        case PlSqlParser.ADJ_DATE:
+                        case PlSqlParser.ADMIN:
+                        case PlSqlParser.ADMINISTER:
+                        case PlSqlParser.ADMINISTRATOR:
+                        case PlSqlParser.ADVANCED:
+                        case PlSqlParser.ADVISE:
+                        case PlSqlParser.ADVISOR:
+                        case PlSqlParser.AFD_DISKSTRING:
+                        case PlSqlParser.AFTER:
+                        case PlSqlParser.AGENT:
+                        case PlSqlParser.AGGREGATE:
+                        case PlSqlParser.A_LETTER:
+                        case PlSqlParser.ALIAS:
+                        case PlSqlParser.ALLOCATE:
+                        case PlSqlParser.ALLOW:
+                        case PlSqlParser.ALL_ROWS:
+                        case PlSqlParser.ALTERNATE:
+                        case PlSqlParser.ALWAYS:
+                        case PlSqlParser.ANALYTIC:
+                        case PlSqlParser.ANALYZE:
+                        case PlSqlParser.ANCESTOR:
+                        case PlSqlParser.ANCILLARY:
+                        case PlSqlParser.AND_EQUAL:
+                        case PlSqlParser.ANOMALY:
+                        case PlSqlParser.ANSI_REARCH:
+                        case PlSqlParser.ANTIJOIN:
+                        case PlSqlParser.ANYSCHEMA:
+                        case PlSqlParser.APPEND:
+                        case PlSqlParser.APPENDCHILDXML:
+                        case PlSqlParser.APPEND_VALUES:
+                        case PlSqlParser.APPLICATION:
+                        case PlSqlParser.APPLY:
+                        case PlSqlParser.APPROX_COUNT_DISTINCT:
+                        case PlSqlParser.ARCHIVAL:
+                        case PlSqlParser.ARCHIVE:
+                        case PlSqlParser.ARCHIVED:
+                        case PlSqlParser.ARCHIVELOG:
+                        case PlSqlParser.ARRAY:
+                        case PlSqlParser.ASCII:
+                        case PlSqlParser.ASCIISTR:
+                        case PlSqlParser.ASIN:
+                        case PlSqlParser.ASIS:
+                        case PlSqlParser.ASSEMBLY:
+                        case PlSqlParser.ASSIGN:
+                        case PlSqlParser.ASSOCIATE:
+                        case PlSqlParser.ASYNC:
+                        case PlSqlParser.ASYNCHRONOUS:
+                        case PlSqlParser.ATAN2:
+                        case PlSqlParser.ATAN:
+                        case PlSqlParser.AT:
+                        case PlSqlParser.ATTRIBUTE:
+                        case PlSqlParser.ATTRIBUTES:
+                        case PlSqlParser.AUDIT:
+                        case PlSqlParser.AUTHENTICATED:
+                        case PlSqlParser.AUTHENTICATION:
+                        case PlSqlParser.AUTHID:
+                        case PlSqlParser.AUTHORIZATION:
+                        case PlSqlParser.AUTOALLOCATE:
+                        case PlSqlParser.AUTO:
+                        case PlSqlParser.AUTOEXTEND:
+                        case PlSqlParser.AUTO_LOGIN:
+                        case PlSqlParser.AUTOMATIC:
+                        case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                        case PlSqlParser.AUTO_REOPTIMIZE:
+                        case PlSqlParser.AVAILABILITY:
+                        case PlSqlParser.AVRO:
+                        case PlSqlParser.BACKGROUND:
+                        case PlSqlParser.BACKINGFILE:
+                        case PlSqlParser.BACKUP:
+                        case PlSqlParser.BACKUPS:
+                        case PlSqlParser.BASIC:
+                        case PlSqlParser.BASICFILE:
+                        case PlSqlParser.BATCH:
+                        case PlSqlParser.BATCHSIZE:
+                        case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                        case PlSqlParser.BECOME:
+                        case PlSqlParser.BEFORE:
+                        case PlSqlParser.BEGIN:
+                        case PlSqlParser.BEGINNING:
+                        case PlSqlParser.BEGIN_OUTLINE_DATA:
+                        case PlSqlParser.BEHALF:
+                        case PlSqlParser.BEQUEATH:
+                        case PlSqlParser.BFILE:
+                        case PlSqlParser.BFILENAME:
+                        case PlSqlParser.BIGFILE:
+                        case PlSqlParser.BINARY:
+                        case PlSqlParser.BINARY_DOUBLE:
+                        case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                        case PlSqlParser.BINARY_DOUBLE_NAN:
+                        case PlSqlParser.BINARY_FLOAT:
+                        case PlSqlParser.BINARY_FLOAT_INFINITY:
+                        case PlSqlParser.BINARY_FLOAT_NAN:
+                        case PlSqlParser.BINARY_INTEGER:
+                        case PlSqlParser.BIND_AWARE:
+                        case PlSqlParser.BINDING:
+                        case PlSqlParser.BIN_TO_NUM:
+                        case PlSqlParser.BITAND:
+                        case PlSqlParser.BITMAP_AND:
+                        case PlSqlParser.BITMAP:
+                        case PlSqlParser.BITMAPS:
+                        case PlSqlParser.BITMAP_TREE:
+                        case PlSqlParser.BITS:
+                        case PlSqlParser.BLOB:
+                        case PlSqlParser.BLOCK:
+                        case PlSqlParser.BLOCK_RANGE:
+                        case PlSqlParser.BLOCKS:
+                        case PlSqlParser.BLOCKSIZE:
+                        case PlSqlParser.BODY:
+                        case PlSqlParser.BOOLEAN:
+                        case PlSqlParser.BOTH:
+                        case PlSqlParser.BOUND:
+                        case PlSqlParser.BRANCH:
+                        case PlSqlParser.BREADTH:
+                        case PlSqlParser.BROADCAST:
+                        case PlSqlParser.BSON:
+                        case PlSqlParser.BUFFER:
+                        case PlSqlParser.BUFFER_CACHE:
+                        case PlSqlParser.BUFFER_POOL:
+                        case PlSqlParser.BUILD:
+                        case PlSqlParser.BULK:
+                        case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                        case PlSqlParser.BYPASS_UJVC:
+                        case PlSqlParser.BYTE:
+                        case PlSqlParser.BYTES:
+                        case PlSqlParser.CACHE:
+                        case PlSqlParser.CACHE_CB:
+                        case PlSqlParser.CACHE_INSTANCES:
+                        case PlSqlParser.CACHE_TEMP_TABLE:
+                        case PlSqlParser.CACHING:
+                        case PlSqlParser.CALCULATED:
+                        case PlSqlParser.CALLBACK:
+                        case PlSqlParser.CALL:
+                        case PlSqlParser.CANCEL:
+                        case PlSqlParser.CAPACITY:
+                        case PlSqlParser.CAPTION:
+                        case PlSqlParser.CARDINALITY:
+                        case PlSqlParser.CASCADE:
+                        case PlSqlParser.CASE:
+                        case PlSqlParser.CAST:
+                        case PlSqlParser.CASESENSITIVE:
+                        case PlSqlParser.CATEGORY:
+                        case PlSqlParser.CDBDEFAULT:
+                        case PlSqlParser.CEIL:
+                        case PlSqlParser.CELL_FLASH_CACHE:
+                        case PlSqlParser.CERTIFICATE:
+                        case PlSqlParser.CFILE:
+                        case PlSqlParser.CHAINED:
+                        case PlSqlParser.CHANGE:
+                        case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                        case PlSqlParser.CHARACTER:
+                        case PlSqlParser.CHARACTERSET:
+                        case PlSqlParser.CHAR:
+                        case PlSqlParser.CHAR_CS:
+                        case PlSqlParser.CHARTOROWID:
+                        case PlSqlParser.CHECK_ACL_REWRITE:
+                        case PlSqlParser.CHECKPOINT:
+                        case PlSqlParser.CHILD:
+                        case PlSqlParser.CHOOSE:
+                        case PlSqlParser.CHR:
+                        case PlSqlParser.CHUNK:
+                        case PlSqlParser.CLASS:
+                        case PlSqlParser.CLASSIFICATION:
+                        case PlSqlParser.CLASSIFIER:
+                        case PlSqlParser.CLAUSE:
+                        case PlSqlParser.CLEAN:
+                        case PlSqlParser.CLEANUP:
+                        case PlSqlParser.CLEAR:
+                        case PlSqlParser.C_LETTER:
+                        case PlSqlParser.CLIENT:
+                        case PlSqlParser.CLOB:
+                        case PlSqlParser.CLONE:
+                        case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                        case PlSqlParser.CLOSE:
+                        case PlSqlParser.CLUSTER_BY_ROWID:
+                        case PlSqlParser.CLUSTER:
+                        case PlSqlParser.CLUSTER_DETAILS:
+                        case PlSqlParser.CLUSTER_DISTANCE:
+                        case PlSqlParser.CLUSTER_ID:
+                        case PlSqlParser.CLUSTERING:
+                        case PlSqlParser.CLUSTERING_FACTOR:
+                        case PlSqlParser.CLUSTER_PROBABILITY:
+                        case PlSqlParser.CLUSTER_SET:
+                        case PlSqlParser.COALESCE:
+                        case PlSqlParser.COALESCE_SQ:
+                        case PlSqlParser.COARSE:
+                        case PlSqlParser.CO_AUTH_IND:
+                        case PlSqlParser.COLD:
+                        case PlSqlParser.COLLECT:
+                        case PlSqlParser.COLUMNAR:
+                        case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                        case PlSqlParser.COLUMN:
+                        case PlSqlParser.COLUMNS:
+                        case PlSqlParser.COLUMN_STATS:
+                        case PlSqlParser.COLUMN_VALUE:
+                        case PlSqlParser.COMMENT:
+                        case PlSqlParser.COMMIT:
+                        case PlSqlParser.COMMITTED:
+                        case PlSqlParser.COMMON:
+                        case PlSqlParser.COMMON_DATA:
+                        case PlSqlParser.COMPACT:
+                        case PlSqlParser.COMPATIBILITY:
+                        case PlSqlParser.COMPILE:
+                        case PlSqlParser.COMPLETE:
+                        case PlSqlParser.COMPLIANCE:
+                        case PlSqlParser.COMPONENT:
+                        case PlSqlParser.COMPONENTS:
+                        case PlSqlParser.COMPOSE:
+                        case PlSqlParser.COMPOSITE:
+                        case PlSqlParser.COMPOSITE_LIMIT:
+                        case PlSqlParser.COMPOUND:
+                        case PlSqlParser.COMPUTE:
+                        case PlSqlParser.CONCAT:
+                        case PlSqlParser.CON_DBID_TO_ID:
+                        case PlSqlParser.CONDITIONAL:
+                        case PlSqlParser.CONDITION:
+                        case PlSqlParser.CONFIRM:
+                        case PlSqlParser.CONFORMING:
+                        case PlSqlParser.CON_GUID_TO_ID:
+                        case PlSqlParser.CON_ID:
+                        case PlSqlParser.CON_NAME_TO_ID:
+                        case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                        case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                        case PlSqlParser.CONNECT_BY_COST_BASED:
+                        case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                        case PlSqlParser.CONNECT_BY_FILTERING:
+                        case PlSqlParser.CONNECT_BY_ISCYCLE:
+                        case PlSqlParser.CONNECT_BY_ISLEAF:
+                        case PlSqlParser.CONNECT_BY_ROOT:
+                        case PlSqlParser.CONNECT_TIME:
+                        case PlSqlParser.CONSIDER:
+                        case PlSqlParser.CONSISTENT:
+                        case PlSqlParser.CONSTANT:
+                        case PlSqlParser.CONST:
+                        case PlSqlParser.CONSTRAINT:
+                        case PlSqlParser.CONSTRAINTS:
+                        case PlSqlParser.CONSTRUCTOR:
+                        case PlSqlParser.CONTAINER:
+                        case PlSqlParser.CONTAINERS:
+                        case PlSqlParser.CONTAINERS_DEFAULT:
+                        case PlSqlParser.CONTAINER_DATA:
+                        case PlSqlParser.CONTAINER_MAP:
+                        case PlSqlParser.CONTENT:
+                        case PlSqlParser.CONTENTS:
+                        case PlSqlParser.CONTEXT:
+                        case PlSqlParser.CONTINUE:
+                        case PlSqlParser.CONTROLFILE:
+                        case PlSqlParser.CON_UID_TO_ID:
+                        case PlSqlParser.CONVERT:
+                        case PlSqlParser.CONVERSION:
+                        case PlSqlParser.COOKIE:
+                        case PlSqlParser.COPY:
+                        case PlSqlParser.CORR_K:
+                        case PlSqlParser.CORR_S:
+                        case PlSqlParser.CORRUPTION:
+                        case PlSqlParser.CORRUPT_XID_ALL:
+                        case PlSqlParser.CORRUPT_XID:
+                        case PlSqlParser.COS:
+                        case PlSqlParser.COSH:
+                        case PlSqlParser.COST:
+                        case PlSqlParser.COST_XML_QUERY_REWRITE:
+                        case PlSqlParser.COUNT:
+                        case PlSqlParser.COUNTED:
+                        case PlSqlParser.COVAR_POP:
+                        case PlSqlParser.COVAR_SAMP:
+                        case PlSqlParser.CPU_COSTING:
+                        case PlSqlParser.CPU_PER_CALL:
+                        case PlSqlParser.CPU_PER_SESSION:
+                        case PlSqlParser.CRASH:
+                        case PlSqlParser.CREATE_FILE_DEST:
+                        case PlSqlParser.CREATE_STORED_OUTLINES:
+                        case PlSqlParser.CREATION:
+                        case PlSqlParser.CREDENTIAL:
+                        case PlSqlParser.CRITICAL:
+                        case PlSqlParser.CROSS:
+                        case PlSqlParser.CROSSEDITION:
+                        case PlSqlParser.CSCONVERT:
+                        case PlSqlParser.CSV:
+                        case PlSqlParser.CUBE_AJ:
+                        case PlSqlParser.CUBE:
+                        case PlSqlParser.CUBE_GB:
+                        case PlSqlParser.CUBE_SJ:
+                        case PlSqlParser.CUME_DISTM:
+                        case PlSqlParser.CURRENT:
+                        case PlSqlParser.CURRENT_DATE:
+                        case PlSqlParser.CURRENT_SCHEMA:
+                        case PlSqlParser.CURRENT_TIME:
+                        case PlSqlParser.CURRENT_TIMESTAMP:
+                        case PlSqlParser.CURRENT_USER:
+                        case PlSqlParser.CURRENTV:
+                        case PlSqlParser.CURSOR:
+                        case PlSqlParser.CURSOR_SHARING_EXACT:
+                        case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                        case PlSqlParser.CUSTOMDATUM:
+                        case PlSqlParser.CV:
+                        case PlSqlParser.CYCLE:
+                        case PlSqlParser.DANGLING:
+                        case PlSqlParser.DATABASE:
+                        case PlSqlParser.DATA:
+                        case PlSqlParser.DATAFILE:
+                        case PlSqlParser.DATAFILES:
+                        case PlSqlParser.DATAMOVEMENT:
+                        case PlSqlParser.DATAOBJNO:
+                        case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                        case PlSqlParser.DATAOBJ_TO_PARTITION:
+                        case PlSqlParser.DATAPUMP:
+                        case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                        case PlSqlParser.DATE:
+                        case PlSqlParser.DATE_FORMAT:
+                        case PlSqlParser.DATE_MODE:
+                        case PlSqlParser.DAY:
+                        case PlSqlParser.DAYS:
+                        case PlSqlParser.DBA:
+                        case PlSqlParser.DBA_RECYCLEBIN:
+                        case PlSqlParser.DBLINK:
+                        case PlSqlParser.DBMS_STATS:
+                        case PlSqlParser.DB_ROLE_CHANGE:
+                        case PlSqlParser.DBTIMEZONE:
+                        case PlSqlParser.DB_UNIQUE_NAME:
+                        case PlSqlParser.DB_VERSION:
+                        case PlSqlParser.DDL:
+                        case PlSqlParser.DEALLOCATE:
+                        case PlSqlParser.DEBUG:
+                        case PlSqlParser.DEBUGGER:
+                        case PlSqlParser.DEC:
+                        case PlSqlParser.DECIMAL:
+                        case PlSqlParser.DECLARE:
+                        case PlSqlParser.DECOMPOSE:
+                        case PlSqlParser.DECORRELATE:
+                        case PlSqlParser.DECR:
+                        case PlSqlParser.DECREMENT:
+                        case PlSqlParser.DECRYPT:
+                        case PlSqlParser.DEDUPLICATE:
+                        case PlSqlParser.DEFAULTS:
+                        case PlSqlParser.DEFAULT_COLLATION:
+                        case PlSqlParser.DEFAULT_CREDENTIAL:
+                        case PlSqlParser.DEFERRABLE:
+                        case PlSqlParser.DEFERRED:
+                        case PlSqlParser.DEFINED:
+                        case PlSqlParser.DEFINE:
+                        case PlSqlParser.DEFINER:
+                        case PlSqlParser.DEGREE:
+                        case PlSqlParser.DELAY:
+                        case PlSqlParser.DELEGATE:
+                        case PlSqlParser.DELETE_ALL:
+                        case PlSqlParser.DELETE:
+                        case PlSqlParser.DELETEXML:
+                        case PlSqlParser.DEMAND:
+                        case PlSqlParser.DENSE_RANKM:
+                        case PlSqlParser.DEPENDENT:
+                        case PlSqlParser.DEPRECATE:
+                        case PlSqlParser.DEPTH:
+                        case PlSqlParser.DEQUEUE:
+                        case PlSqlParser.DEREF:
+                        case PlSqlParser.DEREF_NO_REWRITE:
+                        case PlSqlParser.DESCRIPTION:
+                        case PlSqlParser.DESTROY:
+                        case PlSqlParser.DETACHED:
+                        case PlSqlParser.DETECTED:
+                        case PlSqlParser.DETERMINES:
+                        case PlSqlParser.DETERMINISTIC:
+                        case PlSqlParser.DICTIONARY:
+                        case PlSqlParser.DIMENSION:
+                        case PlSqlParser.DIMENSIONS:
+                        case PlSqlParser.DIRECT_LOAD:
+                        case PlSqlParser.DIRECTORY:
+                        case PlSqlParser.DIRECT_PATH:
+                        case PlSqlParser.DISABLE_ALL:
+                        case PlSqlParser.DISABLE:
+                        case PlSqlParser.DISABLED:
+                        case PlSqlParser.DISABLE_PARALLEL_DML:
+                        case PlSqlParser.DISABLE_PRESET:
+                        case PlSqlParser.DISABLE_RPKE:
+                        case PlSqlParser.DISALLOW:
+                        case PlSqlParser.DISASSOCIATE:
+                        case PlSqlParser.DISCARD:
+                        case PlSqlParser.DISCONNECT:
+                        case PlSqlParser.DISK:
+                        case PlSqlParser.DISKGROUP:
+                        case PlSqlParser.DISKS:
+                        case PlSqlParser.DISMOUNT:
+                        case PlSqlParser.DISTINGUISHED:
+                        case PlSqlParser.DISTRIBUTED:
+                        case PlSqlParser.DISTRIBUTE:
+                        case PlSqlParser.DML:
+                        case PlSqlParser.DML_UPDATE:
+                        case PlSqlParser.DOCFIDELITY:
+                        case PlSqlParser.DOCUMENT:
+                        case PlSqlParser.DOMAIN_INDEX_FILTER:
+                        case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                        case PlSqlParser.DOMAIN_INDEX_SORT:
+                        case PlSqlParser.DOUBLE:
+                        case PlSqlParser.DOWNGRADE:
+                        case PlSqlParser.DRIVING_SITE:
+                        case PlSqlParser.DROP_COLUMN:
+                        case PlSqlParser.DROP_GROUP:
+                        case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                        case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                        case PlSqlParser.DUMP:
+                        case PlSqlParser.DUPLICATE:
+                        case PlSqlParser.DV:
+                        case PlSqlParser.DYNAMIC:
+                        case PlSqlParser.DYNAMIC_SAMPLING:
+                        case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                        case PlSqlParser.E_LETTER:
+                        case PlSqlParser.EACH:
+                        case PlSqlParser.EDITIONABLE:
+                        case PlSqlParser.EDITION:
+                        case PlSqlParser.EDITIONING:
+                        case PlSqlParser.EDITIONS:
+                        case PlSqlParser.ELEMENT:
+                        case PlSqlParser.ELIM_GROUPBY:
+                        case PlSqlParser.ELIMINATE_JOIN:
+                        case PlSqlParser.ELIMINATE_OBY:
+                        case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                        case PlSqlParser.EM:
+                        case PlSqlParser.EMPTY_BLOB:
+                        case PlSqlParser.EMPTY_CLOB:
+                        case PlSqlParser.EMPTY_:
+                        case PlSqlParser.ENABLE_ALL:
+                        case PlSqlParser.ENABLE:
+                        case PlSqlParser.ENABLED:
+                        case PlSqlParser.ENABLE_PARALLEL_DML:
+                        case PlSqlParser.ENABLE_PRESET:
+                        case PlSqlParser.ENCLOSED:
+                        case PlSqlParser.ENCODING:
+                        case PlSqlParser.ENCRYPT:
+                        case PlSqlParser.ENCRYPTION:
+                        case PlSqlParser.END_OUTLINE_DATA:
+                        case PlSqlParser.ENFORCED:
+                        case PlSqlParser.ENFORCE:
+                        case PlSqlParser.ENQUEUE:
+                        case PlSqlParser.ENTERPRISE:
+                        case PlSqlParser.ENTITYESCAPING:
+                        case PlSqlParser.ENTRY:
+                        case PlSqlParser.EQUIPART:
+                        case PlSqlParser.ERR:
+                        case PlSqlParser.ERROR_ARGUMENT:
+                        case PlSqlParser.ERROR:
+                        case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                        case PlSqlParser.ERRORS:
+                        case PlSqlParser.ERROR_INDEX:
+                        case PlSqlParser.ERROR_CODE:
+                        case PlSqlParser.ESCAPE:
+                        case PlSqlParser.ESTIMATE:
+                        case PlSqlParser.EVAL:
+                        case PlSqlParser.EVALNAME:
+                        case PlSqlParser.EVALUATE:
+                        case PlSqlParser.EVALUATION:
+                        case PlSqlParser.EVENTS:
+                        case PlSqlParser.EVERY:
+                        case PlSqlParser.EXCEPT:
+                        case PlSqlParser.EXCEPTION:
+                        case PlSqlParser.EXCEPTION_INIT:
+                        case PlSqlParser.EXCEPTIONS:
+                        case PlSqlParser.EXCHANGE:
+                        case PlSqlParser.EXCLUDE:
+                        case PlSqlParser.EXCLUDING:
+                        case PlSqlParser.EXEC:
+                        case PlSqlParser.EXECUTE:
+                        case PlSqlParser.EXEMPT:
+                        case PlSqlParser.EXISTING:
+                        case PlSqlParser.EXISTS:
+                        case PlSqlParser.EXISTSNODE:
+                        case PlSqlParser.EXIT:
+                        case PlSqlParser.EXPAND_GSET_TO_UNION:
+                        case PlSqlParser.EXPAND_TABLE:
+                        case PlSqlParser.EXP:
+                        case PlSqlParser.EXPIRE:
+                        case PlSqlParser.EXPLAIN:
+                        case PlSqlParser.EXPLOSION:
+                        case PlSqlParser.EXPORT:
+                        case PlSqlParser.EXPR_CORR_CHECK:
+                        case PlSqlParser.EXPRESS:
+                        case PlSqlParser.EXTENDS:
+                        case PlSqlParser.EXTENT:
+                        case PlSqlParser.EXTENTS:
+                        case PlSqlParser.EXTERNAL:
+                        case PlSqlParser.EXTERNALLY:
+                        case PlSqlParser.EXTRACTCLOBXML:
+                        case PlSqlParser.EXTRACT:
+                        case PlSqlParser.EXTRACTVALUE:
+                        case PlSqlParser.EXTRA:
+                        case PlSqlParser.FACILITY:
+                        case PlSqlParser.FACT:
+                        case PlSqlParser.FACTOR:
+                        case PlSqlParser.FACTORIZE_JOIN:
+                        case PlSqlParser.FAILED:
+                        case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                        case PlSqlParser.FAILGROUP:
+                        case PlSqlParser.FAILOVER:
+                        case PlSqlParser.FAILURE:
+                        case PlSqlParser.FALSE:
+                        case PlSqlParser.FAMILY:
+                        case PlSqlParser.FAR:
+                        case PlSqlParser.FAST:
+                        case PlSqlParser.FASTSTART:
+                        case PlSqlParser.FBTSCAN:
+                        case PlSqlParser.FEATURE:
+                        case PlSqlParser.FEATURE_DETAILS:
+                        case PlSqlParser.FEATURE_ID:
+                        case PlSqlParser.FEATURE_SET:
+                        case PlSqlParser.FEATURE_VALUE:
+                        case PlSqlParser.FETCH:
+                        case PlSqlParser.FIELD:
+                        case PlSqlParser.FIELDS:
+                        case PlSqlParser.FILE:
+                        case PlSqlParser.FILE_NAME_CONVERT:
+                        case PlSqlParser.FILEGROUP:
+                        case PlSqlParser.FILESTORE:
+                        case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                        case PlSqlParser.FILTER:
+                        case PlSqlParser.FINAL:
+                        case PlSqlParser.FINE:
+                        case PlSqlParser.FINISH:
+                        case PlSqlParser.FIRST:
+                        case PlSqlParser.FIRSTM:
+                        case PlSqlParser.FIRST_ROWS:
+                        case PlSqlParser.FIRST_VALUE:
+                        case PlSqlParser.FIXED_VIEW_DATA:
+                        case PlSqlParser.FLAGGER:
+                        case PlSqlParser.FLASHBACK:
+                        case PlSqlParser.FLASH_CACHE:
+                        case PlSqlParser.FLOAT:
+                        case PlSqlParser.FLOB:
+                        case PlSqlParser.FLEX:
+                        case PlSqlParser.FLOOR:
+                        case PlSqlParser.FLUSH:
+                        case PlSqlParser.FOLDER:
+                        case PlSqlParser.FOLLOWING:
+                        case PlSqlParser.FOLLOWS:
+                        case PlSqlParser.FORALL:
+                        case PlSqlParser.FORCE:
+                        case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                        case PlSqlParser.FOREIGN:
+                        case PlSqlParser.FOREVER:
+                        case PlSqlParser.FORMAT:
+                        case PlSqlParser.FORWARD:
+                        case PlSqlParser.FRAGMENT_NUMBER:
+                        case PlSqlParser.FREELIST:
+                        case PlSqlParser.FREELISTS:
+                        case PlSqlParser.FREEPOOLS:
+                        case PlSqlParser.FRESH:
+                        case PlSqlParser.FROM_TZ:
+                        case PlSqlParser.FULL:
+                        case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                        case PlSqlParser.FUNCTION:
+                        case PlSqlParser.FUNCTIONS:
+                        case PlSqlParser.FTP:
+                        case PlSqlParser.G_LETTER:
+                        case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                        case PlSqlParser.GATHER_PLAN_STATISTICS:
+                        case PlSqlParser.GBY_CONC_ROLLUP:
+                        case PlSqlParser.GBY_PUSHDOWN:
+                        case PlSqlParser.GENERATED:
+                        case PlSqlParser.GET:
+                        case PlSqlParser.GLOBAL:
+                        case PlSqlParser.GLOBALLY:
+                        case PlSqlParser.GLOBAL_NAME:
+                        case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                        case PlSqlParser.GROUP_BY:
+                        case PlSqlParser.GROUP_ID:
+                        case PlSqlParser.GROUPING:
+                        case PlSqlParser.GROUPING_ID:
+                        case PlSqlParser.GROUPS:
+                        case PlSqlParser.GUARANTEED:
+                        case PlSqlParser.GUARANTEE:
+                        case PlSqlParser.GUARD:
+                        case PlSqlParser.HALF_YEARS:
+                        case PlSqlParser.HASH_AJ:
+                        case PlSqlParser.HASH:
+                        case PlSqlParser.HASHKEYS:
+                        case PlSqlParser.HASH_SJ:
+                        case PlSqlParser.HEADER:
+                        case PlSqlParser.HEAP:
+                        case PlSqlParser.HELP:
+                        case PlSqlParser.HEXTORAW:
+                        case PlSqlParser.HEXTOREF:
+                        case PlSqlParser.HIDDEN_KEYWORD:
+                        case PlSqlParser.HIDE:
+                        case PlSqlParser.HIER_ORDER:
+                        case PlSqlParser.HIERARCHICAL:
+                        case PlSqlParser.HIERARCHY:
+                        case PlSqlParser.HIGH:
+                        case PlSqlParser.HINTSET_BEGIN:
+                        case PlSqlParser.HINTSET_END:
+                        case PlSqlParser.HOT:
+                        case PlSqlParser.HOUR:
+                        case PlSqlParser.HOURS:
+                        case PlSqlParser.HTTP:
+                        case PlSqlParser.HWM_BROKERED:
+                        case PlSqlParser.HYBRID:
+                        case PlSqlParser.H_LETTER:
+                        case PlSqlParser.IDENTIFIER:
+                        case PlSqlParser.IDENTITY:
+                        case PlSqlParser.IDGENERATORS:
+                        case PlSqlParser.ID:
+                        case PlSqlParser.IDLE_TIME:
+                        case PlSqlParser.IF:
+                        case PlSqlParser.IGNORE:
+                        case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                        case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                        case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                        case PlSqlParser.ILM:
+                        case PlSqlParser.IMMEDIATE:
+                        case PlSqlParser.IMPACT:
+                        case PlSqlParser.IMPORT:
+                        case PlSqlParser.INACTIVE:
+                        case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                        case PlSqlParser.INCLUDE:
+                        case PlSqlParser.INCLUDE_VERSION:
+                        case PlSqlParser.INCLUDING:
+                        case PlSqlParser.INCREMENTAL:
+                        case PlSqlParser.INCREMENT:
+                        case PlSqlParser.INCR:
+                        case PlSqlParser.INDENT:
+                        case PlSqlParser.INDEX_ASC:
+                        case PlSqlParser.INDEX_COMBINE:
+                        case PlSqlParser.INDEX_DESC:
+                        case PlSqlParser.INDEXED:
+                        case PlSqlParser.INDEXES:
+                        case PlSqlParser.INDEX_FFS:
+                        case PlSqlParser.INDEX_FILTER:
+                        case PlSqlParser.INDEXING:
+                        case PlSqlParser.INDEX_JOIN:
+                        case PlSqlParser.INDEX_ROWS:
+                        case PlSqlParser.INDEX_RRS:
+                        case PlSqlParser.INDEX_RS_ASC:
+                        case PlSqlParser.INDEX_RS_DESC:
+                        case PlSqlParser.INDEX_RS:
+                        case PlSqlParser.INDEX_SCAN:
+                        case PlSqlParser.INDEX_SKIP_SCAN:
+                        case PlSqlParser.INDEX_SS_ASC:
+                        case PlSqlParser.INDEX_SS_DESC:
+                        case PlSqlParser.INDEX_SS:
+                        case PlSqlParser.INDEX_STATS:
+                        case PlSqlParser.INDEXTYPE:
+                        case PlSqlParser.INDEXTYPES:
+                        case PlSqlParser.INDICATOR:
+                        case PlSqlParser.INDICES:
+                        case PlSqlParser.INFINITE:
+                        case PlSqlParser.INFORMATIONAL:
+                        case PlSqlParser.INHERIT:
+                        case PlSqlParser.INITCAP:
+                        case PlSqlParser.INITIAL:
+                        case PlSqlParser.INITIALIZED:
+                        case PlSqlParser.INITIALLY:
+                        case PlSqlParser.INITRANS:
+                        case PlSqlParser.INLINE:
+                        case PlSqlParser.INLINE_XMLTYPE_NT:
+                        case PlSqlParser.INMEMORY:
+                        case PlSqlParser.IN_MEMORY_METADATA:
+                        case PlSqlParser.INMEMORY_PRUNING:
+                        case PlSqlParser.INNER:
+                        case PlSqlParser.INOUT:
+                        case PlSqlParser.INPLACE:
+                        case PlSqlParser.INSERTCHILDXMLAFTER:
+                        case PlSqlParser.INSERTCHILDXMLBEFORE:
+                        case PlSqlParser.INSERTCHILDXML:
+                        case PlSqlParser.INSERTXMLAFTER:
+                        case PlSqlParser.INSERTXMLBEFORE:
+                        case PlSqlParser.INSTANCE:
+                        case PlSqlParser.INSTANCES:
+                        case PlSqlParser.INSTANTIABLE:
+                        case PlSqlParser.INSTANTLY:
+                        case PlSqlParser.INSTEAD:
+                        case PlSqlParser.INSTR2:
+                        case PlSqlParser.INSTR4:
+                        case PlSqlParser.INSTRB:
+                        case PlSqlParser.INSTRC:
+                        case PlSqlParser.INSTR:
+                        case PlSqlParser.INTEGER:
+                        case PlSqlParser.INTERLEAVED:
+                        case PlSqlParser.INTERMEDIATE:
+                        case PlSqlParser.INTERNAL_CONVERT:
+                        case PlSqlParser.INTERNAL_USE:
+                        case PlSqlParser.INTERPRETED:
+                        case PlSqlParser.INTERVAL:
+                        case PlSqlParser.INT:
+                        case PlSqlParser.INTERNAL:
+                        case PlSqlParser.INVALIDATE:
+                        case PlSqlParser.INVALIDATION:
+                        case PlSqlParser.INVISIBLE:
+                        case PlSqlParser.IN_XQUERY:
+                        case PlSqlParser.IS_LEAF:
+                        case PlSqlParser.ISOLATION:
+                        case PlSqlParser.ISOLATION_LEVEL:
+                        case PlSqlParser.ITEMS:
+                        case PlSqlParser.ITERATE:
+                        case PlSqlParser.ITERATION_NUMBER:
+                        case PlSqlParser.JAVA:
+                        case PlSqlParser.JOB:
+                        case PlSqlParser.JOIN:
+                        case PlSqlParser.JSON_ARRAYAGG:
+                        case PlSqlParser.JSON_ARRAY:
+                        case PlSqlParser.JSON_EQUAL:
+                        case PlSqlParser.JSON_EXISTS2:
+                        case PlSqlParser.JSON_EXISTS:
+                        case PlSqlParser.JSONGET:
+                        case PlSqlParser.JSON:
+                        case PlSqlParser.JSON_OBJECTAGG:
+                        case PlSqlParser.JSON_OBJECT:
+                        case PlSqlParser.JSONPARSE:
+                        case PlSqlParser.JSON_QUERY:
+                        case PlSqlParser.JSON_SERIALIZE:
+                        case PlSqlParser.JSON_TABLE:
+                        case PlSqlParser.JSON_TEXTCONTAINS2:
+                        case PlSqlParser.JSON_TEXTCONTAINS:
+                        case PlSqlParser.JSON_TRANSFORM:
+                        case PlSqlParser.JSON_VALUE:
+                        case PlSqlParser.K_LETTER:
+                        case PlSqlParser.KEEP_DUPLICATES:
+                        case PlSqlParser.KEEP:
+                        case PlSqlParser.KERBEROS:
+                        case PlSqlParser.KEY:
+                        case PlSqlParser.KEY_LENGTH:
+                        case PlSqlParser.KEYSIZE:
+                        case PlSqlParser.KEYS:
+                        case PlSqlParser.KEYSTORE:
+                        case PlSqlParser.KILL:
+                        case PlSqlParser.LABEL:
+                        case PlSqlParser.LANGUAGE:
+                        case PlSqlParser.LAST_DAY:
+                        case PlSqlParser.LAST:
+                        case PlSqlParser.LAST_VALUE:
+                        case PlSqlParser.LATERAL:
+                        case PlSqlParser.LAX:
+                        case PlSqlParser.LAYER:
+                        case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                        case PlSqlParser.LDAP_REGISTRATION:
+                        case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                        case PlSqlParser.LEAF:
+                        case PlSqlParser.LEAD_CDB:
+                        case PlSqlParser.LEAD_CDB_URI:
+                        case PlSqlParser.LEADING:
+                        case PlSqlParser.LEFT:
+                        case PlSqlParser.LENGTH2:
+                        case PlSqlParser.LENGTH4:
+                        case PlSqlParser.LENGTHB:
+                        case PlSqlParser.LENGTHC:
+                        case PlSqlParser.LENGTH:
+                        case PlSqlParser.LESS:
+                        case PlSqlParser.LEVEL:
+                        case PlSqlParser.LEVEL_NAME:
+                        case PlSqlParser.LEVELS:
+                        case PlSqlParser.LIBRARY:
+                        case PlSqlParser.LIFECYCLE:
+                        case PlSqlParser.LIFE:
+                        case PlSqlParser.LIFETIME:
+                        case PlSqlParser.LIKE2:
+                        case PlSqlParser.LIKE4:
+                        case PlSqlParser.LIKEC:
+                        case PlSqlParser.LIKE_EXPAND:
+                        case PlSqlParser.LIMIT:
+                        case PlSqlParser.LINEAR:
+                        case PlSqlParser.LINES:
+                        case PlSqlParser.LINK:
+                        case PlSqlParser.LIST:
+                        case PlSqlParser.LN:
+                        case PlSqlParser.LNNVL:
+                        case PlSqlParser.LOAD:
+                        case PlSqlParser.LOB:
+                        case PlSqlParser.LOBNVL:
+                        case PlSqlParser.LOBS:
+                        case PlSqlParser.LOCAL_INDEXES:
+                        case PlSqlParser.LOCAL:
+                        case PlSqlParser.LOCALTIME:
+                        case PlSqlParser.LOCALTIMESTAMP:
+                        case PlSqlParser.LOCATION:
+                        case PlSqlParser.LOCATOR:
+                        case PlSqlParser.LOCKDOWN:
+                        case PlSqlParser.LOCKED:
+                        case PlSqlParser.LOCKING:
+                        case PlSqlParser.LOGFILE:
+                        case PlSqlParser.LOGFILES:
+                        case PlSqlParser.LOGGING:
+                        case PlSqlParser.LOGICAL:
+                        case PlSqlParser.LOGICAL_READS_PER_CALL:
+                        case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                        case PlSqlParser.LOG:
+                        case PlSqlParser.LOGMINING:
+                        case PlSqlParser.LOGOFF:
+                        case PlSqlParser.LOGON:
+                        case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                        case PlSqlParser.LONG:
+                        case PlSqlParser.LOOP:
+                        case PlSqlParser.LOST:
+                        case PlSqlParser.LOWER:
+                        case PlSqlParser.LOW:
+                        case PlSqlParser.LPAD:
+                        case PlSqlParser.LTRIM:
+                        case PlSqlParser.M_LETTER:
+                        case PlSqlParser.MAIN:
+                        case PlSqlParser.MAKE_REF:
+                        case PlSqlParser.MANAGED:
+                        case PlSqlParser.MANAGE:
+                        case PlSqlParser.MANAGEMENT:
+                        case PlSqlParser.MANAGER:
+                        case PlSqlParser.MANDATORY:
+                        case PlSqlParser.MANUAL:
+                        case PlSqlParser.MAP:
+                        case PlSqlParser.MAPPING:
+                        case PlSqlParser.MASK:
+                        case PlSqlParser.MASTER:
+                        case PlSqlParser.MATCHED:
+                        case PlSqlParser.MATCHES:
+                        case PlSqlParser.MATCH:
+                        case PlSqlParser.MATCH_NUMBER:
+                        case PlSqlParser.MATCH_RECOGNIZE:
+                        case PlSqlParser.MATERIALIZED:
+                        case PlSqlParser.MATERIALIZE:
+                        case PlSqlParser.MAXARCHLOGS:
+                        case PlSqlParser.MAXDATAFILES:
+                        case PlSqlParser.MAXEXTENTS:
+                        case PlSqlParser.MAXIMIZE:
+                        case PlSqlParser.MAXINSTANCES:
+                        case PlSqlParser.MAXLOGFILES:
+                        case PlSqlParser.MAXLOGHISTORY:
+                        case PlSqlParser.MAXLOGMEMBERS:
+                        case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                        case PlSqlParser.MAXSIZE:
+                        case PlSqlParser.MAXTRANS:
+                        case PlSqlParser.MAXVALUE:
+                        case PlSqlParser.MEASURE:
+                        case PlSqlParser.MEASURES:
+                        case PlSqlParser.MEDIUM:
+                        case PlSqlParser.MEMBER:
+                        case PlSqlParser.MEMBER_CAPTION:
+                        case PlSqlParser.MEMBER_DESCRIPTION:
+                        case PlSqlParser.MEMBER_NAME:
+                        case PlSqlParser.MEMBER_UNIQUE_NAME:
+                        case PlSqlParser.MEMCOMPRESS:
+                        case PlSqlParser.MEMORY:
+                        case PlSqlParser.MERGEACTIONS:
+                        case PlSqlParser.MERGE_AJ:
+                        case PlSqlParser.MERGE_CONST_ON:
+                        case PlSqlParser.MERGE:
+                        case PlSqlParser.MERGE_SJ:
+                        case PlSqlParser.METADATA:
+                        case PlSqlParser.METHOD:
+                        case PlSqlParser.MIGRATE:
+                        case PlSqlParser.MIGRATION:
+                        case PlSqlParser.MINEXTENTS:
+                        case PlSqlParser.MINIMIZE:
+                        case PlSqlParser.MINIMUM:
+                        case PlSqlParser.MINING:
+                        case PlSqlParser.MINUS_NULL:
+                        case PlSqlParser.MINUTE:
+                        case PlSqlParser.MINUTES:
+                        case PlSqlParser.MINVALUE:
+                        case PlSqlParser.MIRRORCOLD:
+                        case PlSqlParser.MIRRORHOT:
+                        case PlSqlParser.MIRROR:
+                        case PlSqlParser.MISSING:
+                        case PlSqlParser.MISMATCH:
+                        case PlSqlParser.MLSLABEL:
+                        case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                        case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                        case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                        case PlSqlParser.MODEL_MIN_ANALYSIS:
+                        case PlSqlParser.MODEL:
+                        case PlSqlParser.MODEL_NB:
+                        case PlSqlParser.MODEL_NO_ANALYSIS:
+                        case PlSqlParser.MODEL_PBY:
+                        case PlSqlParser.MODEL_PUSH_REF:
+                        case PlSqlParser.MODEL_SV:
+                        case PlSqlParser.MODIFICATION:
+                        case PlSqlParser.MODIFY_COLUMN_TYPE:
+                        case PlSqlParser.MODIFY:
+                        case PlSqlParser.MOD:
+                        case PlSqlParser.MODULE:
+                        case PlSqlParser.MONITORING:
+                        case PlSqlParser.MONITOR:
+                        case PlSqlParser.MONTH:
+                        case PlSqlParser.MONTHS_BETWEEN:
+                        case PlSqlParser.MONTHS:
+                        case PlSqlParser.MOUNT:
+                        case PlSqlParser.MOUNTPATH:
+                        case PlSqlParser.MOUNTPOINT:
+                        case PlSqlParser.MOVEMENT:
+                        case PlSqlParser.MOVE:
+                        case PlSqlParser.MULTIDIMENSIONAL:
+                        case PlSqlParser.MULTISET:
+                        case PlSqlParser.MV_MERGE:
+                        case PlSqlParser.NAMED:
+                        case PlSqlParser.NAME:
+                        case PlSqlParser.NAMESPACE:
+                        case PlSqlParser.NAN_:
+                        case PlSqlParser.NANVL:
+                        case PlSqlParser.NATIONAL:
+                        case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                        case PlSqlParser.NATIVE:
+                        case PlSqlParser.NATURAL:
+                        case PlSqlParser.NAV:
+                        case PlSqlParser.NCHAR_CS:
+                        case PlSqlParser.NCHAR:
+                        case PlSqlParser.NCHR:
+                        case PlSqlParser.NCLOB:
+                        case PlSqlParser.NEEDED:
+                        case PlSqlParser.NEG:
+                        case PlSqlParser.NESTED:
+                        case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                        case PlSqlParser.NESTED_TABLE_GET_REFS:
+                        case PlSqlParser.NESTED_TABLE_ID:
+                        case PlSqlParser.NESTED_TABLE_SET_REFS:
+                        case PlSqlParser.NESTED_TABLE_SET_SETID:
+                        case PlSqlParser.NETWORK:
+                        case PlSqlParser.NEVER:
+                        case PlSqlParser.NEW:
+                        case PlSqlParser.NEWLINE_:
+                        case PlSqlParser.NEW_TIME:
+                        case PlSqlParser.NEXT_DAY:
+                        case PlSqlParser.NEXT:
+                        case PlSqlParser.NL_AJ:
+                        case PlSqlParser.NLJ_BATCHING:
+                        case PlSqlParser.NLJ_INDEX_FILTER:
+                        case PlSqlParser.NLJ_INDEX_SCAN:
+                        case PlSqlParser.NLJ_PREFETCH:
+                        case PlSqlParser.NLS_CALENDAR:
+                        case PlSqlParser.NLS_CHARACTERSET:
+                        case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                        case PlSqlParser.NLS_CHARSET_ID:
+                        case PlSqlParser.NLS_CHARSET_NAME:
+                        case PlSqlParser.NLS_COMP:
+                        case PlSqlParser.NLS_CURRENCY:
+                        case PlSqlParser.NLS_DATE_FORMAT:
+                        case PlSqlParser.NLS_DATE_LANGUAGE:
+                        case PlSqlParser.NLS_INITCAP:
+                        case PlSqlParser.NLS_ISO_CURRENCY:
+                        case PlSqlParser.NL_SJ:
+                        case PlSqlParser.NLS_LANG:
+                        case PlSqlParser.NLS_LANGUAGE:
+                        case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                        case PlSqlParser.NLS_LOWER:
+                        case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                        case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                        case PlSqlParser.NLS_SORT:
+                        case PlSqlParser.NLSSORT:
+                        case PlSqlParser.NLS_SPECIAL_CHARS:
+                        case PlSqlParser.NLS_TERRITORY:
+                        case PlSqlParser.NLS_UPPER:
+                        case PlSqlParser.NO_ACCESS:
+                        case PlSqlParser.NO_ADAPTIVE_PLAN:
+                        case PlSqlParser.NO_ANSI_REARCH:
+                        case PlSqlParser.NOAPPEND:
+                        case PlSqlParser.NOARCHIVELOG:
+                        case PlSqlParser.NOAUDIT:
+                        case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                        case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                        case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                        case PlSqlParser.NO_BIND_AWARE:
+                        case PlSqlParser.NO_BUFFER:
+                        case PlSqlParser.NOCACHE:
+                        case PlSqlParser.NO_CARTESIAN:
+                        case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                        case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                        case PlSqlParser.NO_CLUSTERING:
+                        case PlSqlParser.NO_COALESCE_SQ:
+                        case PlSqlParser.NO_COMMON_DATA:
+                        case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                        case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                        case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                        case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                        case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                        case PlSqlParser.NOCOPY:
+                        case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                        case PlSqlParser.NO_CPU_COSTING:
+                        case PlSqlParser.NOCPU_COSTING:
+                        case PlSqlParser.NOCYCLE:
+                        case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                        case PlSqlParser.NO_DECORRELATE:
+                        case PlSqlParser.NODELAY:
+                        case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                        case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                        case PlSqlParser.NO_ELIM_GROUPBY:
+                        case PlSqlParser.NO_ELIMINATE_JOIN:
+                        case PlSqlParser.NO_ELIMINATE_OBY:
+                        case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                        case PlSqlParser.NOENTITYESCAPING:
+                        case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                        case PlSqlParser.NO_EXPAND:
+                        case PlSqlParser.NO_EXPAND_TABLE:
+                        case PlSqlParser.NO_FACT:
+                        case PlSqlParser.NO_FACTORIZE_JOIN:
+                        case PlSqlParser.NO_FILTERING:
+                        case PlSqlParser.NOFORCE:
+                        case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                        case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                        case PlSqlParser.NO_GBY_PUSHDOWN:
+                        case PlSqlParser.NOGUARANTEE:
+                        case PlSqlParser.NO_INDEX_FFS:
+                        case PlSqlParser.NO_INDEX:
+                        case PlSqlParser.NO_INDEX_SS:
+                        case PlSqlParser.NO_INMEMORY:
+                        case PlSqlParser.NO_INMEMORY_PRUNING:
+                        case PlSqlParser.NOKEEP:
+                        case PlSqlParser.NO_LOAD:
+                        case PlSqlParser.NOLOCAL:
+                        case PlSqlParser.NOLOGGING:
+                        case PlSqlParser.NOMAPPING:
+                        case PlSqlParser.NOMAXVALUE:
+                        case PlSqlParser.NO_MERGE:
+                        case PlSqlParser.NOMINIMIZE:
+                        case PlSqlParser.NOMINVALUE:
+                        case PlSqlParser.NO_MODEL_PUSH_REF:
+                        case PlSqlParser.NO_MONITORING:
+                        case PlSqlParser.NOMONITORING:
+                        case PlSqlParser.NO_MONITOR:
+                        case PlSqlParser.NO_MULTIMV_REWRITE:
+                        case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                        case PlSqlParser.NONBLOCKING:
+                        case PlSqlParser.NONEDITIONABLE:
+                        case PlSqlParser.NONE:
+                        case PlSqlParser.NONPARTITIONED:
+                        case PlSqlParser.NO_NLJ_BATCHING:
+                        case PlSqlParser.NO_NLJ_PREFETCH:
+                        case PlSqlParser.NO:
+                        case PlSqlParser.NONSCHEMA:
+                        case PlSqlParser.NO_OBJECT_LINK:
+                        case PlSqlParser.NOORDER:
+                        case PlSqlParser.NO_ORDER_ROLLUPS:
+                        case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                        case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                        case PlSqlParser.NOOVERRIDE:
+                        case PlSqlParser.NO_PARALLEL_INDEX:
+                        case PlSqlParser.NOPARALLEL_INDEX:
+                        case PlSqlParser.NO_PARALLEL:
+                        case PlSqlParser.NOPARALLEL:
+                        case PlSqlParser.NO_PARTIAL_COMMIT:
+                        case PlSqlParser.NO_PARTIAL_JOIN:
+                        case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                        case PlSqlParser.NOPARTITION:
+                        case PlSqlParser.NO_PLACE_DISTINCT:
+                        case PlSqlParser.NO_PLACE_GROUP_BY:
+                        case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                        case PlSqlParser.NO_PQ_MAP:
+                        case PlSqlParser.NOPROMPT:
+                        case PlSqlParser.NO_PQ_REPLICATE:
+                        case PlSqlParser.NO_PQ_SKEW:
+                        case PlSqlParser.NO_PRUNE_GSETS:
+                        case PlSqlParser.NO_PULL_PRED:
+                        case PlSqlParser.NO_PUSH_PRED:
+                        case PlSqlParser.NO_PUSH_SUBQ:
+                        case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                        case PlSqlParser.NO_PX_JOIN_FILTER:
+                        case PlSqlParser.NO_QKN_BUFF:
+                        case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                        case PlSqlParser.NO_REF_CASCADE:
+                        case PlSqlParser.NORELOCATE:
+                        case PlSqlParser.NORELY:
+                        case PlSqlParser.NOREPAIR:
+                        case PlSqlParser.NOREPLAY:
+                        case PlSqlParser.NORESETLOGS:
+                        case PlSqlParser.NO_RESULT_CACHE:
+                        case PlSqlParser.NOREVERSE:
+                        case PlSqlParser.NO_REWRITE:
+                        case PlSqlParser.NOREWRITE:
+                        case PlSqlParser.NORMAL:
+                        case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                        case PlSqlParser.NOROWDEPENDENCIES:
+                        case PlSqlParser.NOSCHEMACHECK:
+                        case PlSqlParser.NOSEGMENT:
+                        case PlSqlParser.NO_SEMIJOIN:
+                        case PlSqlParser.NO_SEMI_TO_INNER:
+                        case PlSqlParser.NO_SET_TO_JOIN:
+                        case PlSqlParser.NOSORT:
+                        case PlSqlParser.NO_SQL_TRANSLATION:
+                        case PlSqlParser.NO_SQL_TUNE:
+                        case PlSqlParser.NO_STAR_TRANSFORMATION:
+                        case PlSqlParser.NO_STATEMENT_QUEUING:
+                        case PlSqlParser.NO_STATS_GSETS:
+                        case PlSqlParser.NOSTRICT:
+                        case PlSqlParser.NO_SUBQUERY_PRUNING:
+                        case PlSqlParser.NO_SUBSTRB_PAD:
+                        case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                        case PlSqlParser.NOSWITCH:
+                        case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                        case PlSqlParser.NO_TEMP_TABLE:
+                        case PlSqlParser.NOTHING:
+                        case PlSqlParser.NOTIFICATION:
+                        case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                        case PlSqlParser.NO_UNNEST:
+                        case PlSqlParser.NO_USE_CUBE:
+                        case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                        case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                        case PlSqlParser.NO_USE_HASH:
+                        case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                        case PlSqlParser.NO_USE_MERGE:
+                        case PlSqlParser.NO_USE_NL:
+                        case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                        case PlSqlParser.NOVALIDATE:
+                        case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                        case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                        case PlSqlParser.NO_VECTOR_TRANSFORM:
+                        case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                        case PlSqlParser.NO_XML_DML_REWRITE:
+                        case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                        case PlSqlParser.NO_XMLINDEX_REWRITE:
+                        case PlSqlParser.NO_XML_QUERY_REWRITE:
+                        case PlSqlParser.NO_ZONEMAP:
+                        case PlSqlParser.NTH_VALUE:
+                        case PlSqlParser.NULLIF:
+                        case PlSqlParser.NULLS:
+                        case PlSqlParser.NUMBER:
+                        case PlSqlParser.NUMERIC:
+                        case PlSqlParser.NUM_INDEX_KEYS:
+                        case PlSqlParser.NUMTODSINTERVAL:
+                        case PlSqlParser.NUMTOYMINTERVAL:
+                        case PlSqlParser.NVARCHAR2:
+                        case PlSqlParser.NVL2:
+                        case PlSqlParser.OBJECT2XML:
+                        case PlSqlParser.OBJECT:
+                        case PlSqlParser.OBJ_ID:
+                        case PlSqlParser.OBJNO:
+                        case PlSqlParser.OBJNO_REUSE:
+                        case PlSqlParser.OCCURENCES:
+                        case PlSqlParser.OFFLINE:
+                        case PlSqlParser.OFF:
+                        case PlSqlParser.OFFSET:
+                        case PlSqlParser.OIDINDEX:
+                        case PlSqlParser.OID:
+                        case PlSqlParser.OLAP:
+                        case PlSqlParser.OLD:
+                        case PlSqlParser.OLD_PUSH_PRED:
+                        case PlSqlParser.OLS:
+                        case PlSqlParser.OLTP:
+                        case PlSqlParser.OMIT:
+                        case PlSqlParser.ONE:
+                        case PlSqlParser.ONLINE:
+                        case PlSqlParser.ONLY:
+                        case PlSqlParser.OPAQUE:
+                        case PlSqlParser.OPAQUE_TRANSFORM:
+                        case PlSqlParser.OPAQUE_XCANONICAL:
+                        case PlSqlParser.OPCODE:
+                        case PlSqlParser.OPEN:
+                        case PlSqlParser.OPERATIONS:
+                        case PlSqlParser.OPERATOR:
+                        case PlSqlParser.OPT_ESTIMATE:
+                        case PlSqlParser.OPTIMAL:
+                        case PlSqlParser.OPTIMIZE:
+                        case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                        case PlSqlParser.OPTIMIZER_GOAL:
+                        case PlSqlParser.OPT_PARAM:
+                        case PlSqlParser.ORA_BRANCH:
+                        case PlSqlParser.ORA_CHECK_ACL:
+                        case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                        case PlSqlParser.ORA_CLUSTERING:
+                        case PlSqlParser.ORADATA:
+                        case PlSqlParser.ORC:
+                        case PlSqlParser.ORADEBUG:
+                        case PlSqlParser.ORA_DST_AFFECTED:
+                        case PlSqlParser.ORA_DST_CONVERT:
+                        case PlSqlParser.ORA_DST_ERROR:
+                        case PlSqlParser.ORA_GET_ACLIDS:
+                        case PlSqlParser.ORA_GET_PRIVILEGES:
+                        case PlSqlParser.ORA_HASH:
+                        case PlSqlParser.ORA_INVOKING_USERID:
+                        case PlSqlParser.ORA_INVOKING_USER:
+                        case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                        case PlSqlParser.ORA_INVOKING_XS_USER:
+                        case PlSqlParser.ORA_RAWCOMPARE:
+                        case PlSqlParser.ORA_RAWCONCAT:
+                        case PlSqlParser.ORA_ROWSCN:
+                        case PlSqlParser.ORA_ROWSCN_RAW:
+                        case PlSqlParser.ORA_ROWVERSION:
+                        case PlSqlParser.ORA_TABVERSION:
+                        case PlSqlParser.ORA_WRITE_TIME:
+                        case PlSqlParser.ORDERED:
+                        case PlSqlParser.ORDERED_PREDICATES:
+                        case PlSqlParser.ORDINALITY:
+                        case PlSqlParser.OR_EXPAND:
+                        case PlSqlParser.ORGANIZATION:
+                        case PlSqlParser.OR_PREDICATES:
+                        case PlSqlParser.OSERROR:
+                        case PlSqlParser.OTHER:
+                        case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                        case PlSqlParser.OUTER_JOIN_TO_INNER:
+                        case PlSqlParser.OUTER:
+                        case PlSqlParser.OUTLINE_LEAF:
+                        case PlSqlParser.OUTLINE:
+                        case PlSqlParser.OUT_OF_LINE:
+                        case PlSqlParser.OUT:
+                        case PlSqlParser.OVERFLOW_NOMOVE:
+                        case PlSqlParser.OVERFLOW_:
+                        case PlSqlParser.OVERLAPS:
+                        case PlSqlParser.OVER:
+                        case PlSqlParser.OVERRIDE:
+                        case PlSqlParser.OVERRIDING:
+                        case PlSqlParser.OWNER:
+                        case PlSqlParser.OWNERSHIP:
+                        case PlSqlParser.OWN:
+                        case PlSqlParser.P_LETTER:
+                        case PlSqlParser.PACKAGE:
+                        case PlSqlParser.PACKAGES:
+                        case PlSqlParser.PARALLEL_ENABLE:
+                        case PlSqlParser.PARALLEL_INDEX:
+                        case PlSqlParser.PARALLEL:
+                        case PlSqlParser.PARAMETERS:
+                        case PlSqlParser.PARAM:
+                        case PlSqlParser.PARENT:
+                        case PlSqlParser.PARENT_LEVEL_NAME:
+                        case PlSqlParser.PARENT_UNIQUE_NAME:
+                        case PlSqlParser.PARITY:
+                        case PlSqlParser.PARTIAL_JOIN:
+                        case PlSqlParser.PARTIALLY:
+                        case PlSqlParser.PARTIAL:
+                        case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                        case PlSqlParser.PARTITION_HASH:
+                        case PlSqlParser.PARTITION_LIST:
+                        case PlSqlParser.PARTITION:
+                        case PlSqlParser.PARTITION_RANGE:
+                        case PlSqlParser.PARTITIONS:
+                        case PlSqlParser.PARTNUMINST:
+                        case PlSqlParser.PASSING:
+                        case PlSqlParser.PASSWORD_GRACE_TIME:
+                        case PlSqlParser.PASSWORD_LIFE_TIME:
+                        case PlSqlParser.PASSWORD_LOCK_TIME:
+                        case PlSqlParser.PASSWORD:
+                        case PlSqlParser.PASSWORD_REUSE_MAX:
+                        case PlSqlParser.PASSWORD_REUSE_TIME:
+                        case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                        case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                        case PlSqlParser.PAST:
+                        case PlSqlParser.PATCH:
+                        case PlSqlParser.PATH:
+                        case PlSqlParser.PATH_PREFIX:
+                        case PlSqlParser.PATHS:
+                        case PlSqlParser.PATTERN:
+                        case PlSqlParser.PBL_HS_BEGIN:
+                        case PlSqlParser.PBL_HS_END:
+                        case PlSqlParser.PCTINCREASE:
+                        case PlSqlParser.PCTTHRESHOLD:
+                        case PlSqlParser.PCTUSED:
+                        case PlSqlParser.PCTVERSION:
+                        case PlSqlParser.PENDING:
+                        case PlSqlParser.PERCENT_KEYWORD:
+                        case PlSqlParser.PERCENT_RANKM:
+                        case PlSqlParser.PERFORMANCE:
+                        case PlSqlParser.PERIOD_KEYWORD:
+                        case PlSqlParser.PERMANENT:
+                        case PlSqlParser.PERMISSION:
+                        case PlSqlParser.PERMUTE:
+                        case PlSqlParser.PER:
+                        case PlSqlParser.PFILE:
+                        case PlSqlParser.PHYSICAL:
+                        case PlSqlParser.PIKEY:
+                        case PlSqlParser.PIPELINED:
+                        case PlSqlParser.PIV_GB:
+                        case PlSqlParser.PIVOT:
+                        case PlSqlParser.PIV_SSF:
+                        case PlSqlParser.PLACE_DISTINCT:
+                        case PlSqlParser.PLACE_GROUP_BY:
+                        case PlSqlParser.PLAN:
+                        case PlSqlParser.PLSCOPE_SETTINGS:
+                        case PlSqlParser.PLS_INTEGER:
+                        case PlSqlParser.PLSQL_CCFLAGS:
+                        case PlSqlParser.PLSQL_CODE_TYPE:
+                        case PlSqlParser.PLSQL_DEBUG:
+                        case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                        case PlSqlParser.PLSQL_WARNINGS:
+                        case PlSqlParser.PLUGGABLE:
+                        case PlSqlParser.PMEM:
+                        case PlSqlParser.POINT:
+                        case PlSqlParser.POLICY:
+                        case PlSqlParser.POOL_16K:
+                        case PlSqlParser.POOL_2K:
+                        case PlSqlParser.POOL_32K:
+                        case PlSqlParser.POOL_4K:
+                        case PlSqlParser.POOL_8K:
+                        case PlSqlParser.POSITION:
+                        case PlSqlParser.POSITIVEN:
+                        case PlSqlParser.POSITIVE:
+                        case PlSqlParser.POST_TRANSACTION:
+                        case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                        case PlSqlParser.POWERMULTISET:
+                        case PlSqlParser.POWER:
+                        case PlSqlParser.PQ_CONCURRENT_UNION:
+                        case PlSqlParser.PQ_DISTRIBUTE:
+                        case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                        case PlSqlParser.PQ_FILTER:
+                        case PlSqlParser.PQ_MAP:
+                        case PlSqlParser.PQ_NOMAP:
+                        case PlSqlParser.PQ_REPLICATE:
+                        case PlSqlParser.PQ_SKEW:
+                        case PlSqlParser.PRAGMA:
+                        case PlSqlParser.PREBUILT:
+                        case PlSqlParser.PRECEDES:
+                        case PlSqlParser.PRECEDING:
+                        case PlSqlParser.PRECISION:
+                        case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                        case PlSqlParser.PREDICATE_REORDERS:
+                        case PlSqlParser.PRELOAD:
+                        case PlSqlParser.PREPARE:
+                        case PlSqlParser.PRESENTNNV:
+                        case PlSqlParser.PRESENT:
+                        case PlSqlParser.PRESENTV:
+                        case PlSqlParser.PRESERVE_OID:
+                        case PlSqlParser.PRESERVE:
+                        case PlSqlParser.PRETTY:
+                        case PlSqlParser.PREVIOUS:
+                        case PlSqlParser.PREV:
+                        case PlSqlParser.PRIMARY:
+                        case PlSqlParser.PRINTBLOBTOCLOB:
+                        case PlSqlParser.PRIORITY:
+                        case PlSqlParser.PRIVATE:
+                        case PlSqlParser.PRIVATE_SGA:
+                        case PlSqlParser.PRIVILEGED:
+                        case PlSqlParser.PRIVILEGE:
+                        case PlSqlParser.PRIVILEGES:
+                        case PlSqlParser.PROCEDURAL:
+                        case PlSqlParser.PROCEDURE:
+                        case PlSqlParser.PROCESS:
+                        case PlSqlParser.PROFILE:
+                        case PlSqlParser.PROGRAM:
+                        case PlSqlParser.PROJECT:
+                        case PlSqlParser.PROPAGATE:
+                        case PlSqlParser.PROPERTY:
+                        case PlSqlParser.PROTECTED:
+                        case PlSqlParser.PROTECTION:
+                        case PlSqlParser.PROTOCOL:
+                        case PlSqlParser.PROXY:
+                        case PlSqlParser.PRUNING:
+                        case PlSqlParser.PUBLIC:
+                        case PlSqlParser.PULL_PRED:
+                        case PlSqlParser.PURGE:
+                        case PlSqlParser.PUSH_PRED:
+                        case PlSqlParser.PUSH_SUBQ:
+                        case PlSqlParser.PX_FAULT_TOLERANCE:
+                        case PlSqlParser.PX_GRANULE:
+                        case PlSqlParser.PX_JOIN_FILTER:
+                        case PlSqlParser.QB_NAME:
+                        case PlSqlParser.QUARTERS:
+                        case PlSqlParser.QUERY_BLOCK:
+                        case PlSqlParser.QUERY:
+                        case PlSqlParser.QUEUE_CURR:
+                        case PlSqlParser.QUEUE:
+                        case PlSqlParser.QUEUE_ROWP:
+                        case PlSqlParser.QUIESCE:
+                        case PlSqlParser.QUORUM:
+                        case PlSqlParser.QUOTA:
+                        case PlSqlParser.QUOTAGROUP:
+                        case PlSqlParser.RAISE:
+                        case PlSqlParser.RANDOM_LOCAL:
+                        case PlSqlParser.RANDOM:
+                        case PlSqlParser.RANGE:
+                        case PlSqlParser.RANKM:
+                        case PlSqlParser.RAPIDLY:
+                        case PlSqlParser.RAW:
+                        case PlSqlParser.RAWTOHEX:
+                        case PlSqlParser.RAWTONHEX:
+                        case PlSqlParser.RBA:
+                        case PlSqlParser.RBO_OUTLINE:
+                        case PlSqlParser.RDBA:
+                        case PlSqlParser.READ:
+                        case PlSqlParser.READS:
+                        case PlSqlParser.REALM:
+                        case PlSqlParser.REAL:
+                        case PlSqlParser.REBALANCE:
+                        case PlSqlParser.REBUILD:
+                        case PlSqlParser.RECORD:
+                        case PlSqlParser.RECORDS:
+                        case PlSqlParser.RECORDS_PER_BLOCK:
+                        case PlSqlParser.RECOVERABLE:
+                        case PlSqlParser.RECOVER:
+                        case PlSqlParser.RECOVERY:
+                        case PlSqlParser.RECYCLEBIN:
+                        case PlSqlParser.RECYCLE:
+                        case PlSqlParser.REDACTION:
+                        case PlSqlParser.REDEFINE:
+                        case PlSqlParser.REDO:
+                        case PlSqlParser.REDUCED:
+                        case PlSqlParser.REDUNDANCY:
+                        case PlSqlParser.REF_CASCADE_CURSOR:
+                        case PlSqlParser.REFERENCED:
+                        case PlSqlParser.REFERENCE:
+                        case PlSqlParser.REFERENCES:
+                        case PlSqlParser.REFERENCING:
+                        case PlSqlParser.REF:
+                        case PlSqlParser.REFRESH:
+                        case PlSqlParser.REFTOHEX:
+                        case PlSqlParser.REGEXP_COUNT:
+                        case PlSqlParser.REGEXP_INSTR:
+                        case PlSqlParser.REGEXP_LIKE:
+                        case PlSqlParser.REGEXP_REPLACE:
+                        case PlSqlParser.REGEXP_SUBSTR:
+                        case PlSqlParser.REGISTER:
+                        case PlSqlParser.REGR_AVGX:
+                        case PlSqlParser.REGR_AVGY:
+                        case PlSqlParser.REGR_COUNT:
+                        case PlSqlParser.REGR_INTERCEPT:
+                        case PlSqlParser.REGR_R2:
+                        case PlSqlParser.REGR_SLOPE:
+                        case PlSqlParser.REGR_SXX:
+                        case PlSqlParser.REGR_SXY:
+                        case PlSqlParser.REGR_SYY:
+                        case PlSqlParser.REGULAR:
+                        case PlSqlParser.REJECT:
+                        case PlSqlParser.REKEY:
+                        case PlSqlParser.RELATIONAL:
+                        case PlSqlParser.RELOCATE:
+                        case PlSqlParser.RELY:
+                        case PlSqlParser.REMAINDER:
+                        case PlSqlParser.REMOTE:
+                        case PlSqlParser.REMOTE_MAPPED:
+                        case PlSqlParser.REMOVE:
+                        case PlSqlParser.RENAME:
+                        case PlSqlParser.REPAIR:
+                        case PlSqlParser.REPEAT:
+                        case PlSqlParser.REPLACE:
+                        case PlSqlParser.REPLICATION:
+                        case PlSqlParser.REQUIRED:
+                        case PlSqlParser.RESETLOGS:
+                        case PlSqlParser.RESET:
+                        case PlSqlParser.RESIZE:
+                        case PlSqlParser.RESOLVE:
+                        case PlSqlParser.RESOLVER:
+                        case PlSqlParser.RESPECT:
+                        case PlSqlParser.RESTART:
+                        case PlSqlParser.RESTORE_AS_INTERVALS:
+                        case PlSqlParser.RESTORE:
+                        case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                        case PlSqlParser.RESTRICTED:
+                        case PlSqlParser.RESTRICT_REFERENCES:
+                        case PlSqlParser.RESTRICT:
+                        case PlSqlParser.RESULT_CACHE:
+                        case PlSqlParser.RESULT:
+                        case PlSqlParser.RESUMABLE:
+                        case PlSqlParser.RESUME:
+                        case PlSqlParser.RETENTION:
+                        case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                        case PlSqlParser.RETURNING:
+                        case PlSqlParser.RETURN:
+                        case PlSqlParser.REUSE:
+                        case PlSqlParser.REVERSE:
+                        case PlSqlParser.REWRITE_OR_ERROR:
+                        case PlSqlParser.REWRITE:
+                        case PlSqlParser.RIGHT:
+                        case PlSqlParser.ROLE:
+                        case PlSqlParser.ROLESET:
+                        case PlSqlParser.ROLES:
+                        case PlSqlParser.ROLLBACK:
+                        case PlSqlParser.ROLLING:
+                        case PlSqlParser.ROLLUP:
+                        case PlSqlParser.ROWDEPENDENCIES:
+                        case PlSqlParser.ROWID_MAPPING_TABLE:
+                        case PlSqlParser.ROWID:
+                        case PlSqlParser.ROWIDTOCHAR:
+                        case PlSqlParser.ROWIDTONCHAR:
+                        case PlSqlParser.ROW_LENGTH:
+                        case PlSqlParser.ROWNUM:
+                        case PlSqlParser.ROW:
+                        case PlSqlParser.ROWS:
+                        case PlSqlParser.RPAD:
+                        case PlSqlParser.RTRIM:
+                        case PlSqlParser.RULE:
+                        case PlSqlParser.RULES:
+                        case PlSqlParser.RUNNING:
+                        case PlSqlParser.SALT:
+                        case PlSqlParser.SAMPLE:
+                        case PlSqlParser.SAVE_AS_INTERVALS:
+                        case PlSqlParser.SAVEPOINT:
+                        case PlSqlParser.SAVE:
+                        case PlSqlParser.SB4:
+                        case PlSqlParser.SCALE_ROWS:
+                        case PlSqlParser.SCALE:
+                        case PlSqlParser.SCAN_INSTANCES:
+                        case PlSqlParser.SCAN:
+                        case PlSqlParser.SCHEDULER:
+                        case PlSqlParser.SCHEMACHECK:
+                        case PlSqlParser.SCHEMA:
+                        case PlSqlParser.SCN_ASCENDING:
+                        case PlSqlParser.SCN:
+                        case PlSqlParser.SCOPE:
+                        case PlSqlParser.SCRUB:
+                        case PlSqlParser.SD_ALL:
+                        case PlSqlParser.SD_INHIBIT:
+                        case PlSqlParser.SDO_GEOM_MBR:
+                        case PlSqlParser.SDO_GEOMETRY:
+                        case PlSqlParser.SD_SHOW:
+                        case PlSqlParser.SEARCH:
+                        case PlSqlParser.SECOND:
+                        case PlSqlParser.SECONDS:
+                        case PlSqlParser.SECRET:
+                        case PlSqlParser.SECUREFILE_DBA:
+                        case PlSqlParser.SECUREFILE:
+                        case PlSqlParser.SECURITY:
+                        case PlSqlParser.SEED:
+                        case PlSqlParser.SEG_BLOCK:
+                        case PlSqlParser.SEG_FILE:
+                        case PlSqlParser.SEGMENT:
+                        case PlSqlParser.SELECTIVITY:
+                        case PlSqlParser.SELF:
+                        case PlSqlParser.SEMIJOIN_DRIVER:
+                        case PlSqlParser.SEMIJOIN:
+                        case PlSqlParser.SEMI_TO_INNER:
+                        case PlSqlParser.SEQUENCED:
+                        case PlSqlParser.SEQUENCE:
+                        case PlSqlParser.SEQUENTIAL:
+                        case PlSqlParser.SEQ:
+                        case PlSqlParser.SERIALIZABLE:
+                        case PlSqlParser.SERIALLY_REUSABLE:
+                        case PlSqlParser.SERIAL:
+                        case PlSqlParser.SERVERERROR:
+                        case PlSqlParser.SERVICE_NAME_CONVERT:
+                        case PlSqlParser.SERVICE:
+                        case PlSqlParser.SERVICES:
+                        case PlSqlParser.SESSION_CACHED_CURSORS:
+                        case PlSqlParser.SESSION:
+                        case PlSqlParser.SESSIONS_PER_USER:
+                        case PlSqlParser.SESSIONTIMEZONE:
+                        case PlSqlParser.SESSIONTZNAME:
+                        case PlSqlParser.SET:
+                        case PlSqlParser.SETS:
+                        case PlSqlParser.SETTINGS:
+                        case PlSqlParser.SET_TO_JOIN:
+                        case PlSqlParser.SEVERE:
+                        case PlSqlParser.SHARDSPACE:
+                        case PlSqlParser.SHARED_POOL:
+                        case PlSqlParser.SHARED:
+                        case PlSqlParser.SHARING:
+                        case PlSqlParser.SHELFLIFE:
+                        case PlSqlParser.SHOW:
+                        case PlSqlParser.SHRINK:
+                        case PlSqlParser.SHUTDOWN:
+                        case PlSqlParser.SIBLINGS:
+                        case PlSqlParser.SID:
+                        case PlSqlParser.SITE:
+                        case PlSqlParser.SIGNAL_COMPONENT:
+                        case PlSqlParser.SIGNAL_FUNCTION:
+                        case PlSqlParser.SIGN:
+                        case PlSqlParser.SIGNTYPE:
+                        case PlSqlParser.SIMPLE_INTEGER:
+                        case PlSqlParser.SIMPLE:
+                        case PlSqlParser.SINGLE:
+                        case PlSqlParser.SINGLETASK:
+                        case PlSqlParser.SINH:
+                        case PlSqlParser.SIN:
+                        case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                        case PlSqlParser.SKIP_:
+                        case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                        case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                        case PlSqlParser.SMALLFILE:
+                        case PlSqlParser.SMALLINT:
+                        case PlSqlParser.SNAPSHOT:
+                        case PlSqlParser.SOME:
+                        case PlSqlParser.SORT:
+                        case PlSqlParser.SOUNDEX:
+                        case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                        case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                        case PlSqlParser.SOURCE:
+                        case PlSqlParser.SPACE_KEYWORD:
+                        case PlSqlParser.SPECIFICATION:
+                        case PlSqlParser.SPFILE:
+                        case PlSqlParser.SPLIT:
+                        case PlSqlParser.SPREADSHEET:
+                        case PlSqlParser.SQLDATA:
+                        case PlSqlParser.SQLERROR:
+                        case PlSqlParser.SQLLDR:
+                        case PlSqlParser.SQL:
+                        case PlSqlParser.FILE_EXT:
+                        case PlSqlParser.SQL_MACRO:
+                        case PlSqlParser.SQL_TRACE:
+                        case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                        case PlSqlParser.SQRT:
+                        case PlSqlParser.STALE:
+                        case PlSqlParser.STANDALONE:
+                        case PlSqlParser.STANDARD:
+                        case PlSqlParser.STANDARD_HASH:
+                        case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                        case PlSqlParser.STANDBYS:
+                        case PlSqlParser.STANDBY:
+                        case PlSqlParser.STAR:
+                        case PlSqlParser.STAR_TRANSFORMATION:
+                        case PlSqlParser.STARTUP:
+                        case PlSqlParser.STATEMENT_ID:
+                        case PlSqlParser.STATEMENT_QUEUING:
+                        case PlSqlParser.STATEMENTS:
+                        case PlSqlParser.STATEMENT:
+                        case PlSqlParser.STATE:
+                        case PlSqlParser.STATIC:
+                        case PlSqlParser.STATISTICS:
+                        case PlSqlParser.STATS_BINOMIAL_TEST:
+                        case PlSqlParser.STATS_CROSSTAB:
+                        case PlSqlParser.STATS_F_TEST:
+                        case PlSqlParser.STATS_KS_TEST:
+                        case PlSqlParser.STATS_MODE:
+                        case PlSqlParser.STATS_MW_TEST:
+                        case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                        case PlSqlParser.STATS_T_TEST_INDEP:
+                        case PlSqlParser.STATS_T_TEST_INDEPU:
+                        case PlSqlParser.STATS_T_TEST_ONE:
+                        case PlSqlParser.STATS_T_TEST_PAIRED:
+                        case PlSqlParser.STATS_WSR_TEST:
+                        case PlSqlParser.STDDEV_POP:
+                        case PlSqlParser.STDDEV_SAMP:
+                        case PlSqlParser.STOP:
+                        case PlSqlParser.STORAGE:
+                        case PlSqlParser.STORE:
+                        case PlSqlParser.STREAMS:
+                        case PlSqlParser.STREAM:
+                        case PlSqlParser.STRICT:
+                        case PlSqlParser.STRING:
+                        case PlSqlParser.STRIPE_COLUMNS:
+                        case PlSqlParser.STRIPE_WIDTH:
+                        case PlSqlParser.STRIP:
+                        case PlSqlParser.STRUCTURE:
+                        case PlSqlParser.SUBMULTISET:
+                        case PlSqlParser.SUBPARTITION_REL:
+                        case PlSqlParser.SUBPARTITIONS:
+                        case PlSqlParser.SUBPARTITION:
+                        case PlSqlParser.SUBQUERIES:
+                        case PlSqlParser.SUBQUERY_PRUNING:
+                        case PlSqlParser.SUBSCRIBE:
+                        case PlSqlParser.SUBSET:
+                        case PlSqlParser.SUBSTITUTABLE:
+                        case PlSqlParser.SUBSTR2:
+                        case PlSqlParser.SUBSTR4:
+                        case PlSqlParser.SUBSTRB:
+                        case PlSqlParser.SUBSTRC:
+                        case PlSqlParser.SUBTYPE:
+                        case PlSqlParser.SUCCESSFUL:
+                        case PlSqlParser.SUCCESS:
+                        case PlSqlParser.SUMMARY:
+                        case PlSqlParser.SUPPLEMENTAL:
+                        case PlSqlParser.SUSPEND:
+                        case PlSqlParser.SWAP_JOIN_INPUTS:
+                        case PlSqlParser.SWITCHOVER:
+                        case PlSqlParser.SWITCH:
+                        case PlSqlParser.SYNCHRONOUS:
+                        case PlSqlParser.SYNC:
+                        case PlSqlParser.SYS:
+                        case PlSqlParser.SYSASM:
+                        case PlSqlParser.SYS_AUDIT:
+                        case PlSqlParser.SYSAUX:
+                        case PlSqlParser.SYSBACKUP:
+                        case PlSqlParser.SYS_CHECKACL:
+                        case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                        case PlSqlParser.SYS_CONNECT_BY_PATH:
+                        case PlSqlParser.SYS_CONTEXT:
+                        case PlSqlParser.SYSDATE:
+                        case PlSqlParser.SYSDBA:
+                        case PlSqlParser.SYS_DBURIGEN:
+                        case PlSqlParser.SYSDG:
+                        case PlSqlParser.SYS_DL_CURSOR:
+                        case PlSqlParser.SYS_DM_RXFORM_CHR:
+                        case PlSqlParser.SYS_DM_RXFORM_NUM:
+                        case PlSqlParser.SYS_DOM_COMPARE:
+                        case PlSqlParser.SYS_DST_PRIM2SEC:
+                        case PlSqlParser.SYS_DST_SEC2PRIM:
+                        case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                        case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                        case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                        case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                        case PlSqlParser.SYS_EXTPDTXT:
+                        case PlSqlParser.SYS_EXTRACT_UTC:
+                        case PlSqlParser.SYS_FBT_INSDEL:
+                        case PlSqlParser.SYS_FILTER_ACLS:
+                        case PlSqlParser.SYS_FNMATCHES:
+                        case PlSqlParser.SYS_FNREPLACE:
+                        case PlSqlParser.SYS_GET_ACLIDS:
+                        case PlSqlParser.SYS_GET_COL_ACLIDS:
+                        case PlSqlParser.SYS_GET_PRIVILEGES:
+                        case PlSqlParser.SYS_GETTOKENID:
+                        case PlSqlParser.SYS_GETXTIVAL:
+                        case PlSqlParser.SYS_GUID:
+                        case PlSqlParser.SYSGUID:
+                        case PlSqlParser.SYSKM:
+                        case PlSqlParser.SYS_MAKE_XMLNODEID:
+                        case PlSqlParser.SYS_MAKEXML:
+                        case PlSqlParser.SYS_MKXMLATTR:
+                        case PlSqlParser.SYS_MKXTI:
+                        case PlSqlParser.SYSOBJ:
+                        case PlSqlParser.SYS_OP_ADT2BIN:
+                        case PlSqlParser.SYS_OP_ADTCONS:
+                        case PlSqlParser.SYS_OP_ALSCRVAL:
+                        case PlSqlParser.SYS_OP_ATG:
+                        case PlSqlParser.SYS_OP_BIN2ADT:
+                        case PlSqlParser.SYS_OP_BITVEC:
+                        case PlSqlParser.SYS_OP_BL2R:
+                        case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                        case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                        case PlSqlParser.SYS_OP_C2C:
+                        case PlSqlParser.SYS_OP_CAST:
+                        case PlSqlParser.SYS_OP_CEG:
+                        case PlSqlParser.SYS_OP_CL2C:
+                        case PlSqlParser.SYS_OP_COMBINED_HASH:
+                        case PlSqlParser.SYS_OP_COMP:
+                        case PlSqlParser.SYS_OP_CONVERT:
+                        case PlSqlParser.SYS_OP_COUNTCHG:
+                        case PlSqlParser.SYS_OP_CSCONV:
+                        case PlSqlParser.SYS_OP_CSCONVTEST:
+                        case PlSqlParser.SYS_OP_CSR:
+                        case PlSqlParser.SYS_OP_CSX_PATCH:
+                        case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                        case PlSqlParser.SYS_OP_DECOMP:
+                        case PlSqlParser.SYS_OP_DESCEND:
+                        case PlSqlParser.SYS_OP_DISTINCT:
+                        case PlSqlParser.SYS_OP_DRA:
+                        case PlSqlParser.SYS_OP_DUMP:
+                        case PlSqlParser.SYS_OP_DV_CHECK:
+                        case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                        case PlSqlParser.SYSOPER:
+                        case PlSqlParser.SYS_OP_EXTRACT:
+                        case PlSqlParser.SYS_OP_GROUPING:
+                        case PlSqlParser.SYS_OP_GUID:
+                        case PlSqlParser.SYS_OP_HASH:
+                        case PlSqlParser.SYS_OP_IIX:
+                        case PlSqlParser.SYS_OP_ITR:
+                        case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                        case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                        case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                        case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                        case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                        case PlSqlParser.SYS_OP_LBID:
+                        case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                        case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                        case PlSqlParser.SYS_OP_LOBLOC2ID:
+                        case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                        case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                        case PlSqlParser.SYS_OP_LSVI:
+                        case PlSqlParser.SYS_OP_LVL:
+                        case PlSqlParser.SYS_OP_MAKEOID:
+                        case PlSqlParser.SYS_OP_MAP_NONNULL:
+                        case PlSqlParser.SYS_OP_MSR:
+                        case PlSqlParser.SYS_OP_NICOMBINE:
+                        case PlSqlParser.SYS_OP_NIEXTRACT:
+                        case PlSqlParser.SYS_OP_NII:
+                        case PlSqlParser.SYS_OP_NIX:
+                        case PlSqlParser.SYS_OP_NOEXPAND:
+                        case PlSqlParser.SYS_OP_NTCIMG:
+                        case PlSqlParser.SYS_OP_NUMTORAW:
+                        case PlSqlParser.SYS_OP_OIDVALUE:
+                        case PlSqlParser.SYS_OP_OPNSIZE:
+                        case PlSqlParser.SYS_OP_PAR_1:
+                        case PlSqlParser.SYS_OP_PARGID_1:
+                        case PlSqlParser.SYS_OP_PARGID:
+                        case PlSqlParser.SYS_OP_PAR:
+                        case PlSqlParser.SYS_OP_PART_ID:
+                        case PlSqlParser.SYS_OP_PIVOT:
+                        case PlSqlParser.SYS_OP_R2O:
+                        case PlSqlParser.SYS_OP_RAWTONUM:
+                        case PlSqlParser.SYS_OP_RDTM:
+                        case PlSqlParser.SYS_OP_REF:
+                        case PlSqlParser.SYS_OP_RMTD:
+                        case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                        case PlSqlParser.SYS_OP_RPB:
+                        case PlSqlParser.SYS_OPTLOBPRBSC:
+                        case PlSqlParser.SYS_OP_TOSETID:
+                        case PlSqlParser.SYS_OP_TPR:
+                        case PlSqlParser.SYS_OP_TRTB:
+                        case PlSqlParser.SYS_OPTXICMP:
+                        case PlSqlParser.SYS_OPTXQCASTASNQ:
+                        case PlSqlParser.SYS_OP_UNDESCEND:
+                        case PlSqlParser.SYS_OP_VECAND:
+                        case PlSqlParser.SYS_OP_VECBIT:
+                        case PlSqlParser.SYS_OP_VECOR:
+                        case PlSqlParser.SYS_OP_VECXOR:
+                        case PlSqlParser.SYS_OP_VERSION:
+                        case PlSqlParser.SYS_OP_VREF:
+                        case PlSqlParser.SYS_OP_VVD:
+                        case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                        case PlSqlParser.SYS_OP_XPTHATG:
+                        case PlSqlParser.SYS_OP_XPTHIDX:
+                        case PlSqlParser.SYS_OP_XPTHOP:
+                        case PlSqlParser.SYS_OP_XTXT2SQLT:
+                        case PlSqlParser.SYS_OP_ZONE_ID:
+                        case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                        case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                        case PlSqlParser.SYS_ORDERKEY_PARENT:
+                        case PlSqlParser.SYS_PARALLEL_TXN:
+                        case PlSqlParser.SYS_PATHID_IS_ATTR:
+                        case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                        case PlSqlParser.SYS_PATHID_LASTNAME:
+                        case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                        case PlSqlParser.SYS_PATH_REVERSE:
+                        case PlSqlParser.SYS_PXQEXTRACT:
+                        case PlSqlParser.SYS_RAW_TO_XSID:
+                        case PlSqlParser.SYS_RID_ORDER:
+                        case PlSqlParser.SYS_ROW_DELTA:
+                        case PlSqlParser.SYS_SC_2_XMLT:
+                        case PlSqlParser.SYS_SYNRCIREDO:
+                        case PlSqlParser.SYSTEM_DEFINED:
+                        case PlSqlParser.SYSTEM:
+                        case PlSqlParser.SYSTIMESTAMP:
+                        case PlSqlParser.SYS_TYPEID:
+                        case PlSqlParser.SYS_UMAKEXML:
+                        case PlSqlParser.SYS_XMLANALYZE:
+                        case PlSqlParser.SYS_XMLCONTAINS:
+                        case PlSqlParser.SYS_XMLCONV:
+                        case PlSqlParser.SYS_XMLEXNSURI:
+                        case PlSqlParser.SYS_XMLGEN:
+                        case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                        case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                        case PlSqlParser.SYS_XMLINSTR:
+                        case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                        case PlSqlParser.SYS_XMLNODEID_GETCID:
+                        case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                        case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                        case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                        case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                        case PlSqlParser.SYS_XMLNODEID_GETRID:
+                        case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                        case PlSqlParser.SYS_XMLNODEID_GETTID:
+                        case PlSqlParser.SYS_XMLNODEID:
+                        case PlSqlParser.SYS_XMLT_2_SC:
+                        case PlSqlParser.SYS_XMLTRANSLATE:
+                        case PlSqlParser.SYS_XMLTYPE2SQL:
+                        case PlSqlParser.SYS_XQ_ASQLCNV:
+                        case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                        case PlSqlParser.SYS_XQBASEURI:
+                        case PlSqlParser.SYS_XQCASTABLEERRH:
+                        case PlSqlParser.SYS_XQCODEP2STR:
+                        case PlSqlParser.SYS_XQCODEPEQ:
+                        case PlSqlParser.SYS_XQCON2SEQ:
+                        case PlSqlParser.SYS_XQCONCAT:
+                        case PlSqlParser.SYS_XQDELETE:
+                        case PlSqlParser.SYS_XQDFLTCOLATION:
+                        case PlSqlParser.SYS_XQDOC:
+                        case PlSqlParser.SYS_XQDOCURI:
+                        case PlSqlParser.SYS_XQDURDIV:
+                        case PlSqlParser.SYS_XQED4URI:
+                        case PlSqlParser.SYS_XQENDSWITH:
+                        case PlSqlParser.SYS_XQERRH:
+                        case PlSqlParser.SYS_XQERR:
+                        case PlSqlParser.SYS_XQESHTMLURI:
+                        case PlSqlParser.SYS_XQEXLOBVAL:
+                        case PlSqlParser.SYS_XQEXSTWRP:
+                        case PlSqlParser.SYS_XQEXTRACT:
+                        case PlSqlParser.SYS_XQEXTRREF:
+                        case PlSqlParser.SYS_XQEXVAL:
+                        case PlSqlParser.SYS_XQFB2STR:
+                        case PlSqlParser.SYS_XQFNBOOL:
+                        case PlSqlParser.SYS_XQFNCMP:
+                        case PlSqlParser.SYS_XQFNDATIM:
+                        case PlSqlParser.SYS_XQFNLNAME:
+                        case PlSqlParser.SYS_XQFNNM:
+                        case PlSqlParser.SYS_XQFNNSURI:
+                        case PlSqlParser.SYS_XQFNPREDTRUTH:
+                        case PlSqlParser.SYS_XQFNQNM:
+                        case PlSqlParser.SYS_XQFNROOT:
+                        case PlSqlParser.SYS_XQFORMATNUM:
+                        case PlSqlParser.SYS_XQFTCONTAIN:
+                        case PlSqlParser.SYS_XQFUNCR:
+                        case PlSqlParser.SYS_XQGETCONTENT:
+                        case PlSqlParser.SYS_XQINDXOF:
+                        case PlSqlParser.SYS_XQINSERT:
+                        case PlSqlParser.SYS_XQINSPFX:
+                        case PlSqlParser.SYS_XQIRI2URI:
+                        case PlSqlParser.SYS_XQLANG:
+                        case PlSqlParser.SYS_XQLLNMFRMQNM:
+                        case PlSqlParser.SYS_XQMKNODEREF:
+                        case PlSqlParser.SYS_XQNILLED:
+                        case PlSqlParser.SYS_XQNODENAME:
+                        case PlSqlParser.SYS_XQNORMSPACE:
+                        case PlSqlParser.SYS_XQNORMUCODE:
+                        case PlSqlParser.SYS_XQ_NRNG:
+                        case PlSqlParser.SYS_XQNSP4PFX:
+                        case PlSqlParser.SYS_XQNSPFRMQNM:
+                        case PlSqlParser.SYS_XQPFXFRMQNM:
+                        case PlSqlParser.SYS_XQ_PKSQL2XML:
+                        case PlSqlParser.SYS_XQPOLYABS:
+                        case PlSqlParser.SYS_XQPOLYADD:
+                        case PlSqlParser.SYS_XQPOLYCEL:
+                        case PlSqlParser.SYS_XQPOLYCSTBL:
+                        case PlSqlParser.SYS_XQPOLYCST:
+                        case PlSqlParser.SYS_XQPOLYDIV:
+                        case PlSqlParser.SYS_XQPOLYFLR:
+                        case PlSqlParser.SYS_XQPOLYMOD:
+                        case PlSqlParser.SYS_XQPOLYMUL:
+                        case PlSqlParser.SYS_XQPOLYRND:
+                        case PlSqlParser.SYS_XQPOLYSQRT:
+                        case PlSqlParser.SYS_XQPOLYSUB:
+                        case PlSqlParser.SYS_XQPOLYUMUS:
+                        case PlSqlParser.SYS_XQPOLYUPLS:
+                        case PlSqlParser.SYS_XQPOLYVEQ:
+                        case PlSqlParser.SYS_XQPOLYVGE:
+                        case PlSqlParser.SYS_XQPOLYVGT:
+                        case PlSqlParser.SYS_XQPOLYVLE:
+                        case PlSqlParser.SYS_XQPOLYVLT:
+                        case PlSqlParser.SYS_XQPOLYVNE:
+                        case PlSqlParser.SYS_XQREF2VAL:
+                        case PlSqlParser.SYS_XQRENAME:
+                        case PlSqlParser.SYS_XQREPLACE:
+                        case PlSqlParser.SYS_XQRESVURI:
+                        case PlSqlParser.SYS_XQRNDHALF2EVN:
+                        case PlSqlParser.SYS_XQRSLVQNM:
+                        case PlSqlParser.SYS_XQRYENVPGET:
+                        case PlSqlParser.SYS_XQRYVARGET:
+                        case PlSqlParser.SYS_XQRYWRP:
+                        case PlSqlParser.SYS_XQSEQ2CON4XC:
+                        case PlSqlParser.SYS_XQSEQ2CON:
+                        case PlSqlParser.SYS_XQSEQDEEPEQ:
+                        case PlSqlParser.SYS_XQSEQINSB:
+                        case PlSqlParser.SYS_XQSEQRM:
+                        case PlSqlParser.SYS_XQSEQRVS:
+                        case PlSqlParser.SYS_XQSEQSUB:
+                        case PlSqlParser.SYS_XQSEQTYPMATCH:
+                        case PlSqlParser.SYS_XQSTARTSWITH:
+                        case PlSqlParser.SYS_XQSTATBURI:
+                        case PlSqlParser.SYS_XQSTR2CODEP:
+                        case PlSqlParser.SYS_XQSTRJOIN:
+                        case PlSqlParser.SYS_XQSUBSTRAFT:
+                        case PlSqlParser.SYS_XQSUBSTRBEF:
+                        case PlSqlParser.SYS_XQTOKENIZE:
+                        case PlSqlParser.SYS_XQTREATAS:
+                        case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                        case PlSqlParser.SYS_XQXFORM:
+                        case PlSqlParser.SYS_XSID_TO_RAW:
+                        case PlSqlParser.SYS_ZMAP_FILTER:
+                        case PlSqlParser.SYS_ZMAP_REFRESH:
+                        case PlSqlParser.T_LETTER:
+                        case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                        case PlSqlParser.TABLESPACE_NO:
+                        case PlSqlParser.TABLESPACE:
+                        case PlSqlParser.TABLES:
+                        case PlSqlParser.TABLE_STATS:
+                        case PlSqlParser.TABLE:
+                        case PlSqlParser.TABNO:
+                        case PlSqlParser.TAG:
+                        case PlSqlParser.TANH:
+                        case PlSqlParser.TAN:
+                        case PlSqlParser.TBLORIDXPARTNUM:
+                        case PlSqlParser.TEMPFILE:
+                        case PlSqlParser.TEMPLATE:
+                        case PlSqlParser.TEMPLATE_TABLE:
+                        case PlSqlParser.TEMPORARY:
+                        case PlSqlParser.TEMP_TABLE:
+                        case PlSqlParser.TEST:
+                        case PlSqlParser.TEXT:
+                        case PlSqlParser.THAN:
+                        case PlSqlParser.THEN:
+                        case PlSqlParser.THE:
+                        case PlSqlParser.THREAD:
+                        case PlSqlParser.THROUGH:
+                        case PlSqlParser.TIER:
+                        case PlSqlParser.TIES:
+                        case PlSqlParser.TIMEOUT:
+                        case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                        case PlSqlParser.TIMESTAMP:
+                        case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                        case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                        case PlSqlParser.TIMES:
+                        case PlSqlParser.TIME:
+                        case PlSqlParser.TIMEZONE:
+                        case PlSqlParser.TIMEZONE_ABBR:
+                        case PlSqlParser.TIMEZONE_HOUR:
+                        case PlSqlParser.TIMEZONE_MINUTE:
+                        case PlSqlParser.TIMEZONE_OFFSET:
+                        case PlSqlParser.TIMEZONE_REGION:
+                        case PlSqlParser.TIME_ZONE:
+                        case PlSqlParser.TIMING:
+                        case PlSqlParser.TIV_GB:
+                        case PlSqlParser.TIV_SSF:
+                        case PlSqlParser.TO_ACLID:
+                        case PlSqlParser.TO_BINARY_DOUBLE:
+                        case PlSqlParser.TO_BINARY_FLOAT:
+                        case PlSqlParser.TO_BLOB:
+                        case PlSqlParser.TO_CLOB:
+                        case PlSqlParser.TO_DSINTERVAL:
+                        case PlSqlParser.TO_LOB:
+                        case PlSqlParser.TO_MULTI_BYTE:
+                        case PlSqlParser.TO_NCHAR:
+                        case PlSqlParser.TO_NCLOB:
+                        case PlSqlParser.TO_NUMBER:
+                        case PlSqlParser.TOPLEVEL:
+                        case PlSqlParser.TO_SINGLE_BYTE:
+                        case PlSqlParser.TO_TIMESTAMP:
+                        case PlSqlParser.TO_TIMESTAMP_TZ:
+                        case PlSqlParser.TO_TIME:
+                        case PlSqlParser.TO_TIME_TZ:
+                        case PlSqlParser.TO_YMINTERVAL:
+                        case PlSqlParser.TRACE:
+                        case PlSqlParser.TRACING:
+                        case PlSqlParser.TRACKING:
+                        case PlSqlParser.TRAILING:
+                        case PlSqlParser.TRANSACTION:
+                        case PlSqlParser.TRANSFORM:
+                        case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                        case PlSqlParser.TRANSITIONAL:
+                        case PlSqlParser.TRANSITION:
+                        case PlSqlParser.TRANSLATE:
+                        case PlSqlParser.TRANSLATION:
+                        case PlSqlParser.TREAT:
+                        case PlSqlParser.TRIGGERS:
+                        case PlSqlParser.TRIGGER:
+                        case PlSqlParser.TRUE:
+                        case PlSqlParser.TRUNCATE:
+                        case PlSqlParser.TRUNC:
+                        case PlSqlParser.TRUSTED:
+                        case PlSqlParser.TRUST:
+                        case PlSqlParser.TUNING:
+                        case PlSqlParser.TX:
+                        case PlSqlParser.TYPES:
+                        case PlSqlParser.TYPE:
+                        case PlSqlParser.TZ_OFFSET:
+                        case PlSqlParser.UB2:
+                        case PlSqlParser.UBA:
+                        case PlSqlParser.UCS2:
+                        case PlSqlParser.UDF:
+                        case PlSqlParser.UID:
+                        case PlSqlParser.UNARCHIVED:
+                        case PlSqlParser.UNBOUNDED:
+                        case PlSqlParser.UNBOUND:
+                        case PlSqlParser.UNCONDITIONAL:
+                        case PlSqlParser.UNDER:
+                        case PlSqlParser.UNDO:
+                        case PlSqlParser.UNDROP:
+                        case PlSqlParser.UNIFORM:
+                        case PlSqlParser.UNISTR:
+                        case PlSqlParser.UNLIMITED:
+                        case PlSqlParser.UNLOAD:
+                        case PlSqlParser.UNLOCK:
+                        case PlSqlParser.UNMATCHED:
+                        case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                        case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                        case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                        case PlSqlParser.UNNEST:
+                        case PlSqlParser.UNPACKED:
+                        case PlSqlParser.UNPIVOT:
+                        case PlSqlParser.UNPLUG:
+                        case PlSqlParser.UNPROTECTED:
+                        case PlSqlParser.UNQUIESCE:
+                        case PlSqlParser.UNRECOVERABLE:
+                        case PlSqlParser.UNRESTRICTED:
+                        case PlSqlParser.UNSUBSCRIBE:
+                        case PlSqlParser.UNTIL:
+                        case PlSqlParser.UNUSABLE:
+                        case PlSqlParser.UNUSED:
+                        case PlSqlParser.UPDATABLE:
+                        case PlSqlParser.UPDATED:
+                        case PlSqlParser.UPDATEXML:
+                        case PlSqlParser.UPD_INDEXES:
+                        case PlSqlParser.UPD_JOININDEX:
+                        case PlSqlParser.UPGRADE:
+                        case PlSqlParser.UPPER:
+                        case PlSqlParser.UPSERT:
+                        case PlSqlParser.UROWID:
+                        case PlSqlParser.USABLE:
+                        case PlSqlParser.USAGE:
+                        case PlSqlParser.USE_ANTI:
+                        case PlSqlParser.USE_CONCAT:
+                        case PlSqlParser.USE_CUBE:
+                        case PlSqlParser.USE_HASH_AGGREGATION:
+                        case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                        case PlSqlParser.USE_HASH:
+                        case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                        case PlSqlParser.USE_INVISIBLE_INDEXES:
+                        case PlSqlParser.USE_MERGE_CARTESIAN:
+                        case PlSqlParser.USE_MERGE:
+                        case PlSqlParser.USE_NL:
+                        case PlSqlParser.USE_NL_WITH_INDEX:
+                        case PlSqlParser.USE_PRIVATE_OUTLINES:
+                        case PlSqlParser.USER_DATA:
+                        case PlSqlParser.USER_DEFINED:
+                        case PlSqlParser.USERENV:
+                        case PlSqlParser.USERGROUP:
+                        case PlSqlParser.USER_RECYCLEBIN:
+                        case PlSqlParser.USERS:
+                        case PlSqlParser.USER_TABLESPACES:
+                        case PlSqlParser.USER:
+                        case PlSqlParser.USE_SEMI:
+                        case PlSqlParser.USE_STORED_OUTLINES:
+                        case PlSqlParser.USE_TTT_FOR_GSETS:
+                        case PlSqlParser.USE:
+                        case PlSqlParser.USE_VECTOR_AGGREGATION:
+                        case PlSqlParser.USE_WEAK_NAME_RESL:
+                        case PlSqlParser.USING_NO_EXPAND:
+                        case PlSqlParser.USING_NLS_COMP:
+                        case PlSqlParser.USING:
+                        case PlSqlParser.UTF16BE:
+                        case PlSqlParser.UTF16LE:
+                        case PlSqlParser.UTF32:
+                        case PlSqlParser.UTF8:
+                        case PlSqlParser.V1:
+                        case PlSqlParser.V2:
+                        case PlSqlParser.VALIDATE:
+                        case PlSqlParser.VALIDATE_CONVERSION:
+                        case PlSqlParser.VALIDATION:
+                        case PlSqlParser.VALID_TIME_END:
+                        case PlSqlParser.VALUE:
+                        case PlSqlParser.VARCHAR2:
+                        case PlSqlParser.VARCHAR:
+                        case PlSqlParser.VARIABLE:
+                        case PlSqlParser.VAR_POP:
+                        case PlSqlParser.VARRAYS:
+                        case PlSqlParser.VARRAY:
+                        case PlSqlParser.VAR_SAMP:
+                        case PlSqlParser.VARYING:
+                        case PlSqlParser.VECTOR_READ_TRACE:
+                        case PlSqlParser.VECTOR_READ:
+                        case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                        case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                        case PlSqlParser.VECTOR_TRANSFORM:
+                        case PlSqlParser.VERIFIER:
+                        case PlSqlParser.VERIFY:
+                        case PlSqlParser.VERSIONING:
+                        case PlSqlParser.VERSIONS_ENDSCN:
+                        case PlSqlParser.VERSIONS_ENDTIME:
+                        case PlSqlParser.VERSIONS_OPERATION:
+                        case PlSqlParser.VERSIONS_STARTSCN:
+                        case PlSqlParser.VERSIONS_STARTTIME:
+                        case PlSqlParser.VERSIONS:
+                        case PlSqlParser.VERSIONS_XID:
+                        case PlSqlParser.VERSION:
+                        case PlSqlParser.VIOLATION:
+                        case PlSqlParser.VIRTUAL:
+                        case PlSqlParser.VISIBILITY:
+                        case PlSqlParser.VISIBLE:
+                        case PlSqlParser.VOLUME:
+                        case PlSqlParser.VSIZE:
+                        case PlSqlParser.WAIT:
+                        case PlSqlParser.WALLET:
+                        case PlSqlParser.WARNING:
+                        case PlSqlParser.WEEKS:
+                        case PlSqlParser.WEEK:
+                        case PlSqlParser.WELLFORMED:
+                        case PlSqlParser.WHENEVER:
+                        case PlSqlParser.WHEN:
+                        case PlSqlParser.WHILE:
+                        case PlSqlParser.WHITESPACE:
+                        case PlSqlParser.WIDTH_BUCKET:
+                        case PlSqlParser.WITHIN:
+                        case PlSqlParser.WITHOUT:
+                        case PlSqlParser.WITH_PLSQL:
+                        case PlSqlParser.WORK:
+                        case PlSqlParser.WRAPPED:
+                        case PlSqlParser.WRAPPER:
+                        case PlSqlParser.WRITE:
+                        case PlSqlParser.XDB_FASTPATH_INSERT:
+                        case PlSqlParser.X_DYN_PRUNE:
+                        case PlSqlParser.XID:
+                        case PlSqlParser.XML2OBJECT:
+                        case PlSqlParser.XMLAGG:
+                        case PlSqlParser.XMLATTRIBUTES:
+                        case PlSqlParser.XMLCAST:
+                        case PlSqlParser.XMLCDATA:
+                        case PlSqlParser.XMLCOLATTVAL:
+                        case PlSqlParser.XMLCOMMENT:
+                        case PlSqlParser.XMLCONCAT:
+                        case PlSqlParser.XMLDIFF:
+                        case PlSqlParser.XML_DML_RWT_STMT:
+                        case PlSqlParser.XMLELEMENT:
+                        case PlSqlParser.XMLEXISTS2:
+                        case PlSqlParser.XMLEXISTS:
+                        case PlSqlParser.XMLFOREST:
+                        case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                        case PlSqlParser.XMLINDEX_REWRITE:
+                        case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                        case PlSqlParser.XMLISNODE:
+                        case PlSqlParser.XMLISVALID:
+                        case PlSqlParser.XMLNAMESPACES:
+                        case PlSqlParser.XMLPARSE:
+                        case PlSqlParser.XMLPATCH:
+                        case PlSqlParser.XMLPI:
+                        case PlSqlParser.XMLQUERYVAL:
+                        case PlSqlParser.XMLQUERY:
+                        case PlSqlParser.XMLROOT:
+                        case PlSqlParser.XMLSCHEMA:
+                        case PlSqlParser.XMLSERIALIZE:
+                        case PlSqlParser.XMLTABLE:
+                        case PlSqlParser.XMLTRANSFORMBLOB:
+                        case PlSqlParser.XMLTRANSFORM:
+                        case PlSqlParser.XMLTYPE:
+                        case PlSqlParser.XML:
+                        case PlSqlParser.XPATHTABLE:
+                        case PlSqlParser.XS_SYS_CONTEXT:
+                        case PlSqlParser.XS:
+                        case PlSqlParser.YEARS:
+                        case PlSqlParser.YEAR:
+                        case PlSqlParser.YES:
+                        case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                        case PlSqlParser.ZONEMAP:
+                        case PlSqlParser.ZONE:
+                        case PlSqlParser.PREDICTION:
+                        case PlSqlParser.PREDICTION_BOUNDS:
+                        case PlSqlParser.PREDICTION_COST:
+                        case PlSqlParser.PREDICTION_DETAILS:
+                        case PlSqlParser.PREDICTION_PROBABILITY:
+                        case PlSqlParser.PREDICTION_SET:
+                        case PlSqlParser.BLOCKCHAIN:
+                        case PlSqlParser.COLLATE:
+                        case PlSqlParser.COLLATION:
+                        case PlSqlParser.DEFINITION:
+                        case PlSqlParser.DUPLICATED:
+                        case PlSqlParser.EXTENDED:
+                        case PlSqlParser.HASHING:
+                        case PlSqlParser.IDLE:
+                        case PlSqlParser.IMMUTABLE:
+                        case PlSqlParser.ORACLE_DATAPUMP:
+                        case PlSqlParser.ORACLE_HDFS:
+                        case PlSqlParser.ORACLE_HIVE:
+                        case PlSqlParser.ORACLE_LOADER:
+                        case PlSqlParser.SHARDED:
+                        case PlSqlParser.ISOLATE:
+                        case PlSqlParser.ROOT:
+                        case PlSqlParser.UNITE:
+                        case PlSqlParser.ALGORITHM:
+                        case PlSqlParser.CUME_DIST:
+                        case PlSqlParser.DENSE_RANK:
+                        case PlSqlParser.LISTAGG:
+                        case PlSqlParser.PERCENT_RANK:
+                        case PlSqlParser.PERCENTILE_CONT:
+                        case PlSqlParser.PERCENTILE_DISC:
+                        case PlSqlParser.RANK:
+                        case PlSqlParser.AVG:
+                        case PlSqlParser.CORR:
+                        case PlSqlParser.COVAR_:
+                        case PlSqlParser.LAG:
+                        case PlSqlParser.LEAD:
+                        case PlSqlParser.MAX:
+                        case PlSqlParser.MEDIAN:
+                        case PlSqlParser.MEMOPTIMIZE:
+                        case PlSqlParser.MIN:
+                        case PlSqlParser.NTILE:
+                        case PlSqlParser.NVL:
+                        case PlSqlParser.RATIO_TO_REPORT:
+                        case PlSqlParser.REGR_:
+                        case PlSqlParser.ROUND:
+                        case PlSqlParser.ROW_NUMBER:
+                        case PlSqlParser.SUBSTR:
+                        case PlSqlParser.TO_CHAR:
+                        case PlSqlParser.TRIM:
+                        case PlSqlParser.SUM:
+                        case PlSqlParser.STDDEV:
+                        case PlSqlParser.VAR_:
+                        case PlSqlParser.VARIANCE:
+                        case PlSqlParser.LEAST:
+                        case PlSqlParser.GREATEST:
+                        case PlSqlParser.TO_DATE:
+                        case PlSqlParser.CHARSETID:
+                        case PlSqlParser.CHARSETFORM:
+                        case PlSqlParser.DURATION:
+                        case PlSqlParser.EXTEND:
+                        case PlSqlParser.MAXLEN:
+                        case PlSqlParser.PERSISTABLE:
+                        case PlSqlParser.POLYMORPHIC:
+                        case PlSqlParser.STRUCT:
+                        case PlSqlParser.TDO:
+                        case PlSqlParser.WM_CONCAT:
+                        case PlSqlParser.PERIOD:
+                        case PlSqlParser.DELIMITED_ID:
+                        case PlSqlParser.REGULAR_ID:
+                            {
+                            this.state = 15242;
+                            this.tablespace();
+                            }
+                            break;
+                        case PlSqlParser.DEFAULT:
+                            {
+                            this.state = 15243;
+                            this.match(PlSqlParser.DEFAULT);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    case PlSqlParser.COMPRESS:
+                    case PlSqlParser.NOCOMPRESS:
+                        {
+                        this.state = 15246;
+                        this.key_compression();
+                        }
+                        break;
+                    case PlSqlParser.NOSORT:
+                    case PlSqlParser.SORT:
+                        {
+                        this.state = 15247;
+                        this.sort_or_nosort();
+                        }
+                        break;
+                    case PlSqlParser.REVERSE:
+                        {
+                        this.state = 15248;
+                        this.match(PlSqlParser.REVERSE);
+                        }
+                        break;
+                    case PlSqlParser.INVISIBLE:
+                    case PlSqlParser.VISIBLE:
+                        {
+                        this.state = 15249;
+                        this.visible_or_invisible();
+                        }
+                        break;
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.PARALLEL:
+                        {
+                        this.state = 15250;
+                        this.parallel_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15253;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2022, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sort_or_nosort(): Sort_or_nosortContext {
+        let localContext = new Sort_or_nosortContext(this.context, this.state);
+        this.enterRule(localContext, 1608, PlSqlParser.RULE_sort_or_nosort);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15255;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1190 || _la === 1711)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public exceptions_clause(): Exceptions_clauseContext {
+        let localContext = new Exceptions_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1610, PlSqlParser.RULE_exceptions_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15257;
+            this.match(PlSqlParser.EXCEPTIONS);
+            this.state = 15258;
+            this.match(PlSqlParser.INTO);
+            this.state = 15259;
+            this.tableview_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public move_table_clause(): Move_table_clauseContext {
+        let localContext = new Move_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1612, PlSqlParser.RULE_move_table_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15261;
+            this.match(PlSqlParser.MOVE);
+            this.state = 15263;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2023, this.context) ) {
+            case 1:
+                {
+                this.state = 15262;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            }
+            this.state = 15266;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2024, this.context) ) {
+            case 1:
+                {
+                this.state = 15265;
+                this.segment_attributes_clause();
+                }
+                break;
+            }
+            this.state = 15269;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2025, this.context) ) {
+            case 1:
+                {
+                this.state = 15268;
+                this.table_compression();
+                }
+                break;
+            }
+            this.state = 15272;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2026, this.context) ) {
+            case 1:
+                {
+                this.state = 15271;
+                this.index_org_table_clause();
+                }
+                break;
+            }
+            this.state = 15278;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2028, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 15276;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.LOB:
+                        {
+                        this.state = 15274;
+                        this.lob_storage_clause();
+                        }
+                        break;
+                    case PlSqlParser.VARRAY:
+                        {
+                        this.state = 15275;
+                        this.varray_col_properties();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 15280;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2028, this.context);
+            }
+            this.state = 15282;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2029, this.context) ) {
+            case 1:
+                {
+                this.state = 15281;
+                this.parallel_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_to_partitioned(): Modify_to_partitionedContext {
+        let localContext = new Modify_to_partitionedContext(this.context, this.state);
+        this.enterRule(localContext, 1614, PlSqlParser.RULE_modify_to_partitioned);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15284;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 15287;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+                {
+                this.state = 15285;
+                this.table_partitioning_clauses();
+                }
+                break;
+            case PlSqlParser.NONPARTITIONED:
+                {
+                this.state = 15286;
+                this.match(PlSqlParser.NONPARTITIONED);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 15290;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2031, this.context) ) {
+            case 1:
+                {
+                this.state = 15289;
+                this.filter_condition();
+                }
+                break;
+            }
+            this.state = 15293;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2032, this.context) ) {
+            case 1:
+                {
+                this.state = 15292;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            }
+            this.state = 15296;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2033, this.context) ) {
+            case 1:
+                {
+                this.state = 15295;
+                this.update_index_clauses();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_org_table_clause(): Index_org_table_clauseContext {
+        let localContext = new Index_org_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1616, PlSqlParser.RULE_index_org_table_clause);
+        try {
+            let alternative: number;
+            this.state = 15310;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.PCTTHRESHOLD:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15302;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 15302;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.MAPPING:
+                        case PlSqlParser.NOMAPPING:
+                            {
+                            this.state = 15298;
+                            this.mapping_table_clause();
+                            }
+                            break;
+                        case PlSqlParser.PCTTHRESHOLD:
+                            {
+                            this.state = 15299;
+                            this.match(PlSqlParser.PCTTHRESHOLD);
+                            this.state = 15300;
+                            this.match(PlSqlParser.UNSIGNED_INTEGER);
+                            }
+                            break;
+                        case PlSqlParser.COMPRESS:
+                        case PlSqlParser.NOCOMPRESS:
+                            {
+                            this.state = 15301;
+                            this.key_compression();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 15304;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2035, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                this.state = 15307;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2036, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15306;
+                    this.index_org_overflow_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.OVERFLOW_:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15309;
+                this.index_org_overflow_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public mapping_table_clause(): Mapping_table_clauseContext {
+        let localContext = new Mapping_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1618, PlSqlParser.RULE_mapping_table_clause);
+        try {
+            this.state = 15315;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MAPPING:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15312;
+                this.match(PlSqlParser.MAPPING);
+                this.state = 15313;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case PlSqlParser.NOMAPPING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15314;
+                this.match(PlSqlParser.NOMAPPING);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public key_compression(): Key_compressionContext {
+        let localContext = new Key_compressionContext(this.context, this.state);
+        this.enterRule(localContext, 1620, PlSqlParser.RULE_key_compression);
+        try {
+            this.state = 15320;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOCOMPRESS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15317;
+                this.match(PlSqlParser.NOCOMPRESS);
+                }
+                break;
+            case PlSqlParser.COMPRESS:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15318;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 15319;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_org_overflow_clause(): Index_org_overflow_clauseContext {
+        let localContext = new Index_org_overflow_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1622, PlSqlParser.RULE_index_org_overflow_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15324;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 706) {
+                {
+                this.state = 15322;
+                this.match(PlSqlParser.INCLUDING);
+                this.state = 15323;
+                this.column_name();
+                }
+            }
+
+            this.state = 15326;
+            this.match(PlSqlParser.OVERFLOW_);
+            this.state = 15328;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2041, this.context) ) {
+            case 1:
+                {
+                this.state = 15327;
+                this.segment_attributes_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_clauses(): Column_clausesContext {
+        let localContext = new Column_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1624, PlSqlParser.RULE_column_clauses);
+        try {
+            this.state = 15334;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2042, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15330;
+                this.add_modify_drop_column_clauses();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15331;
+                this.rename_column_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 15332;
+                this.modify_collection_retrieval();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 15333;
+                this.modify_lob_storage_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_collection_retrieval(): Modify_collection_retrievalContext {
+        let localContext = new Modify_collection_retrievalContext(this.context, this.state);
+        this.enterRule(localContext, 1626, PlSqlParser.RULE_modify_collection_retrieval);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15336;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 15337;
+            this.match(PlSqlParser.NESTED);
+            this.state = 15338;
+            this.match(PlSqlParser.TABLE);
+            this.state = 15339;
+            this.collection_item();
+            this.state = 15340;
+            this.match(PlSqlParser.RETURN);
+            this.state = 15341;
+            this.match(PlSqlParser.AS);
+            this.state = 15342;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 878 || _la === 2260)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public collection_item(): Collection_itemContext {
+        let localContext = new Collection_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1628, PlSqlParser.RULE_collection_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15344;
+            this.tableview_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rename_column_clause(): Rename_column_clauseContext {
+        let localContext = new Rename_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1630, PlSqlParser.RULE_rename_column_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15346;
+            this.match(PlSqlParser.RENAME);
+            this.state = 15347;
+            this.match(PlSqlParser.COLUMN);
+            this.state = 15348;
+            this.old_column_name();
+            this.state = 15349;
+            this.match(PlSqlParser.TO);
+            this.state = 15350;
+            this.new_column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public old_column_name(): Old_column_nameContext {
+        let localContext = new Old_column_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1632, PlSqlParser.RULE_old_column_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15352;
+            this.column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public new_column_name(): New_column_nameContext {
+        let localContext = new New_column_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1634, PlSqlParser.RULE_new_column_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15354;
+            this.column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_modify_drop_column_clauses(): Add_modify_drop_column_clausesContext {
+        let localContext = new Add_modify_drop_column_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1636, PlSqlParser.RULE_add_modify_drop_column_clauses);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15360;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 15360;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2043, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 15356;
+                        this.constraint_clauses();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 15357;
+                        this.add_column_clause();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 15358;
+                        this.modify_column_clauses();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 15359;
+                        this.drop_column_clause();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15362;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2044, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_column_clause(): Drop_column_clauseContext {
+        let localContext = new Drop_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1638, PlSqlParser.RULE_drop_column_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 15426;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2055, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15364;
+                this.match(PlSqlParser.SET);
+                this.state = 15365;
+                this.match(PlSqlParser.UNUSED);
+                this.state = 15379;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.COLUMN:
+                    {
+                    this.state = 15366;
+                    this.match(PlSqlParser.COLUMN);
+                    this.state = 15367;
+                    this.column_name();
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    {
+                    this.state = 15368;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 15369;
+                    this.column_name();
+                    this.state = 15374;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 15370;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 15371;
+                        this.column_name();
+                        }
+                        }
+                        this.state = 15376;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 15377;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15386;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2048, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        this.state = 15384;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.CASCADE:
+                            {
+                            this.state = 15381;
+                            this.match(PlSqlParser.CASCADE);
+                            this.state = 15382;
+                            this.match(PlSqlParser.CONSTRAINTS);
+                            }
+                            break;
+                        case PlSqlParser.INVALIDATE:
+                            {
+                            this.state = 15383;
+                            this.match(PlSqlParser.INVALIDATE);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                    }
+                    this.state = 15388;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2048, this.context);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15389;
+                this.match(PlSqlParser.DROP);
+                this.state = 15403;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.COLUMN:
+                    {
+                    this.state = 15390;
+                    this.match(PlSqlParser.COLUMN);
+                    this.state = 15391;
+                    this.column_name();
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 15392;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 15393;
+                    this.column_name();
+                    this.state = 15398;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 15394;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 15395;
+                        this.column_name();
+                        }
+                        }
+                        this.state = 15400;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 15401;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15410;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2052, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        this.state = 15408;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.CASCADE:
+                            {
+                            this.state = 15405;
+                            this.match(PlSqlParser.CASCADE);
+                            this.state = 15406;
+                            this.match(PlSqlParser.CONSTRAINTS);
+                            }
+                            break;
+                        case PlSqlParser.INVALIDATE:
+                            {
+                            this.state = 15407;
+                            this.match(PlSqlParser.INVALIDATE);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                    }
+                    this.state = 15412;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2052, this.context);
+                }
+                this.state = 15415;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2053, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15413;
+                    this.match(PlSqlParser.CHECKPOINT);
+                    this.state = 15414;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 15417;
+                this.match(PlSqlParser.DROP);
+                this.state = 15422;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNUSED:
+                    {
+                    this.state = 15418;
+                    this.match(PlSqlParser.UNUSED);
+                    this.state = 15419;
+                    this.match(PlSqlParser.COLUMNS);
+                    }
+                    break;
+                case PlSqlParser.COLUMNS:
+                    {
+                    this.state = 15420;
+                    this.match(PlSqlParser.COLUMNS);
+                    this.state = 15421;
+                    this.match(PlSqlParser.CONTINUE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                {
+                this.state = 15424;
+                this.match(PlSqlParser.CHECKPOINT);
+                this.state = 15425;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_column_clauses(): Modify_column_clausesContext {
+        let localContext = new Modify_column_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1640, PlSqlParser.RULE_modify_column_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15428;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 15454;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2058, this.context) ) {
+            case 1:
+                {
+                this.state = 15429;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15430;
+                this.modify_col_properties();
+                this.state = 15435;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15431;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15432;
+                    this.modify_col_properties();
+                    }
+                    }
+                    this.state = 15437;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15438;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 15440;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15441;
+                this.modify_col_visibility();
+                this.state = 15446;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15442;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15443;
+                    this.modify_col_visibility();
+                    }
+                    }
+                    this.state = 15448;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15449;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                {
+                this.state = 15451;
+                this.modify_col_properties();
+                }
+                break;
+            case 4:
+                {
+                this.state = 15452;
+                this.modify_col_visibility();
+                }
+                break;
+            case 5:
+                {
+                this.state = 15453;
+                this.modify_col_substitutable();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_col_properties(): Modify_col_propertiesContext {
+        let localContext = new Modify_col_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1642, PlSqlParser.RULE_modify_col_properties);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15456;
+            this.column_name();
+            this.state = 15458;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2059, this.context) ) {
+            case 1:
+                {
+                this.state = 15457;
+                this.datatype();
+                }
+                break;
+            }
+            this.state = 15469;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2061, this.context) ) {
+            case 1:
+                {
+                this.state = 15460;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 15463;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2060, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15461;
+                    this.match(PlSqlParser.ON);
+                    this.state = 15462;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                    break;
+                }
+                this.state = 15465;
+                this.expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 15466;
+                this.identity_clause();
+                }
+                break;
+            case 3:
+                {
+                this.state = 15467;
+                this.match(PlSqlParser.DROP);
+                this.state = 15468;
+                this.match(PlSqlParser.IDENTITY);
+                }
+                break;
+            }
+            this.state = 15474;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2062, this.context) ) {
+            case 1:
+                {
+                this.state = 15471;
+                this.match(PlSqlParser.ENCRYPT);
+                this.state = 15472;
+                this.encryption_spec();
+                }
+                break;
+            case 2:
+                {
+                this.state = 15473;
+                this.match(PlSqlParser.DECRYPT);
+                }
+                break;
+            }
+            this.state = 15479;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2063, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 15476;
+                    this.inline_constraint();
+                    }
+                    }
+                }
+                this.state = 15481;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2063, this.context);
+            }
+            this.state = 15483;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2064, this.context) ) {
+            case 1:
+                {
+                this.state = 15482;
+                this.lob_storage_clause();
+                }
+                break;
+            }
+            this.state = 15486;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2065, this.context) ) {
+            case 1:
+                {
+                this.state = 15485;
+                this.annotations_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_col_visibility(): Modify_col_visibilityContext {
+        let localContext = new Modify_col_visibilityContext(this.context, this.state);
+        this.enterRule(localContext, 1644, PlSqlParser.RULE_modify_col_visibility);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15488;
+            this.column_name();
+            this.state = 15489;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 783 || _la === 2292)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_col_substitutable(): Modify_col_substitutableContext {
+        let localContext = new Modify_col_substitutableContext(this.context, this.state);
+        this.enterRule(localContext, 1646, PlSqlParser.RULE_modify_col_substitutable);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15491;
+            this.match(PlSqlParser.COLUMN);
+            this.state = 15492;
+            this.column_name();
+            this.state = 15494;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 15493;
+                this.match(PlSqlParser.NOT);
+                }
+            }
+
+            this.state = 15496;
+            this.match(PlSqlParser.SUBSTITUTABLE);
+            this.state = 15497;
+            this.match(PlSqlParser.AT);
+            this.state = 15498;
+            this.match(PlSqlParser.ALL);
+            this.state = 15499;
+            this.match(PlSqlParser.LEVELS);
+            this.state = 15501;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2067, this.context) ) {
+            case 1:
+                {
+                this.state = 15500;
+                this.match(PlSqlParser.FORCE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_column_clause(): Add_column_clauseContext {
+        let localContext = new Add_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1648, PlSqlParser.RULE_add_column_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15503;
+            this.match(PlSqlParser.ADD);
+            this.state = 15525;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 15504;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15507;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2068, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15505;
+                    this.column_definition();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 15506;
+                    this.virtual_column_definition();
+                    }
+                    break;
+                }
+                this.state = 15516;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15509;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15512;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2069, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 15510;
+                        this.column_definition();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 15511;
+                        this.virtual_column_definition();
+                        }
+                        break;
+                    }
+                    }
+                    }
+                    this.state = 15518;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15519;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 15523;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2071, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15521;
+                    this.column_definition();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 15522;
+                    this.virtual_column_definition();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 15528;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2073, this.context) ) {
+            case 1:
+                {
+                this.state = 15527;
+                this.column_properties();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public varray_col_properties(): Varray_col_propertiesContext {
+        let localContext = new Varray_col_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1650, PlSqlParser.RULE_varray_col_properties);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15530;
+            this.match(PlSqlParser.VARRAY);
+            this.state = 15531;
+            this.varray_item();
+            this.state = 15537;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2075, this.context) ) {
+            case 1:
+                {
+                this.state = 15533;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 486 || _la === 786 || _la === 1206 || _la === 1782) {
+                    {
+                    this.state = 15532;
+                    this.substitutable_column_clause();
+                    }
+                }
+
+                this.state = 15535;
+                this.varray_storage_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 15536;
+                this.substitutable_column_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public varray_storage_clause(): Varray_storage_clauseContext {
+        let localContext = new Varray_storage_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1652, PlSqlParser.RULE_varray_storage_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15539;
+            this.match(PlSqlParser.STORE);
+            this.state = 15540;
+            this.match(PlSqlParser.AS);
+            this.state = 15542;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 107 || _la === 1642) {
+                {
+                this.state = 15541;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 107 || _la === 1642)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 15544;
+            this.match(PlSqlParser.LOB);
+            this.state = 15553;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2078, this.context) ) {
+            case 1:
+                {
+                this.state = 15546;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                    {
+                    this.state = 15545;
+                    this.lob_segname();
+                    }
+                }
+
+                this.state = 15548;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15549;
+                this.lob_storage_parameters();
+                this.state = 15550;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 15552;
+                this.lob_segname();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_segname(): Lob_segnameContext {
+        let localContext = new Lob_segnameContext(this.context, this.state);
+        this.enterRule(localContext, 1654, PlSqlParser.RULE_lob_segname);
+        try {
+            this.state = 15557;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15555;
+                this.regular_id();
+                }
+                break;
+            case PlSqlParser.DELIMITED_ID:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15556;
+                this.match(PlSqlParser.DELIMITED_ID);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_item(): Lob_itemContext {
+        let localContext = new Lob_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1656, PlSqlParser.RULE_lob_item);
+        try {
+            this.state = 15562;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15559;
+                this.regular_id();
+                }
+                break;
+            case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15560;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.DELIMITED_ID:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 15561;
+                this.match(PlSqlParser.DELIMITED_ID);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_storage_parameters(): Lob_storage_parametersContext {
+        let localContext = new Lob_storage_parametersContext(this.context, this.state);
+        this.enterRule(localContext, 1658, PlSqlParser.RULE_lob_storage_parameters);
+        try {
+            this.state = 15571;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TABLESPACE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15564;
+                this.match(PlSqlParser.TABLESPACE);
+                this.state = 15565;
+                localContext._tablespace_name = this.id_expression();
+                }
+                break;
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.RETENTION:
+                this.enterOuterAlt(localContext, 2);
+                {
+                {
+                this.state = 15566;
+                this.lob_parameters();
+                this.state = 15568;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2081, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15567;
+                    this.storage_clause();
+                    }
+                    break;
+                }
+                }
+                }
+                break;
+            case PlSqlParser.STORAGE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 15570;
+                this.storage_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_storage_clause(): Lob_storage_clauseContext {
+        let localContext = new Lob_storage_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1660, PlSqlParser.RULE_lob_storage_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15573;
+            this.match(PlSqlParser.LOB);
+            this.state = 15618;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2090, this.context) ) {
+            case 1:
+                {
+                this.state = 15574;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15575;
+                this.lob_item();
+                this.state = 15580;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 15576;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 15577;
+                    this.lob_item();
+                    }
+                    }
+                    this.state = 15582;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 15583;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 15584;
+                this.match(PlSqlParser.STORE);
+                this.state = 15585;
+                this.match(PlSqlParser.AS);
+                this.state = 15595;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 15595;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.BASICFILE:
+                        case PlSqlParser.SECUREFILE:
+                            {
+                            this.state = 15586;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 107 || _la === 1642)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        case PlSqlParser.LEFT_PAREN:
+                            {
+                            this.state = 15587;
+                            this.match(PlSqlParser.LEFT_PAREN);
+                            this.state = 15591;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            while (_la === 166 || _la === 205 || _la === 258 || _la === 387 || _la === 388 || _la === 429 || _la === 499 || _la === 505 || _la === 627 || _la === 814 || _la === 1067 || _la === 1075 || _la === 1375 || _la === 1585 || _la === 1764 || _la === 2082) {
+                                {
+                                {
+                                this.state = 15588;
+                                this.lob_storage_parameters();
+                                }
+                                }
+                                this.state = 15593;
+                                this.errorHandler.sync(this);
+                                _la = this.tokenStream.LA(1);
+                            }
+                            this.state = 15594;
+                            this.match(PlSqlParser.RIGHT_PAREN);
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 15597;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2086, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 2:
+                {
+                this.state = 15599;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15600;
+                this.lob_item();
+                this.state = 15601;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 15602;
+                this.match(PlSqlParser.STORE);
+                this.state = 15603;
+                this.match(PlSqlParser.AS);
+                this.state = 15614;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 15614;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 2088, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 15604;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 107 || _la === 1642)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 15605;
+                            this.lob_segname();
+                            }
+                            break;
+                        case 3:
+                            {
+                            this.state = 15606;
+                            this.match(PlSqlParser.LEFT_PAREN);
+                            this.state = 15610;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            while (_la === 166 || _la === 205 || _la === 258 || _la === 387 || _la === 388 || _la === 429 || _la === 499 || _la === 505 || _la === 627 || _la === 814 || _la === 1067 || _la === 1075 || _la === 1375 || _la === 1585 || _la === 1764 || _la === 2082) {
+                                {
+                                {
+                                this.state = 15607;
+                                this.lob_storage_parameters();
+                                }
+                                }
+                                this.state = 15612;
+                                this.errorHandler.sync(this);
+                                _la = this.tokenStream.LA(1);
+                            }
+                            this.state = 15613;
+                            this.match(PlSqlParser.RIGHT_PAREN);
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 15616;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2089, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_lob_storage_clause(): Modify_lob_storage_clauseContext {
+        let localContext = new Modify_lob_storage_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1662, PlSqlParser.RULE_modify_lob_storage_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15620;
+            this.match(PlSqlParser.MODIFY);
+            this.state = 15621;
+            this.match(PlSqlParser.LOB);
+            this.state = 15622;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 15623;
+            this.lob_item();
+            this.state = 15624;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 15625;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 15626;
+            this.modify_lob_parameters();
+            this.state = 15627;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public modify_lob_parameters(): Modify_lob_parametersContext {
+        let localContext = new Modify_lob_parametersContext(this.context, this.state);
+        this.enterRule(localContext, 1664, PlSqlParser.RULE_modify_lob_parameters);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15653;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                this.state = 15653;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2093, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15629;
+                    this.storage_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 15630;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 627 || _la === 1375)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 15631;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 15632;
+                    this.match(PlSqlParser.REBUILD);
+                    this.state = 15633;
+                    this.match(PlSqlParser.FREEPOOLS);
+                    }
+                    break;
+                case 4:
+                    {
+                    this.state = 15634;
+                    this.lob_retention_clause();
+                    }
+                    break;
+                case 5:
+                    {
+                    this.state = 15635;
+                    this.lob_deduplicate_clause();
+                    }
+                    break;
+                case 6:
+                    {
+                    this.state = 15636;
+                    this.lob_compression_clause();
+                    }
+                    break;
+                case 7:
+                    {
+                    this.state = 15637;
+                    this.match(PlSqlParser.ENCRYPT);
+                    this.state = 15638;
+                    this.encryption_spec();
+                    }
+                    break;
+                case 8:
+                    {
+                    this.state = 15639;
+                    this.match(PlSqlParser.DECRYPT);
+                    }
+                    break;
+                case 9:
+                    {
+                    this.state = 15640;
+                    this.match(PlSqlParser.CACHE);
+                    }
+                    break;
+                case 10:
+                    {
+                    this.state = 15645;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2091, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 15641;
+                        this.match(PlSqlParser.CACHE);
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 15642;
+                        this.match(PlSqlParser.NOCACHE);
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 15643;
+                        this.match(PlSqlParser.CACHE);
+                        this.state = 15644;
+                        this.match(PlSqlParser.READS);
+                        }
+                        break;
+                    }
+                    this.state = 15648;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 594 || _la === 885 || _la === 1120) {
+                        {
+                        this.state = 15647;
+                        this.logging_clause();
+                        }
+                    }
+
+                    }
+                    break;
+                case 11:
+                    {
+                    this.state = 15650;
+                    this.allocate_extent_clause();
+                    }
+                    break;
+                case 12:
+                    {
+                    this.state = 15651;
+                    this.shrink_clause();
+                    }
+                    break;
+                case 13:
+                    {
+                    this.state = 15652;
+                    this.deallocate_unused_clause();
+                    }
+                    break;
+                }
+                }
+                this.state = 15655;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 39 || _la === 166 || _la === 258 || ((((_la - 377)) & ~0x1F) === 0 && ((1 << (_la - 377)) & 3073) !== 0) || _la === 505 || _la === 627 || _la === 814 || _la === 1067 || _la === 1075 || _la === 1375 || _la === 1513 || _la === 1585 || _la === 1686 || _la === 1764);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_parameters(): Lob_parametersContext {
+        let localContext = new Lob_parametersContext(this.context, this.state);
+        this.enterRule(localContext, 1666, PlSqlParser.RULE_lob_parameters);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15685;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 15685;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.DISABLE:
+                    case PlSqlParser.ENABLE:
+                        {
+                        this.state = 15657;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 429 || _la === 499)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 15658;
+                        this.match(PlSqlParser.STORAGE);
+                        this.state = 15659;
+                        this.match(PlSqlParser.IN);
+                        this.state = 15660;
+                        this.match(PlSqlParser.ROW);
+                        this.state = 15662;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 2443) {
+                            {
+                            this.state = 15661;
+                            this.match(PlSqlParser.UNSIGNED_INTEGER);
+                            }
+                        }
+
+                        }
+                        break;
+                    case PlSqlParser.CHUNK:
+                        {
+                        this.state = 15664;
+                        this.match(PlSqlParser.CHUNK);
+                        this.state = 15665;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.PCTVERSION:
+                        {
+                        this.state = 15666;
+                        this.match(PlSqlParser.PCTVERSION);
+                        this.state = 15667;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.FREEPOOLS:
+                        {
+                        this.state = 15668;
+                        this.match(PlSqlParser.FREEPOOLS);
+                        this.state = 15669;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.RETENTION:
+                        {
+                        this.state = 15670;
+                        this.lob_retention_clause();
+                        }
+                        break;
+                    case PlSqlParser.DEDUPLICATE:
+                    case PlSqlParser.KEEP_DUPLICATES:
+                        {
+                        this.state = 15671;
+                        this.lob_deduplicate_clause();
+                        }
+                        break;
+                    case PlSqlParser.COMPRESS:
+                    case PlSqlParser.NOCOMPRESS:
+                        {
+                        this.state = 15672;
+                        this.lob_compression_clause();
+                        }
+                        break;
+                    case PlSqlParser.ENCRYPT:
+                        {
+                        this.state = 15673;
+                        this.match(PlSqlParser.ENCRYPT);
+                        this.state = 15674;
+                        this.encryption_spec();
+                        }
+                        break;
+                    case PlSqlParser.DECRYPT:
+                        {
+                        this.state = 15675;
+                        this.match(PlSqlParser.DECRYPT);
+                        }
+                        break;
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.NOCACHE:
+                        {
+                        this.state = 15680;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 2096, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 15676;
+                            this.match(PlSqlParser.CACHE);
+                            }
+                            break;
+                        case 2:
+                            {
+                            this.state = 15677;
+                            this.match(PlSqlParser.NOCACHE);
+                            }
+                            break;
+                        case 3:
+                            {
+                            this.state = 15678;
+                            this.match(PlSqlParser.CACHE);
+                            this.state = 15679;
+                            this.match(PlSqlParser.READS);
+                            }
+                            break;
+                        }
+                        this.state = 15683;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 594 || _la === 885 || _la === 1120) {
+                            {
+                            this.state = 15682;
+                            this.logging_clause();
+                            }
+                        }
+
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15687;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2099, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_deduplicate_clause(): Lob_deduplicate_clauseContext {
+        let localContext = new Lob_deduplicate_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1668, PlSqlParser.RULE_lob_deduplicate_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15689;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 388 || _la === 814)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_compression_clause(): Lob_compression_clauseContext {
+        let localContext = new Lob_compression_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1670, PlSqlParser.RULE_lob_compression_clause);
+        let _la: number;
+        try {
+            this.state = 15696;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NOCOMPRESS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15691;
+                this.match(PlSqlParser.NOCOMPRESS);
+                }
+                break;
+            case PlSqlParser.COMPRESS:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15692;
+                this.match(PlSqlParser.COMPRESS);
+                this.state = 15694;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 676 || _la === 898 || _la === 936) {
+                    {
+                    this.state = 15693;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 676 || _la === 898 || _la === 936)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_retention_clause(): Lob_retention_clauseContext {
+        let localContext = new Lob_retention_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1672, PlSqlParser.RULE_lob_retention_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15698;
+            this.match(PlSqlParser.RETENTION);
+            this.state = 15704;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MAX:
+                {
+                this.state = 15699;
+                this.match(PlSqlParser.MAX);
+                }
+                break;
+            case PlSqlParser.MIN:
+                {
+                this.state = 15700;
+                this.match(PlSqlParser.MIN);
+                this.state = 15701;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case PlSqlParser.AUTO:
+                {
+                this.state = 15702;
+                this.match(PlSqlParser.AUTO);
+                }
+                break;
+            case PlSqlParser.NONE:
+                {
+                this.state = 15703;
+                this.match(PlSqlParser.NONE);
+                }
+                break;
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.COMPRESS:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NOCOMPRESS:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.RIGHT_PAREN:
+                break;
+            default:
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public encryption_spec(): Encryption_specContext {
+        let localContext = new Encryption_specContext(this.context, this.state);
+        this.enterRule(localContext, 1674, PlSqlParser.RULE_encryption_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15708;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2103, this.context) ) {
+            case 1:
+                {
+                this.state = 15706;
+                this.match(PlSqlParser.USING);
+                this.state = 15707;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            this.state = 15713;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2104, this.context) ) {
+            case 1:
+                {
+                this.state = 15710;
+                this.match(PlSqlParser.IDENTIFIED);
+                this.state = 15711;
+                this.match(PlSqlParser.BY);
+                this.state = 15712;
+                this.match(PlSqlParser.REGULAR_ID);
+                }
+                break;
+            }
+            this.state = 15716;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2105, this.context) ) {
+            case 1:
+                {
+                this.state = 15715;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            }
+            this.state = 15722;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2107, this.context) ) {
+            case 1:
+                {
+                this.state = 15719;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1139) {
+                    {
+                    this.state = 15718;
+                    this.match(PlSqlParser.NO);
+                    }
+                }
+
+                this.state = 15721;
+                this.match(PlSqlParser.SALT);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tablespace(): TablespaceContext {
+        let localContext = new TablespaceContext(this.context, this.state);
+        this.enterRule(localContext, 1676, PlSqlParser.RULE_tablespace);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15724;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public varray_item(): Varray_itemContext {
+        let localContext = new Varray_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1678, PlSqlParser.RULE_varray_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15729;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2108, this.context) ) {
+            case 1:
+                {
+                this.state = 15726;
+                this.id_expression();
+                this.state = 15727;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 15734;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2109, this.context) ) {
+            case 1:
+                {
+                this.state = 15731;
+                this.id_expression();
+                this.state = 15732;
+                this.match(PlSqlParser.PERIOD);
+                }
+                break;
+            }
+            this.state = 15736;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_properties(): Column_propertiesContext {
+        let localContext = new Column_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1680, PlSqlParser.RULE_column_properties);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15758;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 15758;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COLUMN:
+                        {
+                        this.state = 15738;
+                        this.object_type_col_properties();
+                        }
+                        break;
+                    case PlSqlParser.NESTED:
+                        {
+                        this.state = 15739;
+                        this.nested_table_col_properties();
+                        }
+                        break;
+                    case PlSqlParser.LOB:
+                    case PlSqlParser.VARRAY:
+                        {
+                        this.state = 15742;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.VARRAY:
+                            {
+                            this.state = 15740;
+                            this.varray_col_properties();
+                            }
+                            break;
+                        case PlSqlParser.LOB:
+                            {
+                            this.state = 15741;
+                            this.lob_storage_clause();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 15755;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 2112, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 15744;
+                            this.match(PlSqlParser.LEFT_PAREN);
+                            this.state = 15745;
+                            this.lob_partition_storage();
+                            this.state = 15750;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            while (_la === 2455) {
+                                {
+                                {
+                                this.state = 15746;
+                                this.match(PlSqlParser.COMMA);
+                                this.state = 15747;
+                                this.lob_partition_storage();
+                                }
+                                }
+                                this.state = 15752;
+                                this.errorHandler.sync(this);
+                                _la = this.tokenStream.LA(1);
+                            }
+                            this.state = 15753;
+                            this.match(PlSqlParser.RIGHT_PAREN);
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    case PlSqlParser.XMLTYPE:
+                        {
+                        this.state = 15757;
+                        this.xmltype_column_properties();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 15760;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2114, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lob_partition_storage(): Lob_partition_storageContext {
+        let localContext = new Lob_partition_storageContext(this.context, this.state);
+        this.enterRule(localContext, 1682, PlSqlParser.RULE_lob_partition_storage);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15762;
+            this.match(PlSqlParser.LOB);
+            this.state = 15795;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2119, this.context) ) {
+            case 1:
+                {
+                this.state = 15763;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15764;
+                this.lob_item();
+                {
+                this.state = 15765;
+                this.match(PlSqlParser.COMMA);
+                this.state = 15766;
+                this.lob_item();
+                }
+                this.state = 15768;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 15769;
+                this.match(PlSqlParser.STORE);
+                this.state = 15770;
+                this.match(PlSqlParser.AS);
+                this.state = 15776;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    this.state = 15776;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.BASICFILE:
+                    case PlSqlParser.SECUREFILE:
+                        {
+                        this.state = 15771;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 107 || _la === 1642)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.LEFT_PAREN:
+                        {
+                        this.state = 15772;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 15773;
+                        this.lob_storage_parameters();
+                        this.state = 15774;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    this.state = 15778;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 107 || _la === 1642 || _la === 2449);
+                }
+                break;
+            case 2:
+                {
+                this.state = 15780;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15781;
+                this.lob_item();
+                this.state = 15782;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 15783;
+                this.match(PlSqlParser.STORE);
+                this.state = 15784;
+                this.match(PlSqlParser.AS);
+                this.state = 15791;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    this.state = 15791;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2117, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 15785;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 107 || _la === 1642)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 15786;
+                        this.lob_segname();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 15787;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 15788;
+                        this.lob_storage_parameters();
+                        this.state = 15789;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    }
+                    }
+                    this.state = 15793;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2449 || _la === 2482);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public period_definition(): Period_definitionContext {
+        let localContext = new Period_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 1684, PlSqlParser.RULE_period_definition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15797;
+            if (!(this.isVersion12())) {
+                throw this.createFailedPredicateException("this.isVersion12()");
+            }
+            this.state = 15798;
+            this.match(PlSqlParser.PERIOD);
+            this.state = 15799;
+            this.match(PlSqlParser.FOR);
+            this.state = 15800;
+            this.column_name();
+            this.state = 15807;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 15801;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15802;
+                this.start_time_column();
+                this.state = 15803;
+                this.match(PlSqlParser.COMMA);
+                this.state = 15804;
+                this.end_time_column();
+                this.state = 15805;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public start_time_column(): Start_time_columnContext {
+        let localContext = new Start_time_columnContext(this.context, this.state);
+        this.enterRule(localContext, 1686, PlSqlParser.RULE_start_time_column);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15809;
+            this.column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public end_time_column(): End_time_columnContext {
+        let localContext = new End_time_columnContext(this.context, this.state);
+        this.enterRule(localContext, 1688, PlSqlParser.RULE_end_time_column);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15811;
+            this.column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_definition(): Column_definitionContext {
+        let localContext = new Column_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 1690, PlSqlParser.RULE_column_definition);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15813;
+            this.column_name();
+            this.state = 15822;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2123, this.context) ) {
+            case 1:
+                {
+                this.state = 15816;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2121, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15814;
+                    this.datatype();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 15815;
+                    this.type_name();
+                    }
+                    break;
+                }
+                this.state = 15820;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2122, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15818;
+                    this.match(PlSqlParser.COLLATE);
+                    this.state = 15819;
+                    this.column_collation_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 15825;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2124, this.context) ) {
+            case 1:
+                {
+                this.state = 15824;
+                this.match(PlSqlParser.SORT);
+                }
+                break;
+            }
+            this.state = 15828;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2125, this.context) ) {
+            case 1:
+                {
+                this.state = 15827;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 783 || _la === 2292)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 15837;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2127, this.context) ) {
+            case 1:
+                {
+                this.state = 15830;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 15833;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2126, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15831;
+                    this.match(PlSqlParser.ON);
+                    this.state = 15832;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                    break;
+                }
+                this.state = 15835;
+                this.expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 15836;
+                this.identity_clause();
+                }
+                break;
+            }
+            this.state = 15841;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2128, this.context) ) {
+            case 1:
+                {
+                this.state = 15839;
+                this.match(PlSqlParser.ENCRYPT);
+                this.state = 15840;
+                this.encryption_spec();
+                }
+                break;
+            }
+            this.state = 15849;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2130, this.context) ) {
+            case 1:
+                {
+                this.state = 15844;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 15843;
+                        this.inline_constraint();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 15846;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2129, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 2:
+                {
+                this.state = 15848;
+                this.inline_ref_constraint();
+                }
+                break;
+            }
+            this.state = 15852;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2131, this.context) ) {
+            case 1:
+                {
+                this.state = 15851;
+                this.annotations_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_collation_name(): Column_collation_nameContext {
+        let localContext = new Column_collation_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1692, PlSqlParser.RULE_column_collation_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15854;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identity_clause(): Identity_clauseContext {
+        let localContext = new Identity_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1694, PlSqlParser.RULE_identity_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15856;
+            this.match(PlSqlParser.GENERATED);
+            this.state = 15864;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALWAYS:
+                {
+                this.state = 15857;
+                this.match(PlSqlParser.ALWAYS);
+                }
+                break;
+            case PlSqlParser.BY:
+                {
+                this.state = 15858;
+                this.match(PlSqlParser.BY);
+                this.state = 15859;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 15862;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1261) {
+                    {
+                    this.state = 15860;
+                    this.match(PlSqlParser.ON);
+                    this.state = 15861;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.AS:
+                break;
+            default:
+                break;
+            }
+            this.state = 15866;
+            this.match(PlSqlParser.AS);
+            this.state = 15867;
+            this.match(PlSqlParser.IDENTITY);
+            this.state = 15869;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2134, this.context) ) {
+            case 1:
+                {
+                this.state = 15868;
+                this.identity_options_parentheses();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identity_options_parentheses(): Identity_options_parenthesesContext {
+        let localContext = new Identity_options_parenthesesContext(this.context, this.state);
+        this.enterRule(localContext, 1696, PlSqlParser.RULE_identity_options_parentheses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 15884;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NOSCALE:
+            case PlSqlParser.ORDER:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.START:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15872;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 15871;
+                        this.identity_options();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 15874;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2135, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15876;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15878;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 15877;
+                    this.identity_options();
+                    }
+                    }
+                    this.state = 15880;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 166 || _la === 348 || _la === 708 || _la === 815 || _la === 933 || _la === 961 || _la === 1067 || _la === 1085 || ((((_la - 1115)) & ~0x1F) === 0 && ((1 << (_la - 1115)) & 134218881) !== 0) || _la === 1183 || _la === 1305 || _la === 1622 || _la === 1739);
+                this.state = 15882;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identity_options(): Identity_optionsContext {
+        let localContext = new Identity_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 1698, PlSqlParser.RULE_identity_options);
+        let _la: number;
+        try {
+            this.state = 15914;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.START:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15886;
+                this.match(PlSqlParser.START);
+                this.state = 15887;
+                this.match(PlSqlParser.WITH);
+                this.state = 15891;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNSIGNED_INTEGER:
+                case PlSqlParser.APPROXIMATE_NUM_LIT:
+                    {
+                    this.state = 15888;
+                    this.numeric();
+                    }
+                    break;
+                case PlSqlParser.LIMIT:
+                    {
+                    this.state = 15889;
+                    this.match(PlSqlParser.LIMIT);
+                    this.state = 15890;
+                    this.match(PlSqlParser.VALUE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case PlSqlParser.INCREMENT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15893;
+                this.match(PlSqlParser.INCREMENT);
+                this.state = 15894;
+                this.match(PlSqlParser.BY);
+                this.state = 15895;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.MAXVALUE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 15896;
+                this.match(PlSqlParser.MAXVALUE);
+                this.state = 15897;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.NOMAXVALUE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 15898;
+                this.match(PlSqlParser.NOMAXVALUE);
+                }
+                break;
+            case PlSqlParser.MINVALUE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 15899;
+                this.match(PlSqlParser.MINVALUE);
+                this.state = 15900;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.NOMINVALUE:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 15901;
+                this.match(PlSqlParser.NOMINVALUE);
+                }
+                break;
+            case PlSqlParser.CYCLE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 15902;
+                this.match(PlSqlParser.CYCLE);
+                }
+                break;
+            case PlSqlParser.NOCYCLE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 15903;
+                this.match(PlSqlParser.NOCYCLE);
+                }
+                break;
+            case PlSqlParser.CACHE:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 15904;
+                this.match(PlSqlParser.CACHE);
+                this.state = 15905;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.NOCACHE:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 15906;
+                this.match(PlSqlParser.NOCACHE);
+                }
+                break;
+            case PlSqlParser.ORDER:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 15907;
+                this.match(PlSqlParser.ORDER);
+                }
+                break;
+            case PlSqlParser.NOORDER:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 15908;
+                this.match(PlSqlParser.NOORDER);
+                }
+                break;
+            case PlSqlParser.SCALE:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 15909;
+                this.match(PlSqlParser.SCALE);
+                this.state = 15910;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1101 || _la === 2431)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case PlSqlParser.NOSCALE:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 15911;
+                this.match(PlSqlParser.NOSCALE);
+                }
+                break;
+            case PlSqlParser.KEEP:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 15912;
+                this.match(PlSqlParser.KEEP);
+                }
+                break;
+            case PlSqlParser.NOKEEP:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 15913;
+                this.match(PlSqlParser.NOKEEP);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public virtual_column_definition(): Virtual_column_definitionContext {
+        let localContext = new Virtual_column_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 1700, PlSqlParser.RULE_virtual_column_definition);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15916;
+            this.column_name();
+            this.state = 15922;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2141, this.context) ) {
+            case 1:
+                {
+                this.state = 15917;
+                this.datatype();
+                this.state = 15920;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2140, this.context) ) {
+                case 1:
+                    {
+                    this.state = 15918;
+                    this.match(PlSqlParser.COLLATE);
+                    this.state = 15919;
+                    this.column_collation_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 15925;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2142, this.context) ) {
+            case 1:
+                {
+                this.state = 15924;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 783 || _la === 2292)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 15928;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2143, this.context) ) {
+            case 1:
+                {
+                this.state = 15927;
+                this.virtual_column_expression();
+                }
+                break;
+            }
+            this.state = 15931;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2144, this.context) ) {
+            case 1:
+                {
+                this.state = 15930;
+                this.match(PlSqlParser.VIRTUAL);
+                }
+                break;
+            }
+            this.state = 15934;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2145, this.context) ) {
+            case 1:
+                {
+                this.state = 15933;
+                this.evaluation_edition_clause();
+                }
+                break;
+            }
+            this.state = 15944;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2147, this.context) ) {
+            case 1:
+                {
+                this.state = 15936;
+                this.match(PlSqlParser.UNUSABLE);
+                this.state = 15937;
+                this.match(PlSqlParser.BEFORE);
+                this.state = 15942;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CURRENT:
+                    {
+                    this.state = 15938;
+                    this.match(PlSqlParser.CURRENT);
+                    this.state = 15939;
+                    this.match(PlSqlParser.EDITION);
+                    }
+                    break;
+                case PlSqlParser.EDITION:
+                    {
+                    this.state = 15940;
+                    this.match(PlSqlParser.EDITION);
+                    this.state = 15941;
+                    this.edition_name();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 15955;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2149, this.context) ) {
+            case 1:
+                {
+                this.state = 15946;
+                this.match(PlSqlParser.UNUSABLE);
+                this.state = 15947;
+                this.match(PlSqlParser.BEGINNING);
+                this.state = 15948;
+                this.match(PlSqlParser.WITH);
+                this.state = 15953;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.NULL_:
+                    {
+                    this.state = 15949;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 336 || _la === 1230)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 15950;
+                    this.match(PlSqlParser.EDITION);
+                    }
+                    break;
+                case PlSqlParser.EDITION:
+                    {
+                    this.state = 15951;
+                    this.match(PlSqlParser.EDITION);
+                    this.state = 15952;
+                    this.edition_name();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 15960;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2150, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 15957;
+                    this.inline_constraint();
+                    }
+                    }
+                }
+                this.state = 15962;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2150, this.context);
+            }
+            this.state = 15964;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2151, this.context) ) {
+            case 1:
+                {
+                this.state = 15963;
+                this.by_user_for_statistics_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public virtual_column_expression(): Virtual_column_expressionContext {
+        let localContext = new Virtual_column_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 1702, PlSqlParser.RULE_virtual_column_expression);
+        let _la: number;
+        try {
+            this.state = 15978;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2154, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 15966;
+                this.autogenerated_sequence_definition();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 15971;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 641) {
+                    {
+                    this.state = 15967;
+                    this.match(PlSqlParser.GENERATED);
+                    this.state = 15969;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 44) {
+                        {
+                        this.state = 15968;
+                        this.match(PlSqlParser.ALWAYS);
+                        }
+                    }
+
+                    }
+                }
+
+                this.state = 15973;
+                this.match(PlSqlParser.AS);
+                this.state = 15974;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15975;
+                this.expression();
+                this.state = 15976;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public autogenerated_sequence_definition(): Autogenerated_sequence_definitionContext {
+        let localContext = new Autogenerated_sequence_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 1704, PlSqlParser.RULE_autogenerated_sequence_definition);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 15980;
+            this.match(PlSqlParser.GENERATED);
+            this.state = 15988;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALWAYS:
+                {
+                this.state = 15981;
+                this.match(PlSqlParser.ALWAYS);
+                }
+                break;
+            case PlSqlParser.BY:
+                {
+                this.state = 15982;
+                this.match(PlSqlParser.BY);
+                this.state = 15983;
+                this.match(PlSqlParser.DEFAULT);
+                this.state = 15986;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1261) {
+                    {
+                    this.state = 15984;
+                    this.match(PlSqlParser.ON);
+                    this.state = 15985;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.AS:
+                break;
+            default:
+                break;
+            }
+            this.state = 15990;
+            this.match(PlSqlParser.AS);
+            this.state = 15991;
+            this.match(PlSqlParser.IDENTITY);
+            this.state = 16001;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2159, this.context) ) {
+            case 1:
+                {
+                this.state = 15992;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 15997;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 166 || _la === 348 || _la === 643 || _la === 708 || _la === 815 || _la === 933 || _la === 961 || _la === 1067 || _la === 1085 || ((((_la - 1115)) & ~0x1F) === 0 && ((1 << (_la - 1115)) & 134218881) !== 0) || _la === 1183 || _la === 1189 || _la === 1305 || _la === 1622 || _la === 1669 || _la === 1678 || _la === 1739) {
+                    {
+                    this.state = 15995;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2157, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 15993;
+                        this.sequence_start_clause();
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 15994;
+                        this.sequence_spec();
+                        }
+                        break;
+                    }
+                    }
+                    this.state = 15999;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 16000;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public by_user_for_statistics_clause(): By_user_for_statistics_clauseContext {
+        let localContext = new By_user_for_statistics_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1706, PlSqlParser.RULE_by_user_for_statistics_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16003;
+            this.match(PlSqlParser.BY);
+            this.state = 16004;
+            this.match(PlSqlParser.USER);
+            this.state = 16005;
+            this.match(PlSqlParser.FOR);
+            this.state = 16006;
+            this.match(PlSqlParser.STATISTICS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public evaluation_edition_clause(): Evaluation_edition_clauseContext {
+        let localContext = new Evaluation_edition_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1708, PlSqlParser.RULE_evaluation_edition_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16008;
+            this.match(PlSqlParser.EVALUATE);
+            this.state = 16009;
+            this.match(PlSqlParser.USING);
+            this.state = 16014;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.NULL_:
+                {
+                this.state = 16010;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 336 || _la === 1230)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 16011;
+                this.match(PlSqlParser.EDITION);
+                }
+                break;
+            case PlSqlParser.EDITION:
+                {
+                this.state = 16012;
+                this.match(PlSqlParser.EDITION);
+                this.state = 16013;
+                this.edition_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public nested_table_col_properties(): Nested_table_col_propertiesContext {
+        let localContext = new Nested_table_col_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1710, PlSqlParser.RULE_nested_table_col_properties);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16016;
+            this.match(PlSqlParser.NESTED);
+            this.state = 16017;
+            this.match(PlSqlParser.TABLE);
+            this.state = 16020;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2161, this.context) ) {
+            case 1:
+                {
+                this.state = 16018;
+                this.nested_item();
+                }
+                break;
+            case 2:
+                {
+                this.state = 16019;
+                this.match(PlSqlParser.COLUMN_VALUE);
+                }
+                break;
+            }
+            this.state = 16023;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 486 || _la === 786 || _la === 1206 || _la === 1782) {
+                {
+                this.state = 16022;
+                this.substitutable_column_clause();
+                }
+            }
+
+            this.state = 16026;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 643 || _la === 874) {
+                {
+                this.state = 16025;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 643 || _la === 874)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 16028;
+            this.match(PlSqlParser.STORE);
+            this.state = 16029;
+            this.match(PlSqlParser.AS);
+            this.state = 16030;
+            this.tableview_name();
+            this.state = 16044;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2166, this.context) ) {
+            case 1:
+                {
+                this.state = 16031;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16038;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    this.state = 16038;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2164, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 16032;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 16033;
+                        this.object_properties();
+                        this.state = 16034;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 16036;
+                        this.physical_properties();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 16037;
+                        this.column_properties();
+                        }
+                        break;
+                    }
+                    }
+                    this.state = 16040;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 220 || _la === 237 || _la === 258 || _la === 260 || _la === 561 || _la === 594 || _la === 698 || _la === 744 || _la === 747 || _la === 869 || _la === 885 || _la === 932 || _la === 1014 || _la === 1075 || _la === 1120 || _la === 1139 || _la === 1308 || _la === 1371 || _la === 1374 || _la === 1608 || _la === 1647 || _la === 1764 || _la === 2082 || _la === 2269 || _la === 2353 || _la === 2449);
+                this.state = 16042;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 16051;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2168, this.context) ) {
+            case 1:
+                {
+                this.state = 16046;
+                this.match(PlSqlParser.RETURN);
+                this.state = 16048;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 16047;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 16050;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 878 || _la === 2260)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public nested_item(): Nested_itemContext {
+        let localContext = new Nested_itemContext(this.context, this.state);
+        this.enterRule(localContext, 1712, PlSqlParser.RULE_nested_item);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16053;
+            this.regular_id();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public substitutable_column_clause(): Substitutable_column_clauseContext {
+        let localContext = new Substitutable_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1714, PlSqlParser.RULE_substitutable_column_clause);
+        let _la: number;
+        try {
+            this.state = 16074;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.IS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16056;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 486) {
+                    {
+                    this.state = 16055;
+                    this.match(PlSqlParser.ELEMENT);
+                    }
+                }
+
+                this.state = 16058;
+                this.match(PlSqlParser.IS);
+                this.state = 16059;
+                this.match(PlSqlParser.OF);
+                this.state = 16061;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2168) {
+                    {
+                    this.state = 16060;
+                    this.match(PlSqlParser.TYPE);
+                    }
+                }
+
+                this.state = 16063;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16064;
+                this.type_name();
+                this.state = 16065;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.NOT:
+            case PlSqlParser.SUBSTITUTABLE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16068;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 16067;
+                    this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 16070;
+                this.match(PlSqlParser.SUBSTITUTABLE);
+                this.state = 16071;
+                this.match(PlSqlParser.AT);
+                this.state = 16072;
+                this.match(PlSqlParser.ALL);
+                this.state = 16073;
+                this.match(PlSqlParser.LEVELS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_name(): Partition_nameContext {
+        let localContext = new Partition_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1716, PlSqlParser.RULE_partition_name);
+        try {
+            this.state = 16078;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16076;
+                this.regular_id();
+                }
+                break;
+            case PlSqlParser.DELIMITED_ID:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16077;
+                this.match(PlSqlParser.DELIMITED_ID);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public supplemental_logging_props(): Supplemental_logging_propsContext {
+        let localContext = new Supplemental_logging_propsContext(this.context, this.state);
+        this.enterRule(localContext, 1718, PlSqlParser.RULE_supplemental_logging_props);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16080;
+            this.match(PlSqlParser.SUPPLEMENTAL);
+            this.state = 16081;
+            this.match(PlSqlParser.LOG);
+            this.state = 16084;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.GROUP:
+                {
+                this.state = 16082;
+                this.supplemental_log_grp_clause();
+                }
+                break;
+            case PlSqlParser.DATA:
+                {
+                this.state = 16083;
+                this.supplemental_id_key_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_type_col_properties(): Object_type_col_propertiesContext {
+        let localContext = new Object_type_col_propertiesContext(this.context, this.state);
+        this.enterRule(localContext, 1720, PlSqlParser.RULE_object_type_col_properties);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16086;
+            this.match(PlSqlParser.COLUMN);
+            this.state = 16087;
+            localContext._column = this.regular_id();
+            this.state = 16088;
+            this.substitutable_column_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public constraint_clauses(): Constraint_clausesContext {
+        let localContext = new Constraint_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1722, PlSqlParser.RULE_constraint_clauses);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 16144;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2182, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16090;
+                this.match(PlSqlParser.ADD);
+                this.state = 16091;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16101;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2176, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16092;
+                    this.out_of_line_constraint();
+                    this.state = 16097;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 16093;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 16094;
+                        this.out_of_line_constraint();
+                        }
+                        }
+                        this.state = 16099;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 16100;
+                    this.out_of_line_ref_constraint();
+                    }
+                    break;
+                }
+                this.state = 16103;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16105;
+                this.match(PlSqlParser.ADD);
+                this.state = 16108;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2177, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16106;
+                    this.out_of_line_constraint();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 16107;
+                    this.out_of_line_ref_constraint();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16110;
+                this.match(PlSqlParser.MODIFY);
+                this.state = 16127;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CONSTRAINT:
+                    {
+                    this.state = 16111;
+                    this.match(PlSqlParser.CONSTRAINT);
+                    this.state = 16112;
+                    this.constraint_name();
+                    }
+                    break;
+                case PlSqlParser.PRIMARY:
+                    {
+                    this.state = 16113;
+                    this.match(PlSqlParser.PRIMARY);
+                    this.state = 16114;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                case PlSqlParser.UNIQUE:
+                    {
+                    this.state = 16115;
+                    this.match(PlSqlParser.UNIQUE);
+                    this.state = 16116;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 16117;
+                    this.column_name();
+                    this.state = 16122;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 16118;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 16119;
+                        this.column_name();
+                        }
+                        }
+                        this.state = 16124;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 16125;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 16129;
+                this.constraint_state();
+                this.state = 16131;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2180, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16130;
+                    this.match(PlSqlParser.CASCADE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16133;
+                this.match(PlSqlParser.RENAME);
+                this.state = 16134;
+                this.match(PlSqlParser.CONSTRAINT);
+                this.state = 16135;
+                this.old_constraint_name();
+                this.state = 16136;
+                this.match(PlSqlParser.TO);
+                this.state = 16137;
+                this.new_constraint_name();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16140;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 16139;
+                        this.drop_constraint_clause();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 16142;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2181, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public old_constraint_name(): Old_constraint_nameContext {
+        let localContext = new Old_constraint_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1724, PlSqlParser.RULE_old_constraint_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16146;
+            this.constraint_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public new_constraint_name(): New_constraint_nameContext {
+        let localContext = new New_constraint_nameContext(this.context, this.state);
+        this.enterRule(localContext, 1726, PlSqlParser.RULE_new_constraint_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16148;
+            this.constraint_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public drop_constraint_clause(): Drop_constraint_clauseContext {
+        let localContext = new Drop_constraint_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1728, PlSqlParser.RULE_drop_constraint_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16150;
+            this.match(PlSqlParser.DROP);
+            this.state = 16167;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PRIMARY:
+                {
+                this.state = 16151;
+                this.match(PlSqlParser.PRIMARY);
+                this.state = 16152;
+                this.match(PlSqlParser.KEY);
+                }
+                break;
+            case PlSqlParser.UNIQUE:
+                {
+                this.state = 16153;
+                this.match(PlSqlParser.UNIQUE);
+                this.state = 16154;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16155;
+                this.column_name();
+                this.state = 16160;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 16156;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 16157;
+                    this.column_name();
+                    }
+                    }
+                    this.state = 16162;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 16163;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.CONSTRAINT:
+                {
+                this.state = 16165;
+                this.match(PlSqlParser.CONSTRAINT);
+                this.state = 16166;
+                this.constraint_name();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16170;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2185, this.context) ) {
+            case 1:
+                {
+                this.state = 16169;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            }
+            this.state = 16174;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2186, this.context) ) {
+            case 1:
+                {
+                this.state = 16172;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 469 || _la === 817)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 16173;
+                this.match(PlSqlParser.INDEX);
+                }
+                break;
+            }
+            this.state = 16177;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2187, this.context) ) {
+            case 1:
+                {
+                this.state = 16176;
+                this.match(PlSqlParser.ONLINE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public check_constraint(): Check_constraintContext {
+        let localContext = new Check_constraintContext(this.context, this.state);
+        this.enterRule(localContext, 1730, PlSqlParser.RULE_check_constraint);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16179;
+            this.match(PlSqlParser.CHECK);
+            this.state = 16180;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 16181;
+            this.condition();
+            this.state = 16182;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 16184;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2188, this.context) ) {
+            case 1:
+                {
+                this.state = 16183;
+                this.match(PlSqlParser.DISABLE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public foreign_key_clause(): Foreign_key_clauseContext {
+        let localContext = new Foreign_key_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1732, PlSqlParser.RULE_foreign_key_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16186;
+            this.match(PlSqlParser.FOREIGN);
+            this.state = 16187;
+            this.match(PlSqlParser.KEY);
+            this.state = 16188;
+            this.paren_column_list();
+            this.state = 16189;
+            this.references_clause();
+            this.state = 16191;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2189, this.context) ) {
+            case 1:
+                {
+                this.state = 16190;
+                this.on_delete_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public references_clause(): References_clauseContext {
+        let localContext = new References_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1734, PlSqlParser.RULE_references_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16193;
+            this.match(PlSqlParser.REFERENCES);
+            this.state = 16194;
+            this.tableview_name();
+            this.state = 16196;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2190, this.context) ) {
+            case 1:
+                {
+                this.state = 16195;
+                this.paren_column_list();
+                }
+                break;
+            }
+            this.state = 16205;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2192, this.context) ) {
+            case 1:
+                {
+                this.state = 16198;
+                this.match(PlSqlParser.ON);
+                this.state = 16199;
+                this.match(PlSqlParser.DELETE);
+                this.state = 16203;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CASCADE:
+                    {
+                    this.state = 16200;
+                    this.match(PlSqlParser.CASCADE);
+                    }
+                    break;
+                case PlSqlParser.SET:
+                    {
+                    this.state = 16201;
+                    this.match(PlSqlParser.SET);
+                    this.state = 16202;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public on_delete_clause(): On_delete_clauseContext {
+        let localContext = new On_delete_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1736, PlSqlParser.RULE_on_delete_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16207;
+            this.match(PlSqlParser.ON);
+            this.state = 16208;
+            this.match(PlSqlParser.DELETE);
+            this.state = 16212;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CASCADE:
+                {
+                this.state = 16209;
+                this.match(PlSqlParser.CASCADE);
+                }
+                break;
+            case PlSqlParser.SET:
+                {
+                this.state = 16210;
+                this.match(PlSqlParser.SET);
+                this.state = 16211;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public anonymous_block(): Anonymous_blockContext {
+        let localContext = new Anonymous_blockContext(this.context, this.state);
+        this.enterRule(localContext, 1738, PlSqlParser.RULE_anonymous_block);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16218;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 382) {
+                {
+                this.state = 16214;
+                this.match(PlSqlParser.DECLARE);
+                this.state = 16216;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2194, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16215;
+                    this.seq_of_declare_specs();
+                    }
+                    break;
+                }
+                }
+            }
+
+            this.state = 16220;
+            this.match(PlSqlParser.BEGIN);
+            this.state = 16221;
+            this.seq_of_statements();
+            this.state = 16228;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 535) {
+                {
+                this.state = 16222;
+                this.match(PlSqlParser.EXCEPTION);
+                this.state = 16224;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 16223;
+                    this.exception_handler();
+                    }
+                    }
+                    this.state = 16226;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 2302);
+                }
+            }
+
+            this.state = 16230;
+            this.match(PlSqlParser.END);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext {
+        let localContext = new Invoker_rights_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1740, PlSqlParser.RULE_invoker_rights_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16232;
+            this.match(PlSqlParser.AUTHID);
+            this.state = 16233;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 341 || _la === 398)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public call_spec(): Call_specContext {
+        let localContext = new Call_specContext(this.context, this.state);
+        this.enterRule(localContext, 1742, PlSqlParser.RULE_call_spec);
+        try {
+            this.state = 16237;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2198, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16235;
+                this.java_spec();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16236;
+                this.c_spec();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public java_spec(): Java_specContext {
+        let localContext = new Java_specContext(this.context, this.state);
+        this.enterRule(localContext, 1744, PlSqlParser.RULE_java_spec);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16239;
+            this.match(PlSqlParser.LANGUAGE);
+            this.state = 16240;
+            this.match(PlSqlParser.JAVA);
+            this.state = 16241;
+            this.match(PlSqlParser.NAME);
+            this.state = 16242;
+            this.match(PlSqlParser.CHAR_STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public c_spec(): C_specContext {
+        let localContext = new C_specContext(this.context, this.state);
+        this.enterRule(localContext, 1746, PlSqlParser.RULE_c_spec);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16247;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LANGUAGE:
+                {
+                this.state = 16244;
+                this.match(PlSqlParser.LANGUAGE);
+                this.state = 16245;
+                this.match(PlSqlParser.C_LETTER);
+                }
+                break;
+            case PlSqlParser.EXTERNAL:
+                {
+                this.state = 16246;
+                this.match(PlSqlParser.EXTERNAL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16260;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NAME:
+                {
+                this.state = 16249;
+                this.match(PlSqlParser.NAME);
+                this.state = 16250;
+                this.id_expression();
+                this.state = 16251;
+                this.match(PlSqlParser.LIBRARY);
+                this.state = 16252;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.LIBRARY:
+                {
+                this.state = 16254;
+                this.match(PlSqlParser.LIBRARY);
+                this.state = 16255;
+                this.identifier();
+                this.state = 16258;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2200, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16256;
+                    this.match(PlSqlParser.NAME);
+                    this.state = 16257;
+                    this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16263;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2202, this.context) ) {
+            case 1:
+                {
+                this.state = 16262;
+                this.c_agent_in_clause();
+                }
+                break;
+            }
+            this.state = 16267;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2203, this.context) ) {
+            case 1:
+                {
+                this.state = 16265;
+                this.match(PlSqlParser.WITH);
+                this.state = 16266;
+                this.match(PlSqlParser.CONTEXT);
+                }
+                break;
+            }
+            this.state = 16270;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2204, this.context) ) {
+            case 1:
+                {
+                this.state = 16269;
+                this.c_parameters_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public c_agent_in_clause(): C_agent_in_clauseContext {
+        let localContext = new C_agent_in_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1748, PlSqlParser.RULE_c_agent_in_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16272;
+            this.match(PlSqlParser.AGENT);
+            this.state = 16273;
+            this.match(PlSqlParser.IN);
+            this.state = 16274;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 16275;
+            this.expressions_();
+            this.state = 16276;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public c_parameters_clause(): C_parameters_clauseContext {
+        let localContext = new C_parameters_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1750, PlSqlParser.RULE_c_parameters_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16278;
+            this.match(PlSqlParser.PARAMETERS);
+            this.state = 16279;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 16280;
+            this.c_external_parameter();
+            this.state = 16285;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 16281;
+                this.match(PlSqlParser.COMMA);
+                this.state = 16282;
+                this.c_external_parameter();
+                }
+                }
+                this.state = 16287;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 16288;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public c_external_parameter(): C_external_parameterContext {
+        let localContext = new C_external_parameterContext(this.context, this.state);
+        this.enterRule(localContext, 1752, PlSqlParser.RULE_c_external_parameter);
+        let _la: number;
+        try {
+            this.state = 16310;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2211, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16290;
+                this.match(PlSqlParser.CONTEXT);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16291;
+                this.match(PlSqlParser.SELF);
+                this.state = 16294;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.TDO:
+                    {
+                    this.state = 16292;
+                    this.match(PlSqlParser.TDO);
+                    }
+                    break;
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.MAXLEN:
+                    {
+                    this.state = 16293;
+                    this.c_property();
+                    }
+                    break;
+                case PlSqlParser.RIGHT_PAREN:
+                case PlSqlParser.COMMA:
+                    break;
+                default:
+                    break;
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16298;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2207, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16296;
+                    this.parameter_name();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 16297;
+                    this.match(PlSqlParser.RETURN);
+                    }
+                    break;
+                }
+                this.state = 16301;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2208, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16300;
+                    this.c_property();
+                    }
+                    break;
+                }
+                this.state = 16305;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 160) {
+                    {
+                    this.state = 16303;
+                    this.match(PlSqlParser.BY);
+                    this.state = 16304;
+                    this.match(PlSqlParser.REFERENCE);
+                    }
+                }
+
+                this.state = 16308;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 142606335) !== 0) || _la === 2482) {
+                    {
+                    this.state = 16307;
+                    localContext._external_datatype = this.regular_id();
+                    }
+                }
+
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public c_property(): C_propertyContext {
+        let localContext = new C_propertyContext(this.context, this.state);
+        this.enterRule(localContext, 1754, PlSqlParser.RULE_c_property);
+        let _la: number;
+        try {
+            this.state = 16321;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INDICATOR:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16312;
+                this.match(PlSqlParser.INDICATOR);
+                this.state = 16314;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2212, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16313;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2435 || _la === 2436)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.LENGTH:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16316;
+                this.match(PlSqlParser.LENGTH);
+                }
+                break;
+            case PlSqlParser.DURATION:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16317;
+                this.match(PlSqlParser.DURATION);
+                }
+                break;
+            case PlSqlParser.MAXLEN:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16318;
+                this.match(PlSqlParser.MAXLEN);
+                }
+                break;
+            case PlSqlParser.CHARSETID:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16319;
+                this.match(PlSqlParser.CHARSETID);
+                }
+                break;
+            case PlSqlParser.CHARSETFORM:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 16320;
+                this.match(PlSqlParser.CHARSETFORM);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parameter(): ParameterContext {
+        let localContext = new ParameterContext(this.context, this.state);
+        this.enterRule(localContext, 1756, PlSqlParser.RULE_parameter);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16323;
+            this.parameter_name();
+            this.state = 16327;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2214, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 16324;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 739 || _la === 751 || _la === 1081 || _la === 1320)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    }
+                }
+                this.state = 16329;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2214, this.context);
+            }
+            this.state = 16331;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967295) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 16330;
+                this.type_spec();
+                }
+            }
+
+            this.state = 16334;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389 || _la === 2459) {
+                {
+                this.state = 16333;
+                this.default_value_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public default_value_part(): Default_value_partContext {
+        let localContext = new Default_value_partContext(this.context, this.state);
+        this.enterRule(localContext, 1758, PlSqlParser.RULE_default_value_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16336;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 389 || _la === 2459)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 16337;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext {
+        let localContext = new Seq_of_declare_specsContext(this.context, this.state);
+        this.enterRule(localContext, 1760, PlSqlParser.RULE_seq_of_declare_specs);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16340;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    {
+                    this.state = 16339;
+                    this.declare_spec();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 16342;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2217, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public declare_spec(): Declare_specContext {
+        let localContext = new Declare_specContext(this.context, this.state);
+        this.enterRule(localContext, 1762, PlSqlParser.RULE_declare_spec);
+        try {
+            this.state = 16355;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2218, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16344;
+                this.pragma_declaration();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16345;
+                this.exception_declaration();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16346;
+                this.procedure_spec();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16347;
+                this.function_spec();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16348;
+                this.variable_declaration();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 16349;
+                this.subtype_declaration();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 16350;
+                this.cursor_declaration();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 16351;
+                this.type_declaration();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 16352;
+                this.procedure_body();
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 16353;
+                this.function_body();
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 16354;
+                this.selection_directive();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public variable_declaration(): Variable_declarationContext {
+        let localContext = new Variable_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1764, PlSqlParser.RULE_variable_declaration);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16357;
+            this.identifier();
+            this.state = 16359;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2219, this.context) ) {
+            case 1:
+                {
+                this.state = 16358;
+                this.match(PlSqlParser.CONSTANT);
+                }
+                break;
+            }
+            this.state = 16361;
+            this.type_spec();
+            this.state = 16366;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206 || _la === 1230) {
+                {
+                this.state = 16363;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 16362;
+                    this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 16365;
+                this.match(PlSqlParser.NULL_);
+                }
+            }
+
+            this.state = 16369;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389 || _la === 2459) {
+                {
+                this.state = 16368;
+                this.default_value_part();
+                }
+            }
+
+            this.state = 16371;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subtype_declaration(): Subtype_declarationContext {
+        let localContext = new Subtype_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1766, PlSqlParser.RULE_subtype_declaration);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16373;
+            this.match(PlSqlParser.SUBTYPE);
+            this.state = 16374;
+            this.identifier();
+            this.state = 16375;
+            this.match(PlSqlParser.IS);
+            this.state = 16376;
+            this.type_spec();
+            this.state = 16382;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1497) {
+                {
+                this.state = 16377;
+                this.match(PlSqlParser.RANGE);
+                this.state = 16378;
+                this.expression();
+                this.state = 16379;
+                this.match(PlSqlParser.DOUBLE_PERIOD);
+                this.state = 16380;
+                this.expression();
+                }
+            }
+
+            this.state = 16386;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 16384;
+                this.match(PlSqlParser.NOT);
+                this.state = 16385;
+                this.match(PlSqlParser.NULL_);
+                }
+            }
+
+            this.state = 16388;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cursor_declaration(): Cursor_declarationContext {
+        let localContext = new Cursor_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1768, PlSqlParser.RULE_cursor_declaration);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16390;
+            this.match(PlSqlParser.CURSOR);
+            this.state = 16391;
+            this.identifier();
+            this.state = 16403;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 16392;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16393;
+                this.parameter_spec();
+                this.state = 16398;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 16394;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 16395;
+                    this.parameter_spec();
+                    }
+                    }
+                    this.state = 16400;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 16401;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+            }
+
+            this.state = 16407;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1588) {
+                {
+                this.state = 16405;
+                this.match(PlSqlParser.RETURN);
+                this.state = 16406;
+                this.type_spec();
+                }
+            }
+
+            this.state = 16411;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 786) {
+                {
+                this.state = 16409;
+                this.match(PlSqlParser.IS);
+                this.state = 16410;
+                this.select_statement();
+                }
+            }
+
+            this.state = 16413;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parameter_spec(): Parameter_specContext {
+        let localContext = new Parameter_specContext(this.context, this.state);
+        this.enterRule(localContext, 1770, PlSqlParser.RULE_parameter_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16415;
+            this.parameter_name();
+            this.state = 16420;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 4294967039) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967295) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 16417;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 739) {
+                    {
+                    this.state = 16416;
+                    this.match(PlSqlParser.IN);
+                    }
+                }
+
+                this.state = 16419;
+                this.type_spec();
+                }
+            }
+
+            this.state = 16423;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389 || _la === 2459) {
+                {
+                this.state = 16422;
+                this.default_value_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public exception_declaration(): Exception_declarationContext {
+        let localContext = new Exception_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1772, PlSqlParser.RULE_exception_declaration);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16425;
+            this.identifier();
+            this.state = 16426;
+            this.match(PlSqlParser.EXCEPTION);
+            this.state = 16427;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pragma_declaration(): Pragma_declarationContext {
+        let localContext = new Pragma_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1774, PlSqlParser.RULE_pragma_declaration);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16429;
+            this.match(PlSqlParser.PRAGMA);
+            this.state = 16470;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SERIALLY_REUSABLE:
+                {
+                this.state = 16430;
+                this.match(PlSqlParser.SERIALLY_REUSABLE);
+                }
+                break;
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                {
+                this.state = 16431;
+                this.match(PlSqlParser.AUTONOMOUS_TRANSACTION);
+                }
+                break;
+            case PlSqlParser.EXCEPTION_INIT:
+                {
+                this.state = 16432;
+                this.match(PlSqlParser.EXCEPTION_INIT);
+                this.state = 16433;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16434;
+                this.exception_name();
+                this.state = 16435;
+                this.match(PlSqlParser.COMMA);
+                this.state = 16436;
+                this.numeric_negative();
+                this.state = 16437;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.INLINE:
+                {
+                this.state = 16439;
+                this.match(PlSqlParser.INLINE);
+                this.state = 16440;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16441;
+                localContext._id1 = this.identifier();
+                this.state = 16442;
+                this.match(PlSqlParser.COMMA);
+                this.state = 16443;
+                this.expression();
+                this.state = 16444;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.RESTRICT_REFERENCES:
+                {
+                this.state = 16446;
+                this.match(PlSqlParser.RESTRICT_REFERENCES);
+                this.state = 16447;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16450;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.INTRODUCER:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 16448;
+                    this.identifier();
+                    }
+                    break;
+                case PlSqlParser.DEFAULT:
+                    {
+                    this.state = 16449;
+                    this.match(PlSqlParser.DEFAULT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 16454;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 16452;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 16453;
+                    this.identifier();
+                    }
+                    }
+                    this.state = 16456;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 2455);
+                this.state = 16458;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.DEPRECATE:
+                {
+                this.state = 16460;
+                this.match(PlSqlParser.DEPRECATE);
+                this.state = 16461;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16462;
+                this.identifier();
+                this.state = 16465;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 16463;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 16464;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                }
+
+                this.state = 16467;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.UDF:
+                {
+                this.state = 16469;
+                this.match(PlSqlParser.UDF);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16472;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public record_type_def(): Record_type_defContext {
+        let localContext = new Record_type_defContext(this.context, this.state);
+        this.enterRule(localContext, 1776, PlSqlParser.RULE_record_type_def);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16474;
+            this.match(PlSqlParser.RECORD);
+            this.state = 16475;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 16476;
+            this.field_spec();
+            this.state = 16481;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 16477;
+                this.match(PlSqlParser.COMMA);
+                this.state = 16478;
+                this.field_spec();
+                }
+                }
+                this.state = 16483;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 16484;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public field_spec(): Field_specContext {
+        let localContext = new Field_specContext(this.context, this.state);
+        this.enterRule(localContext, 1778, PlSqlParser.RULE_field_spec);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16486;
+            this.column_name();
+            this.state = 16488;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967295) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2482) {
+                {
+                this.state = 16487;
+                this.type_spec();
+                }
+            }
+
+            this.state = 16492;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 16490;
+                this.match(PlSqlParser.NOT);
+                this.state = 16491;
+                this.match(PlSqlParser.NULL_);
+                }
+            }
+
+            this.state = 16495;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389 || _la === 2459) {
+                {
+                this.state = 16494;
+                this.default_value_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public ref_cursor_type_def(): Ref_cursor_type_defContext {
+        let localContext = new Ref_cursor_type_defContext(this.context, this.state);
+        this.enterRule(localContext, 1780, PlSqlParser.RULE_ref_cursor_type_def);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16497;
+            this.match(PlSqlParser.REF);
+            this.state = 16498;
+            this.match(PlSqlParser.CURSOR);
+            this.state = 16501;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1588) {
+                {
+                this.state = 16499;
+                this.match(PlSqlParser.RETURN);
+                this.state = 16500;
+                this.type_spec();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_declaration(): Type_declarationContext {
+        let localContext = new Type_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1782, PlSqlParser.RULE_type_declaration);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16503;
+            this.match(PlSqlParser.TYPE);
+            this.state = 16504;
+            this.identifier();
+            this.state = 16505;
+            this.match(PlSqlParser.IS);
+            this.state = 16510;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TABLE:
+                {
+                this.state = 16506;
+                this.table_type_def();
+                }
+                break;
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VARYING:
+                {
+                this.state = 16507;
+                this.varray_type_def();
+                }
+                break;
+            case PlSqlParser.RECORD:
+                {
+                this.state = 16508;
+                this.record_type_def();
+                }
+                break;
+            case PlSqlParser.REF:
+                {
+                this.state = 16509;
+                this.ref_cursor_type_def();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16512;
+            this.match(PlSqlParser.SEMICOLON);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_type_def(): Table_type_defContext {
+        let localContext = new Table_type_defContext(this.context, this.state);
+        this.enterRule(localContext, 1784, PlSqlParser.RULE_table_type_def);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16514;
+            this.match(PlSqlParser.TABLE);
+            this.state = 16515;
+            this.match(PlSqlParser.OF);
+            this.state = 16516;
+            this.type_spec();
+            this.state = 16519;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 16517;
+                this.match(PlSqlParser.NOT);
+                this.state = 16518;
+                this.match(PlSqlParser.NULL_);
+                }
+            }
+
+            this.state = 16522;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 714 || _la === 718) {
+                {
+                this.state = 16521;
+                this.table_indexed_by_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_indexed_by_part(): Table_indexed_by_partContext {
+        let localContext = new Table_indexed_by_partContext(this.context, this.state);
+        this.enterRule(localContext, 1786, PlSqlParser.RULE_table_indexed_by_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16526;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INDEXED:
+                {
+                this.state = 16524;
+                localContext._idx1 = this.match(PlSqlParser.INDEXED);
+                }
+                break;
+            case PlSqlParser.INDEX:
+                {
+                this.state = 16525;
+                localContext._idx2 = this.match(PlSqlParser.INDEX);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16528;
+            this.match(PlSqlParser.BY);
+            this.state = 16529;
+            this.type_spec();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public varray_type_def(): Varray_type_defContext {
+        let localContext = new Varray_type_defContext(this.context, this.state);
+        this.enterRule(localContext, 1788, PlSqlParser.RULE_varray_type_def);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16536;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VARRAY:
+                {
+                this.state = 16531;
+                this.match(PlSqlParser.VARRAY);
+                }
+                break;
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.VARYING:
+                {
+                this.state = 16533;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2271) {
+                    {
+                    this.state = 16532;
+                    this.match(PlSqlParser.VARYING);
+                    }
+                }
+
+                this.state = 16535;
+                this.match(PlSqlParser.ARRAY);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16538;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 16539;
+            this.expression();
+            this.state = 16540;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 16541;
+            this.match(PlSqlParser.OF);
+            this.state = 16542;
+            this.type_spec();
+            this.state = 16545;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2247, this.context) ) {
+            case 1:
+                {
+                this.state = 16543;
+                this.match(PlSqlParser.NOT);
+                this.state = 16544;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        let localContext = new Seq_of_statementsContext(this.context, this.state);
+        this.enterRule(localContext, 1790, PlSqlParser.RULE_seq_of_statements);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16558;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 16558;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2249, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 16550;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 2248, this.context);
+                        while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                            if (alternative === 1) {
+                                {
+                                {
+                                this.state = 16547;
+                                this.pragma_declaration();
+                                }
+                                }
+                            }
+                            this.state = 16552;
+                            this.errorHandler.sync(this);
+                            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2248, this.context);
+                        }
+                        this.state = 16553;
+                        this.statement();
+                        this.state = 16554;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === -1 || _la === 2472)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 16556;
+                        this.label_declaration();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 16557;
+                        this.selection_directive();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 16560;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2250, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public label_declaration(): Label_declarationContext {
+        let localContext = new Label_declarationContext(this.context, this.state);
+        this.enterRule(localContext, 1792, PlSqlParser.RULE_label_declaration);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16562;
+            localContext._ltp1 = this.match(PlSqlParser.LESS_THAN_OP);
+            this.state = 16563;
+            this.match(PlSqlParser.LESS_THAN_OP);
+            this.state = 16564;
+            this.label_name();
+            this.state = 16565;
+            this.match(PlSqlParser.GREATER_THAN_OP);
+            this.state = 16566;
+            this.match(PlSqlParser.GREATER_THAN_OP);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public statement(): StatementContext {
+        let localContext = new StatementContext(this.context, this.state);
+        this.enterRule(localContext, 1794, PlSqlParser.RULE_statement);
+        try {
+            this.state = 16585;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2251, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16568;
+                this.body();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16569;
+                this.block();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16570;
+                this.assignment_statement();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16571;
+                this.continue_statement();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16572;
+                this.exit_statement();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 16573;
+                this.goto_statement();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 16574;
+                this.if_statement();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 16575;
+                this.loop_statement();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 16576;
+                this.forall_statement();
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 16577;
+                this.null_statement();
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 16578;
+                this.raise_statement();
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 16579;
+                this.return_statement();
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 16580;
+                this.case_statement();
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 16581;
+                this.sql_statement();
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 16582;
+                this.call_statement();
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 16583;
+                this.pipe_row_statement();
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 16584;
+                this.grant_statement();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public assignment_statement(): Assignment_statementContext {
+        let localContext = new Assignment_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1796, PlSqlParser.RULE_assignment_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16589;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.LEFT_PAREN:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 16587;
+                this.general_element(0);
+                }
+                break;
+            case PlSqlParser.BINDVAR:
+            case PlSqlParser.COLON:
+                {
+                this.state = 16588;
+                this.bind_variable();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16591;
+            this.match(PlSqlParser.ASSIGN_OP);
+            this.state = 16592;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public continue_statement(): Continue_statementContext {
+        let localContext = new Continue_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1798, PlSqlParser.RULE_continue_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16594;
+            this.match(PlSqlParser.CONTINUE);
+            this.state = 16596;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2253, this.context) ) {
+            case 1:
+                {
+                this.state = 16595;
+                this.label_name();
+                }
+                break;
+            }
+            this.state = 16600;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2254, this.context) ) {
+            case 1:
+                {
+                this.state = 16598;
+                this.match(PlSqlParser.WHEN);
+                this.state = 16599;
+                this.condition();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public exit_statement(): Exit_statementContext {
+        let localContext = new Exit_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1800, PlSqlParser.RULE_exit_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16602;
+            this.match(PlSqlParser.EXIT);
+            this.state = 16604;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2255, this.context) ) {
+            case 1:
+                {
+                this.state = 16603;
+                this.label_name();
+                }
+                break;
+            }
+            this.state = 16608;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2256, this.context) ) {
+            case 1:
+                {
+                this.state = 16606;
+                this.match(PlSqlParser.WHEN);
+                this.state = 16607;
+                this.condition();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public goto_statement(): Goto_statementContext {
+        let localContext = new Goto_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1802, PlSqlParser.RULE_goto_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16610;
+            this.match(PlSqlParser.GOTO);
+            this.state = 16611;
+            this.label_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public if_statement(): If_statementContext {
+        let localContext = new If_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1804, PlSqlParser.RULE_if_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16613;
+            this.match(PlSqlParser.IF);
+            this.state = 16614;
+            this.condition();
+            this.state = 16615;
+            this.match(PlSqlParser.THEN);
+            this.state = 16616;
+            this.seq_of_statements();
+            this.state = 16620;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 492) {
+                {
+                {
+                this.state = 16617;
+                this.elsif_part();
+                }
+                }
+                this.state = 16622;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 16624;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 491) {
+                {
+                this.state = 16623;
+                this.else_part();
+                }
+            }
+
+            this.state = 16626;
+            this.match(PlSqlParser.END);
+            this.state = 16627;
+            this.match(PlSqlParser.IF);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public elsif_part(): Elsif_partContext {
+        let localContext = new Elsif_partContext(this.context, this.state);
+        this.enterRule(localContext, 1806, PlSqlParser.RULE_elsif_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16629;
+            this.match(PlSqlParser.ELSIF);
+            this.state = 16630;
+            this.condition();
+            this.state = 16631;
+            this.match(PlSqlParser.THEN);
+            this.state = 16632;
+            this.seq_of_statements();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public else_part(): Else_partContext {
+        let localContext = new Else_partContext(this.context, this.state);
+        this.enterRule(localContext, 1808, PlSqlParser.RULE_else_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16634;
+            this.match(PlSqlParser.ELSE);
+            this.state = 16635;
+            this.seq_of_statements();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public loop_statement(): Loop_statementContext {
+        let localContext = new Loop_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1810, PlSqlParser.RULE_loop_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16638;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2470) {
+                {
+                this.state = 16637;
+                this.label_declaration();
+                }
+            }
+
+            this.state = 16644;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.WHILE:
+                {
+                this.state = 16640;
+                this.match(PlSqlParser.WHILE);
+                this.state = 16641;
+                this.condition();
+                }
+                break;
+            case PlSqlParser.FOR:
+                {
+                this.state = 16642;
+                this.match(PlSqlParser.FOR);
+                this.state = 16643;
+                this.cursor_loop_param();
+                }
+                break;
+            case PlSqlParser.LOOP:
+                break;
+            default:
+                break;
+            }
+            this.state = 16646;
+            this.match(PlSqlParser.LOOP);
+            this.state = 16647;
+            this.seq_of_statements();
+            this.state = 16648;
+            this.match(PlSqlParser.END);
+            this.state = 16649;
+            this.match(PlSqlParser.LOOP);
+            this.state = 16651;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2261, this.context) ) {
+            case 1:
+                {
+                this.state = 16650;
+                this.label_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cursor_loop_param(): Cursor_loop_paramContext {
+        let localContext = new Cursor_loop_paramContext(this.context, this.state);
+        this.enterRule(localContext, 1812, PlSqlParser.RULE_cursor_loop_param);
+        let _la: number;
+        try {
+            this.state = 16678;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2266, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16653;
+                this.index_name();
+                this.state = 16654;
+                this.match(PlSqlParser.IN);
+                this.state = 16656;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2262, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16655;
+                    this.match(PlSqlParser.REVERSE);
+                    }
+                    break;
+                }
+                this.state = 16658;
+                this.lower_bound();
+                this.state = 16659;
+                localContext._range_separator = this.match(PlSqlParser.DOUBLE_PERIOD);
+                this.state = 16660;
+                this.upper_bound();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16662;
+                this.record_name();
+                this.state = 16663;
+                this.match(PlSqlParser.IN);
+                this.state = 16676;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2265, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16664;
+                    this.cursor_name();
+                    this.state = 16670;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2449) {
+                        {
+                        this.state = 16665;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 16667;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 2263, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 16666;
+                            this.expressions_();
+                            }
+                            break;
+                        }
+                        this.state = 16669;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                    }
+
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 16672;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 16673;
+                    this.select_statement();
+                    this.state = 16674;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public forall_statement(): Forall_statementContext {
+        let localContext = new Forall_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1814, PlSqlParser.RULE_forall_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16680;
+            this.match(PlSqlParser.FORALL);
+            this.state = 16681;
+            this.index_name();
+            this.state = 16682;
+            this.match(PlSqlParser.IN);
+            this.state = 16683;
+            this.bounds_clause();
+            this.state = 16686;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1619) {
+                {
+                this.state = 16684;
+                this.match(PlSqlParser.SAVE);
+                this.state = 16685;
+                this.match(PlSqlParser.EXCEPTIONS);
+                }
+            }
+
+            this.state = 16690;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DELETE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.INSERT:
+            case PlSqlParser.LOCK:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.SELECT:
+            case PlSqlParser.UPDATE:
+            case PlSqlParser.WITH:
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 16688;
+                this.data_manipulation_language_statements();
+                }
+                break;
+            case PlSqlParser.EXECUTE:
+                {
+                this.state = 16689;
+                this.execute_immediate();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public bounds_clause(): Bounds_clauseContext {
+        let localContext = new Bounds_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1816, PlSqlParser.RULE_bounds_clause);
+        let _la: number;
+        try {
+            this.state = 16705;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2270, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16692;
+                this.lower_bound();
+                this.state = 16693;
+                this.match(PlSqlParser.DOUBLE_PERIOD);
+                this.state = 16694;
+                this.upper_bound();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16696;
+                this.match(PlSqlParser.INDICES);
+                this.state = 16697;
+                this.match(PlSqlParser.OF);
+                this.state = 16698;
+                this.general_element(0);
+                this.state = 16700;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 118) {
+                    {
+                    this.state = 16699;
+                    this.between_bound();
+                    }
+                }
+
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16702;
+                this.match(PlSqlParser.VALUES);
+                this.state = 16703;
+                this.match(PlSqlParser.OF);
+                this.state = 16704;
+                this.index_name();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public between_bound(): Between_boundContext {
+        let localContext = new Between_boundContext(this.context, this.state);
+        this.enterRule(localContext, 1818, PlSqlParser.RULE_between_bound);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16707;
+            this.match(PlSqlParser.BETWEEN);
+            this.state = 16708;
+            this.lower_bound();
+            this.state = 16709;
+            this.match(PlSqlParser.AND);
+            this.state = 16710;
+            this.upper_bound();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lower_bound(): Lower_boundContext {
+        let localContext = new Lower_boundContext(this.context, this.state);
+        this.enterRule(localContext, 1820, PlSqlParser.RULE_lower_bound);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16712;
+            this.concatenation(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public upper_bound(): Upper_boundContext {
+        let localContext = new Upper_boundContext(this.context, this.state);
+        this.enterRule(localContext, 1822, PlSqlParser.RULE_upper_bound);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16714;
+            this.concatenation(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public null_statement(): Null_statementContext {
+        let localContext = new Null_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1824, PlSqlParser.RULE_null_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16716;
+            this.match(PlSqlParser.NULL_);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public raise_statement(): Raise_statementContext {
+        let localContext = new Raise_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1826, PlSqlParser.RULE_raise_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16718;
+            this.match(PlSqlParser.RAISE);
+            this.state = 16720;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2271, this.context) ) {
+            case 1:
+                {
+                this.state = 16719;
+                this.exception_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public return_statement(): Return_statementContext {
+        let localContext = new Return_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1828, PlSqlParser.RULE_return_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16722;
+            this.match(PlSqlParser.RETURN);
+            this.state = 16724;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2272, this.context) ) {
+            case 1:
+                {
+                this.state = 16723;
+                this.expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public call_statement(): Call_statementContext {
+        let localContext = new Call_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1830, PlSqlParser.RULE_call_statement);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16727;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2273, this.context) ) {
+            case 1:
+                {
+                this.state = 16726;
+                this.match(PlSqlParser.CALL);
+                }
+                break;
+            }
+            this.state = 16729;
+            this.routine_name();
+            this.state = 16731;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2274, this.context) ) {
+            case 1:
+                {
+                this.state = 16730;
+                this.function_argument();
+                }
+                break;
+            }
+            this.state = 16740;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2276, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 16733;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 16734;
+                    this.routine_name();
+                    this.state = 16736;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2275, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 16735;
+                        this.function_argument();
+                        }
+                        break;
+                    }
+                    }
+                    }
+                }
+                this.state = 16742;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2276, this.context);
+            }
+            this.state = 16745;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2277, this.context) ) {
+            case 1:
+                {
+                this.state = 16743;
+                this.match(PlSqlParser.INTO);
+                this.state = 16744;
+                this.bind_variable();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pipe_row_statement(): Pipe_row_statementContext {
+        let localContext = new Pipe_row_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1832, PlSqlParser.RULE_pipe_row_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16747;
+            this.match(PlSqlParser.PIPE);
+            this.state = 16748;
+            this.match(PlSqlParser.ROW);
+            this.state = 16749;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 16750;
+            this.expression();
+            this.state = 16751;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public selection_directive(): Selection_directiveContext {
+        let localContext = new Selection_directiveContext(this.context, this.state);
+        this.enterRule(localContext, 1834, PlSqlParser.RULE_selection_directive);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16753;
+            this.match(PlSqlParser.DOLLAR_IF);
+            this.state = 16754;
+            this.condition();
+            this.state = 16755;
+            this.match(PlSqlParser.DOLLAR_THEN);
+            this.state = 16757;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2278, this.context) ) {
+            case 1:
+                {
+                this.state = 16756;
+                this.selection_directive_body();
+                }
+                break;
+            }
+            this.state = 16767;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 457) {
+                {
+                {
+                this.state = 16759;
+                this.match(PlSqlParser.DOLLAR_ELSIF);
+                this.state = 16760;
+                this.condition();
+                this.state = 16761;
+                this.match(PlSqlParser.DOLLAR_THEN);
+                this.state = 16763;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2279, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16762;
+                    this.selection_directive_body();
+                    }
+                    break;
+                }
+                }
+                }
+                this.state = 16769;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 16774;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 456) {
+                {
+                this.state = 16770;
+                this.match(PlSqlParser.DOLLAR_ELSE);
+                this.state = 16772;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2281, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16771;
+                    this.selection_directive_body();
+                    }
+                    break;
+                }
+                }
+            }
+
+            this.state = 16776;
+            this.match(PlSqlParser.DOLLAR_END);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public error_directive(): Error_directiveContext {
+        let localContext = new Error_directiveContext(this.context, this.state);
+        this.enterRule(localContext, 1836, PlSqlParser.RULE_error_directive);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16778;
+            this.match(PlSqlParser.DOLLAR_ERROR);
+            this.state = 16779;
+            this.concatenation(0);
+            this.state = 16780;
+            this.match(PlSqlParser.DOLLAR_END);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public selection_directive_body(): Selection_directive_bodyContext {
+        let localContext = new Selection_directive_bodyContext(this.context, this.state);
+        this.enterRule(localContext, 1838, PlSqlParser.RULE_selection_directive_body);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16792;
+            this.errorHandler.sync(this);
+            alternative = 1;
+            do {
+                switch (alternative) {
+                case 1:
+                    {
+                    this.state = 16792;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2284, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 16783;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 2283, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 16782;
+                            this.pragma_declaration();
+                            }
+                            break;
+                        }
+                        this.state = 16785;
+                        this.statement();
+                        this.state = 16786;
+                        this.match(PlSqlParser.SEMICOLON);
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 16788;
+                        this.variable_declaration();
+                        }
+                        break;
+                    case 3:
+                        {
+                        this.state = 16789;
+                        this.error_directive();
+                        }
+                        break;
+                    case 4:
+                        {
+                        this.state = 16790;
+                        this.function_body();
+                        }
+                        break;
+                    case 5:
+                        {
+                        this.state = 16791;
+                        this.procedure_body();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 16794;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2285, this.context);
+            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public body(): BodyContext {
+        let localContext = new BodyContext(this.context, this.state);
+        this.enterRule(localContext, 1840, PlSqlParser.RULE_body);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16796;
+            this.match(PlSqlParser.BEGIN);
+            this.state = 16797;
+            this.seq_of_statements();
+            this.state = 16804;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 535) {
+                {
+                this.state = 16798;
+                this.match(PlSqlParser.EXCEPTION);
+                this.state = 16800;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 16799;
+                    this.exception_handler();
+                    }
+                    }
+                    this.state = 16802;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 2302);
+                }
+            }
+
+            this.state = 16806;
+            this.match(PlSqlParser.END);
+            this.state = 16808;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2288, this.context) ) {
+            case 1:
+                {
+                this.state = 16807;
+                this.label_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public exception_handler(): Exception_handlerContext {
+        let localContext = new Exception_handlerContext(this.context, this.state);
+        this.enterRule(localContext, 1842, PlSqlParser.RULE_exception_handler);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16810;
+            this.match(PlSqlParser.WHEN);
+            this.state = 16811;
+            this.exception_name();
+            this.state = 16816;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 1309) {
+                {
+                {
+                this.state = 16812;
+                this.match(PlSqlParser.OR);
+                this.state = 16813;
+                this.exception_name();
+                }
+                }
+                this.state = 16818;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 16819;
+            this.match(PlSqlParser.THEN);
+            this.state = 16820;
+            this.seq_of_statements();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public trigger_block(): Trigger_blockContext {
+        let localContext = new Trigger_blockContext(this.context, this.state);
+        this.enterRule(localContext, 1844, PlSqlParser.RULE_trigger_block);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16829;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 382) {
+                {
+                this.state = 16822;
+                this.match(PlSqlParser.DECLARE);
+                this.state = 16826;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2290, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 16823;
+                        this.declare_spec();
+                        }
+                        }
+                    }
+                    this.state = 16828;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2290, this.context);
+                }
+                }
+            }
+
+            this.state = 16831;
+            this.body();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tps_block(): Tps_blockContext {
+        let localContext = new Tps_blockContext(this.context, this.state);
+        this.enterRule(localContext, 1846, PlSqlParser.RULE_tps_block);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16836;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2292, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 16833;
+                    this.declare_spec();
+                    }
+                    }
+                }
+                this.state = 16838;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2292, this.context);
+            }
+            this.state = 16839;
+            this.body();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public block(): BlockContext {
+        let localContext = new BlockContext(this.context, this.state);
+        this.enterRule(localContext, 1848, PlSqlParser.RULE_block);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16848;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 382) {
+                {
+                this.state = 16841;
+                this.match(PlSqlParser.DECLARE);
+                this.state = 16845;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2293, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 16842;
+                        this.declare_spec();
+                        }
+                        }
+                    }
+                    this.state = 16847;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2293, this.context);
+                }
+                }
+            }
+
+            this.state = 16850;
+            this.body();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_statement(): Sql_statementContext {
+        let localContext = new Sql_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1850, PlSqlParser.RULE_sql_statement);
+        try {
+            this.state = 16857;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2295, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16852;
+                this.execute_immediate();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16853;
+                this.data_manipulation_language_statements();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16854;
+                this.cursor_manipulation_statements();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16855;
+                this.transaction_control_statements();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16856;
+                this.collection_method_call();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public execute_immediate(): Execute_immediateContext {
+        let localContext = new Execute_immediateContext(this.context, this.state);
+        this.enterRule(localContext, 1852, PlSqlParser.RULE_execute_immediate);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16859;
+            this.match(PlSqlParser.EXECUTE);
+            this.state = 16860;
+            this.match(PlSqlParser.IMMEDIATE);
+            this.state = 16861;
+            this.expression();
+            this.state = 16871;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2298, this.context) ) {
+            case 1:
+                {
+                this.state = 16862;
+                this.into_clause();
+                this.state = 16864;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2296, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16863;
+                    this.using_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 16866;
+                this.using_clause();
+                this.state = 16868;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2297, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16867;
+                    this.dynamic_returning_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 16870;
+                this.dynamic_returning_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dynamic_returning_clause(): Dynamic_returning_clauseContext {
+        let localContext = new Dynamic_returning_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1854, PlSqlParser.RULE_dynamic_returning_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16873;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1587 || _la === 1588)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 16874;
+            this.into_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public data_manipulation_language_statements(): Data_manipulation_language_statementsContext {
+        let localContext = new Data_manipulation_language_statementsContext(this.context, this.state);
+        this.enterRule(localContext, 1856, PlSqlParser.RULE_data_manipulation_language_statements);
+        try {
+            this.state = 16883;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MERGE:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16876;
+                this.merge_statement();
+                }
+                break;
+            case PlSqlParser.LOCK:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16877;
+                this.lock_table_statement();
+                }
+                break;
+            case PlSqlParser.SELECT:
+            case PlSqlParser.WITH:
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16878;
+                this.select_statement();
+                }
+                break;
+            case PlSqlParser.UPDATE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16879;
+                this.update_statement();
+                }
+                break;
+            case PlSqlParser.DELETE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16880;
+                this.delete_statement();
+                }
+                break;
+            case PlSqlParser.INSERT:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 16881;
+                this.insert_statement();
+                }
+                break;
+            case PlSqlParser.EXPLAIN:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 16882;
+                this.explain_statement();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cursor_manipulation_statements(): Cursor_manipulation_statementsContext {
+        let localContext = new Cursor_manipulation_statementsContext(this.context, this.state);
+        this.enterRule(localContext, 1858, PlSqlParser.RULE_cursor_manipulation_statements);
+        try {
+            this.state = 16889;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2300, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16885;
+                this.close_statement();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16886;
+                this.open_statement();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16887;
+                this.fetch_statement();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16888;
+                this.open_for_statement();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public close_statement(): Close_statementContext {
+        let localContext = new Close_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1860, PlSqlParser.RULE_close_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16891;
+            this.match(PlSqlParser.CLOSE);
+            this.state = 16892;
+            this.cursor_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public open_statement(): Open_statementContext {
+        let localContext = new Open_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1862, PlSqlParser.RULE_open_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16894;
+            this.match(PlSqlParser.OPEN);
+            this.state = 16895;
+            this.cursor_name();
+            this.state = 16901;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2302, this.context) ) {
+            case 1:
+                {
+                this.state = 16896;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 16898;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2301, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16897;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 16900;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public fetch_statement(): Fetch_statementContext {
+        let localContext = new Fetch_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1864, PlSqlParser.RULE_fetch_statement);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16903;
+            this.match(PlSqlParser.FETCH);
+            this.state = 16904;
+            this.cursor_name();
+            this.state = 16932;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INTO:
+                {
+                this.state = 16905;
+                localContext._it1 = this.match(PlSqlParser.INTO);
+                this.state = 16906;
+                this.variable_or_collection();
+                this.state = 16911;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2303, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 16907;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 16908;
+                        this.variable_or_collection();
+                        }
+                        }
+                    }
+                    this.state = 16913;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2303, this.context);
+                }
+                }
+                break;
+            case PlSqlParser.BULK:
+                {
+                this.state = 16914;
+                this.match(PlSqlParser.BULK);
+                this.state = 16915;
+                this.match(PlSqlParser.COLLECT);
+                this.state = 16916;
+                this.match(PlSqlParser.INTO);
+                this.state = 16917;
+                this.variable_or_collection();
+                this.state = 16922;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2304, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 16918;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 16919;
+                        this.variable_or_collection();
+                        }
+                        }
+                    }
+                    this.state = 16924;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2304, this.context);
+                }
+                this.state = 16930;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2306, this.context) ) {
+                case 1:
+                    {
+                    this.state = 16925;
+                    this.match(PlSqlParser.LIMIT);
+                    this.state = 16928;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                    case PlSqlParser.APPROXIMATE_NUM_LIT:
+                        {
+                        this.state = 16926;
+                        this.numeric();
+                        }
+                        break;
+                    case PlSqlParser.ABORT:
+                    case PlSqlParser.ABS:
+                    case PlSqlParser.ABSENT:
+                    case PlSqlParser.ACCESS:
+                    case PlSqlParser.ACCESSED:
+                    case PlSqlParser.ACCESSIBLE:
+                    case PlSqlParser.ACCOUNT:
+                    case PlSqlParser.ACL:
+                    case PlSqlParser.ACOS:
+                    case PlSqlParser.ACROSS:
+                    case PlSqlParser.ACTION:
+                    case PlSqlParser.ACTIONS:
+                    case PlSqlParser.ACTIVATE:
+                    case PlSqlParser.ACTIVE:
+                    case PlSqlParser.ACTIVE_COMPONENT:
+                    case PlSqlParser.ACTIVE_DATA:
+                    case PlSqlParser.ACTIVE_FUNCTION:
+                    case PlSqlParser.ACTIVE_TAG:
+                    case PlSqlParser.ACTIVITY:
+                    case PlSqlParser.ADAPTIVE_PLAN:
+                    case PlSqlParser.ADD:
+                    case PlSqlParser.ADD_COLUMN:
+                    case PlSqlParser.ADD_GROUP:
+                    case PlSqlParser.ADD_MONTHS:
+                    case PlSqlParser.ADJ_DATE:
+                    case PlSqlParser.ADMIN:
+                    case PlSqlParser.ADMINISTER:
+                    case PlSqlParser.ADMINISTRATOR:
+                    case PlSqlParser.ADVANCED:
+                    case PlSqlParser.ADVISE:
+                    case PlSqlParser.ADVISOR:
+                    case PlSqlParser.AFD_DISKSTRING:
+                    case PlSqlParser.AFTER:
+                    case PlSqlParser.AGENT:
+                    case PlSqlParser.AGGREGATE:
+                    case PlSqlParser.A_LETTER:
+                    case PlSqlParser.ALIAS:
+                    case PlSqlParser.ALLOCATE:
+                    case PlSqlParser.ALLOW:
+                    case PlSqlParser.ALL_ROWS:
+                    case PlSqlParser.ALTERNATE:
+                    case PlSqlParser.ALWAYS:
+                    case PlSqlParser.ANALYTIC:
+                    case PlSqlParser.ANALYZE:
+                    case PlSqlParser.ANCESTOR:
+                    case PlSqlParser.ANCILLARY:
+                    case PlSqlParser.AND_EQUAL:
+                    case PlSqlParser.ANOMALY:
+                    case PlSqlParser.ANSI_REARCH:
+                    case PlSqlParser.ANTIJOIN:
+                    case PlSqlParser.ANYSCHEMA:
+                    case PlSqlParser.APPEND:
+                    case PlSqlParser.APPENDCHILDXML:
+                    case PlSqlParser.APPEND_VALUES:
+                    case PlSqlParser.APPLICATION:
+                    case PlSqlParser.APPLY:
+                    case PlSqlParser.APPROX_COUNT_DISTINCT:
+                    case PlSqlParser.ARCHIVAL:
+                    case PlSqlParser.ARCHIVE:
+                    case PlSqlParser.ARCHIVED:
+                    case PlSqlParser.ARCHIVELOG:
+                    case PlSqlParser.ARRAY:
+                    case PlSqlParser.ASCII:
+                    case PlSqlParser.ASCIISTR:
+                    case PlSqlParser.ASIN:
+                    case PlSqlParser.ASIS:
+                    case PlSqlParser.ASSEMBLY:
+                    case PlSqlParser.ASSIGN:
+                    case PlSqlParser.ASSOCIATE:
+                    case PlSqlParser.ASYNC:
+                    case PlSqlParser.ASYNCHRONOUS:
+                    case PlSqlParser.ATAN2:
+                    case PlSqlParser.ATAN:
+                    case PlSqlParser.AT:
+                    case PlSqlParser.ATTRIBUTE:
+                    case PlSqlParser.ATTRIBUTES:
+                    case PlSqlParser.AUDIT:
+                    case PlSqlParser.AUTHENTICATED:
+                    case PlSqlParser.AUTHENTICATION:
+                    case PlSqlParser.AUTHID:
+                    case PlSqlParser.AUTHORIZATION:
+                    case PlSqlParser.AUTOALLOCATE:
+                    case PlSqlParser.AUTO:
+                    case PlSqlParser.AUTOEXTEND:
+                    case PlSqlParser.AUTO_LOGIN:
+                    case PlSqlParser.AUTOMATIC:
+                    case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                    case PlSqlParser.AUTO_REOPTIMIZE:
+                    case PlSqlParser.AVAILABILITY:
+                    case PlSqlParser.AVRO:
+                    case PlSqlParser.BACKGROUND:
+                    case PlSqlParser.BACKINGFILE:
+                    case PlSqlParser.BACKUP:
+                    case PlSqlParser.BACKUPS:
+                    case PlSqlParser.BASIC:
+                    case PlSqlParser.BASICFILE:
+                    case PlSqlParser.BATCH:
+                    case PlSqlParser.BATCHSIZE:
+                    case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.BECOME:
+                    case PlSqlParser.BEFORE:
+                    case PlSqlParser.BEGIN:
+                    case PlSqlParser.BEGINNING:
+                    case PlSqlParser.BEGIN_OUTLINE_DATA:
+                    case PlSqlParser.BEHALF:
+                    case PlSqlParser.BEQUEATH:
+                    case PlSqlParser.BFILE:
+                    case PlSqlParser.BFILENAME:
+                    case PlSqlParser.BIGFILE:
+                    case PlSqlParser.BINARY:
+                    case PlSqlParser.BINARY_DOUBLE:
+                    case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                    case PlSqlParser.BINARY_DOUBLE_NAN:
+                    case PlSqlParser.BINARY_FLOAT:
+                    case PlSqlParser.BINARY_FLOAT_INFINITY:
+                    case PlSqlParser.BINARY_FLOAT_NAN:
+                    case PlSqlParser.BINARY_INTEGER:
+                    case PlSqlParser.BIND_AWARE:
+                    case PlSqlParser.BINDING:
+                    case PlSqlParser.BIN_TO_NUM:
+                    case PlSqlParser.BITAND:
+                    case PlSqlParser.BITMAP_AND:
+                    case PlSqlParser.BITMAP:
+                    case PlSqlParser.BITMAPS:
+                    case PlSqlParser.BITMAP_TREE:
+                    case PlSqlParser.BITS:
+                    case PlSqlParser.BLOB:
+                    case PlSqlParser.BLOCK:
+                    case PlSqlParser.BLOCK_RANGE:
+                    case PlSqlParser.BLOCKS:
+                    case PlSqlParser.BLOCKSIZE:
+                    case PlSqlParser.BODY:
+                    case PlSqlParser.BOOLEAN:
+                    case PlSqlParser.BOTH:
+                    case PlSqlParser.BOUND:
+                    case PlSqlParser.BRANCH:
+                    case PlSqlParser.BREADTH:
+                    case PlSqlParser.BROADCAST:
+                    case PlSqlParser.BSON:
+                    case PlSqlParser.BUFFER:
+                    case PlSqlParser.BUFFER_CACHE:
+                    case PlSqlParser.BUFFER_POOL:
+                    case PlSqlParser.BUILD:
+                    case PlSqlParser.BULK:
+                    case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                    case PlSqlParser.BYPASS_UJVC:
+                    case PlSqlParser.BYTE:
+                    case PlSqlParser.BYTES:
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.CACHE_CB:
+                    case PlSqlParser.CACHE_INSTANCES:
+                    case PlSqlParser.CACHE_TEMP_TABLE:
+                    case PlSqlParser.CACHING:
+                    case PlSqlParser.CALCULATED:
+                    case PlSqlParser.CALLBACK:
+                    case PlSqlParser.CALL:
+                    case PlSqlParser.CANCEL:
+                    case PlSqlParser.CAPACITY:
+                    case PlSqlParser.CAPTION:
+                    case PlSqlParser.CARDINALITY:
+                    case PlSqlParser.CASCADE:
+                    case PlSqlParser.CASE:
+                    case PlSqlParser.CAST:
+                    case PlSqlParser.CASESENSITIVE:
+                    case PlSqlParser.CATEGORY:
+                    case PlSqlParser.CDBDEFAULT:
+                    case PlSqlParser.CEIL:
+                    case PlSqlParser.CELL_FLASH_CACHE:
+                    case PlSqlParser.CERTIFICATE:
+                    case PlSqlParser.CFILE:
+                    case PlSqlParser.CHAINED:
+                    case PlSqlParser.CHANGE:
+                    case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                    case PlSqlParser.CHARACTER:
+                    case PlSqlParser.CHARACTERSET:
+                    case PlSqlParser.CHAR:
+                    case PlSqlParser.CHAR_CS:
+                    case PlSqlParser.CHARTOROWID:
+                    case PlSqlParser.CHECK_ACL_REWRITE:
+                    case PlSqlParser.CHECKPOINT:
+                    case PlSqlParser.CHILD:
+                    case PlSqlParser.CHOOSE:
+                    case PlSqlParser.CHR:
+                    case PlSqlParser.CHUNK:
+                    case PlSqlParser.CLASS:
+                    case PlSqlParser.CLASSIFICATION:
+                    case PlSqlParser.CLASSIFIER:
+                    case PlSqlParser.CLAUSE:
+                    case PlSqlParser.CLEAN:
+                    case PlSqlParser.CLEANUP:
+                    case PlSqlParser.CLEAR:
+                    case PlSqlParser.C_LETTER:
+                    case PlSqlParser.CLIENT:
+                    case PlSqlParser.CLOB:
+                    case PlSqlParser.CLONE:
+                    case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                    case PlSqlParser.CLOSE:
+                    case PlSqlParser.CLUSTER_BY_ROWID:
+                    case PlSqlParser.CLUSTER:
+                    case PlSqlParser.CLUSTER_DETAILS:
+                    case PlSqlParser.CLUSTER_DISTANCE:
+                    case PlSqlParser.CLUSTER_ID:
+                    case PlSqlParser.CLUSTERING:
+                    case PlSqlParser.CLUSTERING_FACTOR:
+                    case PlSqlParser.CLUSTER_PROBABILITY:
+                    case PlSqlParser.CLUSTER_SET:
+                    case PlSqlParser.COALESCE:
+                    case PlSqlParser.COALESCE_SQ:
+                    case PlSqlParser.COARSE:
+                    case PlSqlParser.CO_AUTH_IND:
+                    case PlSqlParser.COLD:
+                    case PlSqlParser.COLLECT:
+                    case PlSqlParser.COLUMNAR:
+                    case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                    case PlSqlParser.COLUMN:
+                    case PlSqlParser.COLUMNS:
+                    case PlSqlParser.COLUMN_STATS:
+                    case PlSqlParser.COLUMN_VALUE:
+                    case PlSqlParser.COMMENT:
+                    case PlSqlParser.COMMIT:
+                    case PlSqlParser.COMMITTED:
+                    case PlSqlParser.COMMON:
+                    case PlSqlParser.COMMON_DATA:
+                    case PlSqlParser.COMPACT:
+                    case PlSqlParser.COMPATIBILITY:
+                    case PlSqlParser.COMPILE:
+                    case PlSqlParser.COMPLETE:
+                    case PlSqlParser.COMPLIANCE:
+                    case PlSqlParser.COMPONENT:
+                    case PlSqlParser.COMPONENTS:
+                    case PlSqlParser.COMPOSE:
+                    case PlSqlParser.COMPOSITE:
+                    case PlSqlParser.COMPOSITE_LIMIT:
+                    case PlSqlParser.COMPOUND:
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.CONCAT:
+                    case PlSqlParser.CON_DBID_TO_ID:
+                    case PlSqlParser.CONDITIONAL:
+                    case PlSqlParser.CONDITION:
+                    case PlSqlParser.CONFIRM:
+                    case PlSqlParser.CONFORMING:
+                    case PlSqlParser.CON_GUID_TO_ID:
+                    case PlSqlParser.CON_ID:
+                    case PlSqlParser.CON_NAME_TO_ID:
+                    case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.CONNECT_BY_COST_BASED:
+                    case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.CONNECT_BY_FILTERING:
+                    case PlSqlParser.CONNECT_BY_ISCYCLE:
+                    case PlSqlParser.CONNECT_BY_ISLEAF:
+                    case PlSqlParser.CONNECT_BY_ROOT:
+                    case PlSqlParser.CONNECT_TIME:
+                    case PlSqlParser.CONSIDER:
+                    case PlSqlParser.CONSISTENT:
+                    case PlSqlParser.CONSTANT:
+                    case PlSqlParser.CONST:
+                    case PlSqlParser.CONSTRAINT:
+                    case PlSqlParser.CONSTRAINTS:
+                    case PlSqlParser.CONSTRUCTOR:
+                    case PlSqlParser.CONTAINER:
+                    case PlSqlParser.CONTAINERS:
+                    case PlSqlParser.CONTAINERS_DEFAULT:
+                    case PlSqlParser.CONTAINER_DATA:
+                    case PlSqlParser.CONTAINER_MAP:
+                    case PlSqlParser.CONTENT:
+                    case PlSqlParser.CONTENTS:
+                    case PlSqlParser.CONTEXT:
+                    case PlSqlParser.CONTINUE:
+                    case PlSqlParser.CONTROLFILE:
+                    case PlSqlParser.CON_UID_TO_ID:
+                    case PlSqlParser.CONVERT:
+                    case PlSqlParser.CONVERSION:
+                    case PlSqlParser.COOKIE:
+                    case PlSqlParser.COPY:
+                    case PlSqlParser.CORR_K:
+                    case PlSqlParser.CORR_S:
+                    case PlSqlParser.CORRUPTION:
+                    case PlSqlParser.CORRUPT_XID_ALL:
+                    case PlSqlParser.CORRUPT_XID:
+                    case PlSqlParser.COS:
+                    case PlSqlParser.COSH:
+                    case PlSqlParser.COST:
+                    case PlSqlParser.COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.COUNT:
+                    case PlSqlParser.COUNTED:
+                    case PlSqlParser.COVAR_POP:
+                    case PlSqlParser.COVAR_SAMP:
+                    case PlSqlParser.CPU_COSTING:
+                    case PlSqlParser.CPU_PER_CALL:
+                    case PlSqlParser.CPU_PER_SESSION:
+                    case PlSqlParser.CRASH:
+                    case PlSqlParser.CREATE_FILE_DEST:
+                    case PlSqlParser.CREATE_STORED_OUTLINES:
+                    case PlSqlParser.CREATION:
+                    case PlSqlParser.CREDENTIAL:
+                    case PlSqlParser.CRITICAL:
+                    case PlSqlParser.CROSS:
+                    case PlSqlParser.CROSSEDITION:
+                    case PlSqlParser.CSCONVERT:
+                    case PlSqlParser.CSV:
+                    case PlSqlParser.CUBE_AJ:
+                    case PlSqlParser.CUBE:
+                    case PlSqlParser.CUBE_GB:
+                    case PlSqlParser.CUBE_SJ:
+                    case PlSqlParser.CUME_DISTM:
+                    case PlSqlParser.CURRENT:
+                    case PlSqlParser.CURRENT_DATE:
+                    case PlSqlParser.CURRENT_SCHEMA:
+                    case PlSqlParser.CURRENT_TIME:
+                    case PlSqlParser.CURRENT_TIMESTAMP:
+                    case PlSqlParser.CURRENT_USER:
+                    case PlSqlParser.CURRENTV:
+                    case PlSqlParser.CURSOR:
+                    case PlSqlParser.CURSOR_SHARING_EXACT:
+                    case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                    case PlSqlParser.CUSTOMDATUM:
+                    case PlSqlParser.CV:
+                    case PlSqlParser.CYCLE:
+                    case PlSqlParser.DANGLING:
+                    case PlSqlParser.DATABASE:
+                    case PlSqlParser.DATA:
+                    case PlSqlParser.DATAFILE:
+                    case PlSqlParser.DATAFILES:
+                    case PlSqlParser.DATAMOVEMENT:
+                    case PlSqlParser.DATAOBJNO:
+                    case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                    case PlSqlParser.DATAOBJ_TO_PARTITION:
+                    case PlSqlParser.DATAPUMP:
+                    case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                    case PlSqlParser.DATE:
+                    case PlSqlParser.DATE_FORMAT:
+                    case PlSqlParser.DATE_MODE:
+                    case PlSqlParser.DAY:
+                    case PlSqlParser.DAYS:
+                    case PlSqlParser.DBA:
+                    case PlSqlParser.DBA_RECYCLEBIN:
+                    case PlSqlParser.DBLINK:
+                    case PlSqlParser.DBMS_STATS:
+                    case PlSqlParser.DB_ROLE_CHANGE:
+                    case PlSqlParser.DBTIMEZONE:
+                    case PlSqlParser.DB_UNIQUE_NAME:
+                    case PlSqlParser.DB_VERSION:
+                    case PlSqlParser.DDL:
+                    case PlSqlParser.DEALLOCATE:
+                    case PlSqlParser.DEBUG:
+                    case PlSqlParser.DEBUGGER:
+                    case PlSqlParser.DEC:
+                    case PlSqlParser.DECIMAL:
+                    case PlSqlParser.DECLARE:
+                    case PlSqlParser.DECOMPOSE:
+                    case PlSqlParser.DECORRELATE:
+                    case PlSqlParser.DECR:
+                    case PlSqlParser.DECREMENT:
+                    case PlSqlParser.DECRYPT:
+                    case PlSqlParser.DEDUPLICATE:
+                    case PlSqlParser.DEFAULTS:
+                    case PlSqlParser.DEFAULT_COLLATION:
+                    case PlSqlParser.DEFAULT_CREDENTIAL:
+                    case PlSqlParser.DEFERRABLE:
+                    case PlSqlParser.DEFERRED:
+                    case PlSqlParser.DEFINED:
+                    case PlSqlParser.DEFINE:
+                    case PlSqlParser.DEFINER:
+                    case PlSqlParser.DEGREE:
+                    case PlSqlParser.DELAY:
+                    case PlSqlParser.DELEGATE:
+                    case PlSqlParser.DELETE_ALL:
+                    case PlSqlParser.DELETE:
+                    case PlSqlParser.DELETEXML:
+                    case PlSqlParser.DEMAND:
+                    case PlSqlParser.DENSE_RANKM:
+                    case PlSqlParser.DEPENDENT:
+                    case PlSqlParser.DEPRECATE:
+                    case PlSqlParser.DEPTH:
+                    case PlSqlParser.DEQUEUE:
+                    case PlSqlParser.DEREF:
+                    case PlSqlParser.DEREF_NO_REWRITE:
+                    case PlSqlParser.DESCRIPTION:
+                    case PlSqlParser.DESTROY:
+                    case PlSqlParser.DETACHED:
+                    case PlSqlParser.DETECTED:
+                    case PlSqlParser.DETERMINES:
+                    case PlSqlParser.DETERMINISTIC:
+                    case PlSqlParser.DICTIONARY:
+                    case PlSqlParser.DIMENSION:
+                    case PlSqlParser.DIMENSIONS:
+                    case PlSqlParser.DIRECT_LOAD:
+                    case PlSqlParser.DIRECTORY:
+                    case PlSqlParser.DIRECT_PATH:
+                    case PlSqlParser.DISABLE_ALL:
+                    case PlSqlParser.DISABLE:
+                    case PlSqlParser.DISABLED:
+                    case PlSqlParser.DISABLE_PARALLEL_DML:
+                    case PlSqlParser.DISABLE_PRESET:
+                    case PlSqlParser.DISABLE_RPKE:
+                    case PlSqlParser.DISALLOW:
+                    case PlSqlParser.DISASSOCIATE:
+                    case PlSqlParser.DISCARD:
+                    case PlSqlParser.DISCONNECT:
+                    case PlSqlParser.DISK:
+                    case PlSqlParser.DISKGROUP:
+                    case PlSqlParser.DISKS:
+                    case PlSqlParser.DISMOUNT:
+                    case PlSqlParser.DISTINGUISHED:
+                    case PlSqlParser.DISTRIBUTED:
+                    case PlSqlParser.DISTRIBUTE:
+                    case PlSqlParser.DML:
+                    case PlSqlParser.DML_UPDATE:
+                    case PlSqlParser.DOCFIDELITY:
+                    case PlSqlParser.DOCUMENT:
+                    case PlSqlParser.DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                    case PlSqlParser.DOMAIN_INDEX_SORT:
+                    case PlSqlParser.DOUBLE:
+                    case PlSqlParser.DOWNGRADE:
+                    case PlSqlParser.DRIVING_SITE:
+                    case PlSqlParser.DROP_COLUMN:
+                    case PlSqlParser.DROP_GROUP:
+                    case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.DUMP:
+                    case PlSqlParser.DUPLICATE:
+                    case PlSqlParser.DV:
+                    case PlSqlParser.DYNAMIC:
+                    case PlSqlParser.DYNAMIC_SAMPLING:
+                    case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                    case PlSqlParser.E_LETTER:
+                    case PlSqlParser.EACH:
+                    case PlSqlParser.EDITIONABLE:
+                    case PlSqlParser.EDITION:
+                    case PlSqlParser.EDITIONING:
+                    case PlSqlParser.EDITIONS:
+                    case PlSqlParser.ELEMENT:
+                    case PlSqlParser.ELIM_GROUPBY:
+                    case PlSqlParser.ELIMINATE_JOIN:
+                    case PlSqlParser.ELIMINATE_OBY:
+                    case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.EM:
+                    case PlSqlParser.EMPTY_BLOB:
+                    case PlSqlParser.EMPTY_CLOB:
+                    case PlSqlParser.EMPTY_:
+                    case PlSqlParser.ENABLE_ALL:
+                    case PlSqlParser.ENABLE:
+                    case PlSqlParser.ENABLED:
+                    case PlSqlParser.ENABLE_PARALLEL_DML:
+                    case PlSqlParser.ENABLE_PRESET:
+                    case PlSqlParser.ENCLOSED:
+                    case PlSqlParser.ENCODING:
+                    case PlSqlParser.ENCRYPT:
+                    case PlSqlParser.ENCRYPTION:
+                    case PlSqlParser.END_OUTLINE_DATA:
+                    case PlSqlParser.ENFORCED:
+                    case PlSqlParser.ENFORCE:
+                    case PlSqlParser.ENQUEUE:
+                    case PlSqlParser.ENTERPRISE:
+                    case PlSqlParser.ENTITYESCAPING:
+                    case PlSqlParser.ENTRY:
+                    case PlSqlParser.EQUIPART:
+                    case PlSqlParser.ERR:
+                    case PlSqlParser.ERROR_ARGUMENT:
+                    case PlSqlParser.ERROR:
+                    case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                    case PlSqlParser.ERRORS:
+                    case PlSqlParser.ERROR_INDEX:
+                    case PlSqlParser.ERROR_CODE:
+                    case PlSqlParser.ESCAPE:
+                    case PlSqlParser.ESTIMATE:
+                    case PlSqlParser.EVAL:
+                    case PlSqlParser.EVALNAME:
+                    case PlSqlParser.EVALUATE:
+                    case PlSqlParser.EVALUATION:
+                    case PlSqlParser.EVENTS:
+                    case PlSqlParser.EVERY:
+                    case PlSqlParser.EXCEPT:
+                    case PlSqlParser.EXCEPTION:
+                    case PlSqlParser.EXCEPTION_INIT:
+                    case PlSqlParser.EXCEPTIONS:
+                    case PlSqlParser.EXCHANGE:
+                    case PlSqlParser.EXCLUDE:
+                    case PlSqlParser.EXCLUDING:
+                    case PlSqlParser.EXEC:
+                    case PlSqlParser.EXECUTE:
+                    case PlSqlParser.EXEMPT:
+                    case PlSqlParser.EXISTING:
+                    case PlSqlParser.EXISTS:
+                    case PlSqlParser.EXISTSNODE:
+                    case PlSqlParser.EXIT:
+                    case PlSqlParser.EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.EXPAND_TABLE:
+                    case PlSqlParser.EXP:
+                    case PlSqlParser.EXPIRE:
+                    case PlSqlParser.EXPLAIN:
+                    case PlSqlParser.EXPLOSION:
+                    case PlSqlParser.EXPORT:
+                    case PlSqlParser.EXPR_CORR_CHECK:
+                    case PlSqlParser.EXPRESS:
+                    case PlSqlParser.EXTENDS:
+                    case PlSqlParser.EXTENT:
+                    case PlSqlParser.EXTENTS:
+                    case PlSqlParser.EXTERNAL:
+                    case PlSqlParser.EXTERNALLY:
+                    case PlSqlParser.EXTRACTCLOBXML:
+                    case PlSqlParser.EXTRACT:
+                    case PlSqlParser.EXTRACTVALUE:
+                    case PlSqlParser.EXTRA:
+                    case PlSqlParser.FACILITY:
+                    case PlSqlParser.FACT:
+                    case PlSqlParser.FACTOR:
+                    case PlSqlParser.FACTORIZE_JOIN:
+                    case PlSqlParser.FAILED:
+                    case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                    case PlSqlParser.FAILGROUP:
+                    case PlSqlParser.FAILOVER:
+                    case PlSqlParser.FAILURE:
+                    case PlSqlParser.FALSE:
+                    case PlSqlParser.FAMILY:
+                    case PlSqlParser.FAR:
+                    case PlSqlParser.FAST:
+                    case PlSqlParser.FASTSTART:
+                    case PlSqlParser.FBTSCAN:
+                    case PlSqlParser.FEATURE:
+                    case PlSqlParser.FEATURE_DETAILS:
+                    case PlSqlParser.FEATURE_ID:
+                    case PlSqlParser.FEATURE_SET:
+                    case PlSqlParser.FEATURE_VALUE:
+                    case PlSqlParser.FETCH:
+                    case PlSqlParser.FIELD:
+                    case PlSqlParser.FIELDS:
+                    case PlSqlParser.FILE:
+                    case PlSqlParser.FILE_NAME_CONVERT:
+                    case PlSqlParser.FILEGROUP:
+                    case PlSqlParser.FILESTORE:
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.FILTER:
+                    case PlSqlParser.FINAL:
+                    case PlSqlParser.FINE:
+                    case PlSqlParser.FINISH:
+                    case PlSqlParser.FIRST:
+                    case PlSqlParser.FIRSTM:
+                    case PlSqlParser.FIRST_ROWS:
+                    case PlSqlParser.FIRST_VALUE:
+                    case PlSqlParser.FIXED_VIEW_DATA:
+                    case PlSqlParser.FLAGGER:
+                    case PlSqlParser.FLASHBACK:
+                    case PlSqlParser.FLASH_CACHE:
+                    case PlSqlParser.FLOAT:
+                    case PlSqlParser.FLOB:
+                    case PlSqlParser.FLEX:
+                    case PlSqlParser.FLOOR:
+                    case PlSqlParser.FLUSH:
+                    case PlSqlParser.FOLDER:
+                    case PlSqlParser.FOLLOWING:
+                    case PlSqlParser.FOLLOWS:
+                    case PlSqlParser.FORALL:
+                    case PlSqlParser.FORCE:
+                    case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                    case PlSqlParser.FOREIGN:
+                    case PlSqlParser.FOREVER:
+                    case PlSqlParser.FORMAT:
+                    case PlSqlParser.FORWARD:
+                    case PlSqlParser.FRAGMENT_NUMBER:
+                    case PlSqlParser.FREELIST:
+                    case PlSqlParser.FREELISTS:
+                    case PlSqlParser.FREEPOOLS:
+                    case PlSqlParser.FRESH:
+                    case PlSqlParser.FROM_TZ:
+                    case PlSqlParser.FULL:
+                    case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.FUNCTION:
+                    case PlSqlParser.FUNCTIONS:
+                    case PlSqlParser.FTP:
+                    case PlSqlParser.G_LETTER:
+                    case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.GATHER_PLAN_STATISTICS:
+                    case PlSqlParser.GBY_CONC_ROLLUP:
+                    case PlSqlParser.GBY_PUSHDOWN:
+                    case PlSqlParser.GENERATED:
+                    case PlSqlParser.GET:
+                    case PlSqlParser.GLOBAL:
+                    case PlSqlParser.GLOBALLY:
+                    case PlSqlParser.GLOBAL_NAME:
+                    case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                    case PlSqlParser.GROUP_BY:
+                    case PlSqlParser.GROUP_ID:
+                    case PlSqlParser.GROUPING:
+                    case PlSqlParser.GROUPING_ID:
+                    case PlSqlParser.GROUPS:
+                    case PlSqlParser.GUARANTEED:
+                    case PlSqlParser.GUARANTEE:
+                    case PlSqlParser.GUARD:
+                    case PlSqlParser.HALF_YEARS:
+                    case PlSqlParser.HASH_AJ:
+                    case PlSqlParser.HASH:
+                    case PlSqlParser.HASHKEYS:
+                    case PlSqlParser.HASH_SJ:
+                    case PlSqlParser.HEADER:
+                    case PlSqlParser.HEAP:
+                    case PlSqlParser.HELP:
+                    case PlSqlParser.HEXTORAW:
+                    case PlSqlParser.HEXTOREF:
+                    case PlSqlParser.HIDDEN_KEYWORD:
+                    case PlSqlParser.HIDE:
+                    case PlSqlParser.HIER_ORDER:
+                    case PlSqlParser.HIERARCHICAL:
+                    case PlSqlParser.HIERARCHY:
+                    case PlSqlParser.HIGH:
+                    case PlSqlParser.HINTSET_BEGIN:
+                    case PlSqlParser.HINTSET_END:
+                    case PlSqlParser.HOT:
+                    case PlSqlParser.HOUR:
+                    case PlSqlParser.HOURS:
+                    case PlSqlParser.HTTP:
+                    case PlSqlParser.HWM_BROKERED:
+                    case PlSqlParser.HYBRID:
+                    case PlSqlParser.H_LETTER:
+                    case PlSqlParser.IDENTIFIER:
+                    case PlSqlParser.IDENTITY:
+                    case PlSqlParser.IDGENERATORS:
+                    case PlSqlParser.ID:
+                    case PlSqlParser.IDLE_TIME:
+                    case PlSqlParser.IF:
+                    case PlSqlParser.IGNORE:
+                    case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                    case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                    case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                    case PlSqlParser.ILM:
+                    case PlSqlParser.IMMEDIATE:
+                    case PlSqlParser.IMPACT:
+                    case PlSqlParser.IMPORT:
+                    case PlSqlParser.INACTIVE:
+                    case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                    case PlSqlParser.INCLUDE:
+                    case PlSqlParser.INCLUDE_VERSION:
+                    case PlSqlParser.INCLUDING:
+                    case PlSqlParser.INCREMENTAL:
+                    case PlSqlParser.INCREMENT:
+                    case PlSqlParser.INCR:
+                    case PlSqlParser.INDENT:
+                    case PlSqlParser.INDEX_ASC:
+                    case PlSqlParser.INDEX_COMBINE:
+                    case PlSqlParser.INDEX_DESC:
+                    case PlSqlParser.INDEXED:
+                    case PlSqlParser.INDEXES:
+                    case PlSqlParser.INDEX_FFS:
+                    case PlSqlParser.INDEX_FILTER:
+                    case PlSqlParser.INDEXING:
+                    case PlSqlParser.INDEX_JOIN:
+                    case PlSqlParser.INDEX_ROWS:
+                    case PlSqlParser.INDEX_RRS:
+                    case PlSqlParser.INDEX_RS_ASC:
+                    case PlSqlParser.INDEX_RS_DESC:
+                    case PlSqlParser.INDEX_RS:
+                    case PlSqlParser.INDEX_SCAN:
+                    case PlSqlParser.INDEX_SKIP_SCAN:
+                    case PlSqlParser.INDEX_SS_ASC:
+                    case PlSqlParser.INDEX_SS_DESC:
+                    case PlSqlParser.INDEX_SS:
+                    case PlSqlParser.INDEX_STATS:
+                    case PlSqlParser.INDEXTYPE:
+                    case PlSqlParser.INDEXTYPES:
+                    case PlSqlParser.INDICATOR:
+                    case PlSqlParser.INDICES:
+                    case PlSqlParser.INFINITE:
+                    case PlSqlParser.INFORMATIONAL:
+                    case PlSqlParser.INHERIT:
+                    case PlSqlParser.INITCAP:
+                    case PlSqlParser.INITIAL:
+                    case PlSqlParser.INITIALIZED:
+                    case PlSqlParser.INITIALLY:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.INLINE:
+                    case PlSqlParser.INLINE_XMLTYPE_NT:
+                    case PlSqlParser.INMEMORY:
+                    case PlSqlParser.IN_MEMORY_METADATA:
+                    case PlSqlParser.INMEMORY_PRUNING:
+                    case PlSqlParser.INNER:
+                    case PlSqlParser.INOUT:
+                    case PlSqlParser.INPLACE:
+                    case PlSqlParser.INSERTCHILDXMLAFTER:
+                    case PlSqlParser.INSERTCHILDXMLBEFORE:
+                    case PlSqlParser.INSERTCHILDXML:
+                    case PlSqlParser.INSERTXMLAFTER:
+                    case PlSqlParser.INSERTXMLBEFORE:
+                    case PlSqlParser.INSTANCE:
+                    case PlSqlParser.INSTANCES:
+                    case PlSqlParser.INSTANTIABLE:
+                    case PlSqlParser.INSTANTLY:
+                    case PlSqlParser.INSTEAD:
+                    case PlSqlParser.INSTR2:
+                    case PlSqlParser.INSTR4:
+                    case PlSqlParser.INSTRB:
+                    case PlSqlParser.INSTRC:
+                    case PlSqlParser.INSTR:
+                    case PlSqlParser.INTEGER:
+                    case PlSqlParser.INTERLEAVED:
+                    case PlSqlParser.INTERMEDIATE:
+                    case PlSqlParser.INTERNAL_CONVERT:
+                    case PlSqlParser.INTERNAL_USE:
+                    case PlSqlParser.INTERPRETED:
+                    case PlSqlParser.INTERVAL:
+                    case PlSqlParser.INT:
+                    case PlSqlParser.INTERNAL:
+                    case PlSqlParser.INVALIDATE:
+                    case PlSqlParser.INVALIDATION:
+                    case PlSqlParser.INVISIBLE:
+                    case PlSqlParser.IN_XQUERY:
+                    case PlSqlParser.IS_LEAF:
+                    case PlSqlParser.ISOLATION:
+                    case PlSqlParser.ISOLATION_LEVEL:
+                    case PlSqlParser.ITEMS:
+                    case PlSqlParser.ITERATE:
+                    case PlSqlParser.ITERATION_NUMBER:
+                    case PlSqlParser.JAVA:
+                    case PlSqlParser.JOB:
+                    case PlSqlParser.JOIN:
+                    case PlSqlParser.JSON_ARRAYAGG:
+                    case PlSqlParser.JSON_ARRAY:
+                    case PlSqlParser.JSON_EQUAL:
+                    case PlSqlParser.JSON_EXISTS2:
+                    case PlSqlParser.JSON_EXISTS:
+                    case PlSqlParser.JSONGET:
+                    case PlSqlParser.JSON:
+                    case PlSqlParser.JSON_OBJECTAGG:
+                    case PlSqlParser.JSON_OBJECT:
+                    case PlSqlParser.JSONPARSE:
+                    case PlSqlParser.JSON_QUERY:
+                    case PlSqlParser.JSON_SERIALIZE:
+                    case PlSqlParser.JSON_TABLE:
+                    case PlSqlParser.JSON_TEXTCONTAINS2:
+                    case PlSqlParser.JSON_TEXTCONTAINS:
+                    case PlSqlParser.JSON_TRANSFORM:
+                    case PlSqlParser.JSON_VALUE:
+                    case PlSqlParser.K_LETTER:
+                    case PlSqlParser.KEEP_DUPLICATES:
+                    case PlSqlParser.KEEP:
+                    case PlSqlParser.KERBEROS:
+                    case PlSqlParser.KEY:
+                    case PlSqlParser.KEY_LENGTH:
+                    case PlSqlParser.KEYSIZE:
+                    case PlSqlParser.KEYS:
+                    case PlSqlParser.KEYSTORE:
+                    case PlSqlParser.KILL:
+                    case PlSqlParser.LABEL:
+                    case PlSqlParser.LANGUAGE:
+                    case PlSqlParser.LAST_DAY:
+                    case PlSqlParser.LAST:
+                    case PlSqlParser.LAST_VALUE:
+                    case PlSqlParser.LATERAL:
+                    case PlSqlParser.LAX:
+                    case PlSqlParser.LAYER:
+                    case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                    case PlSqlParser.LDAP_REGISTRATION:
+                    case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                    case PlSqlParser.LEAF:
+                    case PlSqlParser.LEAD_CDB:
+                    case PlSqlParser.LEAD_CDB_URI:
+                    case PlSqlParser.LEADING:
+                    case PlSqlParser.LEFT:
+                    case PlSqlParser.LENGTH2:
+                    case PlSqlParser.LENGTH4:
+                    case PlSqlParser.LENGTHB:
+                    case PlSqlParser.LENGTHC:
+                    case PlSqlParser.LENGTH:
+                    case PlSqlParser.LESS:
+                    case PlSqlParser.LEVEL:
+                    case PlSqlParser.LEVEL_NAME:
+                    case PlSqlParser.LEVELS:
+                    case PlSqlParser.LIBRARY:
+                    case PlSqlParser.LIFECYCLE:
+                    case PlSqlParser.LIFE:
+                    case PlSqlParser.LIFETIME:
+                    case PlSqlParser.LIKE2:
+                    case PlSqlParser.LIKE4:
+                    case PlSqlParser.LIKEC:
+                    case PlSqlParser.LIKE_EXPAND:
+                    case PlSqlParser.LIMIT:
+                    case PlSqlParser.LINEAR:
+                    case PlSqlParser.LINES:
+                    case PlSqlParser.LINK:
+                    case PlSqlParser.LIST:
+                    case PlSqlParser.LN:
+                    case PlSqlParser.LNNVL:
+                    case PlSqlParser.LOAD:
+                    case PlSqlParser.LOB:
+                    case PlSqlParser.LOBNVL:
+                    case PlSqlParser.LOBS:
+                    case PlSqlParser.LOCAL_INDEXES:
+                    case PlSqlParser.LOCAL:
+                    case PlSqlParser.LOCALTIME:
+                    case PlSqlParser.LOCALTIMESTAMP:
+                    case PlSqlParser.LOCATION:
+                    case PlSqlParser.LOCATOR:
+                    case PlSqlParser.LOCKDOWN:
+                    case PlSqlParser.LOCKED:
+                    case PlSqlParser.LOCKING:
+                    case PlSqlParser.LOGFILE:
+                    case PlSqlParser.LOGFILES:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.LOGICAL:
+                    case PlSqlParser.LOGICAL_READS_PER_CALL:
+                    case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                    case PlSqlParser.LOG:
+                    case PlSqlParser.LOGMINING:
+                    case PlSqlParser.LOGOFF:
+                    case PlSqlParser.LOGON:
+                    case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                    case PlSqlParser.LONG:
+                    case PlSqlParser.LOOP:
+                    case PlSqlParser.LOST:
+                    case PlSqlParser.LOWER:
+                    case PlSqlParser.LOW:
+                    case PlSqlParser.LPAD:
+                    case PlSqlParser.LTRIM:
+                    case PlSqlParser.M_LETTER:
+                    case PlSqlParser.MAIN:
+                    case PlSqlParser.MAKE_REF:
+                    case PlSqlParser.MANAGED:
+                    case PlSqlParser.MANAGE:
+                    case PlSqlParser.MANAGEMENT:
+                    case PlSqlParser.MANAGER:
+                    case PlSqlParser.MANDATORY:
+                    case PlSqlParser.MANUAL:
+                    case PlSqlParser.MAP:
+                    case PlSqlParser.MAPPING:
+                    case PlSqlParser.MASK:
+                    case PlSqlParser.MASTER:
+                    case PlSqlParser.MATCHED:
+                    case PlSqlParser.MATCHES:
+                    case PlSqlParser.MATCH:
+                    case PlSqlParser.MATCH_NUMBER:
+                    case PlSqlParser.MATCH_RECOGNIZE:
+                    case PlSqlParser.MATERIALIZED:
+                    case PlSqlParser.MATERIALIZE:
+                    case PlSqlParser.MAXARCHLOGS:
+                    case PlSqlParser.MAXDATAFILES:
+                    case PlSqlParser.MAXEXTENTS:
+                    case PlSqlParser.MAXIMIZE:
+                    case PlSqlParser.MAXINSTANCES:
+                    case PlSqlParser.MAXLOGFILES:
+                    case PlSqlParser.MAXLOGHISTORY:
+                    case PlSqlParser.MAXLOGMEMBERS:
+                    case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                    case PlSqlParser.MAXSIZE:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.MAXVALUE:
+                    case PlSqlParser.MEASURE:
+                    case PlSqlParser.MEASURES:
+                    case PlSqlParser.MEDIUM:
+                    case PlSqlParser.MEMBER:
+                    case PlSqlParser.MEMBER_CAPTION:
+                    case PlSqlParser.MEMBER_DESCRIPTION:
+                    case PlSqlParser.MEMBER_NAME:
+                    case PlSqlParser.MEMBER_UNIQUE_NAME:
+                    case PlSqlParser.MEMCOMPRESS:
+                    case PlSqlParser.MEMORY:
+                    case PlSqlParser.MERGEACTIONS:
+                    case PlSqlParser.MERGE_AJ:
+                    case PlSqlParser.MERGE_CONST_ON:
+                    case PlSqlParser.MERGE:
+                    case PlSqlParser.MERGE_SJ:
+                    case PlSqlParser.METADATA:
+                    case PlSqlParser.METHOD:
+                    case PlSqlParser.MIGRATE:
+                    case PlSqlParser.MIGRATION:
+                    case PlSqlParser.MINEXTENTS:
+                    case PlSqlParser.MINIMIZE:
+                    case PlSqlParser.MINIMUM:
+                    case PlSqlParser.MINING:
+                    case PlSqlParser.MINUS_NULL:
+                    case PlSqlParser.MINUTE:
+                    case PlSqlParser.MINUTES:
+                    case PlSqlParser.MINVALUE:
+                    case PlSqlParser.MIRRORCOLD:
+                    case PlSqlParser.MIRRORHOT:
+                    case PlSqlParser.MIRROR:
+                    case PlSqlParser.MISSING:
+                    case PlSqlParser.MISMATCH:
+                    case PlSqlParser.MLSLABEL:
+                    case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                    case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                    case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                    case PlSqlParser.MODEL_MIN_ANALYSIS:
+                    case PlSqlParser.MODEL:
+                    case PlSqlParser.MODEL_NB:
+                    case PlSqlParser.MODEL_NO_ANALYSIS:
+                    case PlSqlParser.MODEL_PBY:
+                    case PlSqlParser.MODEL_PUSH_REF:
+                    case PlSqlParser.MODEL_SV:
+                    case PlSqlParser.MODIFICATION:
+                    case PlSqlParser.MODIFY_COLUMN_TYPE:
+                    case PlSqlParser.MODIFY:
+                    case PlSqlParser.MOD:
+                    case PlSqlParser.MODULE:
+                    case PlSqlParser.MONITORING:
+                    case PlSqlParser.MONITOR:
+                    case PlSqlParser.MONTH:
+                    case PlSqlParser.MONTHS_BETWEEN:
+                    case PlSqlParser.MONTHS:
+                    case PlSqlParser.MOUNT:
+                    case PlSqlParser.MOUNTPATH:
+                    case PlSqlParser.MOUNTPOINT:
+                    case PlSqlParser.MOVEMENT:
+                    case PlSqlParser.MOVE:
+                    case PlSqlParser.MULTIDIMENSIONAL:
+                    case PlSqlParser.MULTISET:
+                    case PlSqlParser.MV_MERGE:
+                    case PlSqlParser.NAMED:
+                    case PlSqlParser.NAME:
+                    case PlSqlParser.NAMESPACE:
+                    case PlSqlParser.NAN_:
+                    case PlSqlParser.NANVL:
+                    case PlSqlParser.NATIONAL:
+                    case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NATIVE:
+                    case PlSqlParser.NATURAL:
+                    case PlSqlParser.NAV:
+                    case PlSqlParser.NCHAR_CS:
+                    case PlSqlParser.NCHAR:
+                    case PlSqlParser.NCHR:
+                    case PlSqlParser.NCLOB:
+                    case PlSqlParser.NEEDED:
+                    case PlSqlParser.NEG:
+                    case PlSqlParser.NESTED:
+                    case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                    case PlSqlParser.NESTED_TABLE_GET_REFS:
+                    case PlSqlParser.NESTED_TABLE_ID:
+                    case PlSqlParser.NESTED_TABLE_SET_REFS:
+                    case PlSqlParser.NESTED_TABLE_SET_SETID:
+                    case PlSqlParser.NETWORK:
+                    case PlSqlParser.NEVER:
+                    case PlSqlParser.NEW:
+                    case PlSqlParser.NEWLINE_:
+                    case PlSqlParser.NEW_TIME:
+                    case PlSqlParser.NEXT_DAY:
+                    case PlSqlParser.NEXT:
+                    case PlSqlParser.NL_AJ:
+                    case PlSqlParser.NLJ_BATCHING:
+                    case PlSqlParser.NLJ_INDEX_FILTER:
+                    case PlSqlParser.NLJ_INDEX_SCAN:
+                    case PlSqlParser.NLJ_PREFETCH:
+                    case PlSqlParser.NLS_CALENDAR:
+                    case PlSqlParser.NLS_CHARACTERSET:
+                    case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                    case PlSqlParser.NLS_CHARSET_ID:
+                    case PlSqlParser.NLS_CHARSET_NAME:
+                    case PlSqlParser.NLS_COMP:
+                    case PlSqlParser.NLS_CURRENCY:
+                    case PlSqlParser.NLS_DATE_FORMAT:
+                    case PlSqlParser.NLS_DATE_LANGUAGE:
+                    case PlSqlParser.NLS_INITCAP:
+                    case PlSqlParser.NLS_ISO_CURRENCY:
+                    case PlSqlParser.NL_SJ:
+                    case PlSqlParser.NLS_LANG:
+                    case PlSqlParser.NLS_LANGUAGE:
+                    case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                    case PlSqlParser.NLS_LOWER:
+                    case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                    case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                    case PlSqlParser.NLS_SORT:
+                    case PlSqlParser.NLSSORT:
+                    case PlSqlParser.NLS_SPECIAL_CHARS:
+                    case PlSqlParser.NLS_TERRITORY:
+                    case PlSqlParser.NLS_UPPER:
+                    case PlSqlParser.NO_ACCESS:
+                    case PlSqlParser.NO_ADAPTIVE_PLAN:
+                    case PlSqlParser.NO_ANSI_REARCH:
+                    case PlSqlParser.NOAPPEND:
+                    case PlSqlParser.NOARCHIVELOG:
+                    case PlSqlParser.NOAUDIT:
+                    case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                    case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.NO_BIND_AWARE:
+                    case PlSqlParser.NO_BUFFER:
+                    case PlSqlParser.NOCACHE:
+                    case PlSqlParser.NO_CARTESIAN:
+                    case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                    case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                    case PlSqlParser.NO_CLUSTERING:
+                    case PlSqlParser.NO_COALESCE_SQ:
+                    case PlSqlParser.NO_COMMON_DATA:
+                    case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                    case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                    case PlSqlParser.NOCOPY:
+                    case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_CPU_COSTING:
+                    case PlSqlParser.NOCPU_COSTING:
+                    case PlSqlParser.NOCYCLE:
+                    case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                    case PlSqlParser.NO_DECORRELATE:
+                    case PlSqlParser.NODELAY:
+                    case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.NO_ELIM_GROUPBY:
+                    case PlSqlParser.NO_ELIMINATE_JOIN:
+                    case PlSqlParser.NO_ELIMINATE_OBY:
+                    case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.NOENTITYESCAPING:
+                    case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.NO_EXPAND:
+                    case PlSqlParser.NO_EXPAND_TABLE:
+                    case PlSqlParser.NO_FACT:
+                    case PlSqlParser.NO_FACTORIZE_JOIN:
+                    case PlSqlParser.NO_FILTERING:
+                    case PlSqlParser.NOFORCE:
+                    case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.NO_GBY_PUSHDOWN:
+                    case PlSqlParser.NOGUARANTEE:
+                    case PlSqlParser.NO_INDEX_FFS:
+                    case PlSqlParser.NO_INDEX:
+                    case PlSqlParser.NO_INDEX_SS:
+                    case PlSqlParser.NO_INMEMORY:
+                    case PlSqlParser.NO_INMEMORY_PRUNING:
+                    case PlSqlParser.NOKEEP:
+                    case PlSqlParser.NO_LOAD:
+                    case PlSqlParser.NOLOCAL:
+                    case PlSqlParser.NOLOGGING:
+                    case PlSqlParser.NOMAPPING:
+                    case PlSqlParser.NOMAXVALUE:
+                    case PlSqlParser.NO_MERGE:
+                    case PlSqlParser.NOMINIMIZE:
+                    case PlSqlParser.NOMINVALUE:
+                    case PlSqlParser.NO_MODEL_PUSH_REF:
+                    case PlSqlParser.NO_MONITORING:
+                    case PlSqlParser.NOMONITORING:
+                    case PlSqlParser.NO_MONITOR:
+                    case PlSqlParser.NO_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NONBLOCKING:
+                    case PlSqlParser.NONEDITIONABLE:
+                    case PlSqlParser.NONE:
+                    case PlSqlParser.NONPARTITIONED:
+                    case PlSqlParser.NO_NLJ_BATCHING:
+                    case PlSqlParser.NO_NLJ_PREFETCH:
+                    case PlSqlParser.NO:
+                    case PlSqlParser.NONSCHEMA:
+                    case PlSqlParser.NO_OBJECT_LINK:
+                    case PlSqlParser.NOORDER:
+                    case PlSqlParser.NO_ORDER_ROLLUPS:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.NOOVERRIDE:
+                    case PlSqlParser.NO_PARALLEL_INDEX:
+                    case PlSqlParser.NOPARALLEL_INDEX:
+                    case PlSqlParser.NO_PARALLEL:
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.NO_PARTIAL_COMMIT:
+                    case PlSqlParser.NO_PARTIAL_JOIN:
+                    case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.NOPARTITION:
+                    case PlSqlParser.NO_PLACE_DISTINCT:
+                    case PlSqlParser.NO_PLACE_GROUP_BY:
+                    case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                    case PlSqlParser.NO_PQ_MAP:
+                    case PlSqlParser.NOPROMPT:
+                    case PlSqlParser.NO_PQ_REPLICATE:
+                    case PlSqlParser.NO_PQ_SKEW:
+                    case PlSqlParser.NO_PRUNE_GSETS:
+                    case PlSqlParser.NO_PULL_PRED:
+                    case PlSqlParser.NO_PUSH_PRED:
+                    case PlSqlParser.NO_PUSH_SUBQ:
+                    case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                    case PlSqlParser.NO_PX_JOIN_FILTER:
+                    case PlSqlParser.NO_QKN_BUFF:
+                    case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                    case PlSqlParser.NO_REF_CASCADE:
+                    case PlSqlParser.NORELOCATE:
+                    case PlSqlParser.NORELY:
+                    case PlSqlParser.NOREPAIR:
+                    case PlSqlParser.NOREPLAY:
+                    case PlSqlParser.NORESETLOGS:
+                    case PlSqlParser.NO_RESULT_CACHE:
+                    case PlSqlParser.NOREVERSE:
+                    case PlSqlParser.NO_REWRITE:
+                    case PlSqlParser.NOREWRITE:
+                    case PlSqlParser.NORMAL:
+                    case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                    case PlSqlParser.NOROWDEPENDENCIES:
+                    case PlSqlParser.NOSCHEMACHECK:
+                    case PlSqlParser.NOSEGMENT:
+                    case PlSqlParser.NO_SEMIJOIN:
+                    case PlSqlParser.NO_SEMI_TO_INNER:
+                    case PlSqlParser.NO_SET_TO_JOIN:
+                    case PlSqlParser.NOSORT:
+                    case PlSqlParser.NO_SQL_TRANSLATION:
+                    case PlSqlParser.NO_SQL_TUNE:
+                    case PlSqlParser.NO_STAR_TRANSFORMATION:
+                    case PlSqlParser.NO_STATEMENT_QUEUING:
+                    case PlSqlParser.NO_STATS_GSETS:
+                    case PlSqlParser.NOSTRICT:
+                    case PlSqlParser.NO_SUBQUERY_PRUNING:
+                    case PlSqlParser.NO_SUBSTRB_PAD:
+                    case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                    case PlSqlParser.NOSWITCH:
+                    case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.NO_TEMP_TABLE:
+                    case PlSqlParser.NOTHING:
+                    case PlSqlParser.NOTIFICATION:
+                    case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.NO_UNNEST:
+                    case PlSqlParser.NO_USE_CUBE:
+                    case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                    case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.NO_USE_HASH:
+                    case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.NO_USE_MERGE:
+                    case PlSqlParser.NO_USE_NL:
+                    case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.NOVALIDATE:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM:
+                    case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                    case PlSqlParser.NO_XML_DML_REWRITE:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE:
+                    case PlSqlParser.NO_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_ZONEMAP:
+                    case PlSqlParser.NTH_VALUE:
+                    case PlSqlParser.NULLIF:
+                    case PlSqlParser.NULLS:
+                    case PlSqlParser.NUMBER:
+                    case PlSqlParser.NUMERIC:
+                    case PlSqlParser.NUM_INDEX_KEYS:
+                    case PlSqlParser.NUMTODSINTERVAL:
+                    case PlSqlParser.NUMTOYMINTERVAL:
+                    case PlSqlParser.NVARCHAR2:
+                    case PlSqlParser.NVL2:
+                    case PlSqlParser.OBJECT2XML:
+                    case PlSqlParser.OBJECT:
+                    case PlSqlParser.OBJ_ID:
+                    case PlSqlParser.OBJNO:
+                    case PlSqlParser.OBJNO_REUSE:
+                    case PlSqlParser.OCCURENCES:
+                    case PlSqlParser.OFFLINE:
+                    case PlSqlParser.OFF:
+                    case PlSqlParser.OFFSET:
+                    case PlSqlParser.OIDINDEX:
+                    case PlSqlParser.OID:
+                    case PlSqlParser.OLAP:
+                    case PlSqlParser.OLD:
+                    case PlSqlParser.OLD_PUSH_PRED:
+                    case PlSqlParser.OLS:
+                    case PlSqlParser.OLTP:
+                    case PlSqlParser.OMIT:
+                    case PlSqlParser.ONE:
+                    case PlSqlParser.ONLINE:
+                    case PlSqlParser.ONLY:
+                    case PlSqlParser.OPAQUE:
+                    case PlSqlParser.OPAQUE_TRANSFORM:
+                    case PlSqlParser.OPAQUE_XCANONICAL:
+                    case PlSqlParser.OPCODE:
+                    case PlSqlParser.OPEN:
+                    case PlSqlParser.OPERATIONS:
+                    case PlSqlParser.OPERATOR:
+                    case PlSqlParser.OPT_ESTIMATE:
+                    case PlSqlParser.OPTIMAL:
+                    case PlSqlParser.OPTIMIZE:
+                    case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                    case PlSqlParser.OPTIMIZER_GOAL:
+                    case PlSqlParser.OPT_PARAM:
+                    case PlSqlParser.ORA_BRANCH:
+                    case PlSqlParser.ORA_CHECK_ACL:
+                    case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                    case PlSqlParser.ORA_CLUSTERING:
+                    case PlSqlParser.ORADATA:
+                    case PlSqlParser.ORC:
+                    case PlSqlParser.ORADEBUG:
+                    case PlSqlParser.ORA_DST_AFFECTED:
+                    case PlSqlParser.ORA_DST_CONVERT:
+                    case PlSqlParser.ORA_DST_ERROR:
+                    case PlSqlParser.ORA_GET_ACLIDS:
+                    case PlSqlParser.ORA_GET_PRIVILEGES:
+                    case PlSqlParser.ORA_HASH:
+                    case PlSqlParser.ORA_INVOKING_USERID:
+                    case PlSqlParser.ORA_INVOKING_USER:
+                    case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                    case PlSqlParser.ORA_INVOKING_XS_USER:
+                    case PlSqlParser.ORA_RAWCOMPARE:
+                    case PlSqlParser.ORA_RAWCONCAT:
+                    case PlSqlParser.ORA_ROWSCN:
+                    case PlSqlParser.ORA_ROWSCN_RAW:
+                    case PlSqlParser.ORA_ROWVERSION:
+                    case PlSqlParser.ORA_TABVERSION:
+                    case PlSqlParser.ORA_WRITE_TIME:
+                    case PlSqlParser.ORDERED:
+                    case PlSqlParser.ORDERED_PREDICATES:
+                    case PlSqlParser.ORDINALITY:
+                    case PlSqlParser.OR_EXPAND:
+                    case PlSqlParser.ORGANIZATION:
+                    case PlSqlParser.OR_PREDICATES:
+                    case PlSqlParser.OSERROR:
+                    case PlSqlParser.OTHER:
+                    case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.OUTER:
+                    case PlSqlParser.OUTLINE_LEAF:
+                    case PlSqlParser.OUTLINE:
+                    case PlSqlParser.OUT_OF_LINE:
+                    case PlSqlParser.OUT:
+                    case PlSqlParser.OVERFLOW_NOMOVE:
+                    case PlSqlParser.OVERFLOW_:
+                    case PlSqlParser.OVERLAPS:
+                    case PlSqlParser.OVER:
+                    case PlSqlParser.OVERRIDE:
+                    case PlSqlParser.OVERRIDING:
+                    case PlSqlParser.OWNER:
+                    case PlSqlParser.OWNERSHIP:
+                    case PlSqlParser.OWN:
+                    case PlSqlParser.P_LETTER:
+                    case PlSqlParser.PACKAGE:
+                    case PlSqlParser.PACKAGES:
+                    case PlSqlParser.PARALLEL_ENABLE:
+                    case PlSqlParser.PARALLEL_INDEX:
+                    case PlSqlParser.PARALLEL:
+                    case PlSqlParser.PARAMETERS:
+                    case PlSqlParser.PARAM:
+                    case PlSqlParser.PARENT:
+                    case PlSqlParser.PARENT_LEVEL_NAME:
+                    case PlSqlParser.PARENT_UNIQUE_NAME:
+                    case PlSqlParser.PARITY:
+                    case PlSqlParser.PARTIAL_JOIN:
+                    case PlSqlParser.PARTIALLY:
+                    case PlSqlParser.PARTIAL:
+                    case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.PARTITION_HASH:
+                    case PlSqlParser.PARTITION_LIST:
+                    case PlSqlParser.PARTITION:
+                    case PlSqlParser.PARTITION_RANGE:
+                    case PlSqlParser.PARTITIONS:
+                    case PlSqlParser.PARTNUMINST:
+                    case PlSqlParser.PASSING:
+                    case PlSqlParser.PASSWORD_GRACE_TIME:
+                    case PlSqlParser.PASSWORD_LIFE_TIME:
+                    case PlSqlParser.PASSWORD_LOCK_TIME:
+                    case PlSqlParser.PASSWORD:
+                    case PlSqlParser.PASSWORD_REUSE_MAX:
+                    case PlSqlParser.PASSWORD_REUSE_TIME:
+                    case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                    case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                    case PlSqlParser.PAST:
+                    case PlSqlParser.PATCH:
+                    case PlSqlParser.PATH:
+                    case PlSqlParser.PATH_PREFIX:
+                    case PlSqlParser.PATHS:
+                    case PlSqlParser.PATTERN:
+                    case PlSqlParser.PBL_HS_BEGIN:
+                    case PlSqlParser.PBL_HS_END:
+                    case PlSqlParser.PCTINCREASE:
+                    case PlSqlParser.PCTTHRESHOLD:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.PCTVERSION:
+                    case PlSqlParser.PENDING:
+                    case PlSqlParser.PERCENT_KEYWORD:
+                    case PlSqlParser.PERCENT_RANKM:
+                    case PlSqlParser.PERFORMANCE:
+                    case PlSqlParser.PERIOD_KEYWORD:
+                    case PlSqlParser.PERMANENT:
+                    case PlSqlParser.PERMISSION:
+                    case PlSqlParser.PERMUTE:
+                    case PlSqlParser.PER:
+                    case PlSqlParser.PFILE:
+                    case PlSqlParser.PHYSICAL:
+                    case PlSqlParser.PIKEY:
+                    case PlSqlParser.PIPELINED:
+                    case PlSqlParser.PIV_GB:
+                    case PlSqlParser.PIVOT:
+                    case PlSqlParser.PIV_SSF:
+                    case PlSqlParser.PLACE_DISTINCT:
+                    case PlSqlParser.PLACE_GROUP_BY:
+                    case PlSqlParser.PLAN:
+                    case PlSqlParser.PLSCOPE_SETTINGS:
+                    case PlSqlParser.PLS_INTEGER:
+                    case PlSqlParser.PLSQL_CCFLAGS:
+                    case PlSqlParser.PLSQL_CODE_TYPE:
+                    case PlSqlParser.PLSQL_DEBUG:
+                    case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                    case PlSqlParser.PLSQL_WARNINGS:
+                    case PlSqlParser.PLUGGABLE:
+                    case PlSqlParser.PMEM:
+                    case PlSqlParser.POINT:
+                    case PlSqlParser.POLICY:
+                    case PlSqlParser.POOL_16K:
+                    case PlSqlParser.POOL_2K:
+                    case PlSqlParser.POOL_32K:
+                    case PlSqlParser.POOL_4K:
+                    case PlSqlParser.POOL_8K:
+                    case PlSqlParser.POSITION:
+                    case PlSqlParser.POSITIVEN:
+                    case PlSqlParser.POSITIVE:
+                    case PlSqlParser.POST_TRANSACTION:
+                    case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                    case PlSqlParser.POWERMULTISET:
+                    case PlSqlParser.POWER:
+                    case PlSqlParser.PQ_CONCURRENT_UNION:
+                    case PlSqlParser.PQ_DISTRIBUTE:
+                    case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                    case PlSqlParser.PQ_FILTER:
+                    case PlSqlParser.PQ_MAP:
+                    case PlSqlParser.PQ_NOMAP:
+                    case PlSqlParser.PQ_REPLICATE:
+                    case PlSqlParser.PQ_SKEW:
+                    case PlSqlParser.PRAGMA:
+                    case PlSqlParser.PREBUILT:
+                    case PlSqlParser.PRECEDES:
+                    case PlSqlParser.PRECEDING:
+                    case PlSqlParser.PRECISION:
+                    case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                    case PlSqlParser.PREDICATE_REORDERS:
+                    case PlSqlParser.PRELOAD:
+                    case PlSqlParser.PREPARE:
+                    case PlSqlParser.PRESENTNNV:
+                    case PlSqlParser.PRESENT:
+                    case PlSqlParser.PRESENTV:
+                    case PlSqlParser.PRESERVE_OID:
+                    case PlSqlParser.PRESERVE:
+                    case PlSqlParser.PRETTY:
+                    case PlSqlParser.PREVIOUS:
+                    case PlSqlParser.PREV:
+                    case PlSqlParser.PRIMARY:
+                    case PlSqlParser.PRINTBLOBTOCLOB:
+                    case PlSqlParser.PRIORITY:
+                    case PlSqlParser.PRIVATE:
+                    case PlSqlParser.PRIVATE_SGA:
+                    case PlSqlParser.PRIVILEGED:
+                    case PlSqlParser.PRIVILEGE:
+                    case PlSqlParser.PRIVILEGES:
+                    case PlSqlParser.PROCEDURAL:
+                    case PlSqlParser.PROCEDURE:
+                    case PlSqlParser.PROCESS:
+                    case PlSqlParser.PROFILE:
+                    case PlSqlParser.PROGRAM:
+                    case PlSqlParser.PROJECT:
+                    case PlSqlParser.PROPAGATE:
+                    case PlSqlParser.PROPERTY:
+                    case PlSqlParser.PROTECTED:
+                    case PlSqlParser.PROTECTION:
+                    case PlSqlParser.PROTOCOL:
+                    case PlSqlParser.PROXY:
+                    case PlSqlParser.PRUNING:
+                    case PlSqlParser.PUBLIC:
+                    case PlSqlParser.PULL_PRED:
+                    case PlSqlParser.PURGE:
+                    case PlSqlParser.PUSH_PRED:
+                    case PlSqlParser.PUSH_SUBQ:
+                    case PlSqlParser.PX_FAULT_TOLERANCE:
+                    case PlSqlParser.PX_GRANULE:
+                    case PlSqlParser.PX_JOIN_FILTER:
+                    case PlSqlParser.QB_NAME:
+                    case PlSqlParser.QUARTERS:
+                    case PlSqlParser.QUERY_BLOCK:
+                    case PlSqlParser.QUERY:
+                    case PlSqlParser.QUEUE_CURR:
+                    case PlSqlParser.QUEUE:
+                    case PlSqlParser.QUEUE_ROWP:
+                    case PlSqlParser.QUIESCE:
+                    case PlSqlParser.QUORUM:
+                    case PlSqlParser.QUOTA:
+                    case PlSqlParser.QUOTAGROUP:
+                    case PlSqlParser.RAISE:
+                    case PlSqlParser.RANDOM_LOCAL:
+                    case PlSqlParser.RANDOM:
+                    case PlSqlParser.RANGE:
+                    case PlSqlParser.RANKM:
+                    case PlSqlParser.RAPIDLY:
+                    case PlSqlParser.RAW:
+                    case PlSqlParser.RAWTOHEX:
+                    case PlSqlParser.RAWTONHEX:
+                    case PlSqlParser.RBA:
+                    case PlSqlParser.RBO_OUTLINE:
+                    case PlSqlParser.RDBA:
+                    case PlSqlParser.READ:
+                    case PlSqlParser.READS:
+                    case PlSqlParser.REALM:
+                    case PlSqlParser.REAL:
+                    case PlSqlParser.REBALANCE:
+                    case PlSqlParser.REBUILD:
+                    case PlSqlParser.RECORD:
+                    case PlSqlParser.RECORDS:
+                    case PlSqlParser.RECORDS_PER_BLOCK:
+                    case PlSqlParser.RECOVERABLE:
+                    case PlSqlParser.RECOVER:
+                    case PlSqlParser.RECOVERY:
+                    case PlSqlParser.RECYCLEBIN:
+                    case PlSqlParser.RECYCLE:
+                    case PlSqlParser.REDACTION:
+                    case PlSqlParser.REDEFINE:
+                    case PlSqlParser.REDO:
+                    case PlSqlParser.REDUCED:
+                    case PlSqlParser.REDUNDANCY:
+                    case PlSqlParser.REF_CASCADE_CURSOR:
+                    case PlSqlParser.REFERENCED:
+                    case PlSqlParser.REFERENCE:
+                    case PlSqlParser.REFERENCES:
+                    case PlSqlParser.REFERENCING:
+                    case PlSqlParser.REF:
+                    case PlSqlParser.REFRESH:
+                    case PlSqlParser.REFTOHEX:
+                    case PlSqlParser.REGEXP_COUNT:
+                    case PlSqlParser.REGEXP_INSTR:
+                    case PlSqlParser.REGEXP_LIKE:
+                    case PlSqlParser.REGEXP_REPLACE:
+                    case PlSqlParser.REGEXP_SUBSTR:
+                    case PlSqlParser.REGISTER:
+                    case PlSqlParser.REGR_AVGX:
+                    case PlSqlParser.REGR_AVGY:
+                    case PlSqlParser.REGR_COUNT:
+                    case PlSqlParser.REGR_INTERCEPT:
+                    case PlSqlParser.REGR_R2:
+                    case PlSqlParser.REGR_SLOPE:
+                    case PlSqlParser.REGR_SXX:
+                    case PlSqlParser.REGR_SXY:
+                    case PlSqlParser.REGR_SYY:
+                    case PlSqlParser.REGULAR:
+                    case PlSqlParser.REJECT:
+                    case PlSqlParser.REKEY:
+                    case PlSqlParser.RELATIONAL:
+                    case PlSqlParser.RELOCATE:
+                    case PlSqlParser.RELY:
+                    case PlSqlParser.REMAINDER:
+                    case PlSqlParser.REMOTE:
+                    case PlSqlParser.REMOTE_MAPPED:
+                    case PlSqlParser.REMOVE:
+                    case PlSqlParser.RENAME:
+                    case PlSqlParser.REPAIR:
+                    case PlSqlParser.REPEAT:
+                    case PlSqlParser.REPLACE:
+                    case PlSqlParser.REPLICATION:
+                    case PlSqlParser.REQUIRED:
+                    case PlSqlParser.RESETLOGS:
+                    case PlSqlParser.RESET:
+                    case PlSqlParser.RESIZE:
+                    case PlSqlParser.RESOLVE:
+                    case PlSqlParser.RESOLVER:
+                    case PlSqlParser.RESPECT:
+                    case PlSqlParser.RESTART:
+                    case PlSqlParser.RESTORE_AS_INTERVALS:
+                    case PlSqlParser.RESTORE:
+                    case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                    case PlSqlParser.RESTRICTED:
+                    case PlSqlParser.RESTRICT_REFERENCES:
+                    case PlSqlParser.RESTRICT:
+                    case PlSqlParser.RESULT_CACHE:
+                    case PlSqlParser.RESULT:
+                    case PlSqlParser.RESUMABLE:
+                    case PlSqlParser.RESUME:
+                    case PlSqlParser.RETENTION:
+                    case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                    case PlSqlParser.RETURNING:
+                    case PlSqlParser.RETURN:
+                    case PlSqlParser.REUSE:
+                    case PlSqlParser.REVERSE:
+                    case PlSqlParser.REWRITE_OR_ERROR:
+                    case PlSqlParser.REWRITE:
+                    case PlSqlParser.RIGHT:
+                    case PlSqlParser.ROLE:
+                    case PlSqlParser.ROLESET:
+                    case PlSqlParser.ROLES:
+                    case PlSqlParser.ROLLBACK:
+                    case PlSqlParser.ROLLING:
+                    case PlSqlParser.ROLLUP:
+                    case PlSqlParser.ROWDEPENDENCIES:
+                    case PlSqlParser.ROWID_MAPPING_TABLE:
+                    case PlSqlParser.ROWID:
+                    case PlSqlParser.ROWIDTOCHAR:
+                    case PlSqlParser.ROWIDTONCHAR:
+                    case PlSqlParser.ROW_LENGTH:
+                    case PlSqlParser.ROWNUM:
+                    case PlSqlParser.ROW:
+                    case PlSqlParser.ROWS:
+                    case PlSqlParser.RPAD:
+                    case PlSqlParser.RTRIM:
+                    case PlSqlParser.RULE:
+                    case PlSqlParser.RULES:
+                    case PlSqlParser.RUNNING:
+                    case PlSqlParser.SALT:
+                    case PlSqlParser.SAMPLE:
+                    case PlSqlParser.SAVE_AS_INTERVALS:
+                    case PlSqlParser.SAVEPOINT:
+                    case PlSqlParser.SAVE:
+                    case PlSqlParser.SB4:
+                    case PlSqlParser.SCALE_ROWS:
+                    case PlSqlParser.SCALE:
+                    case PlSqlParser.SCAN_INSTANCES:
+                    case PlSqlParser.SCAN:
+                    case PlSqlParser.SCHEDULER:
+                    case PlSqlParser.SCHEMACHECK:
+                    case PlSqlParser.SCHEMA:
+                    case PlSqlParser.SCN_ASCENDING:
+                    case PlSqlParser.SCN:
+                    case PlSqlParser.SCOPE:
+                    case PlSqlParser.SCRUB:
+                    case PlSqlParser.SD_ALL:
+                    case PlSqlParser.SD_INHIBIT:
+                    case PlSqlParser.SDO_GEOM_MBR:
+                    case PlSqlParser.SDO_GEOMETRY:
+                    case PlSqlParser.SD_SHOW:
+                    case PlSqlParser.SEARCH:
+                    case PlSqlParser.SECOND:
+                    case PlSqlParser.SECONDS:
+                    case PlSqlParser.SECRET:
+                    case PlSqlParser.SECUREFILE_DBA:
+                    case PlSqlParser.SECUREFILE:
+                    case PlSqlParser.SECURITY:
+                    case PlSqlParser.SEED:
+                    case PlSqlParser.SEG_BLOCK:
+                    case PlSqlParser.SEG_FILE:
+                    case PlSqlParser.SEGMENT:
+                    case PlSqlParser.SELECTIVITY:
+                    case PlSqlParser.SELF:
+                    case PlSqlParser.SEMIJOIN_DRIVER:
+                    case PlSqlParser.SEMIJOIN:
+                    case PlSqlParser.SEMI_TO_INNER:
+                    case PlSqlParser.SEQUENCED:
+                    case PlSqlParser.SEQUENCE:
+                    case PlSqlParser.SEQUENTIAL:
+                    case PlSqlParser.SEQ:
+                    case PlSqlParser.SERIALIZABLE:
+                    case PlSqlParser.SERIALLY_REUSABLE:
+                    case PlSqlParser.SERIAL:
+                    case PlSqlParser.SERVERERROR:
+                    case PlSqlParser.SERVICE_NAME_CONVERT:
+                    case PlSqlParser.SERVICE:
+                    case PlSqlParser.SERVICES:
+                    case PlSqlParser.SESSION_CACHED_CURSORS:
+                    case PlSqlParser.SESSION:
+                    case PlSqlParser.SESSIONS_PER_USER:
+                    case PlSqlParser.SESSIONTIMEZONE:
+                    case PlSqlParser.SESSIONTZNAME:
+                    case PlSqlParser.SET:
+                    case PlSqlParser.SETS:
+                    case PlSqlParser.SETTINGS:
+                    case PlSqlParser.SET_TO_JOIN:
+                    case PlSqlParser.SEVERE:
+                    case PlSqlParser.SHARDSPACE:
+                    case PlSqlParser.SHARED_POOL:
+                    case PlSqlParser.SHARED:
+                    case PlSqlParser.SHARING:
+                    case PlSqlParser.SHELFLIFE:
+                    case PlSqlParser.SHOW:
+                    case PlSqlParser.SHRINK:
+                    case PlSqlParser.SHUTDOWN:
+                    case PlSqlParser.SIBLINGS:
+                    case PlSqlParser.SID:
+                    case PlSqlParser.SITE:
+                    case PlSqlParser.SIGNAL_COMPONENT:
+                    case PlSqlParser.SIGNAL_FUNCTION:
+                    case PlSqlParser.SIGN:
+                    case PlSqlParser.SIGNTYPE:
+                    case PlSqlParser.SIMPLE_INTEGER:
+                    case PlSqlParser.SIMPLE:
+                    case PlSqlParser.SINGLE:
+                    case PlSqlParser.SINGLETASK:
+                    case PlSqlParser.SINH:
+                    case PlSqlParser.SIN:
+                    case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                    case PlSqlParser.SKIP_:
+                    case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                    case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                    case PlSqlParser.SMALLFILE:
+                    case PlSqlParser.SMALLINT:
+                    case PlSqlParser.SNAPSHOT:
+                    case PlSqlParser.SOME:
+                    case PlSqlParser.SORT:
+                    case PlSqlParser.SOUNDEX:
+                    case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                    case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                    case PlSqlParser.SOURCE:
+                    case PlSqlParser.SPACE_KEYWORD:
+                    case PlSqlParser.SPECIFICATION:
+                    case PlSqlParser.SPFILE:
+                    case PlSqlParser.SPLIT:
+                    case PlSqlParser.SPREADSHEET:
+                    case PlSqlParser.SQLDATA:
+                    case PlSqlParser.SQLERROR:
+                    case PlSqlParser.SQLLDR:
+                    case PlSqlParser.SQL:
+                    case PlSqlParser.FILE_EXT:
+                    case PlSqlParser.SQL_MACRO:
+                    case PlSqlParser.SQL_TRACE:
+                    case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                    case PlSqlParser.SQRT:
+                    case PlSqlParser.STALE:
+                    case PlSqlParser.STANDALONE:
+                    case PlSqlParser.STANDARD:
+                    case PlSqlParser.STANDARD_HASH:
+                    case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                    case PlSqlParser.STANDBYS:
+                    case PlSqlParser.STANDBY:
+                    case PlSqlParser.STAR:
+                    case PlSqlParser.STAR_TRANSFORMATION:
+                    case PlSqlParser.STARTUP:
+                    case PlSqlParser.STATEMENT_ID:
+                    case PlSqlParser.STATEMENT_QUEUING:
+                    case PlSqlParser.STATEMENTS:
+                    case PlSqlParser.STATEMENT:
+                    case PlSqlParser.STATE:
+                    case PlSqlParser.STATIC:
+                    case PlSqlParser.STATISTICS:
+                    case PlSqlParser.STATS_BINOMIAL_TEST:
+                    case PlSqlParser.STATS_CROSSTAB:
+                    case PlSqlParser.STATS_F_TEST:
+                    case PlSqlParser.STATS_KS_TEST:
+                    case PlSqlParser.STATS_MODE:
+                    case PlSqlParser.STATS_MW_TEST:
+                    case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                    case PlSqlParser.STATS_T_TEST_INDEP:
+                    case PlSqlParser.STATS_T_TEST_INDEPU:
+                    case PlSqlParser.STATS_T_TEST_ONE:
+                    case PlSqlParser.STATS_T_TEST_PAIRED:
+                    case PlSqlParser.STATS_WSR_TEST:
+                    case PlSqlParser.STDDEV_POP:
+                    case PlSqlParser.STDDEV_SAMP:
+                    case PlSqlParser.STOP:
+                    case PlSqlParser.STORAGE:
+                    case PlSqlParser.STORE:
+                    case PlSqlParser.STREAMS:
+                    case PlSqlParser.STREAM:
+                    case PlSqlParser.STRICT:
+                    case PlSqlParser.STRING:
+                    case PlSqlParser.STRIPE_COLUMNS:
+                    case PlSqlParser.STRIPE_WIDTH:
+                    case PlSqlParser.STRIP:
+                    case PlSqlParser.STRUCTURE:
+                    case PlSqlParser.SUBMULTISET:
+                    case PlSqlParser.SUBPARTITION_REL:
+                    case PlSqlParser.SUBPARTITIONS:
+                    case PlSqlParser.SUBPARTITION:
+                    case PlSqlParser.SUBQUERIES:
+                    case PlSqlParser.SUBQUERY_PRUNING:
+                    case PlSqlParser.SUBSCRIBE:
+                    case PlSqlParser.SUBSET:
+                    case PlSqlParser.SUBSTITUTABLE:
+                    case PlSqlParser.SUBSTR2:
+                    case PlSqlParser.SUBSTR4:
+                    case PlSqlParser.SUBSTRB:
+                    case PlSqlParser.SUBSTRC:
+                    case PlSqlParser.SUBTYPE:
+                    case PlSqlParser.SUCCESSFUL:
+                    case PlSqlParser.SUCCESS:
+                    case PlSqlParser.SUMMARY:
+                    case PlSqlParser.SUPPLEMENTAL:
+                    case PlSqlParser.SUSPEND:
+                    case PlSqlParser.SWAP_JOIN_INPUTS:
+                    case PlSqlParser.SWITCHOVER:
+                    case PlSqlParser.SWITCH:
+                    case PlSqlParser.SYNCHRONOUS:
+                    case PlSqlParser.SYNC:
+                    case PlSqlParser.SYS:
+                    case PlSqlParser.SYSASM:
+                    case PlSqlParser.SYS_AUDIT:
+                    case PlSqlParser.SYSAUX:
+                    case PlSqlParser.SYSBACKUP:
+                    case PlSqlParser.SYS_CHECKACL:
+                    case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                    case PlSqlParser.SYS_CONNECT_BY_PATH:
+                    case PlSqlParser.SYS_CONTEXT:
+                    case PlSqlParser.SYSDATE:
+                    case PlSqlParser.SYSDBA:
+                    case PlSqlParser.SYS_DBURIGEN:
+                    case PlSqlParser.SYSDG:
+                    case PlSqlParser.SYS_DL_CURSOR:
+                    case PlSqlParser.SYS_DM_RXFORM_CHR:
+                    case PlSqlParser.SYS_DM_RXFORM_NUM:
+                    case PlSqlParser.SYS_DOM_COMPARE:
+                    case PlSqlParser.SYS_DST_PRIM2SEC:
+                    case PlSqlParser.SYS_DST_SEC2PRIM:
+                    case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                    case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                    case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                    case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                    case PlSqlParser.SYS_EXTPDTXT:
+                    case PlSqlParser.SYS_EXTRACT_UTC:
+                    case PlSqlParser.SYS_FBT_INSDEL:
+                    case PlSqlParser.SYS_FILTER_ACLS:
+                    case PlSqlParser.SYS_FNMATCHES:
+                    case PlSqlParser.SYS_FNREPLACE:
+                    case PlSqlParser.SYS_GET_ACLIDS:
+                    case PlSqlParser.SYS_GET_COL_ACLIDS:
+                    case PlSqlParser.SYS_GET_PRIVILEGES:
+                    case PlSqlParser.SYS_GETTOKENID:
+                    case PlSqlParser.SYS_GETXTIVAL:
+                    case PlSqlParser.SYS_GUID:
+                    case PlSqlParser.SYSGUID:
+                    case PlSqlParser.SYSKM:
+                    case PlSqlParser.SYS_MAKE_XMLNODEID:
+                    case PlSqlParser.SYS_MAKEXML:
+                    case PlSqlParser.SYS_MKXMLATTR:
+                    case PlSqlParser.SYS_MKXTI:
+                    case PlSqlParser.SYSOBJ:
+                    case PlSqlParser.SYS_OP_ADT2BIN:
+                    case PlSqlParser.SYS_OP_ADTCONS:
+                    case PlSqlParser.SYS_OP_ALSCRVAL:
+                    case PlSqlParser.SYS_OP_ATG:
+                    case PlSqlParser.SYS_OP_BIN2ADT:
+                    case PlSqlParser.SYS_OP_BITVEC:
+                    case PlSqlParser.SYS_OP_BL2R:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                    case PlSqlParser.SYS_OP_C2C:
+                    case PlSqlParser.SYS_OP_CAST:
+                    case PlSqlParser.SYS_OP_CEG:
+                    case PlSqlParser.SYS_OP_CL2C:
+                    case PlSqlParser.SYS_OP_COMBINED_HASH:
+                    case PlSqlParser.SYS_OP_COMP:
+                    case PlSqlParser.SYS_OP_CONVERT:
+                    case PlSqlParser.SYS_OP_COUNTCHG:
+                    case PlSqlParser.SYS_OP_CSCONV:
+                    case PlSqlParser.SYS_OP_CSCONVTEST:
+                    case PlSqlParser.SYS_OP_CSR:
+                    case PlSqlParser.SYS_OP_CSX_PATCH:
+                    case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                    case PlSqlParser.SYS_OP_DECOMP:
+                    case PlSqlParser.SYS_OP_DESCEND:
+                    case PlSqlParser.SYS_OP_DISTINCT:
+                    case PlSqlParser.SYS_OP_DRA:
+                    case PlSqlParser.SYS_OP_DUMP:
+                    case PlSqlParser.SYS_OP_DV_CHECK:
+                    case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                    case PlSqlParser.SYSOPER:
+                    case PlSqlParser.SYS_OP_EXTRACT:
+                    case PlSqlParser.SYS_OP_GROUPING:
+                    case PlSqlParser.SYS_OP_GUID:
+                    case PlSqlParser.SYS_OP_HASH:
+                    case PlSqlParser.SYS_OP_IIX:
+                    case PlSqlParser.SYS_OP_ITR:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                    case PlSqlParser.SYS_OP_LBID:
+                    case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2ID:
+                    case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                    case PlSqlParser.SYS_OP_LSVI:
+                    case PlSqlParser.SYS_OP_LVL:
+                    case PlSqlParser.SYS_OP_MAKEOID:
+                    case PlSqlParser.SYS_OP_MAP_NONNULL:
+                    case PlSqlParser.SYS_OP_MSR:
+                    case PlSqlParser.SYS_OP_NICOMBINE:
+                    case PlSqlParser.SYS_OP_NIEXTRACT:
+                    case PlSqlParser.SYS_OP_NII:
+                    case PlSqlParser.SYS_OP_NIX:
+                    case PlSqlParser.SYS_OP_NOEXPAND:
+                    case PlSqlParser.SYS_OP_NTCIMG:
+                    case PlSqlParser.SYS_OP_NUMTORAW:
+                    case PlSqlParser.SYS_OP_OIDVALUE:
+                    case PlSqlParser.SYS_OP_OPNSIZE:
+                    case PlSqlParser.SYS_OP_PAR_1:
+                    case PlSqlParser.SYS_OP_PARGID_1:
+                    case PlSqlParser.SYS_OP_PARGID:
+                    case PlSqlParser.SYS_OP_PAR:
+                    case PlSqlParser.SYS_OP_PART_ID:
+                    case PlSqlParser.SYS_OP_PIVOT:
+                    case PlSqlParser.SYS_OP_R2O:
+                    case PlSqlParser.SYS_OP_RAWTONUM:
+                    case PlSqlParser.SYS_OP_RDTM:
+                    case PlSqlParser.SYS_OP_REF:
+                    case PlSqlParser.SYS_OP_RMTD:
+                    case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                    case PlSqlParser.SYS_OP_RPB:
+                    case PlSqlParser.SYS_OPTLOBPRBSC:
+                    case PlSqlParser.SYS_OP_TOSETID:
+                    case PlSqlParser.SYS_OP_TPR:
+                    case PlSqlParser.SYS_OP_TRTB:
+                    case PlSqlParser.SYS_OPTXICMP:
+                    case PlSqlParser.SYS_OPTXQCASTASNQ:
+                    case PlSqlParser.SYS_OP_UNDESCEND:
+                    case PlSqlParser.SYS_OP_VECAND:
+                    case PlSqlParser.SYS_OP_VECBIT:
+                    case PlSqlParser.SYS_OP_VECOR:
+                    case PlSqlParser.SYS_OP_VECXOR:
+                    case PlSqlParser.SYS_OP_VERSION:
+                    case PlSqlParser.SYS_OP_VREF:
+                    case PlSqlParser.SYS_OP_VVD:
+                    case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                    case PlSqlParser.SYS_OP_XPTHATG:
+                    case PlSqlParser.SYS_OP_XPTHIDX:
+                    case PlSqlParser.SYS_OP_XPTHOP:
+                    case PlSqlParser.SYS_OP_XTXT2SQLT:
+                    case PlSqlParser.SYS_OP_ZONE_ID:
+                    case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                    case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                    case PlSqlParser.SYS_ORDERKEY_PARENT:
+                    case PlSqlParser.SYS_PARALLEL_TXN:
+                    case PlSqlParser.SYS_PATHID_IS_ATTR:
+                    case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                    case PlSqlParser.SYS_PATHID_LASTNAME:
+                    case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                    case PlSqlParser.SYS_PATH_REVERSE:
+                    case PlSqlParser.SYS_PXQEXTRACT:
+                    case PlSqlParser.SYS_RAW_TO_XSID:
+                    case PlSqlParser.SYS_RID_ORDER:
+                    case PlSqlParser.SYS_ROW_DELTA:
+                    case PlSqlParser.SYS_SC_2_XMLT:
+                    case PlSqlParser.SYS_SYNRCIREDO:
+                    case PlSqlParser.SYSTEM_DEFINED:
+                    case PlSqlParser.SYSTEM:
+                    case PlSqlParser.SYSTIMESTAMP:
+                    case PlSqlParser.SYS_TYPEID:
+                    case PlSqlParser.SYS_UMAKEXML:
+                    case PlSqlParser.SYS_XMLANALYZE:
+                    case PlSqlParser.SYS_XMLCONTAINS:
+                    case PlSqlParser.SYS_XMLCONV:
+                    case PlSqlParser.SYS_XMLEXNSURI:
+                    case PlSqlParser.SYS_XMLGEN:
+                    case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                    case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                    case PlSqlParser.SYS_XMLINSTR:
+                    case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETCID:
+                    case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                    case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                    case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                    case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETTID:
+                    case PlSqlParser.SYS_XMLNODEID:
+                    case PlSqlParser.SYS_XMLT_2_SC:
+                    case PlSqlParser.SYS_XMLTRANSLATE:
+                    case PlSqlParser.SYS_XMLTYPE2SQL:
+                    case PlSqlParser.SYS_XQ_ASQLCNV:
+                    case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                    case PlSqlParser.SYS_XQBASEURI:
+                    case PlSqlParser.SYS_XQCASTABLEERRH:
+                    case PlSqlParser.SYS_XQCODEP2STR:
+                    case PlSqlParser.SYS_XQCODEPEQ:
+                    case PlSqlParser.SYS_XQCON2SEQ:
+                    case PlSqlParser.SYS_XQCONCAT:
+                    case PlSqlParser.SYS_XQDELETE:
+                    case PlSqlParser.SYS_XQDFLTCOLATION:
+                    case PlSqlParser.SYS_XQDOC:
+                    case PlSqlParser.SYS_XQDOCURI:
+                    case PlSqlParser.SYS_XQDURDIV:
+                    case PlSqlParser.SYS_XQED4URI:
+                    case PlSqlParser.SYS_XQENDSWITH:
+                    case PlSqlParser.SYS_XQERRH:
+                    case PlSqlParser.SYS_XQERR:
+                    case PlSqlParser.SYS_XQESHTMLURI:
+                    case PlSqlParser.SYS_XQEXLOBVAL:
+                    case PlSqlParser.SYS_XQEXSTWRP:
+                    case PlSqlParser.SYS_XQEXTRACT:
+                    case PlSqlParser.SYS_XQEXTRREF:
+                    case PlSqlParser.SYS_XQEXVAL:
+                    case PlSqlParser.SYS_XQFB2STR:
+                    case PlSqlParser.SYS_XQFNBOOL:
+                    case PlSqlParser.SYS_XQFNCMP:
+                    case PlSqlParser.SYS_XQFNDATIM:
+                    case PlSqlParser.SYS_XQFNLNAME:
+                    case PlSqlParser.SYS_XQFNNM:
+                    case PlSqlParser.SYS_XQFNNSURI:
+                    case PlSqlParser.SYS_XQFNPREDTRUTH:
+                    case PlSqlParser.SYS_XQFNQNM:
+                    case PlSqlParser.SYS_XQFNROOT:
+                    case PlSqlParser.SYS_XQFORMATNUM:
+                    case PlSqlParser.SYS_XQFTCONTAIN:
+                    case PlSqlParser.SYS_XQFUNCR:
+                    case PlSqlParser.SYS_XQGETCONTENT:
+                    case PlSqlParser.SYS_XQINDXOF:
+                    case PlSqlParser.SYS_XQINSERT:
+                    case PlSqlParser.SYS_XQINSPFX:
+                    case PlSqlParser.SYS_XQIRI2URI:
+                    case PlSqlParser.SYS_XQLANG:
+                    case PlSqlParser.SYS_XQLLNMFRMQNM:
+                    case PlSqlParser.SYS_XQMKNODEREF:
+                    case PlSqlParser.SYS_XQNILLED:
+                    case PlSqlParser.SYS_XQNODENAME:
+                    case PlSqlParser.SYS_XQNORMSPACE:
+                    case PlSqlParser.SYS_XQNORMUCODE:
+                    case PlSqlParser.SYS_XQ_NRNG:
+                    case PlSqlParser.SYS_XQNSP4PFX:
+                    case PlSqlParser.SYS_XQNSPFRMQNM:
+                    case PlSqlParser.SYS_XQPFXFRMQNM:
+                    case PlSqlParser.SYS_XQ_PKSQL2XML:
+                    case PlSqlParser.SYS_XQPOLYABS:
+                    case PlSqlParser.SYS_XQPOLYADD:
+                    case PlSqlParser.SYS_XQPOLYCEL:
+                    case PlSqlParser.SYS_XQPOLYCSTBL:
+                    case PlSqlParser.SYS_XQPOLYCST:
+                    case PlSqlParser.SYS_XQPOLYDIV:
+                    case PlSqlParser.SYS_XQPOLYFLR:
+                    case PlSqlParser.SYS_XQPOLYMOD:
+                    case PlSqlParser.SYS_XQPOLYMUL:
+                    case PlSqlParser.SYS_XQPOLYRND:
+                    case PlSqlParser.SYS_XQPOLYSQRT:
+                    case PlSqlParser.SYS_XQPOLYSUB:
+                    case PlSqlParser.SYS_XQPOLYUMUS:
+                    case PlSqlParser.SYS_XQPOLYUPLS:
+                    case PlSqlParser.SYS_XQPOLYVEQ:
+                    case PlSqlParser.SYS_XQPOLYVGE:
+                    case PlSqlParser.SYS_XQPOLYVGT:
+                    case PlSqlParser.SYS_XQPOLYVLE:
+                    case PlSqlParser.SYS_XQPOLYVLT:
+                    case PlSqlParser.SYS_XQPOLYVNE:
+                    case PlSqlParser.SYS_XQREF2VAL:
+                    case PlSqlParser.SYS_XQRENAME:
+                    case PlSqlParser.SYS_XQREPLACE:
+                    case PlSqlParser.SYS_XQRESVURI:
+                    case PlSqlParser.SYS_XQRNDHALF2EVN:
+                    case PlSqlParser.SYS_XQRSLVQNM:
+                    case PlSqlParser.SYS_XQRYENVPGET:
+                    case PlSqlParser.SYS_XQRYVARGET:
+                    case PlSqlParser.SYS_XQRYWRP:
+                    case PlSqlParser.SYS_XQSEQ2CON4XC:
+                    case PlSqlParser.SYS_XQSEQ2CON:
+                    case PlSqlParser.SYS_XQSEQDEEPEQ:
+                    case PlSqlParser.SYS_XQSEQINSB:
+                    case PlSqlParser.SYS_XQSEQRM:
+                    case PlSqlParser.SYS_XQSEQRVS:
+                    case PlSqlParser.SYS_XQSEQSUB:
+                    case PlSqlParser.SYS_XQSEQTYPMATCH:
+                    case PlSqlParser.SYS_XQSTARTSWITH:
+                    case PlSqlParser.SYS_XQSTATBURI:
+                    case PlSqlParser.SYS_XQSTR2CODEP:
+                    case PlSqlParser.SYS_XQSTRJOIN:
+                    case PlSqlParser.SYS_XQSUBSTRAFT:
+                    case PlSqlParser.SYS_XQSUBSTRBEF:
+                    case PlSqlParser.SYS_XQTOKENIZE:
+                    case PlSqlParser.SYS_XQTREATAS:
+                    case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                    case PlSqlParser.SYS_XQXFORM:
+                    case PlSqlParser.SYS_XSID_TO_RAW:
+                    case PlSqlParser.SYS_ZMAP_FILTER:
+                    case PlSqlParser.SYS_ZMAP_REFRESH:
+                    case PlSqlParser.T_LETTER:
+                    case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.TABLESPACE_NO:
+                    case PlSqlParser.TABLESPACE:
+                    case PlSqlParser.TABLES:
+                    case PlSqlParser.TABLE_STATS:
+                    case PlSqlParser.TABLE:
+                    case PlSqlParser.TABNO:
+                    case PlSqlParser.TAG:
+                    case PlSqlParser.TANH:
+                    case PlSqlParser.TAN:
+                    case PlSqlParser.TBLORIDXPARTNUM:
+                    case PlSqlParser.TEMPFILE:
+                    case PlSqlParser.TEMPLATE:
+                    case PlSqlParser.TEMPLATE_TABLE:
+                    case PlSqlParser.TEMPORARY:
+                    case PlSqlParser.TEMP_TABLE:
+                    case PlSqlParser.TEST:
+                    case PlSqlParser.TEXT:
+                    case PlSqlParser.THAN:
+                    case PlSqlParser.THEN:
+                    case PlSqlParser.THE:
+                    case PlSqlParser.THREAD:
+                    case PlSqlParser.THROUGH:
+                    case PlSqlParser.TIER:
+                    case PlSqlParser.TIES:
+                    case PlSqlParser.TIMEOUT:
+                    case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP:
+                    case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                    case PlSqlParser.TIMES:
+                    case PlSqlParser.TIME:
+                    case PlSqlParser.TIMEZONE:
+                    case PlSqlParser.TIMEZONE_ABBR:
+                    case PlSqlParser.TIMEZONE_HOUR:
+                    case PlSqlParser.TIMEZONE_MINUTE:
+                    case PlSqlParser.TIMEZONE_OFFSET:
+                    case PlSqlParser.TIMEZONE_REGION:
+                    case PlSqlParser.TIME_ZONE:
+                    case PlSqlParser.TIMING:
+                    case PlSqlParser.TIV_GB:
+                    case PlSqlParser.TIV_SSF:
+                    case PlSqlParser.TO_ACLID:
+                    case PlSqlParser.TO_BINARY_DOUBLE:
+                    case PlSqlParser.TO_BINARY_FLOAT:
+                    case PlSqlParser.TO_BLOB:
+                    case PlSqlParser.TO_CLOB:
+                    case PlSqlParser.TO_DSINTERVAL:
+                    case PlSqlParser.TO_LOB:
+                    case PlSqlParser.TO_MULTI_BYTE:
+                    case PlSqlParser.TO_NCHAR:
+                    case PlSqlParser.TO_NCLOB:
+                    case PlSqlParser.TO_NUMBER:
+                    case PlSqlParser.TOPLEVEL:
+                    case PlSqlParser.TO_SINGLE_BYTE:
+                    case PlSqlParser.TO_TIMESTAMP:
+                    case PlSqlParser.TO_TIMESTAMP_TZ:
+                    case PlSqlParser.TO_TIME:
+                    case PlSqlParser.TO_TIME_TZ:
+                    case PlSqlParser.TO_YMINTERVAL:
+                    case PlSqlParser.TRACE:
+                    case PlSqlParser.TRACING:
+                    case PlSqlParser.TRACKING:
+                    case PlSqlParser.TRAILING:
+                    case PlSqlParser.TRANSACTION:
+                    case PlSqlParser.TRANSFORM:
+                    case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.TRANSITIONAL:
+                    case PlSqlParser.TRANSITION:
+                    case PlSqlParser.TRANSLATE:
+                    case PlSqlParser.TRANSLATION:
+                    case PlSqlParser.TREAT:
+                    case PlSqlParser.TRIGGERS:
+                    case PlSqlParser.TRIGGER:
+                    case PlSqlParser.TRUE:
+                    case PlSqlParser.TRUNCATE:
+                    case PlSqlParser.TRUNC:
+                    case PlSqlParser.TRUSTED:
+                    case PlSqlParser.TRUST:
+                    case PlSqlParser.TUNING:
+                    case PlSqlParser.TX:
+                    case PlSqlParser.TYPES:
+                    case PlSqlParser.TYPE:
+                    case PlSqlParser.TZ_OFFSET:
+                    case PlSqlParser.UB2:
+                    case PlSqlParser.UBA:
+                    case PlSqlParser.UCS2:
+                    case PlSqlParser.UDF:
+                    case PlSqlParser.UID:
+                    case PlSqlParser.UNARCHIVED:
+                    case PlSqlParser.UNBOUNDED:
+                    case PlSqlParser.UNBOUND:
+                    case PlSqlParser.UNCONDITIONAL:
+                    case PlSqlParser.UNDER:
+                    case PlSqlParser.UNDO:
+                    case PlSqlParser.UNDROP:
+                    case PlSqlParser.UNIFORM:
+                    case PlSqlParser.UNISTR:
+                    case PlSqlParser.UNLIMITED:
+                    case PlSqlParser.UNLOAD:
+                    case PlSqlParser.UNLOCK:
+                    case PlSqlParser.UNMATCHED:
+                    case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                    case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                    case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                    case PlSqlParser.UNNEST:
+                    case PlSqlParser.UNPACKED:
+                    case PlSqlParser.UNPIVOT:
+                    case PlSqlParser.UNPLUG:
+                    case PlSqlParser.UNPROTECTED:
+                    case PlSqlParser.UNQUIESCE:
+                    case PlSqlParser.UNRECOVERABLE:
+                    case PlSqlParser.UNRESTRICTED:
+                    case PlSqlParser.UNSUBSCRIBE:
+                    case PlSqlParser.UNTIL:
+                    case PlSqlParser.UNUSABLE:
+                    case PlSqlParser.UNUSED:
+                    case PlSqlParser.UPDATABLE:
+                    case PlSqlParser.UPDATED:
+                    case PlSqlParser.UPDATEXML:
+                    case PlSqlParser.UPD_INDEXES:
+                    case PlSqlParser.UPD_JOININDEX:
+                    case PlSqlParser.UPGRADE:
+                    case PlSqlParser.UPPER:
+                    case PlSqlParser.UPSERT:
+                    case PlSqlParser.UROWID:
+                    case PlSqlParser.USABLE:
+                    case PlSqlParser.USAGE:
+                    case PlSqlParser.USE_ANTI:
+                    case PlSqlParser.USE_CONCAT:
+                    case PlSqlParser.USE_CUBE:
+                    case PlSqlParser.USE_HASH_AGGREGATION:
+                    case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.USE_HASH:
+                    case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                    case PlSqlParser.USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.USE_MERGE_CARTESIAN:
+                    case PlSqlParser.USE_MERGE:
+                    case PlSqlParser.USE_NL:
+                    case PlSqlParser.USE_NL_WITH_INDEX:
+                    case PlSqlParser.USE_PRIVATE_OUTLINES:
+                    case PlSqlParser.USER_DATA:
+                    case PlSqlParser.USER_DEFINED:
+                    case PlSqlParser.USERENV:
+                    case PlSqlParser.USERGROUP:
+                    case PlSqlParser.USER_RECYCLEBIN:
+                    case PlSqlParser.USERS:
+                    case PlSqlParser.USER_TABLESPACES:
+                    case PlSqlParser.USER:
+                    case PlSqlParser.USE_SEMI:
+                    case PlSqlParser.USE_STORED_OUTLINES:
+                    case PlSqlParser.USE_TTT_FOR_GSETS:
+                    case PlSqlParser.USE:
+                    case PlSqlParser.USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.USE_WEAK_NAME_RESL:
+                    case PlSqlParser.USING_NO_EXPAND:
+                    case PlSqlParser.USING_NLS_COMP:
+                    case PlSqlParser.USING:
+                    case PlSqlParser.UTF16BE:
+                    case PlSqlParser.UTF16LE:
+                    case PlSqlParser.UTF32:
+                    case PlSqlParser.UTF8:
+                    case PlSqlParser.V1:
+                    case PlSqlParser.V2:
+                    case PlSqlParser.VALIDATE:
+                    case PlSqlParser.VALIDATE_CONVERSION:
+                    case PlSqlParser.VALIDATION:
+                    case PlSqlParser.VALID_TIME_END:
+                    case PlSqlParser.VALUE:
+                    case PlSqlParser.VARCHAR2:
+                    case PlSqlParser.VARCHAR:
+                    case PlSqlParser.VARIABLE:
+                    case PlSqlParser.VAR_POP:
+                    case PlSqlParser.VARRAYS:
+                    case PlSqlParser.VARRAY:
+                    case PlSqlParser.VAR_SAMP:
+                    case PlSqlParser.VARYING:
+                    case PlSqlParser.VECTOR_READ_TRACE:
+                    case PlSqlParser.VECTOR_READ:
+                    case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.VECTOR_TRANSFORM:
+                    case PlSqlParser.VERIFIER:
+                    case PlSqlParser.VERIFY:
+                    case PlSqlParser.VERSIONING:
+                    case PlSqlParser.VERSIONS_ENDSCN:
+                    case PlSqlParser.VERSIONS_ENDTIME:
+                    case PlSqlParser.VERSIONS_OPERATION:
+                    case PlSqlParser.VERSIONS_STARTSCN:
+                    case PlSqlParser.VERSIONS_STARTTIME:
+                    case PlSqlParser.VERSIONS:
+                    case PlSqlParser.VERSIONS_XID:
+                    case PlSqlParser.VERSION:
+                    case PlSqlParser.VIOLATION:
+                    case PlSqlParser.VIRTUAL:
+                    case PlSqlParser.VISIBILITY:
+                    case PlSqlParser.VISIBLE:
+                    case PlSqlParser.VOLUME:
+                    case PlSqlParser.VSIZE:
+                    case PlSqlParser.WAIT:
+                    case PlSqlParser.WALLET:
+                    case PlSqlParser.WARNING:
+                    case PlSqlParser.WEEKS:
+                    case PlSqlParser.WEEK:
+                    case PlSqlParser.WELLFORMED:
+                    case PlSqlParser.WHENEVER:
+                    case PlSqlParser.WHEN:
+                    case PlSqlParser.WHILE:
+                    case PlSqlParser.WHITESPACE:
+                    case PlSqlParser.WIDTH_BUCKET:
+                    case PlSqlParser.WITHIN:
+                    case PlSqlParser.WITHOUT:
+                    case PlSqlParser.WITH_PLSQL:
+                    case PlSqlParser.WORK:
+                    case PlSqlParser.WRAPPED:
+                    case PlSqlParser.WRAPPER:
+                    case PlSqlParser.WRITE:
+                    case PlSqlParser.XDB_FASTPATH_INSERT:
+                    case PlSqlParser.X_DYN_PRUNE:
+                    case PlSqlParser.XID:
+                    case PlSqlParser.XML2OBJECT:
+                    case PlSqlParser.XMLAGG:
+                    case PlSqlParser.XMLATTRIBUTES:
+                    case PlSqlParser.XMLCAST:
+                    case PlSqlParser.XMLCDATA:
+                    case PlSqlParser.XMLCOLATTVAL:
+                    case PlSqlParser.XMLCOMMENT:
+                    case PlSqlParser.XMLCONCAT:
+                    case PlSqlParser.XMLDIFF:
+                    case PlSqlParser.XML_DML_RWT_STMT:
+                    case PlSqlParser.XMLELEMENT:
+                    case PlSqlParser.XMLEXISTS2:
+                    case PlSqlParser.XMLEXISTS:
+                    case PlSqlParser.XMLFOREST:
+                    case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.XMLINDEX_REWRITE:
+                    case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                    case PlSqlParser.XMLISNODE:
+                    case PlSqlParser.XMLISVALID:
+                    case PlSqlParser.XMLNAMESPACES:
+                    case PlSqlParser.XMLPARSE:
+                    case PlSqlParser.XMLPATCH:
+                    case PlSqlParser.XMLPI:
+                    case PlSqlParser.XMLQUERYVAL:
+                    case PlSqlParser.XMLQUERY:
+                    case PlSqlParser.XMLROOT:
+                    case PlSqlParser.XMLSCHEMA:
+                    case PlSqlParser.XMLSERIALIZE:
+                    case PlSqlParser.XMLTABLE:
+                    case PlSqlParser.XMLTRANSFORMBLOB:
+                    case PlSqlParser.XMLTRANSFORM:
+                    case PlSqlParser.XMLTYPE:
+                    case PlSqlParser.XML:
+                    case PlSqlParser.XPATHTABLE:
+                    case PlSqlParser.XS_SYS_CONTEXT:
+                    case PlSqlParser.XS:
+                    case PlSqlParser.YEARS:
+                    case PlSqlParser.YEAR:
+                    case PlSqlParser.YES:
+                    case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.ZONEMAP:
+                    case PlSqlParser.ZONE:
+                    case PlSqlParser.PREDICTION:
+                    case PlSqlParser.PREDICTION_BOUNDS:
+                    case PlSqlParser.PREDICTION_COST:
+                    case PlSqlParser.PREDICTION_DETAILS:
+                    case PlSqlParser.PREDICTION_PROBABILITY:
+                    case PlSqlParser.PREDICTION_SET:
+                    case PlSqlParser.BLOCKCHAIN:
+                    case PlSqlParser.COLLATE:
+                    case PlSqlParser.COLLATION:
+                    case PlSqlParser.DEFINITION:
+                    case PlSqlParser.DUPLICATED:
+                    case PlSqlParser.EXTENDED:
+                    case PlSqlParser.HASHING:
+                    case PlSqlParser.IDLE:
+                    case PlSqlParser.IMMUTABLE:
+                    case PlSqlParser.ORACLE_DATAPUMP:
+                    case PlSqlParser.ORACLE_HDFS:
+                    case PlSqlParser.ORACLE_HIVE:
+                    case PlSqlParser.ORACLE_LOADER:
+                    case PlSqlParser.SHARDED:
+                    case PlSqlParser.ISOLATE:
+                    case PlSqlParser.ROOT:
+                    case PlSqlParser.UNITE:
+                    case PlSqlParser.ALGORITHM:
+                    case PlSqlParser.CUME_DIST:
+                    case PlSqlParser.DENSE_RANK:
+                    case PlSqlParser.LISTAGG:
+                    case PlSqlParser.PERCENT_RANK:
+                    case PlSqlParser.PERCENTILE_CONT:
+                    case PlSqlParser.PERCENTILE_DISC:
+                    case PlSqlParser.RANK:
+                    case PlSqlParser.AVG:
+                    case PlSqlParser.CORR:
+                    case PlSqlParser.COVAR_:
+                    case PlSqlParser.LAG:
+                    case PlSqlParser.LEAD:
+                    case PlSqlParser.MAX:
+                    case PlSqlParser.MEDIAN:
+                    case PlSqlParser.MEMOPTIMIZE:
+                    case PlSqlParser.MIN:
+                    case PlSqlParser.NTILE:
+                    case PlSqlParser.NVL:
+                    case PlSqlParser.RATIO_TO_REPORT:
+                    case PlSqlParser.REGR_:
+                    case PlSqlParser.ROUND:
+                    case PlSqlParser.ROW_NUMBER:
+                    case PlSqlParser.SUBSTR:
+                    case PlSqlParser.TO_CHAR:
+                    case PlSqlParser.TRIM:
+                    case PlSqlParser.SUM:
+                    case PlSqlParser.STDDEV:
+                    case PlSqlParser.VAR_:
+                    case PlSqlParser.VARIANCE:
+                    case PlSqlParser.LEAST:
+                    case PlSqlParser.GREATEST:
+                    case PlSqlParser.TO_DATE:
+                    case PlSqlParser.CHARSETID:
+                    case PlSqlParser.CHARSETFORM:
+                    case PlSqlParser.DURATION:
+                    case PlSqlParser.EXTEND:
+                    case PlSqlParser.MAXLEN:
+                    case PlSqlParser.PERSISTABLE:
+                    case PlSqlParser.POLYMORPHIC:
+                    case PlSqlParser.STRUCT:
+                    case PlSqlParser.TDO:
+                    case PlSqlParser.WM_CONCAT:
+                    case PlSqlParser.PERIOD:
+                    case PlSqlParser.DELIMITED_ID:
+                    case PlSqlParser.BINDVAR:
+                    case PlSqlParser.COLON:
+                    case PlSqlParser.INTRODUCER:
+                    case PlSqlParser.REGULAR_ID:
+                        {
+                        this.state = 16927;
+                        this.variable_or_collection();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public variable_or_collection(): Variable_or_collectionContext {
+        let localContext = new Variable_or_collectionContext(this.context, this.state);
+        this.enterRule(localContext, 1866, PlSqlParser.RULE_variable_or_collection);
+        try {
+            this.state = 16936;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2308, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16934;
+                this.variable_name();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16935;
+                this.collection_expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public open_for_statement(): Open_for_statementContext {
+        let localContext = new Open_for_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1868, PlSqlParser.RULE_open_for_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16938;
+            this.match(PlSqlParser.OPEN);
+            this.state = 16939;
+            this.variable_name();
+            this.state = 16940;
+            this.match(PlSqlParser.FOR);
+            this.state = 16943;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2309, this.context) ) {
+            case 1:
+                {
+                this.state = 16941;
+                this.select_statement();
+                }
+                break;
+            case 2:
+                {
+                this.state = 16942;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 16946;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2310, this.context) ) {
+            case 1:
+                {
+                this.state = 16945;
+                this.using_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public transaction_control_statements(): Transaction_control_statementsContext {
+        let localContext = new Transaction_control_statementsContext(this.context, this.state);
+        this.enterRule(localContext, 1870, PlSqlParser.RULE_transaction_control_statements);
+        try {
+            this.state = 16953;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2311, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 16948;
+                this.set_transaction_command();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 16949;
+                this.set_constraint_command();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 16950;
+                this.commit_statement();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 16951;
+                this.rollback_statement();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 16952;
+                this.savepoint_statement();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_transaction_command(): Set_transaction_commandContext {
+        let localContext = new Set_transaction_commandContext(this.context, this.state);
+        this.enterRule(localContext, 1872, PlSqlParser.RULE_set_transaction_command);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16955;
+            this.match(PlSqlParser.SET);
+            this.state = 16956;
+            this.match(PlSqlParser.TRANSACTION);
+            this.state = 16970;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2313, this.context) ) {
+            case 1:
+                {
+                this.state = 16957;
+                this.match(PlSqlParser.READ);
+                this.state = 16958;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1260 || _la === 2315)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 16959;
+                this.match(PlSqlParser.ISOLATION);
+                this.state = 16960;
+                this.match(PlSqlParser.LEVEL);
+                this.state = 16964;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.SERIALIZABLE:
+                    {
+                    this.state = 16961;
+                    this.match(PlSqlParser.SERIALIZABLE);
+                    }
+                    break;
+                case PlSqlParser.READ:
+                    {
+                    this.state = 16962;
+                    this.match(PlSqlParser.READ);
+                    this.state = 16963;
+                    this.match(PlSqlParser.COMMITTED);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 16966;
+                this.match(PlSqlParser.USE);
+                this.state = 16967;
+                this.match(PlSqlParser.ROLLBACK);
+                this.state = 16968;
+                this.match(PlSqlParser.SEGMENT);
+                this.state = 16969;
+                this.rollback_segment_name();
+                }
+                break;
+            }
+            this.state = 16974;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2314, this.context) ) {
+            case 1:
+                {
+                this.state = 16972;
+                this.match(PlSqlParser.NAME);
+                this.state = 16973;
+                this.quoted_string();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_constraint_command(): Set_constraint_commandContext {
+        let localContext = new Set_constraint_commandContext(this.context, this.state);
+        this.enterRule(localContext, 1874, PlSqlParser.RULE_set_constraint_command);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16976;
+            this.match(PlSqlParser.SET);
+            this.state = 16977;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 286 || _la === 287)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 16987;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ALL:
+                {
+                this.state = 16978;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 16979;
+                this.constraint_name();
+                this.state = 16984;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 16980;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 16981;
+                    this.constraint_name();
+                    }
+                    }
+                    this.state = 16986;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 16989;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 395 || _la === 699)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public commit_statement(): Commit_statementContext {
+        let localContext = new Commit_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1876, PlSqlParser.RULE_commit_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 16991;
+            this.match(PlSqlParser.COMMIT);
+            this.state = 16993;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2317, this.context) ) {
+            case 1:
+                {
+                this.state = 16992;
+                this.match(PlSqlParser.WORK);
+                }
+                break;
+            }
+            this.state = 16996;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2318, this.context) ) {
+            case 1:
+                {
+                this.state = 16995;
+                this.write_clause();
+                }
+                break;
+            }
+            this.state = 17014;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2322, this.context) ) {
+            case 1:
+                {
+                this.state = 16998;
+                this.match(PlSqlParser.COMMENT);
+                this.state = 16999;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 17001;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2319, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17000;
+                    this.write_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 17003;
+                this.match(PlSqlParser.FORCE);
+                this.state = 17012;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 17004;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    this.state = 17007;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2320, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 17005;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17006;
+                        this.numeric();
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                case PlSqlParser.CORRUPT_XID:
+                    {
+                    this.state = 17009;
+                    this.match(PlSqlParser.CORRUPT_XID);
+                    this.state = 17010;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    break;
+                case PlSqlParser.CORRUPT_XID_ALL:
+                    {
+                    this.state = 17011;
+                    this.match(PlSqlParser.CORRUPT_XID_ALL);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public write_clause(): Write_clauseContext {
+        let localContext = new Write_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1878, PlSqlParser.RULE_write_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17016;
+            this.match(PlSqlParser.WRITE);
+            this.state = 17021;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2324, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 17019;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.BATCH:
+                    case PlSqlParser.IMMEDIATE:
+                        {
+                        this.state = 17017;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 108 || _la === 699)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.NOWAIT:
+                    case PlSqlParser.WAIT:
+                        {
+                        this.state = 17018;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 1221 || _la === 2295)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 17023;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2324, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rollback_statement(): Rollback_statementContext {
+        let localContext = new Rollback_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1880, PlSqlParser.RULE_rollback_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17024;
+            this.match(PlSqlParser.ROLLBACK);
+            this.state = 17026;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2325, this.context) ) {
+            case 1:
+                {
+                this.state = 17025;
+                this.match(PlSqlParser.WORK);
+                }
+                break;
+            }
+            this.state = 17035;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2327, this.context) ) {
+            case 1:
+                {
+                this.state = 17028;
+                this.match(PlSqlParser.TO);
+                this.state = 17030;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2326, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17029;
+                    this.match(PlSqlParser.SAVEPOINT);
+                    }
+                    break;
+                }
+                this.state = 17032;
+                this.savepoint_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 17033;
+                this.match(PlSqlParser.FORCE);
+                this.state = 17034;
+                this.quoted_string();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public savepoint_statement(): Savepoint_statementContext {
+        let localContext = new Savepoint_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1882, PlSqlParser.RULE_savepoint_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17037;
+            this.match(PlSqlParser.SAVEPOINT);
+            this.state = 17038;
+            this.savepoint_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public collection_method_call(): Collection_method_callContext {
+        let localContext = new Collection_method_callContext(this.context, this.state);
+        this.enterRule(localContext, 1884, PlSqlParser.RULE_collection_method_call);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17040;
+            this.expression();
+            this.state = 17041;
+            this.match(PlSqlParser.PERIOD);
+            this.state = 17063;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DELETE:
+            case PlSqlParser.EXTEND:
+                {
+                this.state = 17042;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 403 || _la === 2431)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 17054;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2329, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17043;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 17044;
+                    localContext._expression = this.expression();
+                    localContext._index.push(localContext._expression!);
+                    this.state = 17049;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 17045;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17046;
+                        localContext._expression = this.expression();
+                        localContext._index.push(localContext._expression!);
+                        }
+                        }
+                        this.state = 17051;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 17052;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.TRIM:
+                {
+                this.state = 17056;
+                this.match(PlSqlParser.TRIM);
+                this.state = 17061;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2330, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17057;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 17058;
+                    localContext._expression = this.expression();
+                    localContext._index.push(localContext._expression!);
+                    this.state = 17059;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public explain_statement(): Explain_statementContext {
+        let localContext = new Explain_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1886, PlSqlParser.RULE_explain_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17065;
+            this.match(PlSqlParser.EXPLAIN);
+            this.state = 17066;
+            this.match(PlSqlParser.PLAN);
+            this.state = 17071;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1673) {
+                {
+                this.state = 17067;
+                this.match(PlSqlParser.SET);
+                this.state = 17068;
+                this.match(PlSqlParser.STATEMENT_ID);
+                this.state = 17069;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 17070;
+                this.quoted_string();
+                }
+            }
+
+            this.state = 17075;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 780) {
+                {
+                this.state = 17073;
+                this.match(PlSqlParser.INTO);
+                this.state = 17074;
+                this.tableview_name();
+                }
+            }
+
+            this.state = 17077;
+            this.match(PlSqlParser.FOR);
+            this.state = 17083;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SELECT:
+            case PlSqlParser.WITH:
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 17078;
+                this.select_statement();
+                }
+                break;
+            case PlSqlParser.UPDATE:
+                {
+                this.state = 17079;
+                this.update_statement();
+                }
+                break;
+            case PlSqlParser.DELETE:
+                {
+                this.state = 17080;
+                this.delete_statement();
+                }
+                break;
+            case PlSqlParser.INSERT:
+                {
+                this.state = 17081;
+                this.insert_statement();
+                }
+                break;
+            case PlSqlParser.MERGE:
+                {
+                this.state = 17082;
+                this.merge_statement();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public select_only_statement(): Select_only_statementContext {
+        let localContext = new Select_only_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1888, PlSqlParser.RULE_select_only_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17085;
+            this.subquery();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public select_statement(): Select_statementContext {
+        let localContext = new Select_statementContext(this.context, this.state);
+        this.enterRule(localContext, 1890, PlSqlParser.RULE_select_statement);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17087;
+            this.select_only_statement();
+            this.state = 17094;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2336, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 17092;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.FOR:
+                        {
+                        this.state = 17088;
+                        this.for_update_clause();
+                        }
+                        break;
+                    case PlSqlParser.ORDER:
+                        {
+                        this.state = 17089;
+                        this.order_by_clause();
+                        }
+                        break;
+                    case PlSqlParser.OFFSET:
+                        {
+                        this.state = 17090;
+                        this.offset_clause();
+                        }
+                        break;
+                    case PlSqlParser.FETCH:
+                        {
+                        this.state = 17091;
+                        this.fetch_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 17096;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2336, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public with_clause(): With_clauseContext {
+        let localContext = new With_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1892, PlSqlParser.RULE_with_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 17130;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2344, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17097;
+                this.match(PlSqlParser.WITH);
+                this.state = 17102;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2338, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        this.state = 17100;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.FUNCTION:
+                            {
+                            this.state = 17098;
+                            this.function_body();
+                            }
+                            break;
+                        case PlSqlParser.PROCEDURE:
+                            {
+                            this.state = 17099;
+                            this.procedure_body();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                    }
+                    this.state = 17104;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2338, this.context);
+                }
+                this.state = 17105;
+                this.with_factoring_clause();
+                this.state = 17110;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 17106;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 17107;
+                    this.with_factoring_clause();
+                    }
+                    }
+                    this.state = 17112;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17113;
+                this.match(PlSqlParser.WITH);
+                this.state = 17116;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        this.state = 17116;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.FUNCTION:
+                            {
+                            this.state = 17114;
+                            this.function_body();
+                            }
+                            break;
+                        case PlSqlParser.PROCEDURE:
+                            {
+                            this.state = 17115;
+                            this.procedure_body();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 17118;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2341, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                this.state = 17128;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531735) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 2290089983) !== 0) || _la === 2477 || _la === 2482) {
+                    {
+                    this.state = 17120;
+                    this.with_factoring_clause();
+                    this.state = 17125;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 17121;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17122;
+                        this.with_factoring_clause();
+                        }
+                        }
+                        this.state = 17127;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    }
+                }
+
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public with_factoring_clause(): With_factoring_clauseContext {
+        let localContext = new With_factoring_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1894, PlSqlParser.RULE_with_factoring_clause);
+        try {
+            this.state = 17134;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2345, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17132;
+                this.subquery_factoring_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17133;
+                this.subav_factoring_clause();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subquery_factoring_clause(): Subquery_factoring_clauseContext {
+        let localContext = new Subquery_factoring_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1896, PlSqlParser.RULE_subquery_factoring_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17136;
+            this.query_name();
+            this.state = 17138;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 17137;
+                this.paren_column_list();
+                }
+            }
+
+            this.state = 17140;
+            this.match(PlSqlParser.AS);
+            this.state = 17141;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17142;
+            this.subquery_no_with();
+            this.state = 17144;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1305) {
+                {
+                this.state = 17143;
+                this.order_by_clause();
+                }
+            }
+
+            this.state = 17146;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 17148;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1637) {
+                {
+                this.state = 17147;
+                this.search_clause();
+                }
+            }
+
+            this.state = 17151;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 348) {
+                {
+                this.state = 17150;
+                this.cycle_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public search_clause(): Search_clauseContext {
+        let localContext = new Search_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1898, PlSqlParser.RULE_search_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17153;
+            this.match(PlSqlParser.SEARCH);
+            this.state = 17154;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 152 || _la === 410)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 17155;
+            this.match(PlSqlParser.FIRST);
+            this.state = 17156;
+            this.match(PlSqlParser.BY);
+            this.state = 17157;
+            this.column_name();
+            this.state = 17159;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 70) {
+                {
+                this.state = 17158;
+                this.match(PlSqlParser.ASC);
+                }
+            }
+
+            this.state = 17162;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 414) {
+                {
+                this.state = 17161;
+                this.match(PlSqlParser.DESC);
+                }
+            }
+
+            this.state = 17166;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2352, this.context) ) {
+            case 1:
+                {
+                this.state = 17164;
+                this.match(PlSqlParser.NULLS);
+                this.state = 17165;
+                this.match(PlSqlParser.FIRST);
+                }
+                break;
+            }
+            this.state = 17170;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1231) {
+                {
+                this.state = 17168;
+                this.match(PlSqlParser.NULLS);
+                this.state = 17169;
+                this.match(PlSqlParser.LAST);
+                }
+            }
+
+            this.state = 17190;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17172;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17173;
+                this.column_name();
+                this.state = 17175;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 70) {
+                    {
+                    this.state = 17174;
+                    this.match(PlSqlParser.ASC);
+                    }
+                }
+
+                this.state = 17178;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 414) {
+                    {
+                    this.state = 17177;
+                    this.match(PlSqlParser.DESC);
+                    }
+                }
+
+                this.state = 17182;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2356, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17180;
+                    this.match(PlSqlParser.NULLS);
+                    this.state = 17181;
+                    this.match(PlSqlParser.FIRST);
+                    }
+                    break;
+                }
+                this.state = 17186;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1231) {
+                    {
+                    this.state = 17184;
+                    this.match(PlSqlParser.NULLS);
+                    this.state = 17185;
+                    this.match(PlSqlParser.LAST);
+                    }
+                }
+
+                }
+                }
+                this.state = 17192;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17193;
+            this.match(PlSqlParser.SET);
+            this.state = 17194;
+            this.column_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cycle_clause(): Cycle_clauseContext {
+        let localContext = new Cycle_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1900, PlSqlParser.RULE_cycle_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17196;
+            this.match(PlSqlParser.CYCLE);
+            this.state = 17197;
+            this.column_list();
+            this.state = 17198;
+            this.match(PlSqlParser.SET);
+            this.state = 17199;
+            this.column_name();
+            this.state = 17200;
+            this.match(PlSqlParser.TO);
+            this.state = 17201;
+            this.expression();
+            this.state = 17202;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 17203;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subav_factoring_clause(): Subav_factoring_clauseContext {
+        let localContext = new Subav_factoring_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1902, PlSqlParser.RULE_subav_factoring_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17205;
+            localContext._subav_name = this.id_expression();
+            this.state = 17206;
+            this.match(PlSqlParser.ANALYTIC);
+            this.state = 17207;
+            this.match(PlSqlParser.VIEW);
+            this.state = 17208;
+            this.match(PlSqlParser.AS);
+            this.state = 17209;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17210;
+            this.subav_clause();
+            this.state = 17211;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subav_clause(): Subav_clauseContext {
+        let localContext = new Subav_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1904, PlSqlParser.RULE_subav_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17213;
+            this.match(PlSqlParser.USING);
+            this.state = 17214;
+            localContext._subav_name = this.object_name();
+            this.state = 17216;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 674) {
+                {
+                this.state = 17215;
+                this.hierarchies_clause();
+                }
+            }
+
+            this.state = 17219;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 595) {
+                {
+                this.state = 17218;
+                this.filter_clauses();
+                }
+            }
+
+            this.state = 17222;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 21) {
+                {
+                this.state = 17221;
+                this.add_calcs_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hierarchies_clause(): Hierarchies_clauseContext {
+        let localContext = new Hierarchies_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1906, PlSqlParser.RULE_hierarchies_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17224;
+            this.match(PlSqlParser.HIERARCHIES);
+            this.state = 17225;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17226;
+            localContext._object_name = this.object_name();
+            localContext._hier_alias.push(localContext._object_name!);
+            this.state = 17231;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17227;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17228;
+                localContext._object_name = this.object_name();
+                localContext._hier_alias.push(localContext._object_name!);
+                }
+                }
+                this.state = 17233;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17234;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filter_clauses(): Filter_clausesContext {
+        let localContext = new Filter_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1908, PlSqlParser.RULE_filter_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17236;
+            this.match(PlSqlParser.FILTER);
+            this.state = 17237;
+            this.match(PlSqlParser.FACT);
+            this.state = 17238;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17239;
+            this.filter_clause();
+            this.state = 17244;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17240;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17241;
+                this.filter_clause();
+                }
+                }
+                this.state = 17246;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17247;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public filter_clause(): Filter_clauseContext {
+        let localContext = new Filter_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1910, PlSqlParser.RULE_filter_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17251;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2364, this.context) ) {
+            case 1:
+                {
+                this.state = 17249;
+                this.match(PlSqlParser.MEASURES);
+                }
+                break;
+            case 2:
+                {
+                this.state = 17250;
+                localContext._hier_alias = this.object_name();
+                }
+                break;
+            }
+            this.state = 17253;
+            this.match(PlSqlParser.TO);
+            this.state = 17254;
+            this.condition();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_calcs_clause(): Add_calcs_clauseContext {
+        let localContext = new Add_calcs_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1912, PlSqlParser.RULE_add_calcs_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17256;
+            this.match(PlSqlParser.ADD);
+            this.state = 17257;
+            this.match(PlSqlParser.MEASURES);
+            this.state = 17258;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17259;
+            this.add_calc_meas_clause();
+            this.state = 17264;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17260;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17261;
+                this.add_calc_meas_clause();
+                }
+                }
+                this.state = 17266;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17267;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public add_calc_meas_clause(): Add_calc_meas_clauseContext {
+        let localContext = new Add_calc_meas_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1914, PlSqlParser.RULE_add_calc_meas_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17269;
+            localContext._meas_name = this.id_expression();
+            this.state = 17270;
+            this.match(PlSqlParser.AS);
+            this.state = 17271;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17272;
+            this.expression();
+            this.state = 17273;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subquery(): SubqueryContext {
+        let localContext = new SubqueryContext(this.context, this.state);
+        this.enterRule(localContext, 1916, PlSqlParser.RULE_subquery);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17276;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2310) {
+                {
+                this.state = 17275;
+                this.with_clause();
+                }
+            }
+
+            this.state = 17278;
+            this.subquery_basic_elements();
+            this.state = 17282;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2367, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 17279;
+                    this.subquery_operation_part();
+                    }
+                    }
+                }
+                this.state = 17284;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2367, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subquery_no_with(): Subquery_no_withContext {
+        let localContext = new Subquery_no_withContext(this.context, this.state);
+        this.enterRule(localContext, 1918, PlSqlParser.RULE_subquery_no_with);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17285;
+            this.subquery_basic_elements();
+            this.state = 17289;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 776 || _la === 957 || _la === 2183) {
+                {
+                {
+                this.state = 17286;
+                this.subquery_operation_part();
+                }
+                }
+                this.state = 17291;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subquery_basic_elements(): Subquery_basic_elementsContext {
+        let localContext = new Subquery_basic_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 1920, PlSqlParser.RULE_subquery_basic_elements);
+        try {
+            this.state = 17297;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SELECT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17292;
+                this.query_block();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17293;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17294;
+                this.subquery_no_with();
+                this.state = 17295;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subquery_operation_part(): Subquery_operation_partContext {
+        let localContext = new Subquery_operation_partContext(this.context, this.state);
+        this.enterRule(localContext, 1922, PlSqlParser.RULE_subquery_operation_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17305;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNION:
+                {
+                this.state = 17299;
+                this.match(PlSqlParser.UNION);
+                this.state = 17301;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 38) {
+                    {
+                    this.state = 17300;
+                    this.match(PlSqlParser.ALL);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.INTERSECT:
+                {
+                this.state = 17303;
+                this.match(PlSqlParser.INTERSECT);
+                }
+                break;
+            case PlSqlParser.MINUS:
+                {
+                this.state = 17304;
+                this.match(PlSqlParser.MINUS);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 17307;
+            this.subquery_basic_elements();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public query_block(): Query_blockContext {
+        let localContext = new Query_blockContext(this.context, this.state);
+        this.enterRule(localContext, 1924, PlSqlParser.RULE_query_block);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17309;
+            this.match(PlSqlParser.SELECT);
+            this.state = 17311;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2372, this.context) ) {
+            case 1:
+                {
+                this.state = 17310;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 38 || _la === 445 || _la === 2185)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 17313;
+            this.selected_list();
+            this.state = 17315;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2373, this.context) ) {
+            case 1:
+                {
+                this.state = 17314;
+                this.into_clause();
+                }
+                break;
+            }
+            this.state = 17318;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2374, this.context) ) {
+            case 1:
+                {
+                this.state = 17317;
+                this.from_clause();
+                }
+                break;
+            }
+            this.state = 17321;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2375, this.context) ) {
+            case 1:
+                {
+                this.state = 17320;
+                this.where_clause();
+                }
+                break;
+            }
+            this.state = 17327;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2377, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    this.state = 17325;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.CONNECT:
+                    case PlSqlParser.START:
+                        {
+                        this.state = 17323;
+                        this.hierarchical_query_clause();
+                        }
+                        break;
+                    case PlSqlParser.GROUP:
+                    case PlSqlParser.HAVING:
+                        {
+                        this.state = 17324;
+                        this.group_by_clause();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+                this.state = 17329;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2377, this.context);
+            }
+            this.state = 17331;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2378, this.context) ) {
+            case 1:
+                {
+                this.state = 17330;
+                this.model_clause();
+                }
+                break;
+            }
+            this.state = 17334;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2379, this.context) ) {
+            case 1:
+                {
+                this.state = 17333;
+                this.order_by_clause();
+                }
+                break;
+            }
+            this.state = 17337;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2380, this.context) ) {
+            case 1:
+                {
+                this.state = 17336;
+                this.offset_clause();
+                }
+                break;
+            }
+            this.state = 17340;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2381, this.context) ) {
+            case 1:
+                {
+                this.state = 17339;
+                this.fetch_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public selected_list(): Selected_listContext {
+        let localContext = new Selected_listContext(this.context, this.state);
+        this.enterRule(localContext, 1926, PlSqlParser.RULE_selected_list);
+        try {
+            let alternative: number;
+            this.state = 17351;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2383, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17342;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17343;
+                this.select_list_elements();
+                this.state = 17348;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2382, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 17344;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17345;
+                        this.select_list_elements();
+                        }
+                        }
+                    }
+                    this.state = 17350;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2382, this.context);
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public from_clause(): From_clauseContext {
+        let localContext = new From_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1928, PlSqlParser.RULE_from_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17353;
+            this.match(PlSqlParser.FROM);
+            this.state = 17354;
+            this.table_ref_list();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public select_list_elements(): Select_list_elementsContext {
+        let localContext = new Select_list_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 1930, PlSqlParser.RULE_select_list_elements);
+        try {
+            this.state = 17364;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2385, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17356;
+                this.tableview_name();
+                this.state = 17357;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 17358;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17360;
+                this.expression();
+                this.state = 17362;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2384, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17361;
+                    this.column_alias();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_ref_list(): Table_ref_listContext {
+        let localContext = new Table_ref_listContext(this.context, this.state);
+        this.enterRule(localContext, 1932, PlSqlParser.RULE_table_ref_list);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17366;
+            this.table_ref();
+            this.state = 17371;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2386, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 17367;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 17368;
+                    this.table_ref();
+                    }
+                    }
+                }
+                this.state = 17373;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2386, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_ref(): Table_refContext {
+        let localContext = new Table_refContext(this.context, this.state);
+        this.enterRule(localContext, 1934, PlSqlParser.RULE_table_ref);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17374;
+            this.table_ref_aux();
+            this.state = 17378;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2387, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 17375;
+                    this.join_clause();
+                    }
+                    }
+                }
+                this.state = 17380;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2387, this.context);
+            }
+            this.state = 17383;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2388, this.context) ) {
+            case 1:
+                {
+                this.state = 17381;
+                this.pivot_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 17382;
+                this.unpivot_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_ref_aux(): Table_ref_auxContext {
+        let localContext = new Table_ref_auxContext(this.context, this.state);
+        this.enterRule(localContext, 1936, PlSqlParser.RULE_table_ref_aux);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17385;
+            this.table_ref_aux_internal();
+            this.state = 17389;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2389, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 17386;
+                    this.flashback_query_clause();
+                    }
+                    }
+                }
+                this.state = 17391;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2389, this.context);
+            }
+            this.state = 17394;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2390, this.context) ) {
+            case 1:
+                {
+                this.state = 17392;
+                if (!(this.isNotStartOfJoin())) {
+                    throw this.createFailedPredicateException("this.isNotStartOfJoin()");
+                }
+                this.state = 17393;
+                this.table_alias();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_ref_aux_internal(): Table_ref_aux_internalContext {
+        let localContext = new Table_ref_aux_internalContext(this.context, this.state);
+        this.enterRule(localContext, 1938, PlSqlParser.RULE_table_ref_aux_internal);
+        let _la: number;
+        try {
+            this.state = 17419;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2394, this.context) ) {
+            case 1:
+                localContext = new Table_ref_aux_internal_oneContext(localContext);
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17396;
+                this.dml_table_expression_clause();
+                this.state = 17399;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2391, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17397;
+                    this.pivot_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 17398;
+                    this.unpivot_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                localContext = new Table_ref_aux_internal_twoContext(localContext);
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17401;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17402;
+                this.table_ref();
+                this.state = 17406;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 776 || _la === 957 || _la === 2183) {
+                    {
+                    {
+                    this.state = 17403;
+                    this.subquery_operation_part();
+                    }
+                    }
+                    this.state = 17408;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 17409;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 17412;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2393, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17410;
+                    this.pivot_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 17411;
+                    this.unpivot_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                localContext = new Table_ref_aux_internal_threContext(localContext);
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 17414;
+                this.match(PlSqlParser.ONLY);
+                this.state = 17415;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17416;
+                this.dml_table_expression_clause();
+                this.state = 17417;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public join_clause(): Join_clauseContext {
+        let localContext = new Join_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1940, PlSqlParser.RULE_join_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 17446;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2401, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17422;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1350) {
+                    {
+                    this.state = 17421;
+                    this.query_partition_clause();
+                    }
+                }
+
+                this.state = 17425;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 327 || _la === 1005) {
+                    {
+                    this.state = 17424;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 327 || _la === 1005)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 17429;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.INNER:
+                    {
+                    this.state = 17427;
+                    this.match(PlSqlParser.INNER);
+                    }
+                    break;
+                case PlSqlParser.FULL:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.RIGHT:
+                    {
+                    this.state = 17428;
+                    this.outer_join_type();
+                    }
+                    break;
+                case PlSqlParser.JOIN:
+                    break;
+                default:
+                    break;
+                }
+                this.state = 17431;
+                this.match(PlSqlParser.JOIN);
+                this.state = 17432;
+                this.table_ref_aux();
+                this.state = 17434;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2398, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17433;
+                    this.query_partition_clause();
+                    }
+                    break;
+                }
+                this.state = 17440;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2400, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        this.state = 17438;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.ON:
+                            {
+                            this.state = 17436;
+                            this.join_on_part();
+                            }
+                            break;
+                        case PlSqlParser.USING:
+                            {
+                            this.state = 17437;
+                            this.join_using_part();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                    }
+                    this.state = 17442;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2400, this.context);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17443;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 327 || _la === 1315)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 17444;
+                this.match(PlSqlParser.APPLY);
+                this.state = 17445;
+                this.table_ref_aux();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public join_on_part(): Join_on_partContext {
+        let localContext = new Join_on_partContext(this.context, this.state);
+        this.enterRule(localContext, 1942, PlSqlParser.RULE_join_on_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17448;
+            this.match(PlSqlParser.ON);
+            this.state = 17449;
+            this.condition();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public join_using_part(): Join_using_partContext {
+        let localContext = new Join_using_partContext(this.context, this.state);
+        this.enterRule(localContext, 1944, PlSqlParser.RULE_join_using_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17451;
+            this.match(PlSqlParser.USING);
+            this.state = 17452;
+            this.paren_column_list();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public outer_join_type(): Outer_join_typeContext {
+        let localContext = new Outer_join_typeContext(this.context, this.state);
+        this.enterRule(localContext, 1946, PlSqlParser.RULE_outer_join_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17454;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 631 || _la === 840 || _la === 1594)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 17456;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1315) {
+                {
+                this.state = 17455;
+                this.match(PlSqlParser.OUTER);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public query_partition_clause(): Query_partition_clauseContext {
+        let localContext = new Query_partition_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1948, PlSqlParser.RULE_query_partition_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17458;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 17459;
+            this.match(PlSqlParser.BY);
+            this.state = 17467;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2404, this.context) ) {
+            case 1:
+                {
+                {
+                this.state = 17460;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17463;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2403, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17461;
+                    this.subquery();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 17462;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 17465;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 17466;
+                this.expressions_();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public flashback_query_clause(): Flashback_query_clauseContext {
+        let localContext = new Flashback_query_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1950, PlSqlParser.RULE_flashback_query_clause);
+        let _la: number;
+        try {
+            this.state = 17494;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VERSIONS:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17469;
+                this.match(PlSqlParser.VERSIONS);
+                this.state = 17477;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.PERIOD_KEYWORD:
+                    {
+                    this.state = 17470;
+                    this.match(PlSqlParser.PERIOD_KEYWORD);
+                    this.state = 17471;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 17472;
+                    this.column_name();
+                    this.state = 17473;
+                    this.match(PlSqlParser.BETWEEN);
+                    }
+                    break;
+                case PlSqlParser.BETWEEN:
+                    {
+                    this.state = 17475;
+                    this.match(PlSqlParser.BETWEEN);
+                    this.state = 17476;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1629 || _la === 2110)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 17479;
+                this.expression();
+                this.state = 17480;
+                this.match(PlSqlParser.AND);
+                this.state = 17481;
+                this.expression();
+                }
+                break;
+            case PlSqlParser.AS:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17483;
+                this.match(PlSqlParser.AS);
+                this.state = 17484;
+                this.match(PlSqlParser.OF);
+                this.state = 17492;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.SCN:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.TIMESTAMP:
+                    {
+                    this.state = 17485;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1629 || _la === 1709 || _la === 2110)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 17486;
+                    this.expression();
+                    }
+                    break;
+                case PlSqlParser.PERIOD_KEYWORD:
+                    {
+                    this.state = 17487;
+                    this.match(PlSqlParser.PERIOD_KEYWORD);
+                    this.state = 17488;
+                    this.match(PlSqlParser.FOR);
+                    this.state = 17489;
+                    this.column_name();
+                    this.state = 17490;
+                    this.expression();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pivot_clause(): Pivot_clauseContext {
+        let localContext = new Pivot_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1952, PlSqlParser.RULE_pivot_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17496;
+            this.match(PlSqlParser.PIVOT);
+            this.state = 17498;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2354) {
+                {
+                this.state = 17497;
+                this.match(PlSqlParser.XML);
+                }
+            }
+
+            this.state = 17500;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17501;
+            this.pivot_element();
+            this.state = 17506;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17502;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17503;
+                this.pivot_element();
+                }
+                }
+                this.state = 17508;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17509;
+            this.pivot_for_clause();
+            this.state = 17510;
+            this.pivot_in_clause();
+            this.state = 17511;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 17513;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2410, this.context) ) {
+            case 1:
+                {
+                this.state = 17512;
+                this.table_alias();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pivot_element(): Pivot_elementContext {
+        let localContext = new Pivot_elementContext(this.context, this.state);
+        this.enterRule(localContext, 1954, PlSqlParser.RULE_pivot_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17521;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2411, this.context) ) {
+            case 1:
+                {
+                this.state = 17515;
+                this.numeric_function();
+                }
+                break;
+            case 2:
+                {
+                this.state = 17516;
+                this.aggregate_function_name();
+                this.state = 17517;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17518;
+                this.expression();
+                this.state = 17519;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 17524;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                this.state = 17523;
+                this.column_alias();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pivot_for_clause(): Pivot_for_clauseContext {
+        let localContext = new Pivot_for_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1956, PlSqlParser.RULE_pivot_for_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17526;
+            this.match(PlSqlParser.FOR);
+            this.state = 17529;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 17527;
+                this.column_name();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 17528;
+                this.paren_column_list();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pivot_in_clause(): Pivot_in_clauseContext {
+        let localContext = new Pivot_in_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1958, PlSqlParser.RULE_pivot_in_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17531;
+            this.match(PlSqlParser.IN);
+            this.state = 17532;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17550;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2416, this.context) ) {
+            case 1:
+                {
+                this.state = 17533;
+                this.subquery();
+                }
+                break;
+            case 2:
+                {
+                this.state = 17534;
+                this.match(PlSqlParser.ANY);
+                this.state = 17539;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 17535;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 17536;
+                    this.match(PlSqlParser.ANY);
+                    }
+                    }
+                    this.state = 17541;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 17542;
+                this.pivot_in_clause_element();
+                this.state = 17547;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 17543;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 17544;
+                    this.pivot_in_clause_element();
+                    }
+                    }
+                    this.state = 17549;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            }
+            this.state = 17552;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pivot_in_clause_element(): Pivot_in_clause_elementContext {
+        let localContext = new Pivot_in_clause_elementContext(this.context, this.state);
+        this.enterRule(localContext, 1960, PlSqlParser.RULE_pivot_in_clause_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17554;
+            this.pivot_in_clause_elements();
+            this.state = 17556;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                this.state = 17555;
+                this.column_alias();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public pivot_in_clause_elements(): Pivot_in_clause_elementsContext {
+        let localContext = new Pivot_in_clause_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 1962, PlSqlParser.RULE_pivot_in_clause_elements);
+        try {
+            this.state = 17564;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2419, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17558;
+                this.expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17559;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17561;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2418, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17560;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 17563;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unpivot_clause(): Unpivot_clauseContext {
+        let localContext = new Unpivot_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1964, PlSqlParser.RULE_unpivot_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17566;
+            this.match(PlSqlParser.UNPIVOT);
+            this.state = 17569;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 539 || _la === 704) {
+                {
+                this.state = 17567;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 539 || _la === 704)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 17568;
+                this.match(PlSqlParser.NULLS);
+                }
+            }
+
+            this.state = 17571;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17574;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 17572;
+                this.column_name();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 17573;
+                this.paren_column_list();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 17576;
+            this.pivot_for_clause();
+            this.state = 17577;
+            this.unpivot_in_clause();
+            this.state = 17578;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 17580;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2422, this.context) ) {
+            case 1:
+                {
+                this.state = 17579;
+                this.table_alias();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unpivot_in_clause(): Unpivot_in_clauseContext {
+        let localContext = new Unpivot_in_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1966, PlSqlParser.RULE_unpivot_in_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17582;
+            this.match(PlSqlParser.IN);
+            this.state = 17583;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17584;
+            this.unpivot_in_elements();
+            this.state = 17589;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17585;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17586;
+                this.unpivot_in_elements();
+                }
+                }
+                this.state = 17591;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17592;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unpivot_in_elements(): Unpivot_in_elementsContext {
+        let localContext = new Unpivot_in_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 1968, PlSqlParser.RULE_unpivot_in_elements);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17596;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 17594;
+                this.column_name();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 17595;
+                this.paren_column_list();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 17613;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 69) {
+                {
+                this.state = 17598;
+                this.match(PlSqlParser.AS);
+                this.state = 17611;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DATE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DEFAULT:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.NULL_:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.UNSIGNED_INTEGER:
+                case PlSqlParser.APPROXIMATE_NUM_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 17599;
+                    this.constant();
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 17600;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 17601;
+                    this.constant();
+                    this.state = 17606;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    while (_la === 2455) {
+                        {
+                        {
+                        this.state = 17602;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17603;
+                        this.constant();
+                        }
+                        }
+                        this.state = 17608;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                    }
+                    this.state = 17609;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public hierarchical_query_clause(): Hierarchical_query_clauseContext {
+        let localContext = new Hierarchical_query_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1970, PlSqlParser.RULE_hierarchical_query_clause);
+        try {
+            this.state = 17632;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CONNECT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17615;
+                this.match(PlSqlParser.CONNECT);
+                this.state = 17616;
+                this.match(PlSqlParser.BY);
+                this.state = 17618;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2428, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17617;
+                    this.match(PlSqlParser.NOCYCLE);
+                    }
+                    break;
+                }
+                this.state = 17620;
+                this.condition();
+                this.state = 17622;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2429, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17621;
+                    this.start_part();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.START:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17624;
+                this.start_part();
+                this.state = 17625;
+                this.match(PlSqlParser.CONNECT);
+                this.state = 17626;
+                this.match(PlSqlParser.BY);
+                this.state = 17628;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2430, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17627;
+                    this.match(PlSqlParser.NOCYCLE);
+                    }
+                    break;
+                }
+                this.state = 17630;
+                this.condition();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public start_part(): Start_partContext {
+        let localContext = new Start_partContext(this.context, this.state);
+        this.enterRule(localContext, 1972, PlSqlParser.RULE_start_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17634;
+            this.match(PlSqlParser.START);
+            this.state = 17635;
+            this.match(PlSqlParser.WITH);
+            this.state = 17636;
+            this.condition();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public group_by_clause(): Group_by_clauseContext {
+        let localContext = new Group_by_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1974, PlSqlParser.RULE_group_by_clause);
+        try {
+            let alternative: number;
+            this.state = 17664;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.GROUP:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17638;
+                this.match(PlSqlParser.GROUP);
+                this.state = 17639;
+                this.match(PlSqlParser.BY);
+                this.state = 17640;
+                this.group_by_elements();
+                this.state = 17645;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2432, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 17641;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17642;
+                        this.group_by_elements();
+                        }
+                        }
+                    }
+                    this.state = 17647;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2432, this.context);
+                }
+                this.state = 17649;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2433, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17648;
+                    this.having_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.HAVING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17651;
+                this.having_clause();
+                this.state = 17662;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2435, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17652;
+                    this.match(PlSqlParser.GROUP);
+                    this.state = 17653;
+                    this.match(PlSqlParser.BY);
+                    this.state = 17654;
+                    this.group_by_elements();
+                    this.state = 17659;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2434, this.context);
+                    while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                        if (alternative === 1) {
+                            {
+                            {
+                            this.state = 17655;
+                            this.match(PlSqlParser.COMMA);
+                            this.state = 17656;
+                            this.group_by_elements();
+                            }
+                            }
+                        }
+                        this.state = 17661;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 2434, this.context);
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public group_by_elements(): Group_by_elementsContext {
+        let localContext = new Group_by_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 1976, PlSqlParser.RULE_group_by_elements);
+        try {
+            this.state = 17669;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2437, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17666;
+                this.grouping_sets_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17667;
+                this.rollup_cube_clause();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 17668;
+                this.expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rollup_cube_clause(): Rollup_cube_clauseContext {
+        let localContext = new Rollup_cube_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1978, PlSqlParser.RULE_rollup_cube_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17671;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 332 || _la === 1600)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 17672;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17673;
+            this.grouping_sets_elements();
+            this.state = 17678;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17674;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17675;
+                this.grouping_sets_elements();
+                }
+                }
+                this.state = 17680;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17681;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public grouping_sets_clause(): Grouping_sets_clauseContext {
+        let localContext = new Grouping_sets_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1980, PlSqlParser.RULE_grouping_sets_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17683;
+            this.match(PlSqlParser.GROUPING);
+            this.state = 17684;
+            this.match(PlSqlParser.SETS);
+            this.state = 17685;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17686;
+            this.grouping_sets_elements();
+            this.state = 17691;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17687;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17688;
+                this.grouping_sets_elements();
+                }
+                }
+                this.state = 17693;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17694;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public grouping_sets_elements(): Grouping_sets_elementsContext {
+        let localContext = new Grouping_sets_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 1982, PlSqlParser.RULE_grouping_sets_elements);
+        try {
+            this.state = 17703;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2441, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17696;
+                this.rollup_cube_clause();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17697;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17699;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2440, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17698;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 17701;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 17702;
+                this.expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public having_clause(): Having_clauseContext {
+        let localContext = new Having_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1984, PlSqlParser.RULE_having_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17705;
+            this.match(PlSqlParser.HAVING);
+            this.state = 17706;
+            this.condition();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_clause(): Model_clauseContext {
+        let localContext = new Model_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1986, PlSqlParser.RULE_model_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17708;
+            this.match(PlSqlParser.MODEL);
+            this.state = 17712;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 693 || _la === 815 || _la === 2185) {
+                {
+                {
+                this.state = 17709;
+                this.cell_reference_options();
+                }
+                }
+                this.state = 17714;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17716;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1588) {
+                {
+                this.state = 17715;
+                this.return_rows_clause();
+                }
+            }
+
+            this.state = 17721;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 1529) {
+                {
+                {
+                this.state = 17718;
+                this.reference_model();
+                }
+                }
+                this.state = 17723;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17724;
+            this.main_model();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cell_reference_options(): Cell_reference_optionsContext {
+        let localContext = new Cell_reference_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 1988, PlSqlParser.RULE_cell_reference_options);
+        let _la: number;
+        try {
+            this.state = 17734;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.KEEP:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17726;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 693 || _la === 815)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 17727;
+                this.match(PlSqlParser.NAV);
+                }
+                break;
+            case PlSqlParser.UNIQUE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17728;
+                this.match(PlSqlParser.UNIQUE);
+                this.state = 17732;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.DIMENSION:
+                    {
+                    this.state = 17729;
+                    this.match(PlSqlParser.DIMENSION);
+                    }
+                    break;
+                case PlSqlParser.SINGLE:
+                    {
+                    this.state = 17730;
+                    this.match(PlSqlParser.SINGLE);
+                    this.state = 17731;
+                    this.match(PlSqlParser.REFERENCE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public return_rows_clause(): Return_rows_clauseContext {
+        let localContext = new Return_rows_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 1990, PlSqlParser.RULE_return_rows_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17736;
+            this.match(PlSqlParser.RETURN);
+            this.state = 17737;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 38 || _la === 2208)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 17738;
+            this.match(PlSqlParser.ROWS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public reference_model(): Reference_modelContext {
+        let localContext = new Reference_modelContext(this.context, this.state);
+        this.enterRule(localContext, 1992, PlSqlParser.RULE_reference_model);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17740;
+            this.match(PlSqlParser.REFERENCE);
+            this.state = 17741;
+            this.reference_model_name();
+            this.state = 17742;
+            this.match(PlSqlParser.ON);
+            this.state = 17743;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17744;
+            this.subquery();
+            this.state = 17745;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 17746;
+            this.model_column_clauses();
+            this.state = 17750;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 693 || _la === 815 || _la === 2185) {
+                {
+                {
+                this.state = 17747;
+                this.cell_reference_options();
+                }
+                }
+                this.state = 17752;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public main_model(): Main_modelContext {
+        let localContext = new Main_modelContext(this.context, this.state);
+        this.enterRule(localContext, 1994, PlSqlParser.RULE_main_model);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17755;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 903) {
+                {
+                this.state = 17753;
+                this.match(PlSqlParser.MAIN);
+                this.state = 17754;
+                this.main_model_name();
+                }
+            }
+
+            this.state = 17757;
+            this.model_column_clauses();
+            this.state = 17761;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 693 || _la === 815 || _la === 2185) {
+                {
+                {
+                this.state = 17758;
+                this.cell_reference_options();
+                }
+                }
+                this.state = 17763;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17764;
+            this.model_rules_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_column_clauses(): Model_column_clausesContext {
+        let localContext = new Model_column_clausesContext(this.context, this.state);
+        this.enterRule(localContext, 1996, PlSqlParser.RULE_model_column_clauses);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17767;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1350) {
+                {
+                this.state = 17766;
+                this.model_column_partition_part();
+                }
+            }
+
+            this.state = 17769;
+            this.match(PlSqlParser.DIMENSION);
+            this.state = 17770;
+            this.match(PlSqlParser.BY);
+            this.state = 17771;
+            this.model_column_list();
+            this.state = 17772;
+            this.match(PlSqlParser.MEASURES);
+            this.state = 17773;
+            this.model_column_list();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_column_partition_part(): Model_column_partition_partContext {
+        let localContext = new Model_column_partition_partContext(this.context, this.state);
+        this.enterRule(localContext, 1998, PlSqlParser.RULE_model_column_partition_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17775;
+            this.match(PlSqlParser.PARTITION);
+            this.state = 17776;
+            this.match(PlSqlParser.BY);
+            this.state = 17777;
+            this.model_column_list();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_column_list(): Model_column_listContext {
+        let localContext = new Model_column_listContext(this.context, this.state);
+        this.enterRule(localContext, 2000, PlSqlParser.RULE_model_column_list);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17779;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17780;
+            this.model_column();
+            this.state = 17785;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 17781;
+                this.match(PlSqlParser.COMMA);
+                this.state = 17782;
+                this.model_column();
+                }
+                }
+                this.state = 17787;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 17788;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_column(): Model_columnContext {
+        let localContext = new Model_columnContext(this.context, this.state);
+        this.enterRule(localContext, 2002, PlSqlParser.RULE_model_column);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17792;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2452, this.context) ) {
+            case 1:
+                {
+                this.state = 17790;
+                this.expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 17791;
+                this.query_block();
+                }
+                break;
+            }
+            this.state = 17795;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                {
+                this.state = 17794;
+                this.column_alias();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_rules_clause(): Model_rules_clauseContext {
+        let localContext = new Model_rules_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2004, PlSqlParser.RULE_model_rules_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17798;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1613) {
+                {
+                this.state = 17797;
+                this.model_rules_part();
+                }
+            }
+
+            this.state = 17800;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17809;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2456, this.context) ) {
+            case 1:
+                {
+                this.state = 17801;
+                this.model_rules_element();
+                this.state = 17806;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 17802;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 17803;
+                    this.model_rules_element();
+                    }
+                    }
+                    this.state = 17808;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            }
+            this.state = 17811;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_rules_part(): Model_rules_partContext {
+        let localContext = new Model_rules_partContext(this.context, this.state);
+        this.enterRule(localContext, 2006, PlSqlParser.RULE_model_rules_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17813;
+            this.match(PlSqlParser.RULES);
+            this.state = 17819;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UPDATE:
+                {
+                this.state = 17814;
+                this.match(PlSqlParser.UPDATE);
+                }
+                break;
+            case PlSqlParser.UPSERT:
+                {
+                this.state = 17815;
+                this.match(PlSqlParser.UPSERT);
+                this.state = 17817;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 38) {
+                    {
+                    this.state = 17816;
+                    this.match(PlSqlParser.ALL);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.LEFT_PAREN:
+                break;
+            default:
+                break;
+            }
+            this.state = 17823;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 95 || _la === 1657) {
+                {
+                this.state = 17821;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 95 || _la === 1657)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 17822;
+                this.match(PlSqlParser.ORDER);
+                }
+            }
+
+            this.state = 17826;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 791) {
+                {
+                this.state = 17825;
+                this.model_iterate_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_rules_element(): Model_rules_elementContext {
+        let localContext = new Model_rules_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2008, PlSqlParser.RULE_model_rules_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17833;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2462, this.context) ) {
+            case 1:
+                {
+                this.state = 17828;
+                this.match(PlSqlParser.UPDATE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 17829;
+                this.match(PlSqlParser.UPSERT);
+                this.state = 17831;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2461, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17830;
+                    this.match(PlSqlParser.ALL);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 17835;
+            this.cell_assignment();
+            this.state = 17837;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1305) {
+                {
+                this.state = 17836;
+                this.order_by_clause();
+                }
+            }
+
+            this.state = 17839;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 17840;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cell_assignment(): Cell_assignmentContext {
+        let localContext = new Cell_assignmentContext(this.context, this.state);
+        this.enterRule(localContext, 2010, PlSqlParser.RULE_cell_assignment);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17842;
+            this.model_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_iterate_clause(): Model_iterate_clauseContext {
+        let localContext = new Model_iterate_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2012, PlSqlParser.RULE_model_iterate_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17844;
+            this.match(PlSqlParser.ITERATE);
+            this.state = 17845;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17846;
+            this.expression();
+            this.state = 17847;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 17849;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2204) {
+                {
+                this.state = 17848;
+                this.until_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public until_part(): Until_partContext {
+        let localContext = new Until_partContext(this.context, this.state);
+        this.enterRule(localContext, 2014, PlSqlParser.RULE_until_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17851;
+            this.match(PlSqlParser.UNTIL);
+            this.state = 17852;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 17853;
+            this.condition();
+            this.state = 17854;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public order_by_clause(): Order_by_clauseContext {
+        let localContext = new Order_by_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2016, PlSqlParser.RULE_order_by_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17856;
+            this.match(PlSqlParser.ORDER);
+            this.state = 17858;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1688) {
+                {
+                this.state = 17857;
+                this.match(PlSqlParser.SIBLINGS);
+                }
+            }
+
+            this.state = 17860;
+            this.match(PlSqlParser.BY);
+            this.state = 17861;
+            this.order_by_elements();
+            this.state = 17866;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2466, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 17862;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 17863;
+                    this.order_by_elements();
+                    }
+                    }
+                }
+                this.state = 17868;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2466, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public order_by_elements(): Order_by_elementsContext {
+        let localContext = new Order_by_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 2018, PlSqlParser.RULE_order_by_elements);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17869;
+            this.expression();
+            this.state = 17871;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2467, this.context) ) {
+            case 1:
+                {
+                this.state = 17870;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 70 || _la === 414)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 17875;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2468, this.context) ) {
+            case 1:
+                {
+                this.state = 17873;
+                this.match(PlSqlParser.NULLS);
+                this.state = 17874;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 599 || _la === 826)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public offset_clause(): Offset_clauseContext {
+        let localContext = new Offset_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2020, PlSqlParser.RULE_offset_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17877;
+            this.match(PlSqlParser.OFFSET);
+            this.state = 17878;
+            this.expression();
+            this.state = 17879;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1608 || _la === 1609)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public fetch_clause(): Fetch_clauseContext {
+        let localContext = new Fetch_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2022, PlSqlParser.RULE_fetch_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17881;
+            this.match(PlSqlParser.FETCH);
+            this.state = 17882;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 599 || _la === 1026)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 17887;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2470, this.context) ) {
+            case 1:
+                {
+                this.state = 17883;
+                this.expression();
+                this.state = 17885;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1380) {
+                    {
+                    this.state = 17884;
+                    this.match(PlSqlParser.PERCENT_KEYWORD);
+                    }
+                }
+
+                }
+                break;
+            }
+            this.state = 17889;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1608 || _la === 1609)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 17893;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ONLY:
+                {
+                this.state = 17890;
+                this.match(PlSqlParser.ONLY);
+                }
+                break;
+            case PlSqlParser.WITH:
+                {
+                this.state = 17891;
+                this.match(PlSqlParser.WITH);
+                this.state = 17892;
+                this.match(PlSqlParser.TIES);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public for_update_clause(): For_update_clauseContext {
+        let localContext = new For_update_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2024, PlSqlParser.RULE_for_update_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17895;
+            this.match(PlSqlParser.FOR);
+            this.state = 17896;
+            this.match(PlSqlParser.UPDATE);
+            this.state = 17898;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2472, this.context) ) {
+            case 1:
+                {
+                this.state = 17897;
+                this.for_update_of_part();
+                }
+                break;
+            }
+            this.state = 17901;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2473, this.context) ) {
+            case 1:
+                {
+                this.state = 17900;
+                this.for_update_options();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public for_update_of_part(): For_update_of_partContext {
+        let localContext = new For_update_of_partContext(this.context, this.state);
+        this.enterRule(localContext, 2026, PlSqlParser.RULE_for_update_of_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17903;
+            this.match(PlSqlParser.OF);
+            this.state = 17904;
+            this.column_list();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public for_update_options(): For_update_optionsContext {
+        let localContext = new For_update_optionsContext(this.context, this.state);
+        this.enterRule(localContext, 2028, PlSqlParser.RULE_for_update_options);
+        try {
+            this.state = 17911;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SKIP_:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17906;
+                this.match(PlSqlParser.SKIP_);
+                this.state = 17907;
+                this.match(PlSqlParser.LOCKED);
+                }
+                break;
+            case PlSqlParser.NOWAIT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17908;
+                this.match(PlSqlParser.NOWAIT);
+                }
+                break;
+            case PlSqlParser.WAIT:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 17909;
+                this.match(PlSqlParser.WAIT);
+                this.state = 17910;
+                this.expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_statement(): Update_statementContext {
+        let localContext = new Update_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2030, PlSqlParser.RULE_update_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17913;
+            this.match(PlSqlParser.UPDATE);
+            this.state = 17914;
+            this.general_table_ref();
+            this.state = 17915;
+            this.update_set_clause();
+            this.state = 17917;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2475, this.context) ) {
+            case 1:
+                {
+                this.state = 17916;
+                this.where_clause();
+                }
+                break;
+            }
+            this.state = 17920;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2476, this.context) ) {
+            case 1:
+                {
+                this.state = 17919;
+                this.static_returning_clause();
+                }
+                break;
+            }
+            this.state = 17923;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2477, this.context) ) {
+            case 1:
+                {
+                this.state = 17922;
+                this.error_logging_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public update_set_clause(): Update_set_clauseContext {
+        let localContext = new Update_set_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2032, PlSqlParser.RULE_update_set_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17925;
+            this.match(PlSqlParser.SET);
+            this.state = 17941;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2479, this.context) ) {
+            case 1:
+                {
+                this.state = 17926;
+                this.column_based_update_set_clause();
+                this.state = 17931;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2478, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 17927;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 17928;
+                        this.column_based_update_set_clause();
+                        }
+                        }
+                    }
+                    this.state = 17933;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2478, this.context);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 17934;
+                this.match(PlSqlParser.VALUE);
+                this.state = 17935;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 17936;
+                this.identifier();
+                this.state = 17937;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 17938;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 17939;
+                this.expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_based_update_set_clause(): Column_based_update_set_clauseContext {
+        let localContext = new Column_based_update_set_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2034, PlSqlParser.RULE_column_based_update_set_clause);
+        try {
+            this.state = 17951;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 17943;
+                this.column_name();
+                this.state = 17944;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 17945;
+                this.expression();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 17947;
+                this.paren_column_list();
+                this.state = 17948;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 17949;
+                this.subquery();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public delete_statement(): Delete_statementContext {
+        let localContext = new Delete_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2036, PlSqlParser.RULE_delete_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17953;
+            this.match(PlSqlParser.DELETE);
+            this.state = 17955;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2481, this.context) ) {
+            case 1:
+                {
+                this.state = 17954;
+                this.match(PlSqlParser.FROM);
+                }
+                break;
+            }
+            this.state = 17957;
+            this.general_table_ref();
+            this.state = 17959;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2482, this.context) ) {
+            case 1:
+                {
+                this.state = 17958;
+                this.where_clause();
+                }
+                break;
+            }
+            this.state = 17962;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2483, this.context) ) {
+            case 1:
+                {
+                this.state = 17961;
+                this.static_returning_clause();
+                }
+                break;
+            }
+            this.state = 17965;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2484, this.context) ) {
+            case 1:
+                {
+                this.state = 17964;
+                this.error_logging_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public insert_statement(): Insert_statementContext {
+        let localContext = new Insert_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2038, PlSqlParser.RULE_insert_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17967;
+            this.match(PlSqlParser.INSERT);
+            this.state = 17970;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.INTO:
+                {
+                this.state = 17968;
+                this.single_table_insert();
+                }
+                break;
+            case PlSqlParser.ALL:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.WHEN:
+                {
+                this.state = 17969;
+                this.multi_table_insert();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public single_table_insert(): Single_table_insertContext {
+        let localContext = new Single_table_insertContext(this.context, this.state);
+        this.enterRule(localContext, 2040, PlSqlParser.RULE_single_table_insert);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17972;
+            this.insert_into_clause();
+            this.state = 17978;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VALUES:
+                {
+                this.state = 17973;
+                this.values_clause();
+                this.state = 17975;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2486, this.context) ) {
+                case 1:
+                    {
+                    this.state = 17974;
+                    this.static_returning_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.SELECT:
+            case PlSqlParser.WITH:
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 17977;
+                this.select_statement();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 17981;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2488, this.context) ) {
+            case 1:
+                {
+                this.state = 17980;
+                this.error_logging_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public multi_table_insert(): Multi_table_insertContext {
+        let localContext = new Multi_table_insertContext(this.context, this.state);
+        this.enterRule(localContext, 2042, PlSqlParser.RULE_multi_table_insert);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17990;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2490, this.context) ) {
+            case 1:
+                {
+                this.state = 17983;
+                this.match(PlSqlParser.ALL);
+                this.state = 17985;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                    {
+                    this.state = 17984;
+                    this.multi_table_element();
+                    }
+                    }
+                    this.state = 17987;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 780);
+                }
+                break;
+            case 2:
+                {
+                this.state = 17989;
+                this.conditional_insert_clause();
+                }
+                break;
+            }
+            this.state = 17992;
+            this.select_statement();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public multi_table_element(): Multi_table_elementContext {
+        let localContext = new Multi_table_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2044, PlSqlParser.RULE_multi_table_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 17994;
+            this.insert_into_clause();
+            this.state = 17996;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2259) {
+                {
+                this.state = 17995;
+                this.values_clause();
+                }
+            }
+
+            this.state = 17999;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 889) {
+                {
+                this.state = 17998;
+                this.error_logging_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public conditional_insert_clause(): Conditional_insert_clauseContext {
+        let localContext = new Conditional_insert_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2046, PlSqlParser.RULE_conditional_insert_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18002;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 38 || _la === 599) {
+                {
+                this.state = 18001;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 38 || _la === 599)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 18005;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18004;
+                this.conditional_insert_when_part();
+                }
+                }
+                this.state = 18007;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2302);
+            this.state = 18010;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 491) {
+                {
+                this.state = 18009;
+                this.conditional_insert_else_part();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public conditional_insert_when_part(): Conditional_insert_when_partContext {
+        let localContext = new Conditional_insert_when_partContext(this.context, this.state);
+        this.enterRule(localContext, 2048, PlSqlParser.RULE_conditional_insert_when_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18012;
+            this.match(PlSqlParser.WHEN);
+            this.state = 18013;
+            this.condition();
+            this.state = 18014;
+            this.match(PlSqlParser.THEN);
+            this.state = 18016;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18015;
+                this.multi_table_element();
+                }
+                }
+                this.state = 18018;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 780);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public conditional_insert_else_part(): Conditional_insert_else_partContext {
+        let localContext = new Conditional_insert_else_partContext(this.context, this.state);
+        this.enterRule(localContext, 2050, PlSqlParser.RULE_conditional_insert_else_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18020;
+            this.match(PlSqlParser.ELSE);
+            this.state = 18022;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18021;
+                this.multi_table_element();
+                }
+                }
+                this.state = 18024;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 780);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public insert_into_clause(): Insert_into_clauseContext {
+        let localContext = new Insert_into_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2052, PlSqlParser.RULE_insert_into_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18026;
+            this.match(PlSqlParser.INTO);
+            this.state = 18027;
+            this.general_table_ref();
+            this.state = 18029;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 589) {
+                {
+                this.state = 18028;
+                this.match(PlSqlParser.FIELDS);
+                }
+            }
+
+            this.state = 18032;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2499, this.context) ) {
+            case 1:
+                {
+                this.state = 18031;
+                this.paren_column_list();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public values_clause(): Values_clauseContext {
+        let localContext = new Values_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2054, PlSqlParser.RULE_values_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18034;
+            this.match(PlSqlParser.VALUES);
+            this.state = 18050;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2501, this.context) ) {
+            case 1:
+                {
+                this.state = 18035;
+                this.match(PlSqlParser.REGULAR_ID);
+                }
+                break;
+            case 2:
+                {
+                this.state = 18036;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18037;
+                this.expressions_();
+                this.state = 18038;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 18046;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2500, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 18039;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 18040;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 18041;
+                        this.expressions_();
+                        this.state = 18042;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        }
+                    }
+                    this.state = 18048;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2500, this.context);
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 18049;
+                this.collection_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_statement(): Merge_statementContext {
+        let localContext = new Merge_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2056, PlSqlParser.RULE_merge_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18052;
+            this.match(PlSqlParser.MERGE);
+            this.state = 18053;
+            this.match(PlSqlParser.INTO);
+            this.state = 18054;
+            this.selected_tableview();
+            this.state = 18055;
+            this.match(PlSqlParser.USING);
+            this.state = 18056;
+            this.selected_tableview();
+            this.state = 18057;
+            this.match(PlSqlParser.ON);
+            this.state = 18058;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 18059;
+            this.condition();
+            this.state = 18060;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 18069;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2504, this.context) ) {
+            case 1:
+                {
+                this.state = 18061;
+                this.merge_update_clause();
+                this.state = 18063;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2502, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18062;
+                    this.merge_insert_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 18065;
+                this.merge_insert_clause();
+                this.state = 18067;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2503, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18066;
+                    this.merge_update_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            this.state = 18072;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2505, this.context) ) {
+            case 1:
+                {
+                this.state = 18071;
+                this.error_logging_clause();
+                }
+                break;
+            }
+            this.state = 18075;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2506, this.context) ) {
+            case 1:
+                {
+                this.state = 18074;
+                this.static_returning_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_update_clause(): Merge_update_clauseContext {
+        let localContext = new Merge_update_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2058, PlSqlParser.RULE_merge_update_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18077;
+            this.match(PlSqlParser.WHEN);
+            this.state = 18078;
+            this.match(PlSqlParser.MATCHED);
+            this.state = 18079;
+            this.match(PlSqlParser.THEN);
+            this.state = 18080;
+            this.match(PlSqlParser.UPDATE);
+            this.state = 18081;
+            this.match(PlSqlParser.SET);
+            this.state = 18082;
+            this.merge_element();
+            this.state = 18087;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2507, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 18083;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18084;
+                    this.merge_element();
+                    }
+                    }
+                }
+                this.state = 18089;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2507, this.context);
+            }
+            this.state = 18091;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2508, this.context) ) {
+            case 1:
+                {
+                this.state = 18090;
+                this.where_clause();
+                }
+                break;
+            }
+            this.state = 18094;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2509, this.context) ) {
+            case 1:
+                {
+                this.state = 18093;
+                this.merge_update_delete_part();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_element(): Merge_elementContext {
+        let localContext = new Merge_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2060, PlSqlParser.RULE_merge_element);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18096;
+            this.column_name();
+            this.state = 18097;
+            this.match(PlSqlParser.EQUALS_OP);
+            this.state = 18098;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_update_delete_part(): Merge_update_delete_partContext {
+        let localContext = new Merge_update_delete_partContext(this.context, this.state);
+        this.enterRule(localContext, 2062, PlSqlParser.RULE_merge_update_delete_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18100;
+            this.match(PlSqlParser.DELETE);
+            this.state = 18101;
+            this.where_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public merge_insert_clause(): Merge_insert_clauseContext {
+        let localContext = new Merge_insert_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2064, PlSqlParser.RULE_merge_insert_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18103;
+            this.match(PlSqlParser.WHEN);
+            this.state = 18104;
+            this.match(PlSqlParser.NOT);
+            this.state = 18105;
+            this.match(PlSqlParser.MATCHED);
+            this.state = 18106;
+            this.match(PlSqlParser.THEN);
+            this.state = 18107;
+            this.match(PlSqlParser.INSERT);
+            this.state = 18109;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2449) {
+                {
+                this.state = 18108;
+                this.paren_column_list();
+                }
+            }
+
+            this.state = 18111;
+            this.values_clause();
+            this.state = 18113;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2511, this.context) ) {
+            case 1:
+                {
+                this.state = 18112;
+                this.where_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public selected_tableview(): Selected_tableviewContext {
+        let localContext = new Selected_tableviewContext(this.context, this.state);
+        this.enterRule(localContext, 2066, PlSqlParser.RULE_selected_tableview);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18125;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2512, this.context) ) {
+            case 1:
+                {
+                this.state = 18115;
+                this.tableview_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 18116;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18117;
+                this.select_statement();
+                this.state = 18118;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                {
+                this.state = 18120;
+                this.table_collection_expression();
+                }
+                break;
+            case 4:
+                {
+                this.state = 18121;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18122;
+                this.table_collection_expression();
+                this.state = 18123;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 18128;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2513, this.context) ) {
+            case 1:
+                {
+                this.state = 18127;
+                this.table_alias();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lock_table_statement(): Lock_table_statementContext {
+        let localContext = new Lock_table_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2068, PlSqlParser.RULE_lock_table_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18130;
+            this.match(PlSqlParser.LOCK);
+            this.state = 18131;
+            this.match(PlSqlParser.TABLE);
+            this.state = 18132;
+            this.lock_table_element();
+            this.state = 18137;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 18133;
+                this.match(PlSqlParser.COMMA);
+                this.state = 18134;
+                this.lock_table_element();
+                }
+                }
+                this.state = 18139;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 18140;
+            this.match(PlSqlParser.IN);
+            this.state = 18141;
+            this.lock_mode();
+            this.state = 18142;
+            this.match(PlSqlParser.MODE);
+            this.state = 18144;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2515, this.context) ) {
+            case 1:
+                {
+                this.state = 18143;
+                this.wait_nowait_part();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public wait_nowait_part(): Wait_nowait_partContext {
+        let localContext = new Wait_nowait_partContext(this.context, this.state);
+        this.enterRule(localContext, 2070, PlSqlParser.RULE_wait_nowait_part);
+        try {
+            this.state = 18149;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.WAIT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18146;
+                this.match(PlSqlParser.WAIT);
+                this.state = 18147;
+                this.expression();
+                }
+                break;
+            case PlSqlParser.NOWAIT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18148;
+                this.match(PlSqlParser.NOWAIT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lock_table_element(): Lock_table_elementContext {
+        let localContext = new Lock_table_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2072, PlSqlParser.RULE_lock_table_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18151;
+            this.tableview_name();
+            this.state = 18153;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1350 || _la === 1777) {
+                {
+                this.state = 18152;
+                this.partition_extension_clause();
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lock_mode(): Lock_modeContext {
+        let localContext = new Lock_modeContext(this.context, this.state);
+        this.enterRule(localContext, 2074, PlSqlParser.RULE_lock_mode);
+        let _la: number;
+        try {
+            this.state = 18167;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2519, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18155;
+                this.match(PlSqlParser.ROW);
+                this.state = 18156;
+                this.match(PlSqlParser.SHARE);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18157;
+                this.match(PlSqlParser.ROW);
+                this.state = 18158;
+                this.match(PlSqlParser.EXCLUSIVE);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18159;
+                this.match(PlSqlParser.SHARE);
+                this.state = 18161;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2209) {
+                    {
+                    this.state = 18160;
+                    this.match(PlSqlParser.UPDATE);
+                    }
+                }
+
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18163;
+                this.match(PlSqlParser.SHARE);
+                this.state = 18164;
+                this.match(PlSqlParser.ROW);
+                this.state = 18165;
+                this.match(PlSqlParser.EXCLUSIVE);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18166;
+                this.match(PlSqlParser.EXCLUSIVE);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public general_table_ref(): General_table_refContext {
+        let localContext = new General_table_refContext(this.context, this.state);
+        this.enterRule(localContext, 2076, PlSqlParser.RULE_general_table_ref);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18175;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2520, this.context) ) {
+            case 1:
+                {
+                this.state = 18169;
+                this.dml_table_expression_clause();
+                }
+                break;
+            case 2:
+                {
+                this.state = 18170;
+                this.match(PlSqlParser.ONLY);
+                this.state = 18171;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18172;
+                this.dml_table_expression_clause();
+                this.state = 18173;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 18178;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2521, this.context) ) {
+            case 1:
+                {
+                this.state = 18177;
+                this.table_alias();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public static_returning_clause(): Static_returning_clauseContext {
+        let localContext = new Static_returning_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2078, PlSqlParser.RULE_static_returning_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18180;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1587 || _la === 1588)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 18181;
+            this.expressions_();
+            this.state = 18182;
+            this.into_clause();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public error_logging_clause(): Error_logging_clauseContext {
+        let localContext = new Error_logging_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2080, PlSqlParser.RULE_error_logging_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18184;
+            this.match(PlSqlParser.LOG);
+            this.state = 18185;
+            this.match(PlSqlParser.ERRORS);
+            this.state = 18187;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2522, this.context) ) {
+            case 1:
+                {
+                this.state = 18186;
+                this.error_logging_into_part();
+                }
+                break;
+            }
+            this.state = 18190;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2523, this.context) ) {
+            case 1:
+                {
+                this.state = 18189;
+                this.expression();
+                }
+                break;
+            }
+            this.state = 18193;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2524, this.context) ) {
+            case 1:
+                {
+                this.state = 18192;
+                this.error_logging_reject_part();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public error_logging_into_part(): Error_logging_into_partContext {
+        let localContext = new Error_logging_into_partContext(this.context, this.state);
+        this.enterRule(localContext, 2082, PlSqlParser.RULE_error_logging_into_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18195;
+            this.match(PlSqlParser.INTO);
+            this.state = 18196;
+            this.tableview_name();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public error_logging_reject_part(): Error_logging_reject_partContext {
+        let localContext = new Error_logging_reject_partContext(this.context, this.state);
+        this.enterRule(localContext, 2084, PlSqlParser.RULE_error_logging_reject_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18198;
+            this.match(PlSqlParser.REJECT);
+            this.state = 18199;
+            this.match(PlSqlParser.LIMIT);
+            this.state = 18202;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2525, this.context) ) {
+            case 1:
+                {
+                this.state = 18200;
+                this.match(PlSqlParser.UNLIMITED);
+                }
+                break;
+            case 2:
+                {
+                this.state = 18201;
+                this.expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dml_table_expression_clause(): Dml_table_expression_clauseContext {
+        let localContext = new Dml_table_expression_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2086, PlSqlParser.RULE_dml_table_expression_clause);
+        let _la: number;
+        try {
+            this.state = 18240;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2531, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18204;
+                this.table_collection_expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18205;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18206;
+                this.select_statement();
+                this.state = 18208;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2310) {
+                    {
+                    this.state = 18207;
+                    this.subquery_restriction_clause();
+                    }
+                }
+
+                this.state = 18210;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18212;
+                this.tableview_name();
+                this.state = 18214;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2527, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18213;
+                    this.hierarchies_clause();
+                    }
+                    break;
+                }
+                this.state = 18217;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2528, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18216;
+                    this.sample_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18219;
+                this.json_table_clause();
+                this.state = 18222;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2529, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18220;
+                    this.match(PlSqlParser.AS);
+                    this.state = 18221;
+                    this.identifier();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18224;
+                this.match(PlSqlParser.LATERAL);
+                this.state = 18225;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18226;
+                this.subquery();
+                this.state = 18228;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2310) {
+                    {
+                    this.state = 18227;
+                    this.subquery_restriction_clause();
+                    }
+                }
+
+                this.state = 18230;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 18232;
+                if (!(this.isVersion11())) {
+                    throw this.createFailedPredicateException("this.isVersion11()");
+                }
+                {
+                this.state = 18233;
+                this.match(PlSqlParser.RELATIONAL);
+                this.state = 18234;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18235;
+                this.tableview_name();
+                this.state = 18236;
+                this.match(PlSqlParser.NOT);
+                this.state = 18237;
+                this.match(PlSqlParser.XMLTYPE);
+                this.state = 18238;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_collection_expression(): Table_collection_expressionContext {
+        let localContext = new Table_collection_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2088, PlSqlParser.RULE_table_collection_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18242;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 2085 || _la === 2102)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 18253;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2533, this.context) ) {
+            case 1:
+                {
+                this.state = 18243;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18244;
+                this.subquery();
+                this.state = 18245;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 18247;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18248;
+                this.expression();
+                this.state = 18249;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 18251;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2532, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18250;
+                    this.outer_join_sign();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public subquery_restriction_clause(): Subquery_restriction_clauseContext {
+        let localContext = new Subquery_restriction_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2090, PlSqlParser.RULE_subquery_restriction_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18255;
+            this.match(PlSqlParser.WITH);
+            this.state = 18264;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.READ:
+                {
+                this.state = 18256;
+                this.match(PlSqlParser.READ);
+                this.state = 18257;
+                this.match(PlSqlParser.ONLY);
+                }
+                break;
+            case PlSqlParser.CHECK:
+                {
+                this.state = 18258;
+                this.match(PlSqlParser.CHECK);
+                this.state = 18259;
+                this.match(PlSqlParser.OPTION);
+                this.state = 18262;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2534, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18260;
+                    this.match(PlSqlParser.CONSTRAINT);
+                    this.state = 18261;
+                    this.constraint_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sample_clause(): Sample_clauseContext {
+        let localContext = new Sample_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2092, PlSqlParser.RULE_sample_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18266;
+            this.match(PlSqlParser.SAMPLE);
+            this.state = 18268;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 143) {
+                {
+                this.state = 18267;
+                this.match(PlSqlParser.BLOCK);
+                }
+            }
+
+            this.state = 18270;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 18271;
+            this.expression();
+            this.state = 18274;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2455) {
+                {
+                this.state = 18272;
+                this.match(PlSqlParser.COMMA);
+                this.state = 18273;
+                this.expression();
+                }
+            }
+
+            this.state = 18276;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 18278;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2538, this.context) ) {
+            case 1:
+                {
+                this.state = 18277;
+                this.seed_part();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public seed_part(): Seed_partContext {
+        let localContext = new Seed_partContext(this.context, this.state);
+        this.enterRule(localContext, 2094, PlSqlParser.RULE_seed_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18280;
+            this.match(PlSqlParser.SEED);
+            this.state = 18281;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 18282;
+            this.expression();
+            this.state = 18283;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public condition(): ConditionContext {
+        let localContext = new ConditionContext(this.context, this.state);
+        this.enterRule(localContext, 2096, PlSqlParser.RULE_condition);
+        try {
+            this.state = 18291;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2539, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18285;
+                this.expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18286;
+                this.match(PlSqlParser.JSON_EQUAL);
+                this.state = 18287;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18288;
+                this.expressions_();
+                this.state = 18289;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public expressions_(): Expressions_Context {
+        let localContext = new Expressions_Context(this.context, this.state);
+        this.enterRule(localContext, 2098, PlSqlParser.RULE_expressions_);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18293;
+            this.expression();
+            this.state = 18298;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2540, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 18294;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18295;
+                    this.expression();
+                    }
+                    }
+                }
+                this.state = 18300;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2540, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public expression(): ExpressionContext {
+        let localContext = new ExpressionContext(this.context, this.state);
+        this.enterRule(localContext, 2100, PlSqlParser.RULE_expression);
+        try {
+            this.state = 18303;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2541, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18301;
+                this.cursor_expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18302;
+                this.logical_expression(0);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cursor_expression(): Cursor_expressionContext {
+        let localContext = new Cursor_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2102, PlSqlParser.RULE_cursor_expression);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18305;
+            this.match(PlSqlParser.CURSOR);
+            this.state = 18306;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 18307;
+            this.subquery();
+            this.state = 18308;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public logical_expression(): Logical_expressionContext;
+    public logical_expression(_p: number): Logical_expressionContext;
+    public logical_expression(_p?: number): Logical_expressionContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new Logical_expressionContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 2104;
+        this.enterRecursionRule(localContext, 2104, PlSqlParser.RULE_logical_expression, _p);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            {
+            this.state = 18311;
+            this.unary_logical_expression();
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 18321;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2543, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    this.state = 18319;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2542, this.context) ) {
+                    case 1:
+                        {
+                        localContext = new Logical_expressionContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_logical_expression);
+                        this.state = 18313;
+                        if (!(this.precpred(this.context, 2))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
+                        }
+                        this.state = 18314;
+                        this.match(PlSqlParser.AND);
+                        this.state = 18315;
+                        this.logical_expression(3);
+                        }
+                        break;
+                    case 2:
+                        {
+                        localContext = new Logical_expressionContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_logical_expression);
+                        this.state = 18316;
+                        if (!(this.precpred(this.context, 1))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 1)");
+                        }
+                        this.state = 18317;
+                        this.match(PlSqlParser.OR);
+                        this.state = 18318;
+                        this.logical_expression(2);
+                        }
+                        break;
+                    }
+                    }
+                }
+                this.state = 18323;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2543, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+    public unary_logical_expression(): Unary_logical_expressionContext {
+        let localContext = new Unary_logical_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2106, PlSqlParser.RULE_unary_logical_expression);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18325;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2544, this.context) ) {
+            case 1:
+                {
+                this.state = 18324;
+                this.match(PlSqlParser.NOT);
+                }
+                break;
+            }
+            this.state = 18327;
+            this.multiset_expression(0);
+            this.state = 18329;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2545, this.context) ) {
+            case 1:
+                {
+                this.state = 18328;
+                this.unary_logical_operation();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unary_logical_operation(): Unary_logical_operationContext {
+        let localContext = new Unary_logical_operationContext(this.context, this.state);
+        this.enterRule(localContext, 2108, PlSqlParser.RULE_unary_logical_operation);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18331;
+            this.match(PlSqlParser.IS);
+            this.state = 18333;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1206) {
+                {
+                this.state = 18332;
+                this.match(PlSqlParser.NOT);
+                }
+            }
+
+            this.state = 18335;
+            this.logical_operation();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public logical_operation(): Logical_operationContext {
+        let localContext = new Logical_operationContext(this.context, this.state);
+        this.enterRule(localContext, 2110, PlSqlParser.RULE_logical_operation);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18375;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NULL_:
+                {
+                this.state = 18337;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.NAN_:
+                {
+                this.state = 18338;
+                this.match(PlSqlParser.NAN_);
+                }
+                break;
+            case PlSqlParser.PRESENT:
+                {
+                this.state = 18339;
+                this.match(PlSqlParser.PRESENT);
+                }
+                break;
+            case PlSqlParser.INFINITE:
+                {
+                this.state = 18340;
+                this.match(PlSqlParser.INFINITE);
+                }
+                break;
+            case PlSqlParser.A_LETTER:
+                {
+                this.state = 18341;
+                this.match(PlSqlParser.A_LETTER);
+                this.state = 18342;
+                this.match(PlSqlParser.SET);
+                }
+                break;
+            case PlSqlParser.EMPTY_:
+                {
+                this.state = 18343;
+                this.match(PlSqlParser.EMPTY_);
+                }
+                break;
+            case PlSqlParser.OF:
+                {
+                this.state = 18344;
+                this.match(PlSqlParser.OF);
+                this.state = 18346;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2168) {
+                    {
+                    this.state = 18345;
+                    this.match(PlSqlParser.TYPE);
+                    }
+                }
+
+                this.state = 18348;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18350;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2548, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18349;
+                    this.match(PlSqlParser.ONLY);
+                    }
+                    break;
+                }
+                this.state = 18352;
+                this.type_spec();
+                this.state = 18357;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 18353;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18354;
+                    this.type_spec();
+                    }
+                    }
+                    this.state = 18359;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 18360;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON:
+                {
+                this.state = 18362;
+                this.match(PlSqlParser.JSON);
+                this.state = 18365;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2550, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18363;
+                    this.match(PlSqlParser.FORMAT);
+                    this.state = 18364;
+                    this.match(PlSqlParser.JSON);
+                    }
+                    break;
+                }
+                this.state = 18368;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2551, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18367;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 830 || _la === 1768)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 18373;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2552, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18370;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2308 || _la === 2310)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 18371;
+                    this.match(PlSqlParser.UNIQUE);
+                    this.state = 18372;
+                    this.match(PlSqlParser.KEYS);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public multiset_expression(): Multiset_expressionContext;
+    public multiset_expression(_p: number): Multiset_expressionContext;
+    public multiset_expression(_p?: number): Multiset_expressionContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new Multiset_expressionContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 2112;
+        this.enterRecursionRule(localContext, 2112, PlSqlParser.RULE_multiset_expression, _p);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            {
+            this.state = 18378;
+            this.relational_expression(0);
+            this.state = 18387;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2556, this.context) ) {
+            case 1:
+                {
+                this.state = 18380;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 18379;
+                    localContext._multiset_type = this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 18382;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 937 || _la === 1774)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 18384;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2555, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18383;
+                    this.match(PlSqlParser.OF);
+                    }
+                    break;
+                }
+                this.state = 18386;
+                this.concatenation(0);
+                }
+                break;
+            }
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 18398;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2558, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    {
+                    localContext = new Multiset_expressionContext(parentContext, parentState);
+                    this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_multiset_expression);
+                    this.state = 18389;
+                    if (!(this.precpred(this.context, 1))) {
+                        throw this.createFailedPredicateException("this.precpred(this.context, 1)");
+                    }
+                    this.state = 18390;
+                    this.match(PlSqlParser.MULTISET);
+                    this.state = 18391;
+                    localContext._multiset_operator = this.tokenStream.LT(1);
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 534 || _la === 776 || _la === 2183)) {
+                        localContext._multiset_operator = this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 18393;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2557, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 18392;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 38 || _la === 445)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    }
+                    this.state = 18395;
+                    this.relational_expression(0);
+                    }
+                    }
+                }
+                this.state = 18400;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2558, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+
+    public relational_expression(): Relational_expressionContext;
+    public relational_expression(_p: number): Relational_expressionContext;
+    public relational_expression(_p?: number): Relational_expressionContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new Relational_expressionContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 2114;
+        this.enterRecursionRule(localContext, 2114, PlSqlParser.RULE_relational_expression, _p);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            {
+            this.state = 18402;
+            this.compound_expression();
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 18416;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2561, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    this.state = 18414;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2560, this.context) ) {
+                    case 1:
+                        {
+                        localContext = new Relational_expressionContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_relational_expression);
+                        this.state = 18404;
+                        if (!(this.precpred(this.context, 3))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 3)");
+                        }
+                        this.state = 18405;
+                        this.relational_operator();
+                        this.state = 18406;
+                        this.relational_expression(4);
+                        }
+                        break;
+                    case 2:
+                        {
+                        localContext = new Relational_expressionContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_relational_expression);
+                        this.state = 18408;
+                        if (!(this.precpred(this.context, 2))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
+                        }
+                        this.state = 18410;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 1206) {
+                            {
+                            this.state = 18409;
+                            this.match(PlSqlParser.NOT);
+                            }
+                        }
+
+                        this.state = 18412;
+                        this.match(PlSqlParser.IN);
+                        this.state = 18413;
+                        this.in_elements();
+                        }
+                        break;
+                    }
+                    }
+                }
+                this.state = 18418;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2561, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+    public compound_expression(): Compound_expressionContext {
+        let localContext = new Compound_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2116, PlSqlParser.RULE_compound_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18419;
+            this.concatenation(0);
+            this.state = 18435;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2565, this.context) ) {
+            case 1:
+                {
+                this.state = 18421;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1206) {
+                    {
+                    this.state = 18420;
+                    this.match(PlSqlParser.NOT);
+                    }
+                }
+
+                this.state = 18433;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.IN:
+                    {
+                    this.state = 18423;
+                    this.match(PlSqlParser.IN);
+                    this.state = 18424;
+                    this.in_elements();
+                    }
+                    break;
+                case PlSqlParser.BETWEEN:
+                    {
+                    this.state = 18425;
+                    this.match(PlSqlParser.BETWEEN);
+                    this.state = 18426;
+                    this.between_elements();
+                    }
+                    break;
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE:
+                    {
+                    this.state = 18427;
+                    localContext._like_type = this.tokenStream.LT(1);
+                    _la = this.tokenStream.LA(1);
+                    if(!(((((_la - 854)) & ~0x1F) === 0 && ((1 << (_la - 854)) & 23) !== 0))) {
+                        localContext._like_type = this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 18428;
+                    this.concatenation(0);
+                    this.state = 18431;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2563, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 18429;
+                        this.match(PlSqlParser.ESCAPE);
+                        this.state = 18430;
+                        this.concatenation(0);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public relational_operator(): Relational_operatorContext {
+        let localContext = new Relational_operatorContext(this.context, this.state);
+        this.enterRule(localContext, 2118, PlSqlParser.RULE_relational_operator);
+        let _la: number;
+        try {
+            this.state = 18451;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2568, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18437;
+                this.match(PlSqlParser.EQUALS_OP);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18445;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NOT_EQUAL_OP:
+                    {
+                    this.state = 18438;
+                    this.match(PlSqlParser.NOT_EQUAL_OP);
+                    }
+                    break;
+                case PlSqlParser.LESS_THAN_OP:
+                    {
+                    this.state = 18439;
+                    this.match(PlSqlParser.LESS_THAN_OP);
+                    this.state = 18440;
+                    this.match(PlSqlParser.GREATER_THAN_OP);
+                    }
+                    break;
+                case PlSqlParser.EXCLAMATION_OPERATOR_PART:
+                    {
+                    this.state = 18441;
+                    this.match(PlSqlParser.EXCLAMATION_OPERATOR_PART);
+                    this.state = 18442;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    }
+                    break;
+                case PlSqlParser.CARRET_OPERATOR_PART:
+                    {
+                    this.state = 18443;
+                    this.match(PlSqlParser.CARRET_OPERATOR_PART);
+                    this.state = 18444;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18447;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2469 || _la === 2470)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 18449;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2567, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18448;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public in_elements(): In_elementsContext {
+        let localContext = new In_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 2120, PlSqlParser.RULE_in_elements);
+        let _la: number;
+        try {
+            this.state = 18471;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2570, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18453;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18454;
+                this.subquery();
+                this.state = 18455;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18457;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18458;
+                this.concatenation(0);
+                this.state = 18463;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 18459;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18460;
+                    this.concatenation(0);
+                    }
+                    }
+                    this.state = 18465;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 18466;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18468;
+                this.constant();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18469;
+                this.bind_variable();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18470;
+                this.general_element(0);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public between_elements(): Between_elementsContext {
+        let localContext = new Between_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 2122, PlSqlParser.RULE_between_elements);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18473;
+            this.concatenation(0);
+            this.state = 18474;
+            this.match(PlSqlParser.AND);
+            this.state = 18475;
+            this.concatenation(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public concatenation(): ConcatenationContext;
+    public concatenation(_p: number): ConcatenationContext;
+    public concatenation(_p?: number): ConcatenationContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new ConcatenationContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 2124;
+        this.enterRecursionRule(localContext, 2124, PlSqlParser.RULE_concatenation, _p);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            {
+            this.state = 18478;
+            this.model_expression();
+            this.state = 18487;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2572, this.context) ) {
+            case 1:
+                {
+                this.state = 18479;
+                this.match(PlSqlParser.AT);
+                this.state = 18484;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.LOCAL:
+                    {
+                    this.state = 18480;
+                    this.match(PlSqlParser.LOCAL);
+                    }
+                    break;
+                case PlSqlParser.TIME:
+                    {
+                    this.state = 18481;
+                    this.match(PlSqlParser.TIME);
+                    this.state = 18482;
+                    this.match(PlSqlParser.ZONE);
+                    this.state = 18483;
+                    this.concatenation(0);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 18486;
+                this.interval_expression();
+                }
+                break;
+            }
+            this.state = 18492;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2573, this.context) ) {
+            case 1:
+                {
+                this.state = 18489;
+                this.match(PlSqlParser.ON);
+                this.state = 18490;
+                this.match(PlSqlParser.OVERFLOW_);
+                this.state = 18491;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 520 || _la === 2161)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 18512;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2575, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    this.state = 18510;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2574, this.context) ) {
+                    case 1:
+                        {
+                        localContext = new ConcatenationContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_concatenation);
+                        this.state = 18494;
+                        if (!(this.precpred(this.context, 5))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 5)");
+                        }
+                        this.state = 18495;
+                        localContext._op = this.match(PlSqlParser.DOUBLE_ASTERISK);
+                        this.state = 18496;
+                        this.concatenation(6);
+                        }
+                        break;
+                    case 2:
+                        {
+                        localContext = new ConcatenationContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_concatenation);
+                        this.state = 18497;
+                        if (!(this.precpred(this.context, 4))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 4)");
+                        }
+                        this.state = 18498;
+                        localContext._op = this.tokenStream.LT(1);
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 982 || _la === 2452 || _la === 2456)) {
+                            localContext._op = this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 18499;
+                        this.concatenation(5);
+                        }
+                        break;
+                    case 3:
+                        {
+                        localContext = new ConcatenationContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_concatenation);
+                        this.state = 18500;
+                        if (!(this.precpred(this.context, 3))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 3)");
+                        }
+                        this.state = 18501;
+                        localContext._op = this.tokenStream.LT(1);
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 2453 || _la === 2454)) {
+                            localContext._op = this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 18502;
+                        this.concatenation(4);
+                        }
+                        break;
+                    case 4:
+                        {
+                        localContext = new ConcatenationContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_concatenation);
+                        this.state = 18503;
+                        if (!(this.precpred(this.context, 2))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
+                        }
+                        this.state = 18504;
+                        this.match(PlSqlParser.BAR);
+                        this.state = 18505;
+                        this.match(PlSqlParser.BAR);
+                        this.state = 18506;
+                        this.concatenation(3);
+                        }
+                        break;
+                    case 5:
+                        {
+                        localContext = new ConcatenationContext(parentContext, parentState);
+                        this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_concatenation);
+                        this.state = 18507;
+                        if (!(this.precpred(this.context, 1))) {
+                            throw this.createFailedPredicateException("this.precpred(this.context, 1)");
+                        }
+                        this.state = 18508;
+                        this.match(PlSqlParser.COLLATE);
+                        this.state = 18509;
+                        this.column_collation_name();
+                        }
+                        break;
+                    }
+                    }
+                }
+                this.state = 18514;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2575, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+    public interval_expression(): Interval_expressionContext {
+        let localContext = new Interval_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2126, PlSqlParser.RULE_interval_expression);
+        let _la: number;
+        try {
+            this.state = 18539;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.DAY:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18515;
+                this.match(PlSqlParser.DAY);
+                this.state = 18520;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 18516;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 18517;
+                    this.concatenation(0);
+                    this.state = 18518;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                this.state = 18522;
+                this.match(PlSqlParser.TO);
+                this.state = 18523;
+                this.match(PlSqlParser.SECOND);
+                this.state = 18528;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2577, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18524;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 18525;
+                    this.concatenation(0);
+                    this.state = 18526;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.YEAR:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18530;
+                this.match(PlSqlParser.YEAR);
+                this.state = 18535;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 18531;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 18532;
+                    this.concatenation(0);
+                    this.state = 18533;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                this.state = 18537;
+                this.match(PlSqlParser.TO);
+                this.state = 18538;
+                this.match(PlSqlParser.MONTH);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_expression(): Model_expressionContext {
+        let localContext = new Model_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2128, PlSqlParser.RULE_model_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18542;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2580, this.context) ) {
+            case 1:
+                {
+                this.state = 18541;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2453 || _la === 2454)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 18544;
+            this.unary_expression();
+            this.state = 18549;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2581, this.context) ) {
+            case 1:
+                {
+                this.state = 18545;
+                this.match(PlSqlParser.LEFT_BRACKET);
+                this.state = 18546;
+                this.model_expression_element();
+                this.state = 18547;
+                this.match(PlSqlParser.RIGHT_BRACKET);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public model_expression_element(): Model_expression_elementContext {
+        let localContext = new Model_expression_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2130, PlSqlParser.RULE_model_expression_element);
+        let _la: number;
+        try {
+            this.state = 18574;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2586, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18553;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2582, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18551;
+                    this.match(PlSqlParser.ANY);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 18552;
+                    this.expression();
+                    }
+                    break;
+                }
+                this.state = 18562;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 18555;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18558;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2583, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 18556;
+                        this.match(PlSqlParser.ANY);
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 18557;
+                        this.expression();
+                        }
+                        break;
+                    }
+                    }
+                    }
+                    this.state = 18564;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18565;
+                this.single_column_for_loop();
+                this.state = 18570;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 18566;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18567;
+                    this.single_column_for_loop();
+                    }
+                    }
+                    this.state = 18572;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18573;
+                this.multi_column_for_loop();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public single_column_for_loop(): Single_column_for_loopContext {
+        let localContext = new Single_column_for_loopContext(this.context, this.state);
+        this.enterRule(localContext, 2132, PlSqlParser.RULE_single_column_for_loop);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18576;
+            this.match(PlSqlParser.FOR);
+            this.state = 18577;
+            this.column_name();
+            this.state = 18595;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.IN:
+                {
+                this.state = 18578;
+                this.match(PlSqlParser.IN);
+                this.state = 18579;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18581;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2587, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18580;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 18583;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.FROM:
+            case PlSqlParser.LIKE:
+                {
+                this.state = 18586;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 858) {
+                    {
+                    this.state = 18584;
+                    this.match(PlSqlParser.LIKE);
+                    this.state = 18585;
+                    this.expression();
+                    }
+                }
+
+                this.state = 18588;
+                this.match(PlSqlParser.FROM);
+                this.state = 18589;
+                localContext._fromExpr = this.expression();
+                this.state = 18590;
+                this.match(PlSqlParser.TO);
+                this.state = 18591;
+                localContext._toExpr = this.expression();
+                this.state = 18592;
+                localContext._action_type = this.tokenStream.LT(1);
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 386 || _la === 708)) {
+                    localContext._action_type = this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 18593;
+                localContext._action_expr = this.expression();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public multi_column_for_loop(): Multi_column_for_loopContext {
+        let localContext = new Multi_column_for_loopContext(this.context, this.state);
+        this.enterRule(localContext, 2134, PlSqlParser.RULE_multi_column_for_loop);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18597;
+            this.match(PlSqlParser.FOR);
+            this.state = 18598;
+            this.paren_column_list();
+            this.state = 18599;
+            this.match(PlSqlParser.IN);
+            this.state = 18600;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 18607;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2591, this.context) ) {
+            case 1:
+                {
+                this.state = 18601;
+                this.subquery();
+                }
+                break;
+            case 2:
+                {
+                this.state = 18602;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18604;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2590, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18603;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 18606;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            this.state = 18609;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unary_expression(): Unary_expressionContext {
+        let localContext = new Unary_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2136, PlSqlParser.RULE_unary_expression);
+        let _la: number;
+        try {
+            this.state = 18631;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2594, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18611;
+                this.match(PlSqlParser.PRIOR);
+                this.state = 18612;
+                this.unary_expression_core();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18613;
+                this.match(PlSqlParser.CONNECT_BY_ROOT);
+                this.state = 18614;
+                this.unary_expression_core();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18615;
+                this.match(PlSqlParser.NEW);
+                this.state = 18616;
+                this.unary_expression_core();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18617;
+                this.match(PlSqlParser.OLD);
+                this.state = 18618;
+                this.unary_expression_core();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18619;
+                this.unary_expression_core();
+                this.state = 18629;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2593, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18620;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 18627;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.COUNT:
+                    case PlSqlParser.FIRST:
+                    case PlSqlParser.LAST:
+                    case PlSqlParser.LIMIT:
+                        {
+                        this.state = 18621;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 313 || _la === 599 || _la === 826 || _la === 859)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    case PlSqlParser.EXISTS:
+                    case PlSqlParser.NEXT:
+                    case PlSqlParser.PRIOR:
+                        {
+                        this.state = 18622;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 546 || _la === 1026 || _la === 1456)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        this.state = 18623;
+                        this.match(PlSqlParser.LEFT_PAREN);
+                        this.state = 18624;
+                        localContext._expression = this.expression();
+                        localContext._index.push(localContext._expression!);
+                        this.state = 18625;
+                        this.match(PlSqlParser.RIGHT_PAREN);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public unary_expression_core(): Unary_expression_coreContext {
+        let localContext = new Unary_expression_coreContext(this.context, this.state);
+        this.enterRule(localContext, 2138, PlSqlParser.RULE_unary_expression_core);
+        try {
+            this.state = 18640;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2595, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18633;
+                this.case_expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18634;
+                this.quantified_expression();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18635;
+                this.standard_function();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18636;
+                if (!(this.IsNotNumericFunction())) {
+                    throw this.createFailedPredicateException("this.IsNotNumericFunction()");
+                }
+                this.state = 18637;
+                this.atom();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18638;
+                this.implicit_cursor_expression();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 18639;
+                this.selection_directive_expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public selection_directive_expression(): Selection_directive_expressionContext {
+        let localContext = new Selection_directive_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2140, PlSqlParser.RULE_selection_directive_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18642;
+            this.match(PlSqlParser.DOLLAR_IF);
+            this.state = 18643;
+            this.condition();
+            this.state = 18644;
+            this.match(PlSqlParser.DOLLAR_THEN);
+            this.state = 18645;
+            this.expression();
+            this.state = 18653;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 457) {
+                {
+                {
+                this.state = 18646;
+                this.match(PlSqlParser.DOLLAR_ELSIF);
+                this.state = 18647;
+                this.condition();
+                this.state = 18648;
+                this.match(PlSqlParser.DOLLAR_THEN);
+                this.state = 18649;
+                this.expression();
+                }
+                }
+                this.state = 18655;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 18658;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 456) {
+                {
+                this.state = 18656;
+                this.match(PlSqlParser.DOLLAR_ELSE);
+                this.state = 18657;
+                this.expression();
+                }
+            }
+
+            this.state = 18660;
+            this.match(PlSqlParser.DOLLAR_END);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public implicit_cursor_expression(): Implicit_cursor_expressionContext {
+        let localContext = new Implicit_cursor_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2142, PlSqlParser.RULE_implicit_cursor_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18662;
+            this.match(PlSqlParser.SQL);
+            this.state = 18679;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PERCENT_BULK_ROWCOUNT:
+                {
+                this.state = 18663;
+                this.match(PlSqlParser.PERCENT_BULK_ROWCOUNT);
+                this.state = 18664;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18665;
+                localContext._index = this.expression();
+                this.state = 18666;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.PERCENT_BULK_EXCEPTIONS:
+                {
+                this.state = 18668;
+                this.match(PlSqlParser.PERCENT_BULK_EXCEPTIONS);
+                this.state = 18677;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.PERIOD:
+                    {
+                    this.state = 18669;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 18670;
+                    this.match(PlSqlParser.COUNT);
+                    }
+                    break;
+                case PlSqlParser.LEFT_PAREN:
+                    {
+                    this.state = 18671;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 18672;
+                    this.expression();
+                    this.state = 18673;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    this.state = 18674;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 18675;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 523 || _la === 524)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public collection_expression(): Collection_expressionContext {
+        let localContext = new Collection_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2144, PlSqlParser.RULE_collection_expression);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18681;
+            this.collation_name();
+            this.state = 18682;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 18683;
+            this.expression();
+            this.state = 18684;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 18689;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2600, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 18685;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 18686;
+                    this.general_element_part();
+                    }
+                    }
+                }
+                this.state = 18691;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2600, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public case_statement(): Case_statementContext {
+        let localContext = new Case_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2146, PlSqlParser.RULE_case_statement);
+        try {
+            this.state = 18694;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2601, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18692;
+                this.searched_case_statement();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18693;
+                this.simple_case_statement();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public simple_case_statement(): Simple_case_statementContext {
+        let localContext = new Simple_case_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2148, PlSqlParser.RULE_simple_case_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18697;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2470) {
+                {
+                this.state = 18696;
+                this.label_declaration();
+                }
+            }
+
+            this.state = 18699;
+            localContext._ck1 = this.match(PlSqlParser.CASE);
+            this.state = 18700;
+            this.expression();
+            this.state = 18702;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18701;
+                this.case_when_part_statement();
+                }
+                }
+                this.state = 18704;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2302);
+            this.state = 18707;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 491) {
+                {
+                this.state = 18706;
+                this.case_else_part_statement();
+                }
+            }
+
+            this.state = 18709;
+            this.match(PlSqlParser.END);
+            this.state = 18711;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2605, this.context) ) {
+            case 1:
+                {
+                this.state = 18710;
+                this.match(PlSqlParser.CASE);
+                }
+                break;
+            }
+            this.state = 18714;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2606, this.context) ) {
+            case 1:
+                {
+                this.state = 18713;
+                this.label_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public searched_case_statement(): Searched_case_statementContext {
+        let localContext = new Searched_case_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2150, PlSqlParser.RULE_searched_case_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18717;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2470) {
+                {
+                this.state = 18716;
+                this.label_declaration();
+                }
+            }
+
+            this.state = 18719;
+            localContext._ck1 = this.match(PlSqlParser.CASE);
+            this.state = 18721;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18720;
+                this.case_when_part_statement();
+                }
+                }
+                this.state = 18723;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2302);
+            this.state = 18726;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 491) {
+                {
+                this.state = 18725;
+                this.case_else_part_statement();
+                }
+            }
+
+            this.state = 18728;
+            this.match(PlSqlParser.END);
+            this.state = 18730;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2610, this.context) ) {
+            case 1:
+                {
+                this.state = 18729;
+                this.match(PlSqlParser.CASE);
+                }
+                break;
+            }
+            this.state = 18733;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2611, this.context) ) {
+            case 1:
+                {
+                this.state = 18732;
+                this.label_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public case_when_part_statement(): Case_when_part_statementContext {
+        let localContext = new Case_when_part_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2152, PlSqlParser.RULE_case_when_part_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18735;
+            this.match(PlSqlParser.WHEN);
+            this.state = 18736;
+            this.expression();
+            this.state = 18737;
+            this.match(PlSqlParser.THEN);
+            this.state = 18738;
+            this.seq_of_statements();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public case_else_part_statement(): Case_else_part_statementContext {
+        let localContext = new Case_else_part_statementContext(this.context, this.state);
+        this.enterRule(localContext, 2154, PlSqlParser.RULE_case_else_part_statement);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18740;
+            this.match(PlSqlParser.ELSE);
+            this.state = 18741;
+            this.seq_of_statements();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public case_expression(): Case_expressionContext {
+        let localContext = new Case_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2156, PlSqlParser.RULE_case_expression);
+        try {
+            this.state = 18745;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2612, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18743;
+                this.searched_case_expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18744;
+                this.simple_case_expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public simple_case_expression(): Simple_case_expressionContext {
+        let localContext = new Simple_case_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2158, PlSqlParser.RULE_simple_case_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18747;
+            localContext._ck1 = this.match(PlSqlParser.CASE);
+            this.state = 18748;
+            this.expression();
+            this.state = 18750;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18749;
+                this.case_when_part_expression();
+                }
+                }
+                this.state = 18752;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2302);
+            this.state = 18755;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 491) {
+                {
+                this.state = 18754;
+                this.case_else_part_expression();
+                }
+            }
+
+            this.state = 18757;
+            this.match(PlSqlParser.END);
+            this.state = 18759;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2615, this.context) ) {
+            case 1:
+                {
+                this.state = 18758;
+                this.match(PlSqlParser.CASE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public searched_case_expression(): Searched_case_expressionContext {
+        let localContext = new Searched_case_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2160, PlSqlParser.RULE_searched_case_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18761;
+            localContext._ck1 = this.match(PlSqlParser.CASE);
+            this.state = 18763;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 18762;
+                this.case_when_part_expression();
+                }
+                }
+                this.state = 18765;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 2302);
+            this.state = 18768;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 491) {
+                {
+                this.state = 18767;
+                this.case_else_part_expression();
+                }
+            }
+
+            this.state = 18770;
+            this.match(PlSqlParser.END);
+            this.state = 18772;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2618, this.context) ) {
+            case 1:
+                {
+                this.state = 18771;
+                this.match(PlSqlParser.CASE);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public case_when_part_expression(): Case_when_part_expressionContext {
+        let localContext = new Case_when_part_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2162, PlSqlParser.RULE_case_when_part_expression);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18774;
+            this.match(PlSqlParser.WHEN);
+            this.state = 18775;
+            this.expression();
+            this.state = 18776;
+            this.match(PlSqlParser.THEN);
+            this.state = 18777;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public case_else_part_expression(): Case_else_part_expressionContext {
+        let localContext = new Case_else_part_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2164, PlSqlParser.RULE_case_else_part_expression);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18779;
+            this.match(PlSqlParser.ELSE);
+            this.state = 18780;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public atom(): AtomContext {
+        let localContext = new AtomContext(this.context, this.state);
+        this.enterRule(localContext, 2166, PlSqlParser.RULE_atom);
+        try {
+            let alternative: number;
+            this.state = 18812;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2622, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18782;
+                this.bind_variable();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18783;
+                this.constant();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18784;
+                this.inquiry_directive();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18785;
+                this.general_element(0);
+                this.state = 18787;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2619, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18786;
+                    this.outer_join_sign();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18789;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18790;
+                this.subquery();
+                this.state = 18791;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 18795;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2620, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 18792;
+                        this.subquery_operation_part();
+                        }
+                        }
+                    }
+                    this.state = 18797;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2620, this.context);
+                }
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 18798;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18799;
+                this.expression();
+                this.state = 18800;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 18805;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2621, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 18801;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 18802;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 18807;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2621, this.context);
+                }
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 18808;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18809;
+                this.expressions_();
+                this.state = 18810;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public quantified_expression(): Quantified_expressionContext {
+        let localContext = new Quantified_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2168, PlSqlParser.RULE_quantified_expression);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18814;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 38 || _la === 55 || _la === 546 || _la === 1710)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 18830;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2624, this.context) ) {
+            case 1:
+                {
+                this.state = 18815;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18816;
+                this.select_only_statement();
+                this.state = 18817;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 2:
+                {
+                this.state = 18819;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18820;
+                this.expression();
+                this.state = 18825;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 18821;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18822;
+                    this.expression();
+                    }
+                    }
+                    this.state = 18827;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 18828;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public string_function(): String_functionContext {
+        let localContext = new String_functionContext(this.context, this.state);
+        this.enterRule(localContext, 2170, PlSqlParser.RULE_string_function);
+        let _la: number;
+        try {
+            this.state = 18918;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SUBSTR:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18832;
+                this.match(PlSqlParser.SUBSTR);
+                this.state = 18833;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18834;
+                this.expression();
+                this.state = 18835;
+                this.match(PlSqlParser.COMMA);
+                this.state = 18836;
+                this.expression();
+                this.state = 18839;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 18837;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18838;
+                    this.expression();
+                    }
+                }
+
+                this.state = 18841;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.TO_CHAR:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18843;
+                this.match(PlSqlParser.TO_CHAR);
+                this.state = 18844;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18848;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2626, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18845;
+                    this.table_element();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 18846;
+                    this.standard_function();
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 18847;
+                    this.expression();
+                    }
+                    break;
+                }
+                this.state = 18852;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2627, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18850;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18851;
+                    this.quoted_string();
+                    }
+                    break;
+                }
+                this.state = 18856;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 18854;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18855;
+                    this.quoted_string();
+                    }
+                }
+
+                this.state = 18858;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.DECODE:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18860;
+                this.match(PlSqlParser.DECODE);
+                this.state = 18861;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18862;
+                this.expressions_();
+                this.state = 18863;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.CHR:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18865;
+                this.match(PlSqlParser.CHR);
+                this.state = 18866;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18867;
+                this.concatenation(0);
+                this.state = 18868;
+                this.match(PlSqlParser.USING);
+                this.state = 18869;
+                this.match(PlSqlParser.NCHAR_CS);
+                this.state = 18870;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.NVL:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 18872;
+                this.match(PlSqlParser.NVL);
+                this.state = 18873;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18874;
+                this.expression();
+                this.state = 18875;
+                this.match(PlSqlParser.COMMA);
+                this.state = 18876;
+                this.expression();
+                this.state = 18877;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.TRIM:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 18879;
+                this.match(PlSqlParser.TRIM);
+                this.state = 18880;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18888;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2631, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18882;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2629, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 18881;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 149 || _la === 839 || _la === 2148)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    }
+                    this.state = 18885;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2630, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 18884;
+                        this.expression();
+                        }
+                        break;
+                    }
+                    this.state = 18887;
+                    this.match(PlSqlParser.FROM);
+                    }
+                    break;
+                }
+                this.state = 18890;
+                this.concatenation(0);
+                this.state = 18891;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.TO_DATE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 18893;
+                this.match(PlSqlParser.TO_DATE);
+                this.state = 18894;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18898;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2632, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18895;
+                    this.table_element();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 18896;
+                    this.standard_function();
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 18897;
+                    this.expression();
+                    }
+                    break;
+                }
+                this.state = 18906;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 389) {
+                    {
+                    this.state = 18900;
+                    this.match(PlSqlParser.DEFAULT);
+                    this.state = 18901;
+                    this.concatenation(0);
+                    this.state = 18902;
+                    this.match(PlSqlParser.ON);
+                    this.state = 18903;
+                    this.match(PlSqlParser.CONVERSION);
+                    this.state = 18904;
+                    this.match(PlSqlParser.ERROR);
+                    }
+                }
+
+                this.state = 18914;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 18908;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18909;
+                    this.quoted_string();
+                    this.state = 18912;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 18910;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 18911;
+                        this.quoted_string();
+                        }
+                    }
+
+                    }
+                }
+
+                this.state = 18916;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public standard_function(): Standard_functionContext {
+        let localContext = new Standard_functionContext(this.context, this.state);
+        this.enterRule(localContext, 2172, PlSqlParser.RULE_standard_function);
+        try {
+            this.state = 18925;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2637, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18920;
+                this.string_function();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18921;
+                this.numeric_function_wrapper();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18922;
+                this.json_function();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18923;
+                if (!(this.IsNotNumericFunction())) {
+                    throw this.createFailedPredicateException("this.IsNotNumericFunction()");
+                }
+                this.state = 18924;
+                this.other_function();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_function(): Json_functionContext {
+        let localContext = new Json_functionContext(this.context, this.state);
+        this.enterRule(localContext, 2174, PlSqlParser.RULE_json_function);
+        let _la: number;
+        try {
+            this.state = 19115;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.JSON_ARRAY:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 18927;
+                this.match(PlSqlParser.JSON_ARRAY);
+                this.state = 18928;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18929;
+                this.json_array_element();
+                this.state = 18934;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 18930;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 18931;
+                    this.json_array_element();
+                    }
+                    }
+                    this.state = 18936;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 18938;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 3 || _la === 1230) {
+                    {
+                    this.state = 18937;
+                    this.json_on_null_clause();
+                    }
+                }
+
+                this.state = 18941;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1587) {
+                    {
+                    this.state = 18940;
+                    this.json_return_clause();
+                    }
+                }
+
+                this.state = 18944;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1768) {
+                    {
+                    this.state = 18943;
+                    this.match(PlSqlParser.STRICT);
+                    }
+                }
+
+                this.state = 18946;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_ARRAYAGG:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 18948;
+                this.match(PlSqlParser.JSON_ARRAYAGG);
+                this.state = 18949;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18950;
+                this.expression();
+                this.state = 18953;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 622) {
+                    {
+                    this.state = 18951;
+                    this.match(PlSqlParser.FORMAT);
+                    this.state = 18952;
+                    this.match(PlSqlParser.JSON);
+                    }
+                }
+
+                this.state = 18956;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1305) {
+                    {
+                    this.state = 18955;
+                    this.order_by_clause();
+                    }
+                }
+
+                this.state = 18959;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 3 || _la === 1230) {
+                    {
+                    this.state = 18958;
+                    this.json_on_null_clause();
+                    }
+                }
+
+                this.state = 18962;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1587) {
+                    {
+                    this.state = 18961;
+                    this.json_return_clause();
+                    }
+                }
+
+                this.state = 18965;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1768) {
+                    {
+                    this.state = 18964;
+                    this.match(PlSqlParser.STRICT);
+                    }
+                }
+
+                this.state = 18967;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_OBJECT:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 18969;
+                this.match(PlSqlParser.JSON_OBJECT);
+                this.state = 18970;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18971;
+                this.json_object_content();
+                this.state = 18972;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_OBJECTAGG:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 18974;
+                this.match(PlSqlParser.JSON_OBJECTAGG);
+                this.state = 18975;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 18977;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2647, this.context) ) {
+                case 1:
+                    {
+                    this.state = 18976;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                }
+                this.state = 18979;
+                this.expression();
+                this.state = 18980;
+                this.match(PlSqlParser.VALUE);
+                this.state = 18981;
+                this.expression();
+                this.state = 18985;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 3 || _la === 1230) {
+                    {
+                    this.state = 18982;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 3 || _la === 1230)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 18983;
+                    this.match(PlSqlParser.ON);
+                    this.state = 18984;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                this.state = 19001;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1587) {
+                    {
+                    this.state = 18987;
+                    this.match(PlSqlParser.RETURNING);
+                    this.state = 18999;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.VARCHAR2:
+                        {
+                        this.state = 18988;
+                        this.match(PlSqlParser.VARCHAR2);
+                        this.state = 18995;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 2449) {
+                            {
+                            this.state = 18989;
+                            this.match(PlSqlParser.LEFT_PAREN);
+                            this.state = 18990;
+                            this.match(PlSqlParser.UNSIGNED_INTEGER);
+                            this.state = 18992;
+                            this.errorHandler.sync(this);
+                            _la = this.tokenStream.LA(1);
+                            if (_la === 163 || _la === 196) {
+                                {
+                                this.state = 18991;
+                                _la = this.tokenStream.LA(1);
+                                if(!(_la === 163 || _la === 196)) {
+                                this.errorHandler.recoverInline(this);
+                                }
+                                else {
+                                    this.errorHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                                }
+                            }
+
+                            this.state = 18994;
+                            this.match(PlSqlParser.RIGHT_PAREN);
+                            }
+                        }
+
+                        }
+                        break;
+                    case PlSqlParser.CLOB:
+                        {
+                        this.state = 18997;
+                        this.match(PlSqlParser.CLOB);
+                        }
+                        break;
+                    case PlSqlParser.BLOB:
+                        {
+                        this.state = 18998;
+                        this.match(PlSqlParser.BLOB);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+
+                this.state = 19004;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1768) {
+                    {
+                    this.state = 19003;
+                    this.match(PlSqlParser.STRICT);
+                    }
+                }
+
+                this.state = 19009;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2310) {
+                    {
+                    this.state = 19006;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 19007;
+                    this.match(PlSqlParser.UNIQUE);
+                    this.state = 19008;
+                    this.match(PlSqlParser.KEYS);
+                    }
+                }
+
+                this.state = 19011;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_QUERY:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 19013;
+                this.match(PlSqlParser.JSON_QUERY);
+                this.state = 19014;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19015;
+                this.expression();
+                this.state = 19018;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 622) {
+                    {
+                    this.state = 19016;
+                    this.match(PlSqlParser.FORMAT);
+                    this.state = 19017;
+                    this.match(PlSqlParser.JSON);
+                    }
+                }
+
+                this.state = 19020;
+                this.match(PlSqlParser.COMMA);
+                this.state = 19021;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19022;
+                this.json_query_returning_clause();
+                this.state = 19024;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2308 || _la === 2310) {
+                    {
+                    this.state = 19023;
+                    this.json_query_wrapper_clause();
+                    }
+                }
+
+                this.state = 19027;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2657, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19026;
+                    this.json_query_on_error_clause();
+                    }
+                    break;
+                }
+                this.state = 19030;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 497 || _la === 520 || _la === 1230 || _la === 1261) {
+                    {
+                    this.state = 19029;
+                    this.json_query_on_empty_clause();
+                    }
+                }
+
+                this.state = 19032;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_SERIALIZE:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 19034;
+                this.match(PlSqlParser.JSON_SERIALIZE);
+                this.state = 19035;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19036;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19039;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1587) {
+                    {
+                    this.state = 19037;
+                    this.match(PlSqlParser.RETURNING);
+                    this.state = 19038;
+                    this.json_query_return_type();
+                    }
+                }
+
+                this.state = 19042;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1450) {
+                    {
+                    this.state = 19041;
+                    this.match(PlSqlParser.PRETTY);
+                    }
+                }
+
+                this.state = 19045;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 71) {
+                    {
+                    this.state = 19044;
+                    this.match(PlSqlParser.ASCII);
+                    }
+                }
+
+                this.state = 19048;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2161) {
+                    {
+                    this.state = 19047;
+                    this.match(PlSqlParser.TRUNCATE);
+                    }
+                }
+
+                this.state = 19058;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 497 || _la === 520 || _la === 1230) {
+                    {
+                    this.state = 19054;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.NULL_:
+                        {
+                        this.state = 19050;
+                        this.match(PlSqlParser.NULL_);
+                        }
+                        break;
+                    case PlSqlParser.ERROR:
+                        {
+                        this.state = 19051;
+                        this.match(PlSqlParser.ERROR);
+                        }
+                        break;
+                    case PlSqlParser.EMPTY_:
+                        {
+                        this.state = 19052;
+                        this.match(PlSqlParser.EMPTY_);
+                        this.state = 19053;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 68 || _la === 1240)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 19056;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19057;
+                    this.match(PlSqlParser.ERROR);
+                    }
+                }
+
+                this.state = 19060;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_TRANSFORM:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 19061;
+                this.match(PlSqlParser.JSON_TRANSFORM);
+                this.state = 19062;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19063;
+                this.expression();
+                this.state = 19064;
+                this.match(PlSqlParser.COMMA);
+                this.state = 19065;
+                this.json_transform_op();
+                this.state = 19070;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 19066;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19067;
+                    this.json_transform_op();
+                    }
+                    }
+                    this.state = 19072;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 19073;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.JSON_VALUE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 19075;
+                this.match(PlSqlParser.JSON_VALUE);
+                this.state = 19076;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19077;
+                this.expression();
+                this.state = 19080;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2666, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19078;
+                    this.match(PlSqlParser.FORMAT);
+                    this.state = 19079;
+                    this.match(PlSqlParser.JSON);
+                    }
+                    break;
+                }
+                this.state = 19113;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2674, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19082;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19084;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2445) {
+                        {
+                        this.state = 19083;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                    }
+
+                    this.state = 19087;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1587) {
+                        {
+                        this.state = 19086;
+                        this.json_value_return_clause();
+                        }
+                    }
+
+                    this.state = 19097;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2670, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 19093;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.ERROR:
+                            {
+                            this.state = 19089;
+                            this.match(PlSqlParser.ERROR);
+                            }
+                            break;
+                        case PlSqlParser.NULL_:
+                            {
+                            this.state = 19090;
+                            this.match(PlSqlParser.NULL_);
+                            }
+                            break;
+                        case PlSqlParser.DEFAULT:
+                            {
+                            this.state = 19091;
+                            this.match(PlSqlParser.DEFAULT);
+                            this.state = 19092;
+                            this.literal();
+                            }
+                            break;
+                        case PlSqlParser.ON:
+                            break;
+                        default:
+                            break;
+                        }
+                        this.state = 19095;
+                        this.match(PlSqlParser.ON);
+                        this.state = 19096;
+                        this.match(PlSqlParser.ERROR);
+                        }
+                        break;
+                    }
+                    this.state = 19107;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2672, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 19103;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.ERROR:
+                            {
+                            this.state = 19099;
+                            this.match(PlSqlParser.ERROR);
+                            }
+                            break;
+                        case PlSqlParser.NULL_:
+                            {
+                            this.state = 19100;
+                            this.match(PlSqlParser.NULL_);
+                            }
+                            break;
+                        case PlSqlParser.DEFAULT:
+                            {
+                            this.state = 19101;
+                            this.match(PlSqlParser.DEFAULT);
+                            this.state = 19102;
+                            this.literal();
+                            }
+                            break;
+                        case PlSqlParser.ON:
+                            break;
+                        default:
+                            break;
+                        }
+                        this.state = 19105;
+                        this.match(PlSqlParser.ON);
+                        this.state = 19106;
+                        this.match(PlSqlParser.EMPTY_);
+                        }
+                        break;
+                    }
+                    this.state = 19110;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 520 || _la === 693 || _la === 1230) {
+                        {
+                        this.state = 19109;
+                        this.json_value_on_mismatch_clause();
+                        }
+                    }
+
+                    this.state = 19112;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_object_content(): Json_object_contentContext {
+        let localContext = new Json_object_contentContext(this.context, this.state);
+        this.enterRule(localContext, 2176, PlSqlParser.RULE_json_object_content);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19126;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2677, this.context) ) {
+            case 1:
+                {
+                this.state = 19117;
+                this.json_object_entry();
+                this.state = 19122;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 19118;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19119;
+                    this.json_object_entry();
+                    }
+                    }
+                    this.state = 19124;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 19125;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            }
+            this.state = 19129;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 3 || _la === 1230) {
+                {
+                this.state = 19128;
+                this.json_on_null_clause();
+                }
+            }
+
+            this.state = 19132;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1587) {
+                {
+                this.state = 19131;
+                this.json_return_clause();
+                }
+            }
+
+            this.state = 19135;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1768) {
+                {
+                this.state = 19134;
+                this.match(PlSqlParser.STRICT);
+                }
+            }
+
+            this.state = 19140;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2310) {
+                {
+                this.state = 19137;
+                this.match(PlSqlParser.WITH);
+                this.state = 19138;
+                this.match(PlSqlParser.UNIQUE);
+                this.state = 19139;
+                this.match(PlSqlParser.KEYS);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_object_entry(): Json_object_entryContext {
+        let localContext = new Json_object_entryContext(this.context, this.state);
+        this.enterRule(localContext, 2178, PlSqlParser.RULE_json_object_entry);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19156;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2684, this.context) ) {
+            case 1:
+                {
+                this.state = 19143;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2682, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19142;
+                    this.match(PlSqlParser.KEY);
+                    }
+                    break;
+                }
+                this.state = 19145;
+                this.expression();
+                this.state = 19147;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2683, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19146;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 786 || _la === 2260)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19149;
+                this.expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 19151;
+                this.expression();
+                this.state = 19152;
+                this.match(PlSqlParser.COLON);
+                this.state = 19153;
+                this.expression();
+                }
+                break;
+            case 3:
+                {
+                this.state = 19155;
+                this.identifier();
+                }
+                break;
+            }
+            this.state = 19160;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 622) {
+                {
+                this.state = 19158;
+                this.match(PlSqlParser.FORMAT);
+                this.state = 19159;
+                this.match(PlSqlParser.JSON);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_table_clause(): Json_table_clauseContext {
+        let localContext = new Json_table_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2180, PlSqlParser.RULE_json_table_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19162;
+            this.match(PlSqlParser.JSON_TABLE);
+            this.state = 19163;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 19164;
+            this.expression();
+            this.state = 19167;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 622) {
+                {
+                this.state = 19165;
+                this.match(PlSqlParser.FORMAT);
+                this.state = 19166;
+                this.match(PlSqlParser.JSON);
+                }
+            }
+
+            this.state = 19171;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2455) {
+                {
+                this.state = 19169;
+                this.match(PlSqlParser.COMMA);
+                this.state = 19170;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+            }
+
+            this.state = 19176;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2688, this.context) ) {
+            case 1:
+                {
+                this.state = 19173;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 520 || _la === 1230)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19174;
+                this.match(PlSqlParser.ON);
+                this.state = 19175;
+                this.match(PlSqlParser.ERROR);
+                }
+                break;
+            }
+            this.state = 19181;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 497 || _la === 1230) {
+                {
+                this.state = 19178;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 497 || _la === 1230)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19179;
+                this.match(PlSqlParser.ON);
+                this.state = 19180;
+                this.match(PlSqlParser.EMPTY_);
+                }
+            }
+
+            this.state = 19184;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 238) {
+                {
+                this.state = 19183;
+                this.json_column_clause();
+                }
+            }
+
+            this.state = 19186;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_array_element(): Json_array_elementContext {
+        let localContext = new Json_array_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2182, PlSqlParser.RULE_json_array_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19193;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2691, this.context) ) {
+            case 1:
+                {
+                this.state = 19188;
+                this.expression();
+                }
+                break;
+            case 2:
+                {
+                this.state = 19189;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 3:
+                {
+                this.state = 19190;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case 4:
+                {
+                this.state = 19191;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            case 5:
+                {
+                this.state = 19192;
+                this.json_function();
+                }
+                break;
+            }
+            this.state = 19197;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 622) {
+                {
+                this.state = 19195;
+                this.match(PlSqlParser.FORMAT);
+                this.state = 19196;
+                this.match(PlSqlParser.JSON);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_on_null_clause(): Json_on_null_clauseContext {
+        let localContext = new Json_on_null_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2184, PlSqlParser.RULE_json_on_null_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19199;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 3 || _la === 1230)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 19200;
+            this.match(PlSqlParser.ON);
+            this.state = 19201;
+            this.match(PlSqlParser.NULL_);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_return_clause(): Json_return_clauseContext {
+        let localContext = new Json_return_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2186, PlSqlParser.RULE_json_return_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19203;
+            this.match(PlSqlParser.RETURNING);
+            this.state = 19215;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VARCHAR2:
+                {
+                this.state = 19204;
+                this.match(PlSqlParser.VARCHAR2);
+                this.state = 19211;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 19205;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 19206;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 19208;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 163 || _la === 196) {
+                        {
+                        this.state = 19207;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 163 || _la === 196)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19210;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.CLOB:
+                {
+                this.state = 19213;
+                this.match(PlSqlParser.CLOB);
+                }
+                break;
+            case PlSqlParser.BLOB:
+                {
+                this.state = 19214;
+                this.match(PlSqlParser.BLOB);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_transform_op(): Json_transform_opContext {
+        let localContext = new Json_transform_opContext(this.context, this.state);
+        this.enterRule(localContext, 2188, PlSqlParser.RULE_json_transform_op);
+        let _la: number;
+        try {
+            this.state = 19304;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2713, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19217;
+                this.match(PlSqlParser.REMOVE);
+                this.state = 19218;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19224;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 520 || _la === 693 || _la === 1261) {
+                    {
+                    this.state = 19220;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 520 || _la === 693) {
+                        {
+                        this.state = 19219;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 520 || _la === 693)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19222;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19223;
+                    this.match(PlSqlParser.MISSING);
+                    }
+                }
+
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19226;
+                this.match(PlSqlParser.INSERT);
+                this.state = 19227;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19228;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 19229;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19233;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2698, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19230;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 520 || _la === 693 || _la === 1564)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 19231;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19232;
+                    this.match(PlSqlParser.EXISTING);
+                    }
+                    break;
+                }
+                this.state = 19240;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 520 || _la === 693 || _la === 1230 || _la === 1261 || _la === 1560) {
+                    {
+                    this.state = 19236;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 520 || _la === 693 || _la === 1230 || _la === 1560) {
+                        {
+                        this.state = 19235;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 520 || _la === 693 || _la === 1230 || _la === 1560)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19238;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19239;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19242;
+                this.match(PlSqlParser.REPLACE);
+                this.state = 19243;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19244;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 19245;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19249;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2701, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19246;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 321 || _la === 520 || _la === 693)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 19247;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19248;
+                    this.match(PlSqlParser.MISSING);
+                    }
+                    break;
+                }
+                this.state = 19256;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 520 || _la === 693 || _la === 1230 || _la === 1261) {
+                    {
+                    this.state = 19252;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 520 || _la === 693 || _la === 1230) {
+                        {
+                        this.state = 19251;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 520 || _la === 693 || _la === 1230)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19254;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19255;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 19258;
+                this.expression();
+                this.state = 19261;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 622) {
+                    {
+                    this.state = 19259;
+                    this.match(PlSqlParser.FORMAT);
+                    this.state = 19260;
+                    this.match(PlSqlParser.JSON);
+                    }
+                }
+
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 19263;
+                this.match(PlSqlParser.APPEND);
+                this.state = 19264;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19265;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 19266;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19270;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2705, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19267;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 321 || _la === 520 || _la === 693)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 19268;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19269;
+                    this.match(PlSqlParser.MISSING);
+                    }
+                    break;
+                }
+                this.state = 19277;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 520 || _la === 693 || _la === 1230 || _la === 1261) {
+                    {
+                    this.state = 19273;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 520 || _la === 693 || _la === 1230) {
+                        {
+                        this.state = 19272;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 520 || _la === 693 || _la === 1230)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19275;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19276;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 19279;
+                this.match(PlSqlParser.SET);
+                this.state = 19280;
+                this.match(PlSqlParser.CHAR_STRING);
+                this.state = 19281;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 19282;
+                this.expression();
+                this.state = 19285;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 622) {
+                    {
+                    this.state = 19283;
+                    this.match(PlSqlParser.FORMAT);
+                    this.state = 19284;
+                    this.match(PlSqlParser.JSON);
+                    }
+                }
+
+                this.state = 19290;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2709, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19287;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 520 || _la === 693 || _la === 1564)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 19288;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19289;
+                    this.match(PlSqlParser.EXISTING);
+                    }
+                    break;
+                }
+                this.state = 19295;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2710, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19292;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 321 || _la === 520 || _la === 693)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 19293;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19294;
+                    this.match(PlSqlParser.MISSING);
+                    }
+                    break;
+                }
+                this.state = 19302;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 520 || _la === 693 || _la === 1230 || _la === 1261) {
+                    {
+                    this.state = 19298;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 520 || _la === 693 || _la === 1230) {
+                        {
+                        this.state = 19297;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 520 || _la === 693 || _la === 1230)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19300;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19301;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                }
+
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_column_clause(): Json_column_clauseContext {
+        let localContext = new Json_column_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2190, PlSqlParser.RULE_json_column_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19306;
+            this.match(PlSqlParser.COLUMNS);
+            this.state = 19307;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 19308;
+            this.json_column_definition();
+            this.state = 19313;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 19309;
+                this.match(PlSqlParser.COMMA);
+                this.state = 19310;
+                this.json_column_definition();
+                }
+                }
+                this.state = 19315;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 19316;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_column_definition(): Json_column_definitionContext {
+        let localContext = new Json_column_definitionContext(this.context, this.state);
+        this.enterRule(localContext, 2192, PlSqlParser.RULE_json_column_definition);
+        let _la: number;
+        try {
+            this.state = 19371;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2726, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19318;
+                this.expression();
+                this.state = 19320;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2715, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19319;
+                    this.json_value_return_type();
+                    }
+                    break;
+                }
+                this.state = 19332;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.PATH:
+                    {
+                    this.state = 19323;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 546) {
+                        {
+                        this.state = 19322;
+                        this.match(PlSqlParser.EXISTS);
+                        }
+                    }
+
+                    this.state = 19325;
+                    this.match(PlSqlParser.PATH);
+                    this.state = 19326;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    break;
+                case PlSqlParser.TRUNCATE:
+                    {
+                    this.state = 19327;
+                    this.match(PlSqlParser.TRUNCATE);
+                    this.state = 19330;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1365) {
+                        {
+                        this.state = 19328;
+                        this.match(PlSqlParser.PATH);
+                        this.state = 19329;
+                        this.match(PlSqlParser.CHAR_STRING);
+                        }
+                    }
+
+                    }
+                    break;
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.NULL_:
+                case PlSqlParser.ON:
+                case PlSqlParser.RIGHT_PAREN:
+                case PlSqlParser.COMMA:
+                    break;
+                default:
+                    break;
+                }
+                this.state = 19335;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2719, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19334;
+                    this.json_query_on_error_clause();
+                    }
+                    break;
+                }
+                this.state = 19338;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 497 || _la === 520 || _la === 1230 || _la === 1261) {
+                    {
+                    this.state = 19337;
+                    this.json_query_on_empty_clause();
+                    }
+                }
+
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19340;
+                this.expression();
+                this.state = 19342;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 142 || _la === 215 || _la === 2261) {
+                    {
+                    this.state = 19341;
+                    this.json_query_return_type();
+                    }
+                }
+
+                this.state = 19345;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2161) {
+                    {
+                    this.state = 19344;
+                    this.match(PlSqlParser.TRUNCATE);
+                    }
+                }
+
+                this.state = 19347;
+                this.match(PlSqlParser.FORMAT);
+                this.state = 19348;
+                this.match(PlSqlParser.JSON);
+                this.state = 19350;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2308 || _la === 2310) {
+                    {
+                    this.state = 19349;
+                    this.json_query_wrapper_clause();
+                    }
+                }
+
+                this.state = 19352;
+                this.match(PlSqlParser.PATH);
+                this.state = 19353;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19355;
+                this.match(PlSqlParser.NESTED);
+                this.state = 19357;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2724, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19356;
+                    this.match(PlSqlParser.PATH);
+                    }
+                    break;
+                }
+                this.state = 19359;
+                this.expression();
+                this.state = 19363;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2475) {
+                    {
+                    this.state = 19360;
+                    this.match(PlSqlParser.LEFT_BRACKET);
+                    this.state = 19361;
+                    this.match(PlSqlParser.ASTERISK);
+                    this.state = 19362;
+                    this.match(PlSqlParser.RIGHT_BRACKET);
+                    }
+                }
+
+                this.state = 19365;
+                this.json_column_clause();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 19367;
+                this.expression();
+                this.state = 19368;
+                this.match(PlSqlParser.FOR);
+                this.state = 19369;
+                this.match(PlSqlParser.ORDINALITY);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_query_returning_clause(): Json_query_returning_clauseContext {
+        let localContext = new Json_query_returning_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2194, PlSqlParser.RULE_json_query_returning_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19375;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1587) {
+                {
+                this.state = 19373;
+                this.match(PlSqlParser.RETURNING);
+                this.state = 19374;
+                this.json_query_return_type();
+                }
+            }
+
+            this.state = 19378;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1450) {
+                {
+                this.state = 19377;
+                this.match(PlSqlParser.PRETTY);
+                }
+            }
+
+            this.state = 19381;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 71) {
+                {
+                this.state = 19380;
+                this.match(PlSqlParser.ASCII);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_query_return_type(): Json_query_return_typeContext {
+        let localContext = new Json_query_return_typeContext(this.context, this.state);
+        this.enterRule(localContext, 2196, PlSqlParser.RULE_json_query_return_type);
+        let _la: number;
+        try {
+            this.state = 19394;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.VARCHAR2:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19383;
+                this.match(PlSqlParser.VARCHAR2);
+                this.state = 19390;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 19384;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 19385;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 19387;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 163 || _la === 196) {
+                        {
+                        this.state = 19386;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 163 || _la === 196)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19389;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.CLOB:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19392;
+                this.match(PlSqlParser.CLOB);
+                }
+                break;
+            case PlSqlParser.BLOB:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19393;
+                this.match(PlSqlParser.BLOB);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_query_wrapper_clause(): Json_query_wrapper_clauseContext {
+        let localContext = new Json_query_wrapper_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2198, PlSqlParser.RULE_json_query_wrapper_clause);
+        let _la: number;
+        try {
+            this.state = 19409;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.WITHOUT:
+                this.enterOuterAlt(localContext, 1);
+                {
+                {
+                this.state = 19396;
+                this.match(PlSqlParser.WITHOUT);
+                this.state = 19398;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 68) {
+                    {
+                    this.state = 19397;
+                    this.match(PlSqlParser.ARRAY);
+                    }
+                }
+
+                this.state = 19400;
+                this.match(PlSqlParser.WRAPPER);
+                }
+                }
+                break;
+            case PlSqlParser.WITH:
+                this.enterOuterAlt(localContext, 2);
+                {
+                {
+                this.state = 19401;
+                this.match(PlSqlParser.WITH);
+                this.state = 19403;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 265 || _la === 2178) {
+                    {
+                    this.state = 19402;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 265 || _la === 2178)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 19406;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 68) {
+                    {
+                    this.state = 19405;
+                    this.match(PlSqlParser.ARRAY);
+                    }
+                }
+
+                this.state = 19408;
+                this.match(PlSqlParser.WRAPPER);
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_query_on_error_clause(): Json_query_on_error_clauseContext {
+        let localContext = new Json_query_on_error_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2200, PlSqlParser.RULE_json_query_on_error_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19418;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2737, this.context) ) {
+            case 1:
+                {
+                this.state = 19411;
+                this.match(PlSqlParser.ERROR);
+                }
+                break;
+            case 2:
+                {
+                this.state = 19412;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case 3:
+                {
+                this.state = 19413;
+                this.match(PlSqlParser.EMPTY_);
+                }
+                break;
+            case 4:
+                {
+                this.state = 19414;
+                this.match(PlSqlParser.EMPTY_);
+                this.state = 19415;
+                this.match(PlSqlParser.ARRAY);
+                }
+                break;
+            case 5:
+                {
+                this.state = 19416;
+                this.match(PlSqlParser.EMPTY_);
+                this.state = 19417;
+                this.match(PlSqlParser.OBJECT);
+                }
+                break;
+            }
+            this.state = 19420;
+            this.match(PlSqlParser.ON);
+            this.state = 19421;
+            this.match(PlSqlParser.ERROR);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_query_on_empty_clause(): Json_query_on_empty_clauseContext {
+        let localContext = new Json_query_on_empty_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2202, PlSqlParser.RULE_json_query_on_empty_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19430;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2738, this.context) ) {
+            case 1:
+                {
+                this.state = 19423;
+                this.match(PlSqlParser.ERROR);
+                }
+                break;
+            case 2:
+                {
+                this.state = 19424;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case 3:
+                {
+                this.state = 19425;
+                this.match(PlSqlParser.EMPTY_);
+                }
+                break;
+            case 4:
+                {
+                this.state = 19426;
+                this.match(PlSqlParser.EMPTY_);
+                this.state = 19427;
+                this.match(PlSqlParser.ARRAY);
+                }
+                break;
+            case 5:
+                {
+                this.state = 19428;
+                this.match(PlSqlParser.EMPTY_);
+                this.state = 19429;
+                this.match(PlSqlParser.OBJECT);
+                }
+                break;
+            }
+            this.state = 19432;
+            this.match(PlSqlParser.ON);
+            this.state = 19433;
+            this.match(PlSqlParser.EMPTY_);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_value_return_clause(): Json_value_return_clauseContext {
+        let localContext = new Json_value_return_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2204, PlSqlParser.RULE_json_value_return_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19435;
+            this.match(PlSqlParser.RETURNING);
+            this.state = 19437;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2739, this.context) ) {
+            case 1:
+                {
+                this.state = 19436;
+                this.json_value_return_type();
+                }
+                break;
+            }
+            this.state = 19440;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 71) {
+                {
+                this.state = 19439;
+                this.match(PlSqlParser.ASCII);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_value_return_type(): Json_value_return_typeContext {
+        let localContext = new Json_value_return_typeContext(this.context, this.state);
+        this.enterRule(localContext, 2206, PlSqlParser.RULE_json_value_return_type);
+        let _la: number;
+        try {
+            this.state = 19479;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2748, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19442;
+                this.match(PlSqlParser.VARCHAR2);
+                this.state = 19449;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 19443;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 19444;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    this.state = 19446;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 163 || _la === 196) {
+                        {
+                        this.state = 19445;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 163 || _la === 196)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19448;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                this.state = 19452;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2743, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19451;
+                    this.match(PlSqlParser.TRUNCATE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19454;
+                this.match(PlSqlParser.CLOB);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19455;
+                this.match(PlSqlParser.DATE);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 19456;
+                this.match(PlSqlParser.NUMBER);
+                this.state = 19464;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 19457;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 19458;
+                    this.match(PlSqlParser.INTEGER);
+                    this.state = 19461;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 19459;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 19460;
+                        this.match(PlSqlParser.INTEGER);
+                        }
+                    }
+
+                    this.state = 19463;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 19466;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 19470;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2310) {
+                    {
+                    this.state = 19467;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 19468;
+                    this.match(PlSqlParser.TIME);
+                    this.state = 19469;
+                    this.match(PlSqlParser.ZONE);
+                    }
+                }
+
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 19472;
+                this.match(PlSqlParser.SDO_GEOMETRY);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 19473;
+                this.expression();
+                this.state = 19477;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2248) {
+                    {
+                    this.state = 19474;
+                    this.match(PlSqlParser.USING);
+                    this.state = 19475;
+                    this.match(PlSqlParser.CASESENSITIVE);
+                    this.state = 19476;
+                    this.match(PlSqlParser.MAPPING);
+                    }
+                }
+
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public json_value_on_mismatch_clause(): Json_value_on_mismatch_clauseContext {
+        let localContext = new Json_value_on_mismatch_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2208, PlSqlParser.RULE_json_value_on_mismatch_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19481;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 520 || _la === 693 || _la === 1230)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 19482;
+            this.match(PlSqlParser.ON);
+            this.state = 19483;
+            this.match(PlSqlParser.MISMATCH);
+            this.state = 19492;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 19484;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19485;
+                this.match(PlSqlParser.MISSING);
+                this.state = 19486;
+                this.match(PlSqlParser.DATA);
+                }
+                break;
+            case PlSqlParser.EXTRA:
+                {
+                this.state = 19487;
+                this.match(PlSqlParser.EXTRA);
+                this.state = 19488;
+                this.match(PlSqlParser.DATA);
+                }
+                break;
+            case PlSqlParser.TYPE:
+                {
+                this.state = 19489;
+                this.match(PlSqlParser.TYPE);
+                this.state = 19490;
+                this.match(PlSqlParser.ERROR);
+                this.state = 19491;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.RIGHT_PAREN:
+                break;
+            default:
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public literal(): LiteralContext {
+        let localContext = new LiteralContext(this.context, this.state);
+        this.enterRule(localContext, 2210, PlSqlParser.RULE_literal);
+        try {
+            this.state = 19499;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19494;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case PlSqlParser.CHR:
+            case PlSqlParser.DECODE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.TO_DATE:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19495;
+                this.string_function();
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19496;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.MINUS_SIGN:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 19497;
+                this.numeric_negative();
+                }
+                break;
+            case PlSqlParser.MAXVALUE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 19498;
+                this.match(PlSqlParser.MAXVALUE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public numeric_function_wrapper(): Numeric_function_wrapperContext {
+        let localContext = new Numeric_function_wrapperContext(this.context, this.state);
+        this.enterRule(localContext, 2212, PlSqlParser.RULE_numeric_function_wrapper);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19501;
+            this.numeric_function();
+            this.state = 19504;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2751, this.context) ) {
+            case 1:
+                {
+                this.state = 19502;
+                this.single_column_for_loop();
+                }
+                break;
+            case 2:
+                {
+                this.state = 19503;
+                this.multi_column_for_loop();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public numeric_function(): Numeric_functionContext {
+        let localContext = new Numeric_functionContext(this.context, this.state);
+        this.enterRule(localContext, 2214, PlSqlParser.RULE_numeric_function);
+        let _la: number;
+        try {
+            this.state = 19588;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.SUM:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19506;
+                this.match(PlSqlParser.SUM);
+                this.state = 19507;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19509;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2752, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19508;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 38 || _la === 445)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19511;
+                this.expression();
+                this.state = 19512;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19515;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2753, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19513;
+                    this.over_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19514;
+                    this.keep_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.COUNT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19517;
+                this.match(PlSqlParser.COUNT);
+                this.state = 19518;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19526;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2756, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19519;
+                    this.match(PlSqlParser.ASTERISK);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19524;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2755, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 19521;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 2754, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 19520;
+                            _la = this.tokenStream.LA(1);
+                            if(!(_la === 38 || _la === 445 || _la === 2185)) {
+                            this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            }
+                            break;
+                        }
+                        this.state = 19523;
+                        this.concatenation(0);
+                        }
+                        break;
+                    }
+                    }
+                    break;
+                }
+                this.state = 19528;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19531;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2757, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19529;
+                    this.over_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19530;
+                    this.keep_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.ROUND:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19533;
+                this.match(PlSqlParser.ROUND);
+                this.state = 19534;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19535;
+                this.expression();
+                this.state = 19541;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19536;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19539;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2758, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 19537;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case 2:
+                        {
+                        this.state = 19538;
+                        this.expression();
+                        }
+                        break;
+                    }
+                    }
+                }
+
+                this.state = 19543;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.AVG:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 19545;
+                this.match(PlSqlParser.AVG);
+                this.state = 19546;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19548;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2760, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19547;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 38 || _la === 445)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19550;
+                this.expression();
+                this.state = 19551;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19554;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2761, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19552;
+                    this.over_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19553;
+                    this.keep_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.MIN:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 19556;
+                this.match(PlSqlParser.MIN);
+                this.state = 19557;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19559;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2762, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19558;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 38 || _la === 445)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19561;
+                this.expression();
+                this.state = 19562;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19565;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2763, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19563;
+                    this.over_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19564;
+                    this.keep_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.MAX:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 19567;
+                this.match(PlSqlParser.MAX);
+                this.state = 19568;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19570;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2764, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19569;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 38 || _la === 445)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19572;
+                this.expression();
+                this.state = 19573;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19576;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2765, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19574;
+                    this.over_clause();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19575;
+                    this.keep_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.LEAST:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 19578;
+                this.match(PlSqlParser.LEAST);
+                this.state = 19579;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19580;
+                this.expressions_();
+                this.state = 19581;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.GREATEST:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 19583;
+                this.match(PlSqlParser.GREATEST);
+                this.state = 19584;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19585;
+                this.expressions_();
+                this.state = 19586;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public listagg_overflow_clause(): Listagg_overflow_clauseContext {
+        let localContext = new Listagg_overflow_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2216, PlSqlParser.RULE_listagg_overflow_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 19590;
+            this.match(PlSqlParser.ON);
+            this.state = 19591;
+            this.match(PlSqlParser.OVERFLOW_);
+            this.state = 19592;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 520 || _la === 2161)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 19594;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2445) {
+                {
+                this.state = 19593;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+            }
+
+            this.state = 19598;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2308 || _la === 2310) {
+                {
+                this.state = 19596;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2308 || _la === 2310)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19597;
+                this.match(PlSqlParser.COUNT);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public other_function(): Other_functionContext {
+        let localContext = new Other_functionContext(this.context, this.state);
+        this.enterRule(localContext, 2218, PlSqlParser.RULE_other_function);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.state = 20021;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2834, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 19600;
+                this.over_clause_keyword();
+                this.state = 19601;
+                this.function_argument_analytic();
+                this.state = 19603;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2769, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19602;
+                    this.over_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 19605;
+                this.regular_id();
+                this.state = 19606;
+                this.function_argument_modeling();
+                this.state = 19608;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2770, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19607;
+                    this.using_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 19610;
+                this.match(PlSqlParser.COUNT);
+                this.state = 19611;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19617;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2772, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19612;
+                    this.match(PlSqlParser.ASTERISK);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19614;
+                    this.errorHandler.sync(this);
+                    switch (this.interpreter.adaptivePredict(this.tokenStream, 2771, this.context) ) {
+                    case 1:
+                        {
+                        this.state = 19613;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 38 || _la === 445 || _la === 2185)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        break;
+                    }
+                    this.state = 19616;
+                    this.concatenation(0);
+                    }
+                    break;
+                }
+                this.state = 19619;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19621;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2773, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19620;
+                    this.over_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 19623;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 181 || _la === 2323)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19624;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19631;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2774, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19625;
+                    this.match(PlSqlParser.MULTISET);
+                    this.state = 19626;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 19627;
+                    this.subquery();
+                    this.state = 19628;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 19630;
+                    this.concatenation(0);
+                    }
+                    break;
+                }
+                this.state = 19633;
+                this.match(PlSqlParser.AS);
+                this.state = 19634;
+                this.type_spec();
+                this.state = 19641;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 389) {
+                    {
+                    this.state = 19635;
+                    this.match(PlSqlParser.DEFAULT);
+                    this.state = 19636;
+                    this.concatenation(0);
+                    this.state = 19637;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19638;
+                    this.match(PlSqlParser.CONVERSION);
+                    this.state = 19639;
+                    this.match(PlSqlParser.ERROR);
+                    }
+                }
+
+                this.state = 19649;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19643;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19644;
+                    this.quoted_string();
+                    this.state = 19647;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 19645;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 19646;
+                        this.quoted_string();
+                        }
+                    }
+
+                    }
+                }
+
+                this.state = 19651;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 19653;
+                this.match(PlSqlParser.COALESCE);
+                this.state = 19654;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19655;
+                this.table_element();
+                this.state = 19661;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19656;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19659;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                    case PlSqlParser.APPROXIMATE_NUM_LIT:
+                        {
+                        this.state = 19657;
+                        this.numeric();
+                        }
+                        break;
+                    case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                    case PlSqlParser.CHAR_STRING:
+                        {
+                        this.state = 19658;
+                        this.quoted_string();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+
+                this.state = 19663;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 19665;
+                this.match(PlSqlParser.COLLECT);
+                this.state = 19666;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19668;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2780, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19667;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 445 || _la === 2185)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19670;
+                this.concatenation(0);
+                this.state = 19672;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1305) {
+                    {
+                    this.state = 19671;
+                    this.collect_order_by_part();
+                    }
+                }
+
+                this.state = 19674;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 19676;
+                this.within_or_over_clause_keyword();
+                this.state = 19677;
+                this.function_argument();
+                this.state = 19679;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 19678;
+                        this.within_or_over_part();
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 19681;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2782, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 19683;
+                this.match(PlSqlParser.LISTAGG);
+                this.state = 19684;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19686;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2783, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19685;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 38 || _la === 445 || _la === 2185)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19688;
+                this.argument();
+                this.state = 19691;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19689;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19690;
+                    this.expression();
+                    }
+                }
+
+                this.state = 19694;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1261) {
+                    {
+                    this.state = 19693;
+                    this.listagg_overflow_clause();
+                    }
+                }
+
+                this.state = 19696;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19703;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2786, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19697;
+                    this.match(PlSqlParser.WITHIN);
+                    this.state = 19698;
+                    this.match(PlSqlParser.GROUP);
+                    this.state = 19699;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 19700;
+                    this.order_by_clause();
+                    this.state = 19701;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                this.state = 19706;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2787, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19705;
+                    this.over_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 19708;
+                this.cursor_name();
+                this.state = 19709;
+                _la = this.tokenStream.LA(1);
+                if(!(((((_la - 1377)) & ~0x1F) === 0 && ((1 << (_la - 1377)) & 39) !== 0))) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 19711;
+                this.match(PlSqlParser.DECOMPOSE);
+                this.state = 19712;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19713;
+                this.concatenation(0);
+                this.state = 19715;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 175 || _la === 248) {
+                    {
+                    this.state = 19714;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 175 || _la === 248)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 19717;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 19719;
+                this.match(PlSqlParser.EXTRACT);
+                this.state = 19720;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19721;
+                this.regular_id();
+                this.state = 19722;
+                this.match(PlSqlParser.FROM);
+                this.state = 19723;
+                this.concatenation(0);
+                this.state = 19724;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 19726;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 602 || _la === 827)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19727;
+                this.function_argument_analytic();
+                this.state = 19729;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 693 || _la === 1573) {
+                    {
+                    this.state = 19728;
+                    this.respect_or_ignore_nulls();
+                    }
+                }
+
+                this.state = 19731;
+                this.over_clause();
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 19733;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2404 || _la === 2407)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19734;
+                this.function_argument_analytic();
+                this.state = 19736;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 693 || _la === 1573) {
+                    {
+                    this.state = 19735;
+                    this.respect_or_ignore_nulls();
+                    }
+                }
+
+                this.state = 19738;
+                this.over_clause();
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 19740;
+                this.standard_prediction_function_keyword();
+                this.state = 19741;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19742;
+                this.expressions_();
+                this.state = 19744;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 311) {
+                    {
+                    this.state = 19743;
+                    this.cost_matrix_clause();
+                    }
+                }
+
+                this.state = 19747;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2248) {
+                    {
+                    this.state = 19746;
+                    this.using_clause();
+                    }
+                }
+
+                this.state = 19749;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 19751;
+                _la = this.tokenStream.LA(1);
+                if(!(((((_la - 2127)) & ~0x1F) === 0 && ((1 << (_la - 2127)) & 12803) !== 0))) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19752;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19753;
+                this.concatenation(0);
+                this.state = 19760;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 389) {
+                    {
+                    this.state = 19754;
+                    this.match(PlSqlParser.DEFAULT);
+                    this.state = 19755;
+                    this.concatenation(0);
+                    this.state = 19756;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19757;
+                    this.match(PlSqlParser.CONVERSION);
+                    this.state = 19758;
+                    this.match(PlSqlParser.ERROR);
+                    }
+                }
+
+                this.state = 19768;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19762;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19763;
+                    this.quoted_string();
+                    this.state = 19766;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 19764;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 19765;
+                        this.quoted_string();
+                        }
+                    }
+
+                    }
+                }
+
+                this.state = 19770;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 19772;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2131 || _la === 2144)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19773;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19774;
+                this.concatenation(0);
+                this.state = 19781;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 389) {
+                    {
+                    this.state = 19775;
+                    this.match(PlSqlParser.DEFAULT);
+                    this.state = 19776;
+                    this.concatenation(0);
+                    this.state = 19777;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19778;
+                    this.match(PlSqlParser.CONVERSION);
+                    this.state = 19779;
+                    this.match(PlSqlParser.ERROR);
+                    }
+                }
+
+                this.state = 19783;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 19785;
+                this.match(PlSqlParser.TRANSLATE);
+                this.state = 19786;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19787;
+                this.expression();
+                this.state = 19790;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2248) {
+                    {
+                    this.state = 19788;
+                    this.match(PlSqlParser.USING);
+                    this.state = 19789;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 197 || _la === 1008)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 19796;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 19792;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19793;
+                    this.expression();
+                    }
+                    }
+                    this.state = 19798;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 19799;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 19801;
+                this.match(PlSqlParser.TREAT);
+                this.state = 19802;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19803;
+                this.expression();
+                this.state = 19804;
+                this.match(PlSqlParser.AS);
+                this.state = 19806;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2799, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19805;
+                    this.match(PlSqlParser.REF);
+                    }
+                    break;
+                }
+                this.state = 19808;
+                this.type_spec();
+                this.state = 19809;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19814;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2800, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19810;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19811;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19816;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2800, this.context);
+                }
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 19817;
+                this.match(PlSqlParser.TRIM);
+                this.state = 19818;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19826;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2803, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19820;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 149 || _la === 839 || _la === 2148) {
+                        {
+                        this.state = 19819;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 149 || _la === 839 || _la === 2148)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                    }
+
+                    this.state = 19823;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2438 || _la === 2445) {
+                        {
+                        this.state = 19822;
+                        this.quoted_string();
+                        }
+                    }
+
+                    this.state = 19825;
+                    this.match(PlSqlParser.FROM);
+                    }
+                    break;
+                }
+                this.state = 19828;
+                this.concatenation(0);
+                this.state = 19829;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 20:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 19831;
+                this.match(PlSqlParser.VALIDATE_CONVERSION);
+                this.state = 19832;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19833;
+                this.concatenation(0);
+                this.state = 19834;
+                this.match(PlSqlParser.AS);
+                this.state = 19835;
+                this.type_spec();
+                this.state = 19842;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19836;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19837;
+                    this.quoted_string();
+                    this.state = 19840;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 19838;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 19839;
+                        this.quoted_string();
+                        }
+                    }
+
+                    }
+                }
+
+                this.state = 19844;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 21:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 19846;
+                this.match(PlSqlParser.XMLAGG);
+                this.state = 19847;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19848;
+                this.expression();
+                this.state = 19850;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1305) {
+                    {
+                    this.state = 19849;
+                    this.order_by_clause();
+                    }
+                }
+
+                this.state = 19852;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19857;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2807, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19853;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19854;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19859;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2807, this.context);
+                }
+                }
+                break;
+            case 22:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 19860;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2325 || _la === 2333)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19861;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19862;
+                this.xml_multiuse_expression_element();
+                this.state = 19867;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 19863;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19864;
+                    this.xml_multiuse_expression_element();
+                    }
+                    }
+                    this.state = 19869;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 19870;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19875;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2809, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19871;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19872;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19877;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2809, this.context);
+                }
+                }
+                break;
+            case 23:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 19878;
+                this.match(PlSqlParser.XMLELEMENT);
+                this.state = 19879;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19881;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2810, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19880;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 515 || _la === 1097)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19884;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2811, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19883;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 529 || _la === 998)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                this.state = 19886;
+                this.expression();
+                this.state = 19889;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2812, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19887;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19888;
+                    this.xml_attributes_clause();
+                    }
+                    break;
+                }
+                this.state = 19898;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 19891;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19892;
+                    this.expression();
+                    this.state = 19894;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                        {
+                        this.state = 19893;
+                        this.column_alias();
+                        }
+                    }
+
+                    }
+                    }
+                    this.state = 19900;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 19901;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19906;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2815, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19902;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19903;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19908;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2815, this.context);
+                }
+                }
+                break;
+            case 24:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 19909;
+                this.match(PlSqlParser.XMLEXISTS);
+                this.state = 19910;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19911;
+                this.expression();
+                this.state = 19913;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1354) {
+                    {
+                    this.state = 19912;
+                    this.xml_passing_clause();
+                    }
+                }
+
+                this.state = 19915;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 25:
+                this.enterOuterAlt(localContext, 25);
+                {
+                this.state = 19917;
+                this.match(PlSqlParser.XMLPARSE);
+                this.state = 19918;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19919;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 294 || _la === 455)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19920;
+                this.concatenation(0);
+                this.state = 19922;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2300) {
+                    {
+                    this.state = 19921;
+                    this.match(PlSqlParser.WELLFORMED);
+                    }
+                }
+
+                this.state = 19924;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19929;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2818, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19925;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19926;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19931;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2818, this.context);
+                }
+                }
+                break;
+            case 26:
+                this.enterOuterAlt(localContext, 26);
+                {
+                this.state = 19932;
+                this.match(PlSqlParser.XMLPI);
+                this.state = 19933;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19938;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NAME:
+                    {
+                    this.state = 19934;
+                    this.match(PlSqlParser.NAME);
+                    this.state = 19935;
+                    this.identifier();
+                    }
+                    break;
+                case PlSqlParser.EVALNAME:
+                    {
+                    this.state = 19936;
+                    this.match(PlSqlParser.EVALNAME);
+                    this.state = 19937;
+                    this.concatenation(0);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 19942;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19940;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19941;
+                    this.concatenation(0);
+                    }
+                }
+
+                this.state = 19944;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19949;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2821, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19945;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19946;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19951;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2821, this.context);
+                }
+                }
+                break;
+            case 27:
+                this.enterOuterAlt(localContext, 27);
+                {
+                this.state = 19952;
+                this.match(PlSqlParser.XMLQUERY);
+                this.state = 19953;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19954;
+                this.concatenation(0);
+                this.state = 19956;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1354) {
+                    {
+                    this.state = 19955;
+                    this.xml_passing_clause();
+                    }
+                }
+
+                this.state = 19958;
+                this.match(PlSqlParser.RETURNING);
+                this.state = 19959;
+                this.match(PlSqlParser.CONTENT);
+                this.state = 19963;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1230) {
+                    {
+                    this.state = 19960;
+                    this.match(PlSqlParser.NULL_);
+                    this.state = 19961;
+                    this.match(PlSqlParser.ON);
+                    this.state = 19962;
+                    this.match(PlSqlParser.EMPTY_);
+                    }
+                }
+
+                this.state = 19965;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19970;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2824, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19966;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19967;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19972;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2824, this.context);
+                }
+                }
+                break;
+            case 28:
+                this.enterOuterAlt(localContext, 28);
+                {
+                this.state = 19973;
+                this.match(PlSqlParser.XMLROOT);
+                this.state = 19974;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19975;
+                this.concatenation(0);
+                this.state = 19978;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2825, this.context) ) {
+                case 1:
+                    {
+                    this.state = 19976;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19977;
+                    this.xmlroot_param_version_part();
+                    }
+                    break;
+                }
+                this.state = 19982;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 19980;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 19981;
+                    this.xmlroot_param_standalone_part();
+                    }
+                }
+
+                this.state = 19984;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 19989;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2827, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 19985;
+                        this.match(PlSqlParser.PERIOD);
+                        this.state = 19986;
+                        this.general_element_part();
+                        }
+                        }
+                    }
+                    this.state = 19991;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2827, this.context);
+                }
+                }
+                break;
+            case 29:
+                this.enterOuterAlt(localContext, 29);
+                {
+                this.state = 19992;
+                this.match(PlSqlParser.XMLSERIALIZE);
+                this.state = 19993;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 19994;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 294 || _la === 455)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 19995;
+                this.concatenation(0);
+                this.state = 19998;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 19996;
+                    this.match(PlSqlParser.AS);
+                    this.state = 19997;
+                    this.type_spec();
+                    }
+                }
+
+                this.state = 20001;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 504) {
+                    {
+                    this.state = 20000;
+                    this.xmlserialize_param_enconding_part();
+                    }
+                }
+
+                this.state = 20004;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2287) {
+                    {
+                    this.state = 20003;
+                    this.xmlserialize_param_version_part();
+                    }
+                }
+
+                this.state = 20007;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 710 || _la === 1139) {
+                    {
+                    this.state = 20006;
+                    this.xmlserialize_param_ident_part();
+                    }
+                }
+
+                this.state = 20011;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 671 || _la === 1685) {
+                    {
+                    this.state = 20009;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 671 || _la === 1685)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    this.state = 20010;
+                    this.match(PlSqlParser.DEFAULTS);
+                    }
+                }
+
+                this.state = 20013;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 20016;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2833, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20014;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20015;
+                    this.general_element_part();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 30:
+                this.enterOuterAlt(localContext, 30);
+                {
+                this.state = 20018;
+                this.match(PlSqlParser.TIME);
+                this.state = 20019;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 31:
+                this.enterOuterAlt(localContext, 31);
+                {
+                this.state = 20020;
+                this.xmltable();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public over_clause_keyword(): Over_clause_keywordContext {
+        let localContext = new Over_clause_keywordContext(this.context, this.state);
+        this.enterRule(localContext, 2220, PlSqlParser.RULE_over_clause_keyword);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20023;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1228 || _la === 2267 || ((((_la - 2400)) & ~0x1F) === 0 && ((1 << (_la - 2400)) & 31644519) !== 0) || _la === 2437)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public within_or_over_clause_keyword(): Within_or_over_clause_keywordContext {
+        let localContext = new Within_or_over_clause_keywordContext(this.context, this.state);
+        this.enterRule(localContext, 2222, PlSqlParser.RULE_within_or_over_clause_keyword);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20025;
+            _la = this.tokenStream.LA(1);
+            if(!(((((_la - 2393)) & ~0x1F) === 0 && ((1 << (_la - 2393)) & 123) !== 0))) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public standard_prediction_function_keyword(): Standard_prediction_function_keywordContext {
+        let localContext = new Standard_prediction_function_keywordContext(this.context, this.state);
+        this.enterRule(localContext, 2224, PlSqlParser.RULE_standard_prediction_function_keyword);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20027;
+            _la = this.tokenStream.LA(1);
+            if(!(((((_la - 2367)) & ~0x1F) === 0 && ((1 << (_la - 2367)) & 63) !== 0))) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public over_clause(): Over_clauseContext {
+        let localContext = new Over_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2226, PlSqlParser.RULE_over_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20029;
+            this.match(PlSqlParser.OVER);
+            this.state = 20030;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20051;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ORDER:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.RIGHT_PAREN:
+                {
+                this.state = 20032;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1350) {
+                    {
+                    this.state = 20031;
+                    this.query_partition_clause();
+                    }
+                }
+
+                this.state = 20038;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1305) {
+                    {
+                    this.state = 20034;
+                    this.order_by_clause();
+                    this.state = 20036;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 1497 || _la === 1609) {
+                        {
+                        this.state = 20035;
+                        this.windowing_clause();
+                        }
+                    }
+
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.HIERARCHY:
+                {
+                this.state = 20040;
+                this.match(PlSqlParser.HIERARCHY);
+                this.state = 20041;
+                localContext._th = this.id_expression();
+                this.state = 20042;
+                this.match(PlSqlParser.OFFSET);
+                this.state = 20043;
+                this.numeric();
+                this.state = 20049;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 10) {
+                    {
+                    this.state = 20044;
+                    this.match(PlSqlParser.ACROSS);
+                    this.state = 20045;
+                    this.match(PlSqlParser.ANCESTOR);
+                    this.state = 20046;
+                    this.match(PlSqlParser.AT);
+                    this.state = 20047;
+                    this.match(PlSqlParser.LEVEL);
+                    this.state = 20048;
+                    this.id_expression();
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 20053;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public windowing_clause(): Windowing_clauseContext {
+        let localContext = new Windowing_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2228, PlSqlParser.RULE_windowing_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20055;
+            this.windowing_type();
+            this.state = 20062;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2840, this.context) ) {
+            case 1:
+                {
+                this.state = 20056;
+                this.match(PlSqlParser.BETWEEN);
+                this.state = 20057;
+                this.windowing_elements();
+                this.state = 20058;
+                this.match(PlSqlParser.AND);
+                this.state = 20059;
+                this.windowing_elements();
+                }
+                break;
+            case 2:
+                {
+                this.state = 20061;
+                this.windowing_elements();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public windowing_type(): Windowing_typeContext {
+        let localContext = new Windowing_typeContext(this.context, this.state);
+        this.enterRule(localContext, 2230, PlSqlParser.RULE_windowing_type);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20064;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1497 || _la === 1609)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public windowing_elements(): Windowing_elementsContext {
+        let localContext = new Windowing_elementsContext(this.context, this.state);
+        this.enterRule(localContext, 2232, PlSqlParser.RULE_windowing_elements);
+        let _la: number;
+        try {
+            this.state = 20073;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2841, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20066;
+                this.match(PlSqlParser.UNBOUNDED);
+                this.state = 20067;
+                this.match(PlSqlParser.PRECEDING);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20068;
+                this.match(PlSqlParser.CURRENT);
+                this.state = 20069;
+                this.match(PlSqlParser.ROW);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 20070;
+                this.concatenation(0);
+                this.state = 20071;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 614 || _la === 1438)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_clause(): Using_clauseContext {
+        let localContext = new Using_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2234, PlSqlParser.RULE_using_clause);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20075;
+            this.match(PlSqlParser.USING);
+            this.state = 20085;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2843, this.context) ) {
+            case 1:
+                {
+                this.state = 20076;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            case 2:
+                {
+                this.state = 20077;
+                this.using_element();
+                this.state = 20082;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2842, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 20078;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 20079;
+                        this.using_element();
+                        }
+                        }
+                    }
+                    this.state = 20084;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2842, this.context);
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public using_element(): Using_elementContext {
+        let localContext = new Using_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2236, PlSqlParser.RULE_using_element);
+        try {
+            this.state = 20095;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2844, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20087;
+                this.match(PlSqlParser.IN);
+                this.state = 20088;
+                this.expression();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20089;
+                this.match(PlSqlParser.IN);
+                this.state = 20090;
+                this.match(PlSqlParser.OUT);
+                this.state = 20091;
+                this.assignable_element();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 20092;
+                this.match(PlSqlParser.OUT);
+                this.state = 20093;
+                this.assignable_element();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 20094;
+                this.expression();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public assignable_element(): Assignable_elementContext {
+        let localContext = new Assignable_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2238, PlSqlParser.RULE_assignable_element);
+        try {
+            this.state = 20099;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.LEFT_PAREN:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20097;
+                this.general_element(0);
+                }
+                break;
+            case PlSqlParser.BINDVAR:
+            case PlSqlParser.COLON:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20098;
+                this.bind_variable();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public collect_order_by_part(): Collect_order_by_partContext {
+        let localContext = new Collect_order_by_partContext(this.context, this.state);
+        this.enterRule(localContext, 2240, PlSqlParser.RULE_collect_order_by_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20101;
+            this.match(PlSqlParser.ORDER);
+            this.state = 20102;
+            this.match(PlSqlParser.BY);
+            this.state = 20103;
+            this.concatenation(0);
+            this.state = 20108;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 20104;
+                this.match(PlSqlParser.COMMA);
+                this.state = 20105;
+                this.concatenation(0);
+                }
+                }
+                this.state = 20110;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public within_or_over_part(): Within_or_over_partContext {
+        let localContext = new Within_or_over_partContext(this.context, this.state);
+        this.enterRule(localContext, 2242, PlSqlParser.RULE_within_or_over_part);
+        try {
+            this.state = 20118;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.WITHIN:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20111;
+                this.match(PlSqlParser.WITHIN);
+                this.state = 20112;
+                this.match(PlSqlParser.GROUP);
+                this.state = 20113;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 20114;
+                this.order_by_clause();
+                this.state = 20115;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case PlSqlParser.OVER:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20117;
+                this.over_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public string_delimiter(): String_delimiterContext;
+    public string_delimiter(_p: number): String_delimiterContext;
+    public string_delimiter(_p?: number): String_delimiterContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new String_delimiterContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 2244;
+        this.enterRecursionRule(localContext, 2244, PlSqlParser.RULE_string_delimiter, _p);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20128;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2848, this.context) ) {
+            case 1:
+                {
+                this.state = 20121;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+                break;
+            case 2:
+                {
+                this.state = 20122;
+                this.string_function();
+                }
+                break;
+            case 3:
+                {
+                this.state = 20123;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 20124;
+                this.string_delimiter(0);
+                this.state = 20125;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            case 4:
+                {
+                this.state = 20127;
+                this.id_expression();
+                }
+                break;
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 20136;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2849, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    {
+                    localContext = new String_delimiterContext(parentContext, parentState);
+                    this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_string_delimiter);
+                    this.state = 20130;
+                    if (!(this.precpred(this.context, 3))) {
+                        throw this.createFailedPredicateException("this.precpred(this.context, 3)");
+                    }
+                    this.state = 20131;
+                    this.match(PlSqlParser.BAR);
+                    this.state = 20132;
+                    this.match(PlSqlParser.BAR);
+                    this.state = 20133;
+                    this.string_delimiter(4);
+                    }
+                    }
+                }
+                this.state = 20138;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2849, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+    public cost_matrix_clause(): Cost_matrix_clauseContext {
+        let localContext = new Cost_matrix_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2246, PlSqlParser.RULE_cost_matrix_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20139;
+            this.match(PlSqlParser.COST);
+            this.state = 20161;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.MODEL:
+                {
+                this.state = 20140;
+                this.match(PlSqlParser.MODEL);
+                this.state = 20142;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 91) {
+                    {
+                    this.state = 20141;
+                    this.match(PlSqlParser.AUTO);
+                    }
+                }
+
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 20144;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 20145;
+                this.cost_class_name();
+                this.state = 20150;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 20146;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20147;
+                    this.cost_class_name();
+                    }
+                    }
+                    this.state = 20152;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 20153;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                this.state = 20154;
+                this.match(PlSqlParser.VALUES);
+                this.state = 20155;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 20157;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2852, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20156;
+                    this.expressions_();
+                    }
+                    break;
+                }
+                this.state = 20159;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_passing_clause(): Xml_passing_clauseContext {
+        let localContext = new Xml_passing_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2248, PlSqlParser.RULE_xml_passing_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20163;
+            this.match(PlSqlParser.PASSING);
+            this.state = 20166;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2854, this.context) ) {
+            case 1:
+                {
+                this.state = 20164;
+                this.match(PlSqlParser.BY);
+                this.state = 20165;
+                this.match(PlSqlParser.VALUE);
+                }
+                break;
+            }
+            this.state = 20168;
+            this.expression();
+            this.state = 20170;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2855, this.context) ) {
+            case 1:
+                {
+                this.state = 20169;
+                this.column_alias();
+                }
+                break;
+            }
+            this.state = 20179;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 20172;
+                this.match(PlSqlParser.COMMA);
+                this.state = 20173;
+                this.expression();
+                this.state = 20175;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2856, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20174;
+                    this.column_alias();
+                    }
+                    break;
+                }
+                }
+                }
+                this.state = 20181;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_attributes_clause(): Xml_attributes_clauseContext {
+        let localContext = new Xml_attributes_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2250, PlSqlParser.RULE_xml_attributes_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20182;
+            this.match(PlSqlParser.XMLATTRIBUTES);
+            this.state = 20183;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20185;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2858, this.context) ) {
+            case 1:
+                {
+                this.state = 20184;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 515 || _la === 1097)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 20188;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2859, this.context) ) {
+            case 1:
+                {
+                this.state = 20187;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1184 || _la === 1626)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            }
+            this.state = 20190;
+            this.xml_multiuse_expression_element();
+            this.state = 20195;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 20191;
+                this.match(PlSqlParser.COMMA);
+                this.state = 20192;
+                this.xml_multiuse_expression_element();
+                }
+                }
+                this.state = 20197;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 20198;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_namespaces_clause(): Xml_namespaces_clauseContext {
+        let localContext = new Xml_namespaces_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2252, PlSqlParser.RULE_xml_namespaces_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20200;
+            this.match(PlSqlParser.XMLNAMESPACES);
+            this.state = 20201;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20205;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2861, this.context) ) {
+            case 1:
+                {
+                this.state = 20202;
+                this.concatenation(0);
+                this.state = 20203;
+                this.column_alias();
+                }
+                break;
+            }
+            this.state = 20213;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2455) {
+                {
+                {
+                this.state = 20207;
+                this.match(PlSqlParser.COMMA);
+                this.state = 20208;
+                this.concatenation(0);
+                this.state = 20209;
+                this.column_alias();
+                }
+                }
+                this.state = 20215;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 20217;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 389) {
+                {
+                this.state = 20216;
+                this.xml_general_default_part();
+                }
+            }
+
+            this.state = 20219;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_table_column(): Xml_table_columnContext {
+        let localContext = new Xml_table_columnContext(this.context, this.state);
+        this.enterRule(localContext, 2254, PlSqlParser.RULE_xml_table_column);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20221;
+            this.xml_column_name();
+            this.state = 20232;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.FOR:
+                {
+                this.state = 20222;
+                this.match(PlSqlParser.FOR);
+                this.state = 20223;
+                this.match(PlSqlParser.ORDINALITY);
+                }
+                break;
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NATURALN:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 20224;
+                this.type_spec();
+                this.state = 20227;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1365) {
+                    {
+                    this.state = 20225;
+                    this.match(PlSqlParser.PATH);
+                    this.state = 20226;
+                    this.concatenation(0);
+                    }
+                }
+
+                this.state = 20230;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 389) {
+                    {
+                    this.state = 20229;
+                    this.xml_general_default_part();
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_general_default_part(): Xml_general_default_partContext {
+        let localContext = new Xml_general_default_partContext(this.context, this.state);
+        this.enterRule(localContext, 2256, PlSqlParser.RULE_xml_general_default_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20234;
+            this.match(PlSqlParser.DEFAULT);
+            this.state = 20235;
+            this.concatenation(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_multiuse_expression_element(): Xml_multiuse_expression_elementContext {
+        let localContext = new Xml_multiuse_expression_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2258, PlSqlParser.RULE_xml_multiuse_expression_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20237;
+            this.expression();
+            this.state = 20245;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2868, this.context) ) {
+            case 1:
+                {
+                {
+                this.state = 20239;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 20238;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 20241;
+                this.id_expression();
+                }
+                }
+                break;
+            case 2:
+                {
+                {
+                this.state = 20242;
+                this.match(PlSqlParser.AS);
+                this.state = 20243;
+                this.match(PlSqlParser.EVALNAME);
+                this.state = 20244;
+                this.expression();
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlroot_param_version_part(): Xmlroot_param_version_partContext {
+        let localContext = new Xmlroot_param_version_partContext(this.context, this.state);
+        this.enterRule(localContext, 2260, PlSqlParser.RULE_xmlroot_param_version_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20247;
+            this.match(PlSqlParser.VERSION);
+            this.state = 20251;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2869, this.context) ) {
+            case 1:
+                {
+                this.state = 20248;
+                this.match(PlSqlParser.NO);
+                this.state = 20249;
+                this.match(PlSqlParser.VALUE);
+                }
+                break;
+            case 2:
+                {
+                this.state = 20250;
+                this.expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlroot_param_standalone_part(): Xmlroot_param_standalone_partContext {
+        let localContext = new Xmlroot_param_standalone_partContext(this.context, this.state);
+        this.enterRule(localContext, 2262, PlSqlParser.RULE_xmlroot_param_standalone_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20253;
+            this.match(PlSqlParser.STANDALONE);
+            this.state = 20259;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.YES:
+                {
+                this.state = 20254;
+                this.match(PlSqlParser.YES);
+                }
+                break;
+            case PlSqlParser.NO:
+                {
+                this.state = 20255;
+                this.match(PlSqlParser.NO);
+                this.state = 20257;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2260) {
+                    {
+                    this.state = 20256;
+                    this.match(PlSqlParser.VALUE);
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlserialize_param_enconding_part(): Xmlserialize_param_enconding_partContext {
+        let localContext = new Xmlserialize_param_enconding_partContext(this.context, this.state);
+        this.enterRule(localContext, 2264, PlSqlParser.RULE_xmlserialize_param_enconding_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20261;
+            this.match(PlSqlParser.ENCODING);
+            this.state = 20262;
+            this.concatenation(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlserialize_param_version_part(): Xmlserialize_param_version_partContext {
+        let localContext = new Xmlserialize_param_version_partContext(this.context, this.state);
+        this.enterRule(localContext, 2266, PlSqlParser.RULE_xmlserialize_param_version_part);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20264;
+            this.match(PlSqlParser.VERSION);
+            this.state = 20265;
+            this.concatenation(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmlserialize_param_ident_part(): Xmlserialize_param_ident_partContext {
+        let localContext = new Xmlserialize_param_ident_partContext(this.context, this.state);
+        this.enterRule(localContext, 2268, PlSqlParser.RULE_xmlserialize_param_ident_part);
+        let _la: number;
+        try {
+            this.state = 20275;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.NO:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20267;
+                this.match(PlSqlParser.NO);
+                this.state = 20268;
+                this.match(PlSqlParser.INDENT);
+                }
+                break;
+            case PlSqlParser.INDENT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20269;
+                this.match(PlSqlParser.INDENT);
+                this.state = 20273;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1701) {
+                    {
+                    this.state = 20270;
+                    this.match(PlSqlParser.SIZE);
+                    this.state = 20271;
+                    this.match(PlSqlParser.EQUALS_OP);
+                    this.state = 20272;
+                    this.concatenation(0);
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public annotations_clause(): Annotations_clauseContext {
+        let localContext = new Annotations_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2270, PlSqlParser.RULE_annotations_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20277;
+            this.match(PlSqlParser.ANNOTATIONS);
+            this.state = 20278;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20279;
+            this.annotations_list();
+            this.state = 20280;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public annotations_list(): Annotations_listContext {
+        let localContext = new Annotations_listContext(this.context, this.state);
+        this.enterRule(localContext, 2272, PlSqlParser.RULE_annotations_list);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20296;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2876, this.context) ) {
+            case 1:
+                {
+                this.state = 20282;
+                this.match(PlSqlParser.ADD);
+                this.state = 20288;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2874, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20283;
+                    this.match(PlSqlParser.IF);
+                    this.state = 20284;
+                    this.match(PlSqlParser.NOT);
+                    this.state = 20285;
+                    this.match(PlSqlParser.EXISTS);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 20286;
+                    this.match(PlSqlParser.OR);
+                    this.state = 20287;
+                    this.match(PlSqlParser.REPLACE);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 20290;
+                this.match(PlSqlParser.DROP);
+                this.state = 20293;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2875, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20291;
+                    this.match(PlSqlParser.IF);
+                    this.state = 20292;
+                    this.match(PlSqlParser.EXISTS);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 3:
+                {
+                this.state = 20295;
+                this.match(PlSqlParser.REPLACE);
+                }
+                break;
+            }
+            this.state = 20298;
+            this.annotation();
+            this.state = 20303;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2877, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20299;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20300;
+                    this.annotations_list();
+                    }
+                    }
+                }
+                this.state = 20305;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2877, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public annotation(): AnnotationContext {
+        let localContext = new AnnotationContext(this.context, this.state);
+        this.enterRule(localContext, 2274, PlSqlParser.RULE_annotation);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20306;
+            this.identifier();
+            this.state = 20308;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2445) {
+                {
+                this.state = 20307;
+                this.match(PlSqlParser.CHAR_STRING);
+                }
+            }
+
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_plus_command(): Sql_plus_commandContext {
+        let localContext = new Sql_plus_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2276, PlSqlParser.RULE_sql_plus_command);
+        let _la: number;
+        try {
+            this.state = 20320;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2879, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20310;
+                this.match(PlSqlParser.EXIT);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20311;
+                this.match(PlSqlParser.PROMPT_MESSAGE);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 20312;
+                this.match(PlSqlParser.SHOW);
+                this.state = 20313;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 518 || _la === 522)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 20314;
+                this.whenever_command();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 20315;
+                this.timing_command();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 20316;
+                this.start_command();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 20317;
+                this.set_command();
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 20318;
+                this.clear_command();
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 20319;
+                this.execute_command();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public execute_command(): Execute_commandContext {
+        let localContext = new Execute_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2278, PlSqlParser.RULE_execute_command);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20322;
+            if (!(this.isLineStart())) {
+                throw this.createFailedPredicateException("this.isLineStart()");
+            }
+            this.state = 20323;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 542 || _la === 543)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 20324;
+            this.statement();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public start_command(): Start_commandContext {
+        let localContext = new Start_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2280, PlSqlParser.RULE_start_command);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20331;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.START:
+                {
+                this.state = 20326;
+                this.match(PlSqlParser.START);
+                }
+                break;
+            case PlSqlParser.AT_SIGN:
+                {
+                this.state = 20327;
+                this.match(PlSqlParser.AT_SIGN);
+                this.state = 20329;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2458) {
+                    {
+                    this.state = 20328;
+                    this.match(PlSqlParser.AT_SIGN);
+                    }
+                }
+
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 20333;
+            this.sql_plus_filepath();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sql_plus_filepath(): Sql_plus_filepathContext {
+        let localContext = new Sql_plus_filepathContext(this.context, this.state);
+        this.enterRule(localContext, 2282, PlSqlParser.RULE_sql_plus_filepath);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20338;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2882, this.context) ) {
+            case 1:
+                {
+                this.state = 20335;
+                this.id_expression();
+                this.state = 20336;
+                this.match(PlSqlParser.COLON);
+                }
+                break;
+            }
+            this.state = 20341;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2456 || _la === 2457) {
+                {
+                this.state = 20340;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 2456 || _la === 2457)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 20348;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2884, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20343;
+                    this.id_expression();
+                    this.state = 20344;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 2456 || _la === 2457)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    }
+                }
+                this.state = 20350;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2884, this.context);
+            }
+            this.state = 20351;
+            this.id_expression();
+            this.state = 20352;
+            this.match(PlSqlParser.PERIOD);
+            this.state = 20353;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1724 || _la === 1725)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public whenever_command(): Whenever_commandContext {
+        let localContext = new Whenever_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2284, PlSqlParser.RULE_whenever_command);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20355;
+            this.match(PlSqlParser.WHENEVER);
+            this.state = 20356;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1311 || _la === 1722)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 20372;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.EXIT:
+                {
+                this.state = 20357;
+                this.match(PlSqlParser.EXIT);
+                this.state = 20363;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2885, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20358;
+                    this.match(PlSqlParser.SUCCESS);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 20359;
+                    this.match(PlSqlParser.FAILURE);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 20360;
+                    this.match(PlSqlParser.WARNING);
+                    }
+                    break;
+                case 4:
+                    {
+                    this.state = 20361;
+                    this.variable_name();
+                    }
+                    break;
+                case 5:
+                    {
+                    this.state = 20362;
+                    this.numeric();
+                    }
+                    break;
+                }
+                this.state = 20366;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2886, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20365;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 242 || _la === 1598)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.CONTINUE:
+                {
+                this.state = 20368;
+                this.match(PlSqlParser.CONTINUE);
+                this.state = 20370;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2887, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20369;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 242 || _la === 1134 || _la === 1598)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public set_command(): Set_commandContext {
+        let localContext = new Set_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2286, PlSqlParser.RULE_set_command);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20374;
+            this.match(PlSqlParser.SET);
+            this.state = 20390;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2891, this.context) ) {
+            case 1:
+                {
+                this.state = 20378;
+                this.errorHandler.sync(this);
+                alternative = 1;
+                do {
+                    switch (alternative) {
+                    case 1:
+                        {
+                        {
+                        this.state = 20375;
+                        this.regular_id();
+                        this.state = 20376;
+                        _la = this.tokenStream.LA(1);
+                        if(!(_la === 1246 || _la === 1261)) {
+                        this.errorHandler.recoverInline(this);
+                        }
+                        else {
+                            this.errorHandler.reportMatch(this);
+                            this.consume();
+                        }
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 20380;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2889, this.context);
+                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                }
+                break;
+            case 2:
+                {
+                {
+                this.state = 20382;
+                this.regular_id();
+                this.state = 20388;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2890, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20383;
+                    this.match(PlSqlParser.CHAR_STRING);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 20384;
+                    this.match(PlSqlParser.ON);
+                    }
+                    break;
+                case 3:
+                    {
+                    this.state = 20385;
+                    this.match(PlSqlParser.OFF);
+                    }
+                    break;
+                case 4:
+                    {
+                    this.state = 20386;
+                    this.numeric();
+                    }
+                    break;
+                case 5:
+                    {
+                    this.state = 20387;
+                    this.regular_id();
+                    }
+                    break;
+                }
+                }
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public timing_command(): Timing_commandContext {
+        let localContext = new Timing_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2288, PlSqlParser.RULE_timing_command);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20392;
+            this.match(PlSqlParser.TIMING);
+            this.state = 20402;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2893, this.context) ) {
+            case 1:
+                {
+                this.state = 20393;
+                this.match(PlSqlParser.START);
+                this.state = 20397;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2892, this.context);
+                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                    if (alternative === 1) {
+                        {
+                        {
+                        this.state = 20394;
+                        localContext._timing_text = this.id_expression();
+                        }
+                        }
+                    }
+                    this.state = 20399;
+                    this.errorHandler.sync(this);
+                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 2892, this.context);
+                }
+                }
+                break;
+            case 2:
+                {
+                this.state = 20400;
+                this.match(PlSqlParser.SHOW);
+                }
+                break;
+            case 3:
+                {
+                this.state = 20401;
+                this.match(PlSqlParser.STOP);
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public clear_command(): Clear_commandContext {
+        let localContext = new Clear_commandContext(this.context, this.state);
+        this.enterRule(localContext, 2290, PlSqlParser.RULE_clear_command);
+        try {
+            this.state = 20410;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.CLEAR:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20404;
+                this.match(PlSqlParser.CLEAR);
+                {
+                this.state = 20406;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2894, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20405;
+                    this.match(PlSqlParser.COLUMN);
+                    }
+                    break;
+                }
+                this.state = 20408;
+                this.regular_id();
+                }
+                }
+                break;
+            case PlSqlParser.ALL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20409;
+                this.match(PlSqlParser.ALL);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public partition_extension_clause(): Partition_extension_clauseContext {
+        let localContext = new Partition_extension_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2292, PlSqlParser.RULE_partition_extension_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20412;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 1350 || _la === 1777)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 20414;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 621) {
+                {
+                this.state = 20413;
+                this.match(PlSqlParser.FOR);
+                }
+            }
+
+            this.state = 20416;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20418;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2897, this.context) ) {
+            case 1:
+                {
+                this.state = 20417;
+                this.expressions_();
+                }
+                break;
+            }
+            this.state = 20420;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_alias(): Column_aliasContext {
+        let localContext = new Column_aliasContext(this.context, this.state);
+        this.enterRule(localContext, 2294, PlSqlParser.RULE_column_alias);
+        let _la: number;
+        try {
+            this.state = 20430;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2900, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20423;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 69) {
+                    {
+                    this.state = 20422;
+                    this.match(PlSqlParser.AS);
+                    }
+                }
+
+                this.state = 20427;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.INTRODUCER:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 20425;
+                    this.identifier();
+                    }
+                    break;
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 20426;
+                    this.quoted_string();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20429;
+                this.match(PlSqlParser.AS);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_alias(): Table_aliasContext {
+        let localContext = new Table_aliasContext(this.context, this.state);
+        this.enterRule(localContext, 2296, PlSqlParser.RULE_table_alias);
+        try {
+            this.state = 20434;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20432;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20433;
+                this.quoted_string();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public where_clause(): Where_clauseContext {
+        let localContext = new Where_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2298, PlSqlParser.RULE_where_clause);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20436;
+            this.match(PlSqlParser.WHERE);
+            this.state = 20441;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2902, this.context) ) {
+            case 1:
+                {
+                this.state = 20437;
+                this.match(PlSqlParser.CURRENT);
+                this.state = 20438;
+                this.match(PlSqlParser.OF);
+                this.state = 20439;
+                this.cursor_name();
+                }
+                break;
+            case 2:
+                {
+                this.state = 20440;
+                this.condition();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public into_clause(): Into_clauseContext {
+        let localContext = new Into_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2300, PlSqlParser.RULE_into_clause);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20445;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 159) {
+                {
+                this.state = 20443;
+                this.match(PlSqlParser.BULK);
+                this.state = 20444;
+                this.match(PlSqlParser.COLLECT);
+                }
+            }
+
+            this.state = 20447;
+            this.match(PlSqlParser.INTO);
+            this.state = 20450;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.LEFT_PAREN:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 20448;
+                this.general_element(0);
+                }
+                break;
+            case PlSqlParser.BINDVAR:
+            case PlSqlParser.COLON:
+                {
+                this.state = 20449;
+                this.bind_variable();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 20459;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2906, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20452;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20455;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.ABORT:
+                    case PlSqlParser.ABS:
+                    case PlSqlParser.ABSENT:
+                    case PlSqlParser.ACCESS:
+                    case PlSqlParser.ACCESSED:
+                    case PlSqlParser.ACCESSIBLE:
+                    case PlSqlParser.ACCOUNT:
+                    case PlSqlParser.ACL:
+                    case PlSqlParser.ACOS:
+                    case PlSqlParser.ACROSS:
+                    case PlSqlParser.ACTION:
+                    case PlSqlParser.ACTIONS:
+                    case PlSqlParser.ACTIVATE:
+                    case PlSqlParser.ACTIVE:
+                    case PlSqlParser.ACTIVE_COMPONENT:
+                    case PlSqlParser.ACTIVE_DATA:
+                    case PlSqlParser.ACTIVE_FUNCTION:
+                    case PlSqlParser.ACTIVE_TAG:
+                    case PlSqlParser.ACTIVITY:
+                    case PlSqlParser.ADAPTIVE_PLAN:
+                    case PlSqlParser.ADD:
+                    case PlSqlParser.ADD_COLUMN:
+                    case PlSqlParser.ADD_GROUP:
+                    case PlSqlParser.ADD_MONTHS:
+                    case PlSqlParser.ADJ_DATE:
+                    case PlSqlParser.ADMIN:
+                    case PlSqlParser.ADMINISTER:
+                    case PlSqlParser.ADMINISTRATOR:
+                    case PlSqlParser.ADVANCED:
+                    case PlSqlParser.ADVISE:
+                    case PlSqlParser.ADVISOR:
+                    case PlSqlParser.AFD_DISKSTRING:
+                    case PlSqlParser.AFTER:
+                    case PlSqlParser.AGENT:
+                    case PlSqlParser.AGGREGATE:
+                    case PlSqlParser.A_LETTER:
+                    case PlSqlParser.ALIAS:
+                    case PlSqlParser.ALLOCATE:
+                    case PlSqlParser.ALLOW:
+                    case PlSqlParser.ALL_ROWS:
+                    case PlSqlParser.ALTERNATE:
+                    case PlSqlParser.ALWAYS:
+                    case PlSqlParser.ANALYTIC:
+                    case PlSqlParser.ANALYZE:
+                    case PlSqlParser.ANCESTOR:
+                    case PlSqlParser.ANCILLARY:
+                    case PlSqlParser.AND_EQUAL:
+                    case PlSqlParser.ANOMALY:
+                    case PlSqlParser.ANSI_REARCH:
+                    case PlSqlParser.ANTIJOIN:
+                    case PlSqlParser.ANYSCHEMA:
+                    case PlSqlParser.APPEND:
+                    case PlSqlParser.APPENDCHILDXML:
+                    case PlSqlParser.APPEND_VALUES:
+                    case PlSqlParser.APPLICATION:
+                    case PlSqlParser.APPLY:
+                    case PlSqlParser.APPROX_COUNT_DISTINCT:
+                    case PlSqlParser.ARCHIVAL:
+                    case PlSqlParser.ARCHIVE:
+                    case PlSqlParser.ARCHIVED:
+                    case PlSqlParser.ARCHIVELOG:
+                    case PlSqlParser.ARRAY:
+                    case PlSqlParser.ASCII:
+                    case PlSqlParser.ASCIISTR:
+                    case PlSqlParser.ASIN:
+                    case PlSqlParser.ASIS:
+                    case PlSqlParser.ASSEMBLY:
+                    case PlSqlParser.ASSIGN:
+                    case PlSqlParser.ASSOCIATE:
+                    case PlSqlParser.ASYNC:
+                    case PlSqlParser.ASYNCHRONOUS:
+                    case PlSqlParser.ATAN2:
+                    case PlSqlParser.ATAN:
+                    case PlSqlParser.AT:
+                    case PlSqlParser.ATTRIBUTE:
+                    case PlSqlParser.ATTRIBUTES:
+                    case PlSqlParser.AUDIT:
+                    case PlSqlParser.AUTHENTICATED:
+                    case PlSqlParser.AUTHENTICATION:
+                    case PlSqlParser.AUTHID:
+                    case PlSqlParser.AUTHORIZATION:
+                    case PlSqlParser.AUTOALLOCATE:
+                    case PlSqlParser.AUTO:
+                    case PlSqlParser.AUTOEXTEND:
+                    case PlSqlParser.AUTO_LOGIN:
+                    case PlSqlParser.AUTOMATIC:
+                    case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                    case PlSqlParser.AUTO_REOPTIMIZE:
+                    case PlSqlParser.AVAILABILITY:
+                    case PlSqlParser.AVRO:
+                    case PlSqlParser.BACKGROUND:
+                    case PlSqlParser.BACKINGFILE:
+                    case PlSqlParser.BACKUP:
+                    case PlSqlParser.BACKUPS:
+                    case PlSqlParser.BASIC:
+                    case PlSqlParser.BASICFILE:
+                    case PlSqlParser.BATCH:
+                    case PlSqlParser.BATCHSIZE:
+                    case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.BECOME:
+                    case PlSqlParser.BEFORE:
+                    case PlSqlParser.BEGIN:
+                    case PlSqlParser.BEGINNING:
+                    case PlSqlParser.BEGIN_OUTLINE_DATA:
+                    case PlSqlParser.BEHALF:
+                    case PlSqlParser.BEQUEATH:
+                    case PlSqlParser.BFILE:
+                    case PlSqlParser.BFILENAME:
+                    case PlSqlParser.BIGFILE:
+                    case PlSqlParser.BINARY:
+                    case PlSqlParser.BINARY_DOUBLE:
+                    case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                    case PlSqlParser.BINARY_DOUBLE_NAN:
+                    case PlSqlParser.BINARY_FLOAT:
+                    case PlSqlParser.BINARY_FLOAT_INFINITY:
+                    case PlSqlParser.BINARY_FLOAT_NAN:
+                    case PlSqlParser.BINARY_INTEGER:
+                    case PlSqlParser.BIND_AWARE:
+                    case PlSqlParser.BINDING:
+                    case PlSqlParser.BIN_TO_NUM:
+                    case PlSqlParser.BITAND:
+                    case PlSqlParser.BITMAP_AND:
+                    case PlSqlParser.BITMAP:
+                    case PlSqlParser.BITMAPS:
+                    case PlSqlParser.BITMAP_TREE:
+                    case PlSqlParser.BITS:
+                    case PlSqlParser.BLOB:
+                    case PlSqlParser.BLOCK:
+                    case PlSqlParser.BLOCK_RANGE:
+                    case PlSqlParser.BLOCKS:
+                    case PlSqlParser.BLOCKSIZE:
+                    case PlSqlParser.BODY:
+                    case PlSqlParser.BOOLEAN:
+                    case PlSqlParser.BOTH:
+                    case PlSqlParser.BOUND:
+                    case PlSqlParser.BRANCH:
+                    case PlSqlParser.BREADTH:
+                    case PlSqlParser.BROADCAST:
+                    case PlSqlParser.BSON:
+                    case PlSqlParser.BUFFER:
+                    case PlSqlParser.BUFFER_CACHE:
+                    case PlSqlParser.BUFFER_POOL:
+                    case PlSqlParser.BUILD:
+                    case PlSqlParser.BULK:
+                    case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                    case PlSqlParser.BYPASS_UJVC:
+                    case PlSqlParser.BYTE:
+                    case PlSqlParser.BYTES:
+                    case PlSqlParser.CACHE:
+                    case PlSqlParser.CACHE_CB:
+                    case PlSqlParser.CACHE_INSTANCES:
+                    case PlSqlParser.CACHE_TEMP_TABLE:
+                    case PlSqlParser.CACHING:
+                    case PlSqlParser.CALCULATED:
+                    case PlSqlParser.CALLBACK:
+                    case PlSqlParser.CALL:
+                    case PlSqlParser.CANCEL:
+                    case PlSqlParser.CAPACITY:
+                    case PlSqlParser.CAPTION:
+                    case PlSqlParser.CARDINALITY:
+                    case PlSqlParser.CASCADE:
+                    case PlSqlParser.CASE:
+                    case PlSqlParser.CAST:
+                    case PlSqlParser.CASESENSITIVE:
+                    case PlSqlParser.CATEGORY:
+                    case PlSqlParser.CDBDEFAULT:
+                    case PlSqlParser.CEIL:
+                    case PlSqlParser.CELL_FLASH_CACHE:
+                    case PlSqlParser.CERTIFICATE:
+                    case PlSqlParser.CFILE:
+                    case PlSqlParser.CHAINED:
+                    case PlSqlParser.CHANGE:
+                    case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                    case PlSqlParser.CHARACTER:
+                    case PlSqlParser.CHARACTERSET:
+                    case PlSqlParser.CHAR:
+                    case PlSqlParser.CHAR_CS:
+                    case PlSqlParser.CHARTOROWID:
+                    case PlSqlParser.CHECK_ACL_REWRITE:
+                    case PlSqlParser.CHECKPOINT:
+                    case PlSqlParser.CHILD:
+                    case PlSqlParser.CHOOSE:
+                    case PlSqlParser.CHR:
+                    case PlSqlParser.CHUNK:
+                    case PlSqlParser.CLASS:
+                    case PlSqlParser.CLASSIFICATION:
+                    case PlSqlParser.CLASSIFIER:
+                    case PlSqlParser.CLAUSE:
+                    case PlSqlParser.CLEAN:
+                    case PlSqlParser.CLEANUP:
+                    case PlSqlParser.CLEAR:
+                    case PlSqlParser.C_LETTER:
+                    case PlSqlParser.CLIENT:
+                    case PlSqlParser.CLOB:
+                    case PlSqlParser.CLONE:
+                    case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                    case PlSqlParser.CLOSE:
+                    case PlSqlParser.CLUSTER_BY_ROWID:
+                    case PlSqlParser.CLUSTER:
+                    case PlSqlParser.CLUSTER_DETAILS:
+                    case PlSqlParser.CLUSTER_DISTANCE:
+                    case PlSqlParser.CLUSTER_ID:
+                    case PlSqlParser.CLUSTERING:
+                    case PlSqlParser.CLUSTERING_FACTOR:
+                    case PlSqlParser.CLUSTER_PROBABILITY:
+                    case PlSqlParser.CLUSTER_SET:
+                    case PlSqlParser.COALESCE:
+                    case PlSqlParser.COALESCE_SQ:
+                    case PlSqlParser.COARSE:
+                    case PlSqlParser.CO_AUTH_IND:
+                    case PlSqlParser.COLD:
+                    case PlSqlParser.COLLECT:
+                    case PlSqlParser.COLUMNAR:
+                    case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                    case PlSqlParser.COLUMN:
+                    case PlSqlParser.COLUMNS:
+                    case PlSqlParser.COLUMN_STATS:
+                    case PlSqlParser.COLUMN_VALUE:
+                    case PlSqlParser.COMMENT:
+                    case PlSqlParser.COMMIT:
+                    case PlSqlParser.COMMITTED:
+                    case PlSqlParser.COMMON:
+                    case PlSqlParser.COMMON_DATA:
+                    case PlSqlParser.COMPACT:
+                    case PlSqlParser.COMPATIBILITY:
+                    case PlSqlParser.COMPILE:
+                    case PlSqlParser.COMPLETE:
+                    case PlSqlParser.COMPLIANCE:
+                    case PlSqlParser.COMPONENT:
+                    case PlSqlParser.COMPONENTS:
+                    case PlSqlParser.COMPOSE:
+                    case PlSqlParser.COMPOSITE:
+                    case PlSqlParser.COMPOSITE_LIMIT:
+                    case PlSqlParser.COMPOUND:
+                    case PlSqlParser.COMPUTE:
+                    case PlSqlParser.CONCAT:
+                    case PlSqlParser.CON_DBID_TO_ID:
+                    case PlSqlParser.CONDITIONAL:
+                    case PlSqlParser.CONDITION:
+                    case PlSqlParser.CONFIRM:
+                    case PlSqlParser.CONFORMING:
+                    case PlSqlParser.CON_GUID_TO_ID:
+                    case PlSqlParser.CON_ID:
+                    case PlSqlParser.CON_NAME_TO_ID:
+                    case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.CONNECT_BY_COST_BASED:
+                    case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.CONNECT_BY_FILTERING:
+                    case PlSqlParser.CONNECT_BY_ISCYCLE:
+                    case PlSqlParser.CONNECT_BY_ISLEAF:
+                    case PlSqlParser.CONNECT_BY_ROOT:
+                    case PlSqlParser.CONNECT_TIME:
+                    case PlSqlParser.CONSIDER:
+                    case PlSqlParser.CONSISTENT:
+                    case PlSqlParser.CONSTANT:
+                    case PlSqlParser.CONST:
+                    case PlSqlParser.CONSTRAINT:
+                    case PlSqlParser.CONSTRAINTS:
+                    case PlSqlParser.CONSTRUCTOR:
+                    case PlSqlParser.CONTAINER:
+                    case PlSqlParser.CONTAINERS:
+                    case PlSqlParser.CONTAINERS_DEFAULT:
+                    case PlSqlParser.CONTAINER_DATA:
+                    case PlSqlParser.CONTAINER_MAP:
+                    case PlSqlParser.CONTENT:
+                    case PlSqlParser.CONTENTS:
+                    case PlSqlParser.CONTEXT:
+                    case PlSqlParser.CONTINUE:
+                    case PlSqlParser.CONTROLFILE:
+                    case PlSqlParser.CON_UID_TO_ID:
+                    case PlSqlParser.CONVERT:
+                    case PlSqlParser.CONVERSION:
+                    case PlSqlParser.COOKIE:
+                    case PlSqlParser.COPY:
+                    case PlSqlParser.CORR_K:
+                    case PlSqlParser.CORR_S:
+                    case PlSqlParser.CORRUPTION:
+                    case PlSqlParser.CORRUPT_XID_ALL:
+                    case PlSqlParser.CORRUPT_XID:
+                    case PlSqlParser.COS:
+                    case PlSqlParser.COSH:
+                    case PlSqlParser.COST:
+                    case PlSqlParser.COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.COUNT:
+                    case PlSqlParser.COUNTED:
+                    case PlSqlParser.COVAR_POP:
+                    case PlSqlParser.COVAR_SAMP:
+                    case PlSqlParser.CPU_COSTING:
+                    case PlSqlParser.CPU_PER_CALL:
+                    case PlSqlParser.CPU_PER_SESSION:
+                    case PlSqlParser.CRASH:
+                    case PlSqlParser.CREATE_FILE_DEST:
+                    case PlSqlParser.CREATE_STORED_OUTLINES:
+                    case PlSqlParser.CREATION:
+                    case PlSqlParser.CREDENTIAL:
+                    case PlSqlParser.CRITICAL:
+                    case PlSqlParser.CROSS:
+                    case PlSqlParser.CROSSEDITION:
+                    case PlSqlParser.CSCONVERT:
+                    case PlSqlParser.CSV:
+                    case PlSqlParser.CUBE_AJ:
+                    case PlSqlParser.CUBE:
+                    case PlSqlParser.CUBE_GB:
+                    case PlSqlParser.CUBE_SJ:
+                    case PlSqlParser.CUME_DISTM:
+                    case PlSqlParser.CURRENT:
+                    case PlSqlParser.CURRENT_DATE:
+                    case PlSqlParser.CURRENT_SCHEMA:
+                    case PlSqlParser.CURRENT_TIME:
+                    case PlSqlParser.CURRENT_TIMESTAMP:
+                    case PlSqlParser.CURRENT_USER:
+                    case PlSqlParser.CURRENTV:
+                    case PlSqlParser.CURSOR:
+                    case PlSqlParser.CURSOR_SHARING_EXACT:
+                    case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                    case PlSqlParser.CUSTOMDATUM:
+                    case PlSqlParser.CV:
+                    case PlSqlParser.CYCLE:
+                    case PlSqlParser.DANGLING:
+                    case PlSqlParser.DATABASE:
+                    case PlSqlParser.DATA:
+                    case PlSqlParser.DATAFILE:
+                    case PlSqlParser.DATAFILES:
+                    case PlSqlParser.DATAMOVEMENT:
+                    case PlSqlParser.DATAOBJNO:
+                    case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                    case PlSqlParser.DATAOBJ_TO_PARTITION:
+                    case PlSqlParser.DATAPUMP:
+                    case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                    case PlSqlParser.DATE:
+                    case PlSqlParser.DATE_FORMAT:
+                    case PlSqlParser.DATE_MODE:
+                    case PlSqlParser.DAY:
+                    case PlSqlParser.DAYS:
+                    case PlSqlParser.DBA:
+                    case PlSqlParser.DBA_RECYCLEBIN:
+                    case PlSqlParser.DBLINK:
+                    case PlSqlParser.DBMS_STATS:
+                    case PlSqlParser.DB_ROLE_CHANGE:
+                    case PlSqlParser.DBTIMEZONE:
+                    case PlSqlParser.DB_UNIQUE_NAME:
+                    case PlSqlParser.DB_VERSION:
+                    case PlSqlParser.DDL:
+                    case PlSqlParser.DEALLOCATE:
+                    case PlSqlParser.DEBUG:
+                    case PlSqlParser.DEBUGGER:
+                    case PlSqlParser.DEC:
+                    case PlSqlParser.DECIMAL:
+                    case PlSqlParser.DECLARE:
+                    case PlSqlParser.DECOMPOSE:
+                    case PlSqlParser.DECORRELATE:
+                    case PlSqlParser.DECR:
+                    case PlSqlParser.DECREMENT:
+                    case PlSqlParser.DECRYPT:
+                    case PlSqlParser.DEDUPLICATE:
+                    case PlSqlParser.DEFAULTS:
+                    case PlSqlParser.DEFAULT_COLLATION:
+                    case PlSqlParser.DEFAULT_CREDENTIAL:
+                    case PlSqlParser.DEFERRABLE:
+                    case PlSqlParser.DEFERRED:
+                    case PlSqlParser.DEFINED:
+                    case PlSqlParser.DEFINE:
+                    case PlSqlParser.DEFINER:
+                    case PlSqlParser.DEGREE:
+                    case PlSqlParser.DELAY:
+                    case PlSqlParser.DELEGATE:
+                    case PlSqlParser.DELETE_ALL:
+                    case PlSqlParser.DELETE:
+                    case PlSqlParser.DELETEXML:
+                    case PlSqlParser.DEMAND:
+                    case PlSqlParser.DENSE_RANKM:
+                    case PlSqlParser.DEPENDENT:
+                    case PlSqlParser.DEPRECATE:
+                    case PlSqlParser.DEPTH:
+                    case PlSqlParser.DEQUEUE:
+                    case PlSqlParser.DEREF:
+                    case PlSqlParser.DEREF_NO_REWRITE:
+                    case PlSqlParser.DESCRIPTION:
+                    case PlSqlParser.DESTROY:
+                    case PlSqlParser.DETACHED:
+                    case PlSqlParser.DETECTED:
+                    case PlSqlParser.DETERMINES:
+                    case PlSqlParser.DETERMINISTIC:
+                    case PlSqlParser.DICTIONARY:
+                    case PlSqlParser.DIMENSION:
+                    case PlSqlParser.DIMENSIONS:
+                    case PlSqlParser.DIRECT_LOAD:
+                    case PlSqlParser.DIRECTORY:
+                    case PlSqlParser.DIRECT_PATH:
+                    case PlSqlParser.DISABLE_ALL:
+                    case PlSqlParser.DISABLE:
+                    case PlSqlParser.DISABLED:
+                    case PlSqlParser.DISABLE_PARALLEL_DML:
+                    case PlSqlParser.DISABLE_PRESET:
+                    case PlSqlParser.DISABLE_RPKE:
+                    case PlSqlParser.DISALLOW:
+                    case PlSqlParser.DISASSOCIATE:
+                    case PlSqlParser.DISCARD:
+                    case PlSqlParser.DISCONNECT:
+                    case PlSqlParser.DISK:
+                    case PlSqlParser.DISKGROUP:
+                    case PlSqlParser.DISKS:
+                    case PlSqlParser.DISMOUNT:
+                    case PlSqlParser.DISTINGUISHED:
+                    case PlSqlParser.DISTRIBUTED:
+                    case PlSqlParser.DISTRIBUTE:
+                    case PlSqlParser.DML:
+                    case PlSqlParser.DML_UPDATE:
+                    case PlSqlParser.DOCFIDELITY:
+                    case PlSqlParser.DOCUMENT:
+                    case PlSqlParser.DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                    case PlSqlParser.DOMAIN_INDEX_SORT:
+                    case PlSqlParser.DOUBLE:
+                    case PlSqlParser.DOWNGRADE:
+                    case PlSqlParser.DRIVING_SITE:
+                    case PlSqlParser.DROP_COLUMN:
+                    case PlSqlParser.DROP_GROUP:
+                    case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.DUMP:
+                    case PlSqlParser.DUPLICATE:
+                    case PlSqlParser.DV:
+                    case PlSqlParser.DYNAMIC:
+                    case PlSqlParser.DYNAMIC_SAMPLING:
+                    case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                    case PlSqlParser.E_LETTER:
+                    case PlSqlParser.EACH:
+                    case PlSqlParser.EDITIONABLE:
+                    case PlSqlParser.EDITION:
+                    case PlSqlParser.EDITIONING:
+                    case PlSqlParser.EDITIONS:
+                    case PlSqlParser.ELEMENT:
+                    case PlSqlParser.ELIM_GROUPBY:
+                    case PlSqlParser.ELIMINATE_JOIN:
+                    case PlSqlParser.ELIMINATE_OBY:
+                    case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.EM:
+                    case PlSqlParser.EMPTY_BLOB:
+                    case PlSqlParser.EMPTY_CLOB:
+                    case PlSqlParser.EMPTY_:
+                    case PlSqlParser.ENABLE_ALL:
+                    case PlSqlParser.ENABLE:
+                    case PlSqlParser.ENABLED:
+                    case PlSqlParser.ENABLE_PARALLEL_DML:
+                    case PlSqlParser.ENABLE_PRESET:
+                    case PlSqlParser.ENCLOSED:
+                    case PlSqlParser.ENCODING:
+                    case PlSqlParser.ENCRYPT:
+                    case PlSqlParser.ENCRYPTION:
+                    case PlSqlParser.END_OUTLINE_DATA:
+                    case PlSqlParser.ENFORCED:
+                    case PlSqlParser.ENFORCE:
+                    case PlSqlParser.ENQUEUE:
+                    case PlSqlParser.ENTERPRISE:
+                    case PlSqlParser.ENTITYESCAPING:
+                    case PlSqlParser.ENTRY:
+                    case PlSqlParser.EQUIPART:
+                    case PlSqlParser.ERR:
+                    case PlSqlParser.ERROR_ARGUMENT:
+                    case PlSqlParser.ERROR:
+                    case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                    case PlSqlParser.ERRORS:
+                    case PlSqlParser.ERROR_INDEX:
+                    case PlSqlParser.ERROR_CODE:
+                    case PlSqlParser.ESCAPE:
+                    case PlSqlParser.ESTIMATE:
+                    case PlSqlParser.EVAL:
+                    case PlSqlParser.EVALNAME:
+                    case PlSqlParser.EVALUATE:
+                    case PlSqlParser.EVALUATION:
+                    case PlSqlParser.EVENTS:
+                    case PlSqlParser.EVERY:
+                    case PlSqlParser.EXCEPT:
+                    case PlSqlParser.EXCEPTION:
+                    case PlSqlParser.EXCEPTION_INIT:
+                    case PlSqlParser.EXCEPTIONS:
+                    case PlSqlParser.EXCHANGE:
+                    case PlSqlParser.EXCLUDE:
+                    case PlSqlParser.EXCLUDING:
+                    case PlSqlParser.EXEC:
+                    case PlSqlParser.EXECUTE:
+                    case PlSqlParser.EXEMPT:
+                    case PlSqlParser.EXISTING:
+                    case PlSqlParser.EXISTS:
+                    case PlSqlParser.EXISTSNODE:
+                    case PlSqlParser.EXIT:
+                    case PlSqlParser.EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.EXPAND_TABLE:
+                    case PlSqlParser.EXP:
+                    case PlSqlParser.EXPIRE:
+                    case PlSqlParser.EXPLAIN:
+                    case PlSqlParser.EXPLOSION:
+                    case PlSqlParser.EXPORT:
+                    case PlSqlParser.EXPR_CORR_CHECK:
+                    case PlSqlParser.EXPRESS:
+                    case PlSqlParser.EXTENDS:
+                    case PlSqlParser.EXTENT:
+                    case PlSqlParser.EXTENTS:
+                    case PlSqlParser.EXTERNAL:
+                    case PlSqlParser.EXTERNALLY:
+                    case PlSqlParser.EXTRACTCLOBXML:
+                    case PlSqlParser.EXTRACT:
+                    case PlSqlParser.EXTRACTVALUE:
+                    case PlSqlParser.EXTRA:
+                    case PlSqlParser.FACILITY:
+                    case PlSqlParser.FACT:
+                    case PlSqlParser.FACTOR:
+                    case PlSqlParser.FACTORIZE_JOIN:
+                    case PlSqlParser.FAILED:
+                    case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                    case PlSqlParser.FAILGROUP:
+                    case PlSqlParser.FAILOVER:
+                    case PlSqlParser.FAILURE:
+                    case PlSqlParser.FALSE:
+                    case PlSqlParser.FAMILY:
+                    case PlSqlParser.FAR:
+                    case PlSqlParser.FAST:
+                    case PlSqlParser.FASTSTART:
+                    case PlSqlParser.FBTSCAN:
+                    case PlSqlParser.FEATURE:
+                    case PlSqlParser.FEATURE_DETAILS:
+                    case PlSqlParser.FEATURE_ID:
+                    case PlSqlParser.FEATURE_SET:
+                    case PlSqlParser.FEATURE_VALUE:
+                    case PlSqlParser.FETCH:
+                    case PlSqlParser.FIELD:
+                    case PlSqlParser.FIELDS:
+                    case PlSqlParser.FILE:
+                    case PlSqlParser.FILE_NAME_CONVERT:
+                    case PlSqlParser.FILEGROUP:
+                    case PlSqlParser.FILESTORE:
+                    case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                    case PlSqlParser.FILTER:
+                    case PlSqlParser.FINAL:
+                    case PlSqlParser.FINE:
+                    case PlSqlParser.FINISH:
+                    case PlSqlParser.FIRST:
+                    case PlSqlParser.FIRSTM:
+                    case PlSqlParser.FIRST_ROWS:
+                    case PlSqlParser.FIRST_VALUE:
+                    case PlSqlParser.FIXED_VIEW_DATA:
+                    case PlSqlParser.FLAGGER:
+                    case PlSqlParser.FLASHBACK:
+                    case PlSqlParser.FLASH_CACHE:
+                    case PlSqlParser.FLOAT:
+                    case PlSqlParser.FLOB:
+                    case PlSqlParser.FLEX:
+                    case PlSqlParser.FLOOR:
+                    case PlSqlParser.FLUSH:
+                    case PlSqlParser.FOLDER:
+                    case PlSqlParser.FOLLOWING:
+                    case PlSqlParser.FOLLOWS:
+                    case PlSqlParser.FORALL:
+                    case PlSqlParser.FORCE:
+                    case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                    case PlSqlParser.FOREIGN:
+                    case PlSqlParser.FOREVER:
+                    case PlSqlParser.FORMAT:
+                    case PlSqlParser.FORWARD:
+                    case PlSqlParser.FRAGMENT_NUMBER:
+                    case PlSqlParser.FREELIST:
+                    case PlSqlParser.FREELISTS:
+                    case PlSqlParser.FREEPOOLS:
+                    case PlSqlParser.FRESH:
+                    case PlSqlParser.FROM_TZ:
+                    case PlSqlParser.FULL:
+                    case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.FUNCTION:
+                    case PlSqlParser.FUNCTIONS:
+                    case PlSqlParser.FTP:
+                    case PlSqlParser.G_LETTER:
+                    case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.GATHER_PLAN_STATISTICS:
+                    case PlSqlParser.GBY_CONC_ROLLUP:
+                    case PlSqlParser.GBY_PUSHDOWN:
+                    case PlSqlParser.GENERATED:
+                    case PlSqlParser.GET:
+                    case PlSqlParser.GLOBAL:
+                    case PlSqlParser.GLOBALLY:
+                    case PlSqlParser.GLOBAL_NAME:
+                    case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                    case PlSqlParser.GROUP_BY:
+                    case PlSqlParser.GROUP_ID:
+                    case PlSqlParser.GROUPING:
+                    case PlSqlParser.GROUPING_ID:
+                    case PlSqlParser.GROUPS:
+                    case PlSqlParser.GUARANTEED:
+                    case PlSqlParser.GUARANTEE:
+                    case PlSqlParser.GUARD:
+                    case PlSqlParser.HALF_YEARS:
+                    case PlSqlParser.HASH_AJ:
+                    case PlSqlParser.HASH:
+                    case PlSqlParser.HASHKEYS:
+                    case PlSqlParser.HASH_SJ:
+                    case PlSqlParser.HEADER:
+                    case PlSqlParser.HEAP:
+                    case PlSqlParser.HELP:
+                    case PlSqlParser.HEXTORAW:
+                    case PlSqlParser.HEXTOREF:
+                    case PlSqlParser.HIDDEN_KEYWORD:
+                    case PlSqlParser.HIDE:
+                    case PlSqlParser.HIER_ORDER:
+                    case PlSqlParser.HIERARCHICAL:
+                    case PlSqlParser.HIERARCHY:
+                    case PlSqlParser.HIGH:
+                    case PlSqlParser.HINTSET_BEGIN:
+                    case PlSqlParser.HINTSET_END:
+                    case PlSqlParser.HOT:
+                    case PlSqlParser.HOUR:
+                    case PlSqlParser.HOURS:
+                    case PlSqlParser.HTTP:
+                    case PlSqlParser.HWM_BROKERED:
+                    case PlSqlParser.HYBRID:
+                    case PlSqlParser.H_LETTER:
+                    case PlSqlParser.IDENTIFIER:
+                    case PlSqlParser.IDENTITY:
+                    case PlSqlParser.IDGENERATORS:
+                    case PlSqlParser.ID:
+                    case PlSqlParser.IDLE_TIME:
+                    case PlSqlParser.IF:
+                    case PlSqlParser.IGNORE:
+                    case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                    case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                    case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                    case PlSqlParser.ILM:
+                    case PlSqlParser.IMMEDIATE:
+                    case PlSqlParser.IMPACT:
+                    case PlSqlParser.IMPORT:
+                    case PlSqlParser.INACTIVE:
+                    case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                    case PlSqlParser.INCLUDE:
+                    case PlSqlParser.INCLUDE_VERSION:
+                    case PlSqlParser.INCLUDING:
+                    case PlSqlParser.INCREMENTAL:
+                    case PlSqlParser.INCREMENT:
+                    case PlSqlParser.INCR:
+                    case PlSqlParser.INDENT:
+                    case PlSqlParser.INDEX_ASC:
+                    case PlSqlParser.INDEX_COMBINE:
+                    case PlSqlParser.INDEX_DESC:
+                    case PlSqlParser.INDEXED:
+                    case PlSqlParser.INDEXES:
+                    case PlSqlParser.INDEX_FFS:
+                    case PlSqlParser.INDEX_FILTER:
+                    case PlSqlParser.INDEXING:
+                    case PlSqlParser.INDEX_JOIN:
+                    case PlSqlParser.INDEX_ROWS:
+                    case PlSqlParser.INDEX_RRS:
+                    case PlSqlParser.INDEX_RS_ASC:
+                    case PlSqlParser.INDEX_RS_DESC:
+                    case PlSqlParser.INDEX_RS:
+                    case PlSqlParser.INDEX_SCAN:
+                    case PlSqlParser.INDEX_SKIP_SCAN:
+                    case PlSqlParser.INDEX_SS_ASC:
+                    case PlSqlParser.INDEX_SS_DESC:
+                    case PlSqlParser.INDEX_SS:
+                    case PlSqlParser.INDEX_STATS:
+                    case PlSqlParser.INDEXTYPE:
+                    case PlSqlParser.INDEXTYPES:
+                    case PlSqlParser.INDICATOR:
+                    case PlSqlParser.INDICES:
+                    case PlSqlParser.INFINITE:
+                    case PlSqlParser.INFORMATIONAL:
+                    case PlSqlParser.INHERIT:
+                    case PlSqlParser.INITCAP:
+                    case PlSqlParser.INITIAL:
+                    case PlSqlParser.INITIALIZED:
+                    case PlSqlParser.INITIALLY:
+                    case PlSqlParser.INITRANS:
+                    case PlSqlParser.INLINE:
+                    case PlSqlParser.INLINE_XMLTYPE_NT:
+                    case PlSqlParser.INMEMORY:
+                    case PlSqlParser.IN_MEMORY_METADATA:
+                    case PlSqlParser.INMEMORY_PRUNING:
+                    case PlSqlParser.INNER:
+                    case PlSqlParser.INOUT:
+                    case PlSqlParser.INPLACE:
+                    case PlSqlParser.INSERTCHILDXMLAFTER:
+                    case PlSqlParser.INSERTCHILDXMLBEFORE:
+                    case PlSqlParser.INSERTCHILDXML:
+                    case PlSqlParser.INSERTXMLAFTER:
+                    case PlSqlParser.INSERTXMLBEFORE:
+                    case PlSqlParser.INSTANCE:
+                    case PlSqlParser.INSTANCES:
+                    case PlSqlParser.INSTANTIABLE:
+                    case PlSqlParser.INSTANTLY:
+                    case PlSqlParser.INSTEAD:
+                    case PlSqlParser.INSTR2:
+                    case PlSqlParser.INSTR4:
+                    case PlSqlParser.INSTRB:
+                    case PlSqlParser.INSTRC:
+                    case PlSqlParser.INSTR:
+                    case PlSqlParser.INTEGER:
+                    case PlSqlParser.INTERLEAVED:
+                    case PlSqlParser.INTERMEDIATE:
+                    case PlSqlParser.INTERNAL_CONVERT:
+                    case PlSqlParser.INTERNAL_USE:
+                    case PlSqlParser.INTERPRETED:
+                    case PlSqlParser.INTERVAL:
+                    case PlSqlParser.INT:
+                    case PlSqlParser.INTERNAL:
+                    case PlSqlParser.INVALIDATE:
+                    case PlSqlParser.INVALIDATION:
+                    case PlSqlParser.INVISIBLE:
+                    case PlSqlParser.IN_XQUERY:
+                    case PlSqlParser.IS_LEAF:
+                    case PlSqlParser.ISOLATION:
+                    case PlSqlParser.ISOLATION_LEVEL:
+                    case PlSqlParser.ITEMS:
+                    case PlSqlParser.ITERATE:
+                    case PlSqlParser.ITERATION_NUMBER:
+                    case PlSqlParser.JAVA:
+                    case PlSqlParser.JOB:
+                    case PlSqlParser.JOIN:
+                    case PlSqlParser.JSON_ARRAYAGG:
+                    case PlSqlParser.JSON_ARRAY:
+                    case PlSqlParser.JSON_EQUAL:
+                    case PlSqlParser.JSON_EXISTS2:
+                    case PlSqlParser.JSON_EXISTS:
+                    case PlSqlParser.JSONGET:
+                    case PlSqlParser.JSON:
+                    case PlSqlParser.JSON_OBJECTAGG:
+                    case PlSqlParser.JSON_OBJECT:
+                    case PlSqlParser.JSONPARSE:
+                    case PlSqlParser.JSON_QUERY:
+                    case PlSqlParser.JSON_SERIALIZE:
+                    case PlSqlParser.JSON_TABLE:
+                    case PlSqlParser.JSON_TEXTCONTAINS2:
+                    case PlSqlParser.JSON_TEXTCONTAINS:
+                    case PlSqlParser.JSON_TRANSFORM:
+                    case PlSqlParser.JSON_VALUE:
+                    case PlSqlParser.K_LETTER:
+                    case PlSqlParser.KEEP_DUPLICATES:
+                    case PlSqlParser.KEEP:
+                    case PlSqlParser.KERBEROS:
+                    case PlSqlParser.KEY:
+                    case PlSqlParser.KEY_LENGTH:
+                    case PlSqlParser.KEYSIZE:
+                    case PlSqlParser.KEYS:
+                    case PlSqlParser.KEYSTORE:
+                    case PlSqlParser.KILL:
+                    case PlSqlParser.LABEL:
+                    case PlSqlParser.LANGUAGE:
+                    case PlSqlParser.LAST_DAY:
+                    case PlSqlParser.LAST:
+                    case PlSqlParser.LAST_VALUE:
+                    case PlSqlParser.LATERAL:
+                    case PlSqlParser.LAX:
+                    case PlSqlParser.LAYER:
+                    case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                    case PlSqlParser.LDAP_REGISTRATION:
+                    case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                    case PlSqlParser.LEAF:
+                    case PlSqlParser.LEAD_CDB:
+                    case PlSqlParser.LEAD_CDB_URI:
+                    case PlSqlParser.LEADING:
+                    case PlSqlParser.LEFT:
+                    case PlSqlParser.LENGTH2:
+                    case PlSqlParser.LENGTH4:
+                    case PlSqlParser.LENGTHB:
+                    case PlSqlParser.LENGTHC:
+                    case PlSqlParser.LENGTH:
+                    case PlSqlParser.LESS:
+                    case PlSqlParser.LEVEL:
+                    case PlSqlParser.LEVEL_NAME:
+                    case PlSqlParser.LEVELS:
+                    case PlSqlParser.LIBRARY:
+                    case PlSqlParser.LIFECYCLE:
+                    case PlSqlParser.LIFE:
+                    case PlSqlParser.LIFETIME:
+                    case PlSqlParser.LIKE2:
+                    case PlSqlParser.LIKE4:
+                    case PlSqlParser.LIKEC:
+                    case PlSqlParser.LIKE_EXPAND:
+                    case PlSqlParser.LIMIT:
+                    case PlSqlParser.LINEAR:
+                    case PlSqlParser.LINES:
+                    case PlSqlParser.LINK:
+                    case PlSqlParser.LIST:
+                    case PlSqlParser.LN:
+                    case PlSqlParser.LNNVL:
+                    case PlSqlParser.LOAD:
+                    case PlSqlParser.LOB:
+                    case PlSqlParser.LOBNVL:
+                    case PlSqlParser.LOBS:
+                    case PlSqlParser.LOCAL_INDEXES:
+                    case PlSqlParser.LOCAL:
+                    case PlSqlParser.LOCALTIME:
+                    case PlSqlParser.LOCALTIMESTAMP:
+                    case PlSqlParser.LOCATION:
+                    case PlSqlParser.LOCATOR:
+                    case PlSqlParser.LOCKDOWN:
+                    case PlSqlParser.LOCKED:
+                    case PlSqlParser.LOCKING:
+                    case PlSqlParser.LOGFILE:
+                    case PlSqlParser.LOGFILES:
+                    case PlSqlParser.LOGGING:
+                    case PlSqlParser.LOGICAL:
+                    case PlSqlParser.LOGICAL_READS_PER_CALL:
+                    case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                    case PlSqlParser.LOG:
+                    case PlSqlParser.LOGMINING:
+                    case PlSqlParser.LOGOFF:
+                    case PlSqlParser.LOGON:
+                    case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                    case PlSqlParser.LONG:
+                    case PlSqlParser.LOOP:
+                    case PlSqlParser.LOST:
+                    case PlSqlParser.LOWER:
+                    case PlSqlParser.LOW:
+                    case PlSqlParser.LPAD:
+                    case PlSqlParser.LTRIM:
+                    case PlSqlParser.M_LETTER:
+                    case PlSqlParser.MAIN:
+                    case PlSqlParser.MAKE_REF:
+                    case PlSqlParser.MANAGED:
+                    case PlSqlParser.MANAGE:
+                    case PlSqlParser.MANAGEMENT:
+                    case PlSqlParser.MANAGER:
+                    case PlSqlParser.MANDATORY:
+                    case PlSqlParser.MANUAL:
+                    case PlSqlParser.MAP:
+                    case PlSqlParser.MAPPING:
+                    case PlSqlParser.MASK:
+                    case PlSqlParser.MASTER:
+                    case PlSqlParser.MATCHED:
+                    case PlSqlParser.MATCHES:
+                    case PlSqlParser.MATCH:
+                    case PlSqlParser.MATCH_NUMBER:
+                    case PlSqlParser.MATCH_RECOGNIZE:
+                    case PlSqlParser.MATERIALIZED:
+                    case PlSqlParser.MATERIALIZE:
+                    case PlSqlParser.MAXARCHLOGS:
+                    case PlSqlParser.MAXDATAFILES:
+                    case PlSqlParser.MAXEXTENTS:
+                    case PlSqlParser.MAXIMIZE:
+                    case PlSqlParser.MAXINSTANCES:
+                    case PlSqlParser.MAXLOGFILES:
+                    case PlSqlParser.MAXLOGHISTORY:
+                    case PlSqlParser.MAXLOGMEMBERS:
+                    case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                    case PlSqlParser.MAXSIZE:
+                    case PlSqlParser.MAXTRANS:
+                    case PlSqlParser.MAXVALUE:
+                    case PlSqlParser.MEASURE:
+                    case PlSqlParser.MEASURES:
+                    case PlSqlParser.MEDIUM:
+                    case PlSqlParser.MEMBER:
+                    case PlSqlParser.MEMBER_CAPTION:
+                    case PlSqlParser.MEMBER_DESCRIPTION:
+                    case PlSqlParser.MEMBER_NAME:
+                    case PlSqlParser.MEMBER_UNIQUE_NAME:
+                    case PlSqlParser.MEMCOMPRESS:
+                    case PlSqlParser.MEMORY:
+                    case PlSqlParser.MERGEACTIONS:
+                    case PlSqlParser.MERGE_AJ:
+                    case PlSqlParser.MERGE_CONST_ON:
+                    case PlSqlParser.MERGE:
+                    case PlSqlParser.MERGE_SJ:
+                    case PlSqlParser.METADATA:
+                    case PlSqlParser.METHOD:
+                    case PlSqlParser.MIGRATE:
+                    case PlSqlParser.MIGRATION:
+                    case PlSqlParser.MINEXTENTS:
+                    case PlSqlParser.MINIMIZE:
+                    case PlSqlParser.MINIMUM:
+                    case PlSqlParser.MINING:
+                    case PlSqlParser.MINUS_NULL:
+                    case PlSqlParser.MINUTE:
+                    case PlSqlParser.MINUTES:
+                    case PlSqlParser.MINVALUE:
+                    case PlSqlParser.MIRRORCOLD:
+                    case PlSqlParser.MIRRORHOT:
+                    case PlSqlParser.MIRROR:
+                    case PlSqlParser.MISSING:
+                    case PlSqlParser.MISMATCH:
+                    case PlSqlParser.MLSLABEL:
+                    case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                    case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                    case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                    case PlSqlParser.MODEL_MIN_ANALYSIS:
+                    case PlSqlParser.MODEL:
+                    case PlSqlParser.MODEL_NB:
+                    case PlSqlParser.MODEL_NO_ANALYSIS:
+                    case PlSqlParser.MODEL_PBY:
+                    case PlSqlParser.MODEL_PUSH_REF:
+                    case PlSqlParser.MODEL_SV:
+                    case PlSqlParser.MODIFICATION:
+                    case PlSqlParser.MODIFY_COLUMN_TYPE:
+                    case PlSqlParser.MODIFY:
+                    case PlSqlParser.MOD:
+                    case PlSqlParser.MODULE:
+                    case PlSqlParser.MONITORING:
+                    case PlSqlParser.MONITOR:
+                    case PlSqlParser.MONTH:
+                    case PlSqlParser.MONTHS_BETWEEN:
+                    case PlSqlParser.MONTHS:
+                    case PlSqlParser.MOUNT:
+                    case PlSqlParser.MOUNTPATH:
+                    case PlSqlParser.MOUNTPOINT:
+                    case PlSqlParser.MOVEMENT:
+                    case PlSqlParser.MOVE:
+                    case PlSqlParser.MULTIDIMENSIONAL:
+                    case PlSqlParser.MULTISET:
+                    case PlSqlParser.MV_MERGE:
+                    case PlSqlParser.NAMED:
+                    case PlSqlParser.NAME:
+                    case PlSqlParser.NAMESPACE:
+                    case PlSqlParser.NAN_:
+                    case PlSqlParser.NANVL:
+                    case PlSqlParser.NATIONAL:
+                    case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NATIVE:
+                    case PlSqlParser.NATURAL:
+                    case PlSqlParser.NAV:
+                    case PlSqlParser.NCHAR_CS:
+                    case PlSqlParser.NCHAR:
+                    case PlSqlParser.NCHR:
+                    case PlSqlParser.NCLOB:
+                    case PlSqlParser.NEEDED:
+                    case PlSqlParser.NEG:
+                    case PlSqlParser.NESTED:
+                    case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                    case PlSqlParser.NESTED_TABLE_GET_REFS:
+                    case PlSqlParser.NESTED_TABLE_ID:
+                    case PlSqlParser.NESTED_TABLE_SET_REFS:
+                    case PlSqlParser.NESTED_TABLE_SET_SETID:
+                    case PlSqlParser.NETWORK:
+                    case PlSqlParser.NEVER:
+                    case PlSqlParser.NEW:
+                    case PlSqlParser.NEWLINE_:
+                    case PlSqlParser.NEW_TIME:
+                    case PlSqlParser.NEXT_DAY:
+                    case PlSqlParser.NEXT:
+                    case PlSqlParser.NL_AJ:
+                    case PlSqlParser.NLJ_BATCHING:
+                    case PlSqlParser.NLJ_INDEX_FILTER:
+                    case PlSqlParser.NLJ_INDEX_SCAN:
+                    case PlSqlParser.NLJ_PREFETCH:
+                    case PlSqlParser.NLS_CALENDAR:
+                    case PlSqlParser.NLS_CHARACTERSET:
+                    case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                    case PlSqlParser.NLS_CHARSET_ID:
+                    case PlSqlParser.NLS_CHARSET_NAME:
+                    case PlSqlParser.NLS_COMP:
+                    case PlSqlParser.NLS_CURRENCY:
+                    case PlSqlParser.NLS_DATE_FORMAT:
+                    case PlSqlParser.NLS_DATE_LANGUAGE:
+                    case PlSqlParser.NLS_INITCAP:
+                    case PlSqlParser.NLS_ISO_CURRENCY:
+                    case PlSqlParser.NL_SJ:
+                    case PlSqlParser.NLS_LANG:
+                    case PlSqlParser.NLS_LANGUAGE:
+                    case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                    case PlSqlParser.NLS_LOWER:
+                    case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                    case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                    case PlSqlParser.NLS_SORT:
+                    case PlSqlParser.NLSSORT:
+                    case PlSqlParser.NLS_SPECIAL_CHARS:
+                    case PlSqlParser.NLS_TERRITORY:
+                    case PlSqlParser.NLS_UPPER:
+                    case PlSqlParser.NO_ACCESS:
+                    case PlSqlParser.NO_ADAPTIVE_PLAN:
+                    case PlSqlParser.NO_ANSI_REARCH:
+                    case PlSqlParser.NOAPPEND:
+                    case PlSqlParser.NOARCHIVELOG:
+                    case PlSqlParser.NOAUDIT:
+                    case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                    case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                    case PlSqlParser.NO_BIND_AWARE:
+                    case PlSqlParser.NO_BUFFER:
+                    case PlSqlParser.NOCACHE:
+                    case PlSqlParser.NO_CARTESIAN:
+                    case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                    case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                    case PlSqlParser.NO_CLUSTERING:
+                    case PlSqlParser.NO_COALESCE_SQ:
+                    case PlSqlParser.NO_COMMON_DATA:
+                    case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                    case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                    case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                    case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                    case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                    case PlSqlParser.NOCOPY:
+                    case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_CPU_COSTING:
+                    case PlSqlParser.NOCPU_COSTING:
+                    case PlSqlParser.NOCYCLE:
+                    case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                    case PlSqlParser.NO_DECORRELATE:
+                    case PlSqlParser.NODELAY:
+                    case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                    case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                    case PlSqlParser.NO_ELIM_GROUPBY:
+                    case PlSqlParser.NO_ELIMINATE_JOIN:
+                    case PlSqlParser.NO_ELIMINATE_OBY:
+                    case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                    case PlSqlParser.NOENTITYESCAPING:
+                    case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                    case PlSqlParser.NO_EXPAND:
+                    case PlSqlParser.NO_EXPAND_TABLE:
+                    case PlSqlParser.NO_FACT:
+                    case PlSqlParser.NO_FACTORIZE_JOIN:
+                    case PlSqlParser.NO_FILTERING:
+                    case PlSqlParser.NOFORCE:
+                    case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                    case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                    case PlSqlParser.NO_GBY_PUSHDOWN:
+                    case PlSqlParser.NOGUARANTEE:
+                    case PlSqlParser.NO_INDEX_FFS:
+                    case PlSqlParser.NO_INDEX:
+                    case PlSqlParser.NO_INDEX_SS:
+                    case PlSqlParser.NO_INMEMORY:
+                    case PlSqlParser.NO_INMEMORY_PRUNING:
+                    case PlSqlParser.NOKEEP:
+                    case PlSqlParser.NO_LOAD:
+                    case PlSqlParser.NOLOCAL:
+                    case PlSqlParser.NOLOGGING:
+                    case PlSqlParser.NOMAPPING:
+                    case PlSqlParser.NOMAXVALUE:
+                    case PlSqlParser.NO_MERGE:
+                    case PlSqlParser.NOMINIMIZE:
+                    case PlSqlParser.NOMINVALUE:
+                    case PlSqlParser.NO_MODEL_PUSH_REF:
+                    case PlSqlParser.NO_MONITORING:
+                    case PlSqlParser.NOMONITORING:
+                    case PlSqlParser.NO_MONITOR:
+                    case PlSqlParser.NO_MULTIMV_REWRITE:
+                    case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                    case PlSqlParser.NONBLOCKING:
+                    case PlSqlParser.NONEDITIONABLE:
+                    case PlSqlParser.NONE:
+                    case PlSqlParser.NONPARTITIONED:
+                    case PlSqlParser.NO_NLJ_BATCHING:
+                    case PlSqlParser.NO_NLJ_PREFETCH:
+                    case PlSqlParser.NO:
+                    case PlSqlParser.NONSCHEMA:
+                    case PlSqlParser.NO_OBJECT_LINK:
+                    case PlSqlParser.NOORDER:
+                    case PlSqlParser.NO_ORDER_ROLLUPS:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.NOOVERRIDE:
+                    case PlSqlParser.NO_PARALLEL_INDEX:
+                    case PlSqlParser.NOPARALLEL_INDEX:
+                    case PlSqlParser.NO_PARALLEL:
+                    case PlSqlParser.NOPARALLEL:
+                    case PlSqlParser.NO_PARTIAL_COMMIT:
+                    case PlSqlParser.NO_PARTIAL_JOIN:
+                    case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.NOPARTITION:
+                    case PlSqlParser.NO_PLACE_DISTINCT:
+                    case PlSqlParser.NO_PLACE_GROUP_BY:
+                    case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                    case PlSqlParser.NO_PQ_MAP:
+                    case PlSqlParser.NOPROMPT:
+                    case PlSqlParser.NO_PQ_REPLICATE:
+                    case PlSqlParser.NO_PQ_SKEW:
+                    case PlSqlParser.NO_PRUNE_GSETS:
+                    case PlSqlParser.NO_PULL_PRED:
+                    case PlSqlParser.NO_PUSH_PRED:
+                    case PlSqlParser.NO_PUSH_SUBQ:
+                    case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                    case PlSqlParser.NO_PX_JOIN_FILTER:
+                    case PlSqlParser.NO_QKN_BUFF:
+                    case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                    case PlSqlParser.NO_REF_CASCADE:
+                    case PlSqlParser.NORELOCATE:
+                    case PlSqlParser.NORELY:
+                    case PlSqlParser.NOREPAIR:
+                    case PlSqlParser.NOREPLAY:
+                    case PlSqlParser.NORESETLOGS:
+                    case PlSqlParser.NO_RESULT_CACHE:
+                    case PlSqlParser.NOREVERSE:
+                    case PlSqlParser.NO_REWRITE:
+                    case PlSqlParser.NOREWRITE:
+                    case PlSqlParser.NORMAL:
+                    case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                    case PlSqlParser.NOROWDEPENDENCIES:
+                    case PlSqlParser.NOSCHEMACHECK:
+                    case PlSqlParser.NOSEGMENT:
+                    case PlSqlParser.NO_SEMIJOIN:
+                    case PlSqlParser.NO_SEMI_TO_INNER:
+                    case PlSqlParser.NO_SET_TO_JOIN:
+                    case PlSqlParser.NOSORT:
+                    case PlSqlParser.NO_SQL_TRANSLATION:
+                    case PlSqlParser.NO_SQL_TUNE:
+                    case PlSqlParser.NO_STAR_TRANSFORMATION:
+                    case PlSqlParser.NO_STATEMENT_QUEUING:
+                    case PlSqlParser.NO_STATS_GSETS:
+                    case PlSqlParser.NOSTRICT:
+                    case PlSqlParser.NO_SUBQUERY_PRUNING:
+                    case PlSqlParser.NO_SUBSTRB_PAD:
+                    case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                    case PlSqlParser.NOSWITCH:
+                    case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.NO_TEMP_TABLE:
+                    case PlSqlParser.NOTHING:
+                    case PlSqlParser.NOTIFICATION:
+                    case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.NO_UNNEST:
+                    case PlSqlParser.NO_USE_CUBE:
+                    case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                    case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.NO_USE_HASH:
+                    case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.NO_USE_MERGE:
+                    case PlSqlParser.NO_USE_NL:
+                    case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.NOVALIDATE:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.NO_VECTOR_TRANSFORM:
+                    case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                    case PlSqlParser.NO_XML_DML_REWRITE:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.NO_XMLINDEX_REWRITE:
+                    case PlSqlParser.NO_XML_QUERY_REWRITE:
+                    case PlSqlParser.NO_ZONEMAP:
+                    case PlSqlParser.NTH_VALUE:
+                    case PlSqlParser.NULLIF:
+                    case PlSqlParser.NULLS:
+                    case PlSqlParser.NUMBER:
+                    case PlSqlParser.NUMERIC:
+                    case PlSqlParser.NUM_INDEX_KEYS:
+                    case PlSqlParser.NUMTODSINTERVAL:
+                    case PlSqlParser.NUMTOYMINTERVAL:
+                    case PlSqlParser.NVARCHAR2:
+                    case PlSqlParser.NVL2:
+                    case PlSqlParser.OBJECT2XML:
+                    case PlSqlParser.OBJECT:
+                    case PlSqlParser.OBJ_ID:
+                    case PlSqlParser.OBJNO:
+                    case PlSqlParser.OBJNO_REUSE:
+                    case PlSqlParser.OCCURENCES:
+                    case PlSqlParser.OFFLINE:
+                    case PlSqlParser.OFF:
+                    case PlSqlParser.OFFSET:
+                    case PlSqlParser.OIDINDEX:
+                    case PlSqlParser.OID:
+                    case PlSqlParser.OLAP:
+                    case PlSqlParser.OLD:
+                    case PlSqlParser.OLD_PUSH_PRED:
+                    case PlSqlParser.OLS:
+                    case PlSqlParser.OLTP:
+                    case PlSqlParser.OMIT:
+                    case PlSqlParser.ONE:
+                    case PlSqlParser.ONLINE:
+                    case PlSqlParser.ONLY:
+                    case PlSqlParser.OPAQUE:
+                    case PlSqlParser.OPAQUE_TRANSFORM:
+                    case PlSqlParser.OPAQUE_XCANONICAL:
+                    case PlSqlParser.OPCODE:
+                    case PlSqlParser.OPEN:
+                    case PlSqlParser.OPERATIONS:
+                    case PlSqlParser.OPERATOR:
+                    case PlSqlParser.OPT_ESTIMATE:
+                    case PlSqlParser.OPTIMAL:
+                    case PlSqlParser.OPTIMIZE:
+                    case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                    case PlSqlParser.OPTIMIZER_GOAL:
+                    case PlSqlParser.OPT_PARAM:
+                    case PlSqlParser.ORA_BRANCH:
+                    case PlSqlParser.ORA_CHECK_ACL:
+                    case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                    case PlSqlParser.ORA_CLUSTERING:
+                    case PlSqlParser.ORADATA:
+                    case PlSqlParser.ORC:
+                    case PlSqlParser.ORADEBUG:
+                    case PlSqlParser.ORA_DST_AFFECTED:
+                    case PlSqlParser.ORA_DST_CONVERT:
+                    case PlSqlParser.ORA_DST_ERROR:
+                    case PlSqlParser.ORA_GET_ACLIDS:
+                    case PlSqlParser.ORA_GET_PRIVILEGES:
+                    case PlSqlParser.ORA_HASH:
+                    case PlSqlParser.ORA_INVOKING_USERID:
+                    case PlSqlParser.ORA_INVOKING_USER:
+                    case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                    case PlSqlParser.ORA_INVOKING_XS_USER:
+                    case PlSqlParser.ORA_RAWCOMPARE:
+                    case PlSqlParser.ORA_RAWCONCAT:
+                    case PlSqlParser.ORA_ROWSCN:
+                    case PlSqlParser.ORA_ROWSCN_RAW:
+                    case PlSqlParser.ORA_ROWVERSION:
+                    case PlSqlParser.ORA_TABVERSION:
+                    case PlSqlParser.ORA_WRITE_TIME:
+                    case PlSqlParser.ORDERED:
+                    case PlSqlParser.ORDERED_PREDICATES:
+                    case PlSqlParser.ORDINALITY:
+                    case PlSqlParser.OR_EXPAND:
+                    case PlSqlParser.ORGANIZATION:
+                    case PlSqlParser.OR_PREDICATES:
+                    case PlSqlParser.OSERROR:
+                    case PlSqlParser.OTHER:
+                    case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                    case PlSqlParser.OUTER_JOIN_TO_INNER:
+                    case PlSqlParser.OUTER:
+                    case PlSqlParser.OUTLINE_LEAF:
+                    case PlSqlParser.OUTLINE:
+                    case PlSqlParser.OUT_OF_LINE:
+                    case PlSqlParser.OUT:
+                    case PlSqlParser.OVERFLOW_NOMOVE:
+                    case PlSqlParser.OVERFLOW_:
+                    case PlSqlParser.OVERLAPS:
+                    case PlSqlParser.OVER:
+                    case PlSqlParser.OVERRIDE:
+                    case PlSqlParser.OVERRIDING:
+                    case PlSqlParser.OWNER:
+                    case PlSqlParser.OWNERSHIP:
+                    case PlSqlParser.OWN:
+                    case PlSqlParser.P_LETTER:
+                    case PlSqlParser.PACKAGE:
+                    case PlSqlParser.PACKAGES:
+                    case PlSqlParser.PARALLEL_ENABLE:
+                    case PlSqlParser.PARALLEL_INDEX:
+                    case PlSqlParser.PARALLEL:
+                    case PlSqlParser.PARAMETERS:
+                    case PlSqlParser.PARAM:
+                    case PlSqlParser.PARENT:
+                    case PlSqlParser.PARENT_LEVEL_NAME:
+                    case PlSqlParser.PARENT_UNIQUE_NAME:
+                    case PlSqlParser.PARITY:
+                    case PlSqlParser.PARTIAL_JOIN:
+                    case PlSqlParser.PARTIALLY:
+                    case PlSqlParser.PARTIAL:
+                    case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                    case PlSqlParser.PARTITION_HASH:
+                    case PlSqlParser.PARTITION_LIST:
+                    case PlSqlParser.PARTITION:
+                    case PlSqlParser.PARTITION_RANGE:
+                    case PlSqlParser.PARTITIONS:
+                    case PlSqlParser.PARTNUMINST:
+                    case PlSqlParser.PASSING:
+                    case PlSqlParser.PASSWORD_GRACE_TIME:
+                    case PlSqlParser.PASSWORD_LIFE_TIME:
+                    case PlSqlParser.PASSWORD_LOCK_TIME:
+                    case PlSqlParser.PASSWORD:
+                    case PlSqlParser.PASSWORD_REUSE_MAX:
+                    case PlSqlParser.PASSWORD_REUSE_TIME:
+                    case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                    case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                    case PlSqlParser.PAST:
+                    case PlSqlParser.PATCH:
+                    case PlSqlParser.PATH:
+                    case PlSqlParser.PATH_PREFIX:
+                    case PlSqlParser.PATHS:
+                    case PlSqlParser.PATTERN:
+                    case PlSqlParser.PBL_HS_BEGIN:
+                    case PlSqlParser.PBL_HS_END:
+                    case PlSqlParser.PCTINCREASE:
+                    case PlSqlParser.PCTTHRESHOLD:
+                    case PlSqlParser.PCTUSED:
+                    case PlSqlParser.PCTVERSION:
+                    case PlSqlParser.PENDING:
+                    case PlSqlParser.PERCENT_KEYWORD:
+                    case PlSqlParser.PERCENT_RANKM:
+                    case PlSqlParser.PERFORMANCE:
+                    case PlSqlParser.PERIOD_KEYWORD:
+                    case PlSqlParser.PERMANENT:
+                    case PlSqlParser.PERMISSION:
+                    case PlSqlParser.PERMUTE:
+                    case PlSqlParser.PER:
+                    case PlSqlParser.PFILE:
+                    case PlSqlParser.PHYSICAL:
+                    case PlSqlParser.PIKEY:
+                    case PlSqlParser.PIPELINED:
+                    case PlSqlParser.PIV_GB:
+                    case PlSqlParser.PIVOT:
+                    case PlSqlParser.PIV_SSF:
+                    case PlSqlParser.PLACE_DISTINCT:
+                    case PlSqlParser.PLACE_GROUP_BY:
+                    case PlSqlParser.PLAN:
+                    case PlSqlParser.PLSCOPE_SETTINGS:
+                    case PlSqlParser.PLS_INTEGER:
+                    case PlSqlParser.PLSQL_CCFLAGS:
+                    case PlSqlParser.PLSQL_CODE_TYPE:
+                    case PlSqlParser.PLSQL_DEBUG:
+                    case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                    case PlSqlParser.PLSQL_WARNINGS:
+                    case PlSqlParser.PLUGGABLE:
+                    case PlSqlParser.PMEM:
+                    case PlSqlParser.POINT:
+                    case PlSqlParser.POLICY:
+                    case PlSqlParser.POOL_16K:
+                    case PlSqlParser.POOL_2K:
+                    case PlSqlParser.POOL_32K:
+                    case PlSqlParser.POOL_4K:
+                    case PlSqlParser.POOL_8K:
+                    case PlSqlParser.POSITION:
+                    case PlSqlParser.POSITIVEN:
+                    case PlSqlParser.POSITIVE:
+                    case PlSqlParser.POST_TRANSACTION:
+                    case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                    case PlSqlParser.POWERMULTISET:
+                    case PlSqlParser.POWER:
+                    case PlSqlParser.PQ_CONCURRENT_UNION:
+                    case PlSqlParser.PQ_DISTRIBUTE:
+                    case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                    case PlSqlParser.PQ_FILTER:
+                    case PlSqlParser.PQ_MAP:
+                    case PlSqlParser.PQ_NOMAP:
+                    case PlSqlParser.PQ_REPLICATE:
+                    case PlSqlParser.PQ_SKEW:
+                    case PlSqlParser.PRAGMA:
+                    case PlSqlParser.PREBUILT:
+                    case PlSqlParser.PRECEDES:
+                    case PlSqlParser.PRECEDING:
+                    case PlSqlParser.PRECISION:
+                    case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                    case PlSqlParser.PREDICATE_REORDERS:
+                    case PlSqlParser.PRELOAD:
+                    case PlSqlParser.PREPARE:
+                    case PlSqlParser.PRESENTNNV:
+                    case PlSqlParser.PRESENT:
+                    case PlSqlParser.PRESENTV:
+                    case PlSqlParser.PRESERVE_OID:
+                    case PlSqlParser.PRESERVE:
+                    case PlSqlParser.PRETTY:
+                    case PlSqlParser.PREVIOUS:
+                    case PlSqlParser.PREV:
+                    case PlSqlParser.PRIMARY:
+                    case PlSqlParser.PRINTBLOBTOCLOB:
+                    case PlSqlParser.PRIORITY:
+                    case PlSqlParser.PRIVATE:
+                    case PlSqlParser.PRIVATE_SGA:
+                    case PlSqlParser.PRIVILEGED:
+                    case PlSqlParser.PRIVILEGE:
+                    case PlSqlParser.PRIVILEGES:
+                    case PlSqlParser.PROCEDURAL:
+                    case PlSqlParser.PROCEDURE:
+                    case PlSqlParser.PROCESS:
+                    case PlSqlParser.PROFILE:
+                    case PlSqlParser.PROGRAM:
+                    case PlSqlParser.PROJECT:
+                    case PlSqlParser.PROPAGATE:
+                    case PlSqlParser.PROPERTY:
+                    case PlSqlParser.PROTECTED:
+                    case PlSqlParser.PROTECTION:
+                    case PlSqlParser.PROTOCOL:
+                    case PlSqlParser.PROXY:
+                    case PlSqlParser.PRUNING:
+                    case PlSqlParser.PUBLIC:
+                    case PlSqlParser.PULL_PRED:
+                    case PlSqlParser.PURGE:
+                    case PlSqlParser.PUSH_PRED:
+                    case PlSqlParser.PUSH_SUBQ:
+                    case PlSqlParser.PX_FAULT_TOLERANCE:
+                    case PlSqlParser.PX_GRANULE:
+                    case PlSqlParser.PX_JOIN_FILTER:
+                    case PlSqlParser.QB_NAME:
+                    case PlSqlParser.QUARTERS:
+                    case PlSqlParser.QUERY_BLOCK:
+                    case PlSqlParser.QUERY:
+                    case PlSqlParser.QUEUE_CURR:
+                    case PlSqlParser.QUEUE:
+                    case PlSqlParser.QUEUE_ROWP:
+                    case PlSqlParser.QUIESCE:
+                    case PlSqlParser.QUORUM:
+                    case PlSqlParser.QUOTA:
+                    case PlSqlParser.QUOTAGROUP:
+                    case PlSqlParser.RAISE:
+                    case PlSqlParser.RANDOM_LOCAL:
+                    case PlSqlParser.RANDOM:
+                    case PlSqlParser.RANGE:
+                    case PlSqlParser.RANKM:
+                    case PlSqlParser.RAPIDLY:
+                    case PlSqlParser.RAW:
+                    case PlSqlParser.RAWTOHEX:
+                    case PlSqlParser.RAWTONHEX:
+                    case PlSqlParser.RBA:
+                    case PlSqlParser.RBO_OUTLINE:
+                    case PlSqlParser.RDBA:
+                    case PlSqlParser.READ:
+                    case PlSqlParser.READS:
+                    case PlSqlParser.REALM:
+                    case PlSqlParser.REAL:
+                    case PlSqlParser.REBALANCE:
+                    case PlSqlParser.REBUILD:
+                    case PlSqlParser.RECORD:
+                    case PlSqlParser.RECORDS:
+                    case PlSqlParser.RECORDS_PER_BLOCK:
+                    case PlSqlParser.RECOVERABLE:
+                    case PlSqlParser.RECOVER:
+                    case PlSqlParser.RECOVERY:
+                    case PlSqlParser.RECYCLEBIN:
+                    case PlSqlParser.RECYCLE:
+                    case PlSqlParser.REDACTION:
+                    case PlSqlParser.REDEFINE:
+                    case PlSqlParser.REDO:
+                    case PlSqlParser.REDUCED:
+                    case PlSqlParser.REDUNDANCY:
+                    case PlSqlParser.REF_CASCADE_CURSOR:
+                    case PlSqlParser.REFERENCED:
+                    case PlSqlParser.REFERENCE:
+                    case PlSqlParser.REFERENCES:
+                    case PlSqlParser.REFERENCING:
+                    case PlSqlParser.REF:
+                    case PlSqlParser.REFRESH:
+                    case PlSqlParser.REFTOHEX:
+                    case PlSqlParser.REGEXP_COUNT:
+                    case PlSqlParser.REGEXP_INSTR:
+                    case PlSqlParser.REGEXP_LIKE:
+                    case PlSqlParser.REGEXP_REPLACE:
+                    case PlSqlParser.REGEXP_SUBSTR:
+                    case PlSqlParser.REGISTER:
+                    case PlSqlParser.REGR_AVGX:
+                    case PlSqlParser.REGR_AVGY:
+                    case PlSqlParser.REGR_COUNT:
+                    case PlSqlParser.REGR_INTERCEPT:
+                    case PlSqlParser.REGR_R2:
+                    case PlSqlParser.REGR_SLOPE:
+                    case PlSqlParser.REGR_SXX:
+                    case PlSqlParser.REGR_SXY:
+                    case PlSqlParser.REGR_SYY:
+                    case PlSqlParser.REGULAR:
+                    case PlSqlParser.REJECT:
+                    case PlSqlParser.REKEY:
+                    case PlSqlParser.RELATIONAL:
+                    case PlSqlParser.RELOCATE:
+                    case PlSqlParser.RELY:
+                    case PlSqlParser.REMAINDER:
+                    case PlSqlParser.REMOTE:
+                    case PlSqlParser.REMOTE_MAPPED:
+                    case PlSqlParser.REMOVE:
+                    case PlSqlParser.RENAME:
+                    case PlSqlParser.REPAIR:
+                    case PlSqlParser.REPEAT:
+                    case PlSqlParser.REPLACE:
+                    case PlSqlParser.REPLICATION:
+                    case PlSqlParser.REQUIRED:
+                    case PlSqlParser.RESETLOGS:
+                    case PlSqlParser.RESET:
+                    case PlSqlParser.RESIZE:
+                    case PlSqlParser.RESOLVE:
+                    case PlSqlParser.RESOLVER:
+                    case PlSqlParser.RESPECT:
+                    case PlSqlParser.RESTART:
+                    case PlSqlParser.RESTORE_AS_INTERVALS:
+                    case PlSqlParser.RESTORE:
+                    case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                    case PlSqlParser.RESTRICTED:
+                    case PlSqlParser.RESTRICT_REFERENCES:
+                    case PlSqlParser.RESTRICT:
+                    case PlSqlParser.RESULT_CACHE:
+                    case PlSqlParser.RESULT:
+                    case PlSqlParser.RESUMABLE:
+                    case PlSqlParser.RESUME:
+                    case PlSqlParser.RETENTION:
+                    case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                    case PlSqlParser.RETURNING:
+                    case PlSqlParser.RETURN:
+                    case PlSqlParser.REUSE:
+                    case PlSqlParser.REVERSE:
+                    case PlSqlParser.REWRITE_OR_ERROR:
+                    case PlSqlParser.REWRITE:
+                    case PlSqlParser.RIGHT:
+                    case PlSqlParser.ROLE:
+                    case PlSqlParser.ROLESET:
+                    case PlSqlParser.ROLES:
+                    case PlSqlParser.ROLLBACK:
+                    case PlSqlParser.ROLLING:
+                    case PlSqlParser.ROLLUP:
+                    case PlSqlParser.ROWDEPENDENCIES:
+                    case PlSqlParser.ROWID_MAPPING_TABLE:
+                    case PlSqlParser.ROWID:
+                    case PlSqlParser.ROWIDTOCHAR:
+                    case PlSqlParser.ROWIDTONCHAR:
+                    case PlSqlParser.ROW_LENGTH:
+                    case PlSqlParser.ROWNUM:
+                    case PlSqlParser.ROW:
+                    case PlSqlParser.ROWS:
+                    case PlSqlParser.RPAD:
+                    case PlSqlParser.RTRIM:
+                    case PlSqlParser.RULE:
+                    case PlSqlParser.RULES:
+                    case PlSqlParser.RUNNING:
+                    case PlSqlParser.SALT:
+                    case PlSqlParser.SAMPLE:
+                    case PlSqlParser.SAVE_AS_INTERVALS:
+                    case PlSqlParser.SAVEPOINT:
+                    case PlSqlParser.SAVE:
+                    case PlSqlParser.SB4:
+                    case PlSqlParser.SCALE_ROWS:
+                    case PlSqlParser.SCALE:
+                    case PlSqlParser.SCAN_INSTANCES:
+                    case PlSqlParser.SCAN:
+                    case PlSqlParser.SCHEDULER:
+                    case PlSqlParser.SCHEMACHECK:
+                    case PlSqlParser.SCHEMA:
+                    case PlSqlParser.SCN_ASCENDING:
+                    case PlSqlParser.SCN:
+                    case PlSqlParser.SCOPE:
+                    case PlSqlParser.SCRUB:
+                    case PlSqlParser.SD_ALL:
+                    case PlSqlParser.SD_INHIBIT:
+                    case PlSqlParser.SDO_GEOM_MBR:
+                    case PlSqlParser.SDO_GEOMETRY:
+                    case PlSqlParser.SD_SHOW:
+                    case PlSqlParser.SEARCH:
+                    case PlSqlParser.SECOND:
+                    case PlSqlParser.SECONDS:
+                    case PlSqlParser.SECRET:
+                    case PlSqlParser.SECUREFILE_DBA:
+                    case PlSqlParser.SECUREFILE:
+                    case PlSqlParser.SECURITY:
+                    case PlSqlParser.SEED:
+                    case PlSqlParser.SEG_BLOCK:
+                    case PlSqlParser.SEG_FILE:
+                    case PlSqlParser.SEGMENT:
+                    case PlSqlParser.SELECTIVITY:
+                    case PlSqlParser.SELF:
+                    case PlSqlParser.SEMIJOIN_DRIVER:
+                    case PlSqlParser.SEMIJOIN:
+                    case PlSqlParser.SEMI_TO_INNER:
+                    case PlSqlParser.SEQUENCED:
+                    case PlSqlParser.SEQUENCE:
+                    case PlSqlParser.SEQUENTIAL:
+                    case PlSqlParser.SEQ:
+                    case PlSqlParser.SERIALIZABLE:
+                    case PlSqlParser.SERIALLY_REUSABLE:
+                    case PlSqlParser.SERIAL:
+                    case PlSqlParser.SERVERERROR:
+                    case PlSqlParser.SERVICE_NAME_CONVERT:
+                    case PlSqlParser.SERVICE:
+                    case PlSqlParser.SERVICES:
+                    case PlSqlParser.SESSION_CACHED_CURSORS:
+                    case PlSqlParser.SESSION:
+                    case PlSqlParser.SESSIONS_PER_USER:
+                    case PlSqlParser.SESSIONTIMEZONE:
+                    case PlSqlParser.SESSIONTZNAME:
+                    case PlSqlParser.SET:
+                    case PlSqlParser.SETS:
+                    case PlSqlParser.SETTINGS:
+                    case PlSqlParser.SET_TO_JOIN:
+                    case PlSqlParser.SEVERE:
+                    case PlSqlParser.SHARDSPACE:
+                    case PlSqlParser.SHARED_POOL:
+                    case PlSqlParser.SHARED:
+                    case PlSqlParser.SHARING:
+                    case PlSqlParser.SHELFLIFE:
+                    case PlSqlParser.SHOW:
+                    case PlSqlParser.SHRINK:
+                    case PlSqlParser.SHUTDOWN:
+                    case PlSqlParser.SIBLINGS:
+                    case PlSqlParser.SID:
+                    case PlSqlParser.SITE:
+                    case PlSqlParser.SIGNAL_COMPONENT:
+                    case PlSqlParser.SIGNAL_FUNCTION:
+                    case PlSqlParser.SIGN:
+                    case PlSqlParser.SIGNTYPE:
+                    case PlSqlParser.SIMPLE_INTEGER:
+                    case PlSqlParser.SIMPLE:
+                    case PlSqlParser.SINGLE:
+                    case PlSqlParser.SINGLETASK:
+                    case PlSqlParser.SINH:
+                    case PlSqlParser.SIN:
+                    case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                    case PlSqlParser.SKIP_:
+                    case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                    case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                    case PlSqlParser.SMALLFILE:
+                    case PlSqlParser.SMALLINT:
+                    case PlSqlParser.SNAPSHOT:
+                    case PlSqlParser.SOME:
+                    case PlSqlParser.SORT:
+                    case PlSqlParser.SOUNDEX:
+                    case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                    case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                    case PlSqlParser.SOURCE:
+                    case PlSqlParser.SPACE_KEYWORD:
+                    case PlSqlParser.SPECIFICATION:
+                    case PlSqlParser.SPFILE:
+                    case PlSqlParser.SPLIT:
+                    case PlSqlParser.SPREADSHEET:
+                    case PlSqlParser.SQLDATA:
+                    case PlSqlParser.SQLERROR:
+                    case PlSqlParser.SQLLDR:
+                    case PlSqlParser.SQL:
+                    case PlSqlParser.FILE_EXT:
+                    case PlSqlParser.SQL_MACRO:
+                    case PlSqlParser.SQL_TRACE:
+                    case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                    case PlSqlParser.SQRT:
+                    case PlSqlParser.STALE:
+                    case PlSqlParser.STANDALONE:
+                    case PlSqlParser.STANDARD:
+                    case PlSqlParser.STANDARD_HASH:
+                    case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                    case PlSqlParser.STANDBYS:
+                    case PlSqlParser.STANDBY:
+                    case PlSqlParser.STAR:
+                    case PlSqlParser.STAR_TRANSFORMATION:
+                    case PlSqlParser.STARTUP:
+                    case PlSqlParser.STATEMENT_ID:
+                    case PlSqlParser.STATEMENT_QUEUING:
+                    case PlSqlParser.STATEMENTS:
+                    case PlSqlParser.STATEMENT:
+                    case PlSqlParser.STATE:
+                    case PlSqlParser.STATIC:
+                    case PlSqlParser.STATISTICS:
+                    case PlSqlParser.STATS_BINOMIAL_TEST:
+                    case PlSqlParser.STATS_CROSSTAB:
+                    case PlSqlParser.STATS_F_TEST:
+                    case PlSqlParser.STATS_KS_TEST:
+                    case PlSqlParser.STATS_MODE:
+                    case PlSqlParser.STATS_MW_TEST:
+                    case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                    case PlSqlParser.STATS_T_TEST_INDEP:
+                    case PlSqlParser.STATS_T_TEST_INDEPU:
+                    case PlSqlParser.STATS_T_TEST_ONE:
+                    case PlSqlParser.STATS_T_TEST_PAIRED:
+                    case PlSqlParser.STATS_WSR_TEST:
+                    case PlSqlParser.STDDEV_POP:
+                    case PlSqlParser.STDDEV_SAMP:
+                    case PlSqlParser.STOP:
+                    case PlSqlParser.STORAGE:
+                    case PlSqlParser.STORE:
+                    case PlSqlParser.STREAMS:
+                    case PlSqlParser.STREAM:
+                    case PlSqlParser.STRICT:
+                    case PlSqlParser.STRING:
+                    case PlSqlParser.STRIPE_COLUMNS:
+                    case PlSqlParser.STRIPE_WIDTH:
+                    case PlSqlParser.STRIP:
+                    case PlSqlParser.STRUCTURE:
+                    case PlSqlParser.SUBMULTISET:
+                    case PlSqlParser.SUBPARTITION_REL:
+                    case PlSqlParser.SUBPARTITIONS:
+                    case PlSqlParser.SUBPARTITION:
+                    case PlSqlParser.SUBQUERIES:
+                    case PlSqlParser.SUBQUERY_PRUNING:
+                    case PlSqlParser.SUBSCRIBE:
+                    case PlSqlParser.SUBSET:
+                    case PlSqlParser.SUBSTITUTABLE:
+                    case PlSqlParser.SUBSTR2:
+                    case PlSqlParser.SUBSTR4:
+                    case PlSqlParser.SUBSTRB:
+                    case PlSqlParser.SUBSTRC:
+                    case PlSqlParser.SUBTYPE:
+                    case PlSqlParser.SUCCESSFUL:
+                    case PlSqlParser.SUCCESS:
+                    case PlSqlParser.SUMMARY:
+                    case PlSqlParser.SUPPLEMENTAL:
+                    case PlSqlParser.SUSPEND:
+                    case PlSqlParser.SWAP_JOIN_INPUTS:
+                    case PlSqlParser.SWITCHOVER:
+                    case PlSqlParser.SWITCH:
+                    case PlSqlParser.SYNCHRONOUS:
+                    case PlSqlParser.SYNC:
+                    case PlSqlParser.SYS:
+                    case PlSqlParser.SYSASM:
+                    case PlSqlParser.SYS_AUDIT:
+                    case PlSqlParser.SYSAUX:
+                    case PlSqlParser.SYSBACKUP:
+                    case PlSqlParser.SYS_CHECKACL:
+                    case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                    case PlSqlParser.SYS_CONNECT_BY_PATH:
+                    case PlSqlParser.SYS_CONTEXT:
+                    case PlSqlParser.SYSDATE:
+                    case PlSqlParser.SYSDBA:
+                    case PlSqlParser.SYS_DBURIGEN:
+                    case PlSqlParser.SYSDG:
+                    case PlSqlParser.SYS_DL_CURSOR:
+                    case PlSqlParser.SYS_DM_RXFORM_CHR:
+                    case PlSqlParser.SYS_DM_RXFORM_NUM:
+                    case PlSqlParser.SYS_DOM_COMPARE:
+                    case PlSqlParser.SYS_DST_PRIM2SEC:
+                    case PlSqlParser.SYS_DST_SEC2PRIM:
+                    case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                    case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                    case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                    case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                    case PlSqlParser.SYS_EXTPDTXT:
+                    case PlSqlParser.SYS_EXTRACT_UTC:
+                    case PlSqlParser.SYS_FBT_INSDEL:
+                    case PlSqlParser.SYS_FILTER_ACLS:
+                    case PlSqlParser.SYS_FNMATCHES:
+                    case PlSqlParser.SYS_FNREPLACE:
+                    case PlSqlParser.SYS_GET_ACLIDS:
+                    case PlSqlParser.SYS_GET_COL_ACLIDS:
+                    case PlSqlParser.SYS_GET_PRIVILEGES:
+                    case PlSqlParser.SYS_GETTOKENID:
+                    case PlSqlParser.SYS_GETXTIVAL:
+                    case PlSqlParser.SYS_GUID:
+                    case PlSqlParser.SYSGUID:
+                    case PlSqlParser.SYSKM:
+                    case PlSqlParser.SYS_MAKE_XMLNODEID:
+                    case PlSqlParser.SYS_MAKEXML:
+                    case PlSqlParser.SYS_MKXMLATTR:
+                    case PlSqlParser.SYS_MKXTI:
+                    case PlSqlParser.SYSOBJ:
+                    case PlSqlParser.SYS_OP_ADT2BIN:
+                    case PlSqlParser.SYS_OP_ADTCONS:
+                    case PlSqlParser.SYS_OP_ALSCRVAL:
+                    case PlSqlParser.SYS_OP_ATG:
+                    case PlSqlParser.SYS_OP_BIN2ADT:
+                    case PlSqlParser.SYS_OP_BITVEC:
+                    case PlSqlParser.SYS_OP_BL2R:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                    case PlSqlParser.SYS_OP_C2C:
+                    case PlSqlParser.SYS_OP_CAST:
+                    case PlSqlParser.SYS_OP_CEG:
+                    case PlSqlParser.SYS_OP_CL2C:
+                    case PlSqlParser.SYS_OP_COMBINED_HASH:
+                    case PlSqlParser.SYS_OP_COMP:
+                    case PlSqlParser.SYS_OP_CONVERT:
+                    case PlSqlParser.SYS_OP_COUNTCHG:
+                    case PlSqlParser.SYS_OP_CSCONV:
+                    case PlSqlParser.SYS_OP_CSCONVTEST:
+                    case PlSqlParser.SYS_OP_CSR:
+                    case PlSqlParser.SYS_OP_CSX_PATCH:
+                    case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                    case PlSqlParser.SYS_OP_DECOMP:
+                    case PlSqlParser.SYS_OP_DESCEND:
+                    case PlSqlParser.SYS_OP_DISTINCT:
+                    case PlSqlParser.SYS_OP_DRA:
+                    case PlSqlParser.SYS_OP_DUMP:
+                    case PlSqlParser.SYS_OP_DV_CHECK:
+                    case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                    case PlSqlParser.SYSOPER:
+                    case PlSqlParser.SYS_OP_EXTRACT:
+                    case PlSqlParser.SYS_OP_GROUPING:
+                    case PlSqlParser.SYS_OP_GUID:
+                    case PlSqlParser.SYS_OP_HASH:
+                    case PlSqlParser.SYS_OP_IIX:
+                    case PlSqlParser.SYS_OP_ITR:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                    case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                    case PlSqlParser.SYS_OP_LBID:
+                    case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2ID:
+                    case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                    case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                    case PlSqlParser.SYS_OP_LSVI:
+                    case PlSqlParser.SYS_OP_LVL:
+                    case PlSqlParser.SYS_OP_MAKEOID:
+                    case PlSqlParser.SYS_OP_MAP_NONNULL:
+                    case PlSqlParser.SYS_OP_MSR:
+                    case PlSqlParser.SYS_OP_NICOMBINE:
+                    case PlSqlParser.SYS_OP_NIEXTRACT:
+                    case PlSqlParser.SYS_OP_NII:
+                    case PlSqlParser.SYS_OP_NIX:
+                    case PlSqlParser.SYS_OP_NOEXPAND:
+                    case PlSqlParser.SYS_OP_NTCIMG:
+                    case PlSqlParser.SYS_OP_NUMTORAW:
+                    case PlSqlParser.SYS_OP_OIDVALUE:
+                    case PlSqlParser.SYS_OP_OPNSIZE:
+                    case PlSqlParser.SYS_OP_PAR_1:
+                    case PlSqlParser.SYS_OP_PARGID_1:
+                    case PlSqlParser.SYS_OP_PARGID:
+                    case PlSqlParser.SYS_OP_PAR:
+                    case PlSqlParser.SYS_OP_PART_ID:
+                    case PlSqlParser.SYS_OP_PIVOT:
+                    case PlSqlParser.SYS_OP_R2O:
+                    case PlSqlParser.SYS_OP_RAWTONUM:
+                    case PlSqlParser.SYS_OP_RDTM:
+                    case PlSqlParser.SYS_OP_REF:
+                    case PlSqlParser.SYS_OP_RMTD:
+                    case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                    case PlSqlParser.SYS_OP_RPB:
+                    case PlSqlParser.SYS_OPTLOBPRBSC:
+                    case PlSqlParser.SYS_OP_TOSETID:
+                    case PlSqlParser.SYS_OP_TPR:
+                    case PlSqlParser.SYS_OP_TRTB:
+                    case PlSqlParser.SYS_OPTXICMP:
+                    case PlSqlParser.SYS_OPTXQCASTASNQ:
+                    case PlSqlParser.SYS_OP_UNDESCEND:
+                    case PlSqlParser.SYS_OP_VECAND:
+                    case PlSqlParser.SYS_OP_VECBIT:
+                    case PlSqlParser.SYS_OP_VECOR:
+                    case PlSqlParser.SYS_OP_VECXOR:
+                    case PlSqlParser.SYS_OP_VERSION:
+                    case PlSqlParser.SYS_OP_VREF:
+                    case PlSqlParser.SYS_OP_VVD:
+                    case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                    case PlSqlParser.SYS_OP_XPTHATG:
+                    case PlSqlParser.SYS_OP_XPTHIDX:
+                    case PlSqlParser.SYS_OP_XPTHOP:
+                    case PlSqlParser.SYS_OP_XTXT2SQLT:
+                    case PlSqlParser.SYS_OP_ZONE_ID:
+                    case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                    case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                    case PlSqlParser.SYS_ORDERKEY_PARENT:
+                    case PlSqlParser.SYS_PARALLEL_TXN:
+                    case PlSqlParser.SYS_PATHID_IS_ATTR:
+                    case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                    case PlSqlParser.SYS_PATHID_LASTNAME:
+                    case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                    case PlSqlParser.SYS_PATH_REVERSE:
+                    case PlSqlParser.SYS_PXQEXTRACT:
+                    case PlSqlParser.SYS_RAW_TO_XSID:
+                    case PlSqlParser.SYS_RID_ORDER:
+                    case PlSqlParser.SYS_ROW_DELTA:
+                    case PlSqlParser.SYS_SC_2_XMLT:
+                    case PlSqlParser.SYS_SYNRCIREDO:
+                    case PlSqlParser.SYSTEM_DEFINED:
+                    case PlSqlParser.SYSTEM:
+                    case PlSqlParser.SYSTIMESTAMP:
+                    case PlSqlParser.SYS_TYPEID:
+                    case PlSqlParser.SYS_UMAKEXML:
+                    case PlSqlParser.SYS_XMLANALYZE:
+                    case PlSqlParser.SYS_XMLCONTAINS:
+                    case PlSqlParser.SYS_XMLCONV:
+                    case PlSqlParser.SYS_XMLEXNSURI:
+                    case PlSqlParser.SYS_XMLGEN:
+                    case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                    case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                    case PlSqlParser.SYS_XMLINSTR:
+                    case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETCID:
+                    case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                    case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                    case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                    case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETRID:
+                    case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                    case PlSqlParser.SYS_XMLNODEID_GETTID:
+                    case PlSqlParser.SYS_XMLNODEID:
+                    case PlSqlParser.SYS_XMLT_2_SC:
+                    case PlSqlParser.SYS_XMLTRANSLATE:
+                    case PlSqlParser.SYS_XMLTYPE2SQL:
+                    case PlSqlParser.SYS_XQ_ASQLCNV:
+                    case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                    case PlSqlParser.SYS_XQBASEURI:
+                    case PlSqlParser.SYS_XQCASTABLEERRH:
+                    case PlSqlParser.SYS_XQCODEP2STR:
+                    case PlSqlParser.SYS_XQCODEPEQ:
+                    case PlSqlParser.SYS_XQCON2SEQ:
+                    case PlSqlParser.SYS_XQCONCAT:
+                    case PlSqlParser.SYS_XQDELETE:
+                    case PlSqlParser.SYS_XQDFLTCOLATION:
+                    case PlSqlParser.SYS_XQDOC:
+                    case PlSqlParser.SYS_XQDOCURI:
+                    case PlSqlParser.SYS_XQDURDIV:
+                    case PlSqlParser.SYS_XQED4URI:
+                    case PlSqlParser.SYS_XQENDSWITH:
+                    case PlSqlParser.SYS_XQERRH:
+                    case PlSqlParser.SYS_XQERR:
+                    case PlSqlParser.SYS_XQESHTMLURI:
+                    case PlSqlParser.SYS_XQEXLOBVAL:
+                    case PlSqlParser.SYS_XQEXSTWRP:
+                    case PlSqlParser.SYS_XQEXTRACT:
+                    case PlSqlParser.SYS_XQEXTRREF:
+                    case PlSqlParser.SYS_XQEXVAL:
+                    case PlSqlParser.SYS_XQFB2STR:
+                    case PlSqlParser.SYS_XQFNBOOL:
+                    case PlSqlParser.SYS_XQFNCMP:
+                    case PlSqlParser.SYS_XQFNDATIM:
+                    case PlSqlParser.SYS_XQFNLNAME:
+                    case PlSqlParser.SYS_XQFNNM:
+                    case PlSqlParser.SYS_XQFNNSURI:
+                    case PlSqlParser.SYS_XQFNPREDTRUTH:
+                    case PlSqlParser.SYS_XQFNQNM:
+                    case PlSqlParser.SYS_XQFNROOT:
+                    case PlSqlParser.SYS_XQFORMATNUM:
+                    case PlSqlParser.SYS_XQFTCONTAIN:
+                    case PlSqlParser.SYS_XQFUNCR:
+                    case PlSqlParser.SYS_XQGETCONTENT:
+                    case PlSqlParser.SYS_XQINDXOF:
+                    case PlSqlParser.SYS_XQINSERT:
+                    case PlSqlParser.SYS_XQINSPFX:
+                    case PlSqlParser.SYS_XQIRI2URI:
+                    case PlSqlParser.SYS_XQLANG:
+                    case PlSqlParser.SYS_XQLLNMFRMQNM:
+                    case PlSqlParser.SYS_XQMKNODEREF:
+                    case PlSqlParser.SYS_XQNILLED:
+                    case PlSqlParser.SYS_XQNODENAME:
+                    case PlSqlParser.SYS_XQNORMSPACE:
+                    case PlSqlParser.SYS_XQNORMUCODE:
+                    case PlSqlParser.SYS_XQ_NRNG:
+                    case PlSqlParser.SYS_XQNSP4PFX:
+                    case PlSqlParser.SYS_XQNSPFRMQNM:
+                    case PlSqlParser.SYS_XQPFXFRMQNM:
+                    case PlSqlParser.SYS_XQ_PKSQL2XML:
+                    case PlSqlParser.SYS_XQPOLYABS:
+                    case PlSqlParser.SYS_XQPOLYADD:
+                    case PlSqlParser.SYS_XQPOLYCEL:
+                    case PlSqlParser.SYS_XQPOLYCSTBL:
+                    case PlSqlParser.SYS_XQPOLYCST:
+                    case PlSqlParser.SYS_XQPOLYDIV:
+                    case PlSqlParser.SYS_XQPOLYFLR:
+                    case PlSqlParser.SYS_XQPOLYMOD:
+                    case PlSqlParser.SYS_XQPOLYMUL:
+                    case PlSqlParser.SYS_XQPOLYRND:
+                    case PlSqlParser.SYS_XQPOLYSQRT:
+                    case PlSqlParser.SYS_XQPOLYSUB:
+                    case PlSqlParser.SYS_XQPOLYUMUS:
+                    case PlSqlParser.SYS_XQPOLYUPLS:
+                    case PlSqlParser.SYS_XQPOLYVEQ:
+                    case PlSqlParser.SYS_XQPOLYVGE:
+                    case PlSqlParser.SYS_XQPOLYVGT:
+                    case PlSqlParser.SYS_XQPOLYVLE:
+                    case PlSqlParser.SYS_XQPOLYVLT:
+                    case PlSqlParser.SYS_XQPOLYVNE:
+                    case PlSqlParser.SYS_XQREF2VAL:
+                    case PlSqlParser.SYS_XQRENAME:
+                    case PlSqlParser.SYS_XQREPLACE:
+                    case PlSqlParser.SYS_XQRESVURI:
+                    case PlSqlParser.SYS_XQRNDHALF2EVN:
+                    case PlSqlParser.SYS_XQRSLVQNM:
+                    case PlSqlParser.SYS_XQRYENVPGET:
+                    case PlSqlParser.SYS_XQRYVARGET:
+                    case PlSqlParser.SYS_XQRYWRP:
+                    case PlSqlParser.SYS_XQSEQ2CON4XC:
+                    case PlSqlParser.SYS_XQSEQ2CON:
+                    case PlSqlParser.SYS_XQSEQDEEPEQ:
+                    case PlSqlParser.SYS_XQSEQINSB:
+                    case PlSqlParser.SYS_XQSEQRM:
+                    case PlSqlParser.SYS_XQSEQRVS:
+                    case PlSqlParser.SYS_XQSEQSUB:
+                    case PlSqlParser.SYS_XQSEQTYPMATCH:
+                    case PlSqlParser.SYS_XQSTARTSWITH:
+                    case PlSqlParser.SYS_XQSTATBURI:
+                    case PlSqlParser.SYS_XQSTR2CODEP:
+                    case PlSqlParser.SYS_XQSTRJOIN:
+                    case PlSqlParser.SYS_XQSUBSTRAFT:
+                    case PlSqlParser.SYS_XQSUBSTRBEF:
+                    case PlSqlParser.SYS_XQTOKENIZE:
+                    case PlSqlParser.SYS_XQTREATAS:
+                    case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                    case PlSqlParser.SYS_XQXFORM:
+                    case PlSqlParser.SYS_XSID_TO_RAW:
+                    case PlSqlParser.SYS_ZMAP_FILTER:
+                    case PlSqlParser.SYS_ZMAP_REFRESH:
+                    case PlSqlParser.T_LETTER:
+                    case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                    case PlSqlParser.TABLESPACE_NO:
+                    case PlSqlParser.TABLESPACE:
+                    case PlSqlParser.TABLES:
+                    case PlSqlParser.TABLE_STATS:
+                    case PlSqlParser.TABLE:
+                    case PlSqlParser.TABNO:
+                    case PlSqlParser.TAG:
+                    case PlSqlParser.TANH:
+                    case PlSqlParser.TAN:
+                    case PlSqlParser.TBLORIDXPARTNUM:
+                    case PlSqlParser.TEMPFILE:
+                    case PlSqlParser.TEMPLATE:
+                    case PlSqlParser.TEMPLATE_TABLE:
+                    case PlSqlParser.TEMPORARY:
+                    case PlSqlParser.TEMP_TABLE:
+                    case PlSqlParser.TEST:
+                    case PlSqlParser.TEXT:
+                    case PlSqlParser.THAN:
+                    case PlSqlParser.THEN:
+                    case PlSqlParser.THE:
+                    case PlSqlParser.THREAD:
+                    case PlSqlParser.THROUGH:
+                    case PlSqlParser.TIER:
+                    case PlSqlParser.TIES:
+                    case PlSqlParser.TIMEOUT:
+                    case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP:
+                    case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                    case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                    case PlSqlParser.TIMES:
+                    case PlSqlParser.TIME:
+                    case PlSqlParser.TIMEZONE:
+                    case PlSqlParser.TIMEZONE_ABBR:
+                    case PlSqlParser.TIMEZONE_HOUR:
+                    case PlSqlParser.TIMEZONE_MINUTE:
+                    case PlSqlParser.TIMEZONE_OFFSET:
+                    case PlSqlParser.TIMEZONE_REGION:
+                    case PlSqlParser.TIME_ZONE:
+                    case PlSqlParser.TIMING:
+                    case PlSqlParser.TIV_GB:
+                    case PlSqlParser.TIV_SSF:
+                    case PlSqlParser.TO_ACLID:
+                    case PlSqlParser.TO_BINARY_DOUBLE:
+                    case PlSqlParser.TO_BINARY_FLOAT:
+                    case PlSqlParser.TO_BLOB:
+                    case PlSqlParser.TO_CLOB:
+                    case PlSqlParser.TO_DSINTERVAL:
+                    case PlSqlParser.TO_LOB:
+                    case PlSqlParser.TO_MULTI_BYTE:
+                    case PlSqlParser.TO_NCHAR:
+                    case PlSqlParser.TO_NCLOB:
+                    case PlSqlParser.TO_NUMBER:
+                    case PlSqlParser.TOPLEVEL:
+                    case PlSqlParser.TO_SINGLE_BYTE:
+                    case PlSqlParser.TO_TIMESTAMP:
+                    case PlSqlParser.TO_TIMESTAMP_TZ:
+                    case PlSqlParser.TO_TIME:
+                    case PlSqlParser.TO_TIME_TZ:
+                    case PlSqlParser.TO_YMINTERVAL:
+                    case PlSqlParser.TRACE:
+                    case PlSqlParser.TRACING:
+                    case PlSqlParser.TRACKING:
+                    case PlSqlParser.TRAILING:
+                    case PlSqlParser.TRANSACTION:
+                    case PlSqlParser.TRANSFORM:
+                    case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                    case PlSqlParser.TRANSITIONAL:
+                    case PlSqlParser.TRANSITION:
+                    case PlSqlParser.TRANSLATE:
+                    case PlSqlParser.TRANSLATION:
+                    case PlSqlParser.TREAT:
+                    case PlSqlParser.TRIGGERS:
+                    case PlSqlParser.TRIGGER:
+                    case PlSqlParser.TRUE:
+                    case PlSqlParser.TRUNCATE:
+                    case PlSqlParser.TRUNC:
+                    case PlSqlParser.TRUSTED:
+                    case PlSqlParser.TRUST:
+                    case PlSqlParser.TUNING:
+                    case PlSqlParser.TX:
+                    case PlSqlParser.TYPES:
+                    case PlSqlParser.TYPE:
+                    case PlSqlParser.TZ_OFFSET:
+                    case PlSqlParser.UB2:
+                    case PlSqlParser.UBA:
+                    case PlSqlParser.UCS2:
+                    case PlSqlParser.UDF:
+                    case PlSqlParser.UID:
+                    case PlSqlParser.UNARCHIVED:
+                    case PlSqlParser.UNBOUNDED:
+                    case PlSqlParser.UNBOUND:
+                    case PlSqlParser.UNCONDITIONAL:
+                    case PlSqlParser.UNDER:
+                    case PlSqlParser.UNDO:
+                    case PlSqlParser.UNDROP:
+                    case PlSqlParser.UNIFORM:
+                    case PlSqlParser.UNISTR:
+                    case PlSqlParser.UNLIMITED:
+                    case PlSqlParser.UNLOAD:
+                    case PlSqlParser.UNLOCK:
+                    case PlSqlParser.UNMATCHED:
+                    case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                    case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                    case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                    case PlSqlParser.UNNEST:
+                    case PlSqlParser.UNPACKED:
+                    case PlSqlParser.UNPIVOT:
+                    case PlSqlParser.UNPLUG:
+                    case PlSqlParser.UNPROTECTED:
+                    case PlSqlParser.UNQUIESCE:
+                    case PlSqlParser.UNRECOVERABLE:
+                    case PlSqlParser.UNRESTRICTED:
+                    case PlSqlParser.UNSUBSCRIBE:
+                    case PlSqlParser.UNTIL:
+                    case PlSqlParser.UNUSABLE:
+                    case PlSqlParser.UNUSED:
+                    case PlSqlParser.UPDATABLE:
+                    case PlSqlParser.UPDATED:
+                    case PlSqlParser.UPDATEXML:
+                    case PlSqlParser.UPD_INDEXES:
+                    case PlSqlParser.UPD_JOININDEX:
+                    case PlSqlParser.UPGRADE:
+                    case PlSqlParser.UPPER:
+                    case PlSqlParser.UPSERT:
+                    case PlSqlParser.UROWID:
+                    case PlSqlParser.USABLE:
+                    case PlSqlParser.USAGE:
+                    case PlSqlParser.USE_ANTI:
+                    case PlSqlParser.USE_CONCAT:
+                    case PlSqlParser.USE_CUBE:
+                    case PlSqlParser.USE_HASH_AGGREGATION:
+                    case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                    case PlSqlParser.USE_HASH:
+                    case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                    case PlSqlParser.USE_INVISIBLE_INDEXES:
+                    case PlSqlParser.USE_MERGE_CARTESIAN:
+                    case PlSqlParser.USE_MERGE:
+                    case PlSqlParser.USE_NL:
+                    case PlSqlParser.USE_NL_WITH_INDEX:
+                    case PlSqlParser.USE_PRIVATE_OUTLINES:
+                    case PlSqlParser.USER_DATA:
+                    case PlSqlParser.USER_DEFINED:
+                    case PlSqlParser.USERENV:
+                    case PlSqlParser.USERGROUP:
+                    case PlSqlParser.USER_RECYCLEBIN:
+                    case PlSqlParser.USERS:
+                    case PlSqlParser.USER_TABLESPACES:
+                    case PlSqlParser.USER:
+                    case PlSqlParser.USE_SEMI:
+                    case PlSqlParser.USE_STORED_OUTLINES:
+                    case PlSqlParser.USE_TTT_FOR_GSETS:
+                    case PlSqlParser.USE:
+                    case PlSqlParser.USE_VECTOR_AGGREGATION:
+                    case PlSqlParser.USE_WEAK_NAME_RESL:
+                    case PlSqlParser.USING_NO_EXPAND:
+                    case PlSqlParser.USING_NLS_COMP:
+                    case PlSqlParser.USING:
+                    case PlSqlParser.UTF16BE:
+                    case PlSqlParser.UTF16LE:
+                    case PlSqlParser.UTF32:
+                    case PlSqlParser.UTF8:
+                    case PlSqlParser.V1:
+                    case PlSqlParser.V2:
+                    case PlSqlParser.VALIDATE:
+                    case PlSqlParser.VALIDATE_CONVERSION:
+                    case PlSqlParser.VALIDATION:
+                    case PlSqlParser.VALID_TIME_END:
+                    case PlSqlParser.VALUE:
+                    case PlSqlParser.VARCHAR2:
+                    case PlSqlParser.VARCHAR:
+                    case PlSqlParser.VARIABLE:
+                    case PlSqlParser.VAR_POP:
+                    case PlSqlParser.VARRAYS:
+                    case PlSqlParser.VARRAY:
+                    case PlSqlParser.VAR_SAMP:
+                    case PlSqlParser.VARYING:
+                    case PlSqlParser.VECTOR_READ_TRACE:
+                    case PlSqlParser.VECTOR_READ:
+                    case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                    case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                    case PlSqlParser.VECTOR_TRANSFORM:
+                    case PlSqlParser.VERIFIER:
+                    case PlSqlParser.VERIFY:
+                    case PlSqlParser.VERSIONING:
+                    case PlSqlParser.VERSIONS_ENDSCN:
+                    case PlSqlParser.VERSIONS_ENDTIME:
+                    case PlSqlParser.VERSIONS_OPERATION:
+                    case PlSqlParser.VERSIONS_STARTSCN:
+                    case PlSqlParser.VERSIONS_STARTTIME:
+                    case PlSqlParser.VERSIONS:
+                    case PlSqlParser.VERSIONS_XID:
+                    case PlSqlParser.VERSION:
+                    case PlSqlParser.VIOLATION:
+                    case PlSqlParser.VIRTUAL:
+                    case PlSqlParser.VISIBILITY:
+                    case PlSqlParser.VISIBLE:
+                    case PlSqlParser.VOLUME:
+                    case PlSqlParser.VSIZE:
+                    case PlSqlParser.WAIT:
+                    case PlSqlParser.WALLET:
+                    case PlSqlParser.WARNING:
+                    case PlSqlParser.WEEKS:
+                    case PlSqlParser.WEEK:
+                    case PlSqlParser.WELLFORMED:
+                    case PlSqlParser.WHENEVER:
+                    case PlSqlParser.WHEN:
+                    case PlSqlParser.WHILE:
+                    case PlSqlParser.WHITESPACE:
+                    case PlSqlParser.WIDTH_BUCKET:
+                    case PlSqlParser.WITHIN:
+                    case PlSqlParser.WITHOUT:
+                    case PlSqlParser.WITH_PLSQL:
+                    case PlSqlParser.WORK:
+                    case PlSqlParser.WRAPPED:
+                    case PlSqlParser.WRAPPER:
+                    case PlSqlParser.WRITE:
+                    case PlSqlParser.XDB_FASTPATH_INSERT:
+                    case PlSqlParser.X_DYN_PRUNE:
+                    case PlSqlParser.XID:
+                    case PlSqlParser.XML2OBJECT:
+                    case PlSqlParser.XMLAGG:
+                    case PlSqlParser.XMLATTRIBUTES:
+                    case PlSqlParser.XMLCAST:
+                    case PlSqlParser.XMLCDATA:
+                    case PlSqlParser.XMLCOLATTVAL:
+                    case PlSqlParser.XMLCOMMENT:
+                    case PlSqlParser.XMLCONCAT:
+                    case PlSqlParser.XMLDIFF:
+                    case PlSqlParser.XML_DML_RWT_STMT:
+                    case PlSqlParser.XMLELEMENT:
+                    case PlSqlParser.XMLEXISTS2:
+                    case PlSqlParser.XMLEXISTS:
+                    case PlSqlParser.XMLFOREST:
+                    case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                    case PlSqlParser.XMLINDEX_REWRITE:
+                    case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                    case PlSqlParser.XMLISNODE:
+                    case PlSqlParser.XMLISVALID:
+                    case PlSqlParser.XMLNAMESPACES:
+                    case PlSqlParser.XMLPARSE:
+                    case PlSqlParser.XMLPATCH:
+                    case PlSqlParser.XMLPI:
+                    case PlSqlParser.XMLQUERYVAL:
+                    case PlSqlParser.XMLQUERY:
+                    case PlSqlParser.XMLROOT:
+                    case PlSqlParser.XMLSCHEMA:
+                    case PlSqlParser.XMLSERIALIZE:
+                    case PlSqlParser.XMLTABLE:
+                    case PlSqlParser.XMLTRANSFORMBLOB:
+                    case PlSqlParser.XMLTRANSFORM:
+                    case PlSqlParser.XMLTYPE:
+                    case PlSqlParser.XML:
+                    case PlSqlParser.XPATHTABLE:
+                    case PlSqlParser.XS_SYS_CONTEXT:
+                    case PlSqlParser.XS:
+                    case PlSqlParser.YEARS:
+                    case PlSqlParser.YEAR:
+                    case PlSqlParser.YES:
+                    case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                    case PlSqlParser.ZONEMAP:
+                    case PlSqlParser.ZONE:
+                    case PlSqlParser.PREDICTION:
+                    case PlSqlParser.PREDICTION_BOUNDS:
+                    case PlSqlParser.PREDICTION_COST:
+                    case PlSqlParser.PREDICTION_DETAILS:
+                    case PlSqlParser.PREDICTION_PROBABILITY:
+                    case PlSqlParser.PREDICTION_SET:
+                    case PlSqlParser.BLOCKCHAIN:
+                    case PlSqlParser.COLLATE:
+                    case PlSqlParser.COLLATION:
+                    case PlSqlParser.DEFINITION:
+                    case PlSqlParser.DUPLICATED:
+                    case PlSqlParser.EXTENDED:
+                    case PlSqlParser.HASHING:
+                    case PlSqlParser.IDLE:
+                    case PlSqlParser.IMMUTABLE:
+                    case PlSqlParser.ORACLE_DATAPUMP:
+                    case PlSqlParser.ORACLE_HDFS:
+                    case PlSqlParser.ORACLE_HIVE:
+                    case PlSqlParser.ORACLE_LOADER:
+                    case PlSqlParser.SHARDED:
+                    case PlSqlParser.ISOLATE:
+                    case PlSqlParser.ROOT:
+                    case PlSqlParser.UNITE:
+                    case PlSqlParser.ALGORITHM:
+                    case PlSqlParser.CUME_DIST:
+                    case PlSqlParser.DENSE_RANK:
+                    case PlSqlParser.LISTAGG:
+                    case PlSqlParser.PERCENT_RANK:
+                    case PlSqlParser.PERCENTILE_CONT:
+                    case PlSqlParser.PERCENTILE_DISC:
+                    case PlSqlParser.RANK:
+                    case PlSqlParser.AVG:
+                    case PlSqlParser.CORR:
+                    case PlSqlParser.COVAR_:
+                    case PlSqlParser.LAG:
+                    case PlSqlParser.LEAD:
+                    case PlSqlParser.MAX:
+                    case PlSqlParser.MEDIAN:
+                    case PlSqlParser.MEMOPTIMIZE:
+                    case PlSqlParser.MIN:
+                    case PlSqlParser.NTILE:
+                    case PlSqlParser.NVL:
+                    case PlSqlParser.RATIO_TO_REPORT:
+                    case PlSqlParser.REGR_:
+                    case PlSqlParser.ROUND:
+                    case PlSqlParser.ROW_NUMBER:
+                    case PlSqlParser.SUBSTR:
+                    case PlSqlParser.TO_CHAR:
+                    case PlSqlParser.TRIM:
+                    case PlSqlParser.SUM:
+                    case PlSqlParser.STDDEV:
+                    case PlSqlParser.VAR_:
+                    case PlSqlParser.VARIANCE:
+                    case PlSqlParser.LEAST:
+                    case PlSqlParser.GREATEST:
+                    case PlSqlParser.TO_DATE:
+                    case PlSqlParser.CHARSETID:
+                    case PlSqlParser.CHARSETFORM:
+                    case PlSqlParser.DURATION:
+                    case PlSqlParser.EXTEND:
+                    case PlSqlParser.MAXLEN:
+                    case PlSqlParser.PERSISTABLE:
+                    case PlSqlParser.POLYMORPHIC:
+                    case PlSqlParser.STRUCT:
+                    case PlSqlParser.TDO:
+                    case PlSqlParser.WM_CONCAT:
+                    case PlSqlParser.PERIOD:
+                    case PlSqlParser.DELIMITED_ID:
+                    case PlSqlParser.LEFT_PAREN:
+                    case PlSqlParser.INTRODUCER:
+                    case PlSqlParser.REGULAR_ID:
+                        {
+                        this.state = 20453;
+                        this.general_element(0);
+                        }
+                        break;
+                    case PlSqlParser.BINDVAR:
+                    case PlSqlParser.COLON:
+                        {
+                        this.state = 20454;
+                        this.bind_variable();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    }
+                }
+                this.state = 20461;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2906, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xml_column_name(): Xml_column_nameContext {
+        let localContext = new Xml_column_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2302, PlSqlParser.RULE_xml_column_name);
+        try {
+            this.state = 20464;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20462;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20463;
+                this.quoted_string();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cost_class_name(): Cost_class_nameContext {
+        let localContext = new Cost_class_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2304, PlSqlParser.RULE_cost_class_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20466;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public attribute_name(): Attribute_nameContext {
+        let localContext = new Attribute_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2306, PlSqlParser.RULE_attribute_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20468;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public savepoint_name(): Savepoint_nameContext {
+        let localContext = new Savepoint_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2308, PlSqlParser.RULE_savepoint_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20470;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public rollback_segment_name(): Rollback_segment_nameContext {
+        let localContext = new Rollback_segment_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2310, PlSqlParser.RULE_rollback_segment_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20472;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public schema_name(): Schema_nameContext {
+        let localContext = new Schema_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2312, PlSqlParser.RULE_schema_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20474;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public routine_name(): Routine_nameContext {
+        let localContext = new Routine_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2314, PlSqlParser.RULE_routine_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20476;
+            this.identifier();
+            this.state = 20481;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2908, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20477;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20478;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20483;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2908, this.context);
+            }
+            this.state = 20486;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2909, this.context) ) {
+            case 1:
+                {
+                this.state = 20484;
+                this.match(PlSqlParser.AT_SIGN);
+                this.state = 20485;
+                this.link_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public package_name(): Package_nameContext {
+        let localContext = new Package_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2316, PlSqlParser.RULE_package_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20488;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public implementation_type_name(): Implementation_type_nameContext {
+        let localContext = new Implementation_type_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2318, PlSqlParser.RULE_implementation_type_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20490;
+            this.identifier();
+            this.state = 20493;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2910, this.context) ) {
+            case 1:
+                {
+                this.state = 20491;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20492;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public parameter_name(): Parameter_nameContext {
+        let localContext = new Parameter_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2320, PlSqlParser.RULE_parameter_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20495;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public reference_model_name(): Reference_model_nameContext {
+        let localContext = new Reference_model_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2322, PlSqlParser.RULE_reference_model_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20497;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public main_model_name(): Main_model_nameContext {
+        let localContext = new Main_model_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2324, PlSqlParser.RULE_main_model_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20499;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public container_tableview_name(): Container_tableview_nameContext {
+        let localContext = new Container_tableview_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2326, PlSqlParser.RULE_container_tableview_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20501;
+            this.identifier();
+            this.state = 20504;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2911, this.context) ) {
+            case 1:
+                {
+                this.state = 20502;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20503;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public aggregate_function_name(): Aggregate_function_nameContext {
+        let localContext = new Aggregate_function_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2328, PlSqlParser.RULE_aggregate_function_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20506;
+            this.identifier();
+            this.state = 20511;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2912, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20507;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20508;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20513;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2912, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public query_name(): Query_nameContext {
+        let localContext = new Query_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2330, PlSqlParser.RULE_query_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20514;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public grantee_name(): Grantee_nameContext {
+        let localContext = new Grantee_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2332, PlSqlParser.RULE_grantee_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20516;
+            this.id_expression();
+            this.state = 20518;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2913, this.context) ) {
+            case 1:
+                {
+                this.state = 20517;
+                this.identified_by();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public role_name(): Role_nameContext {
+        let localContext = new Role_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2334, PlSqlParser.RULE_role_name);
+        try {
+            this.state = 20522;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20520;
+                this.id_expression();
+                }
+                break;
+            case PlSqlParser.CONNECT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20521;
+                this.match(PlSqlParser.CONNECT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public constraint_name(): Constraint_nameContext {
+        let localContext = new Constraint_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2336, PlSqlParser.RULE_constraint_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20524;
+            this.identifier();
+            this.state = 20529;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2915, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20525;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20526;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20531;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2915, this.context);
+            }
+            this.state = 20534;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2916, this.context) ) {
+            case 1:
+                {
+                this.state = 20532;
+                this.match(PlSqlParser.AT_SIGN);
+                this.state = 20533;
+                this.link_name();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public label_name(): Label_nameContext {
+        let localContext = new Label_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2338, PlSqlParser.RULE_label_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20536;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_name(): Type_nameContext {
+        let localContext = new Type_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2340, PlSqlParser.RULE_type_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20538;
+            this.id_expression();
+            this.state = 20543;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2917, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20539;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20540;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20545;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2917, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public sequence_name(): Sequence_nameContext {
+        let localContext = new Sequence_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2342, PlSqlParser.RULE_sequence_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20546;
+            this.id_expression();
+            this.state = 20551;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2918, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20547;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20548;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20553;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2918, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public exception_name(): Exception_nameContext {
+        let localContext = new Exception_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2344, PlSqlParser.RULE_exception_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20554;
+            this.identifier();
+            this.state = 20559;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2919, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20555;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20556;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20561;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2919, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_name(): Function_nameContext {
+        let localContext = new Function_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2346, PlSqlParser.RULE_function_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20562;
+            this.identifier();
+            this.state = 20565;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2920, this.context) ) {
+            case 1:
+                {
+                this.state = 20563;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20564;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public procedure_name(): Procedure_nameContext {
+        let localContext = new Procedure_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2348, PlSqlParser.RULE_procedure_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20567;
+            this.identifier();
+            this.state = 20570;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2921, this.context) ) {
+            case 1:
+                {
+                this.state = 20568;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20569;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public trigger_name(): Trigger_nameContext {
+        let localContext = new Trigger_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2350, PlSqlParser.RULE_trigger_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20572;
+            this.identifier();
+            this.state = 20575;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2922, this.context) ) {
+            case 1:
+                {
+                this.state = 20573;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20574;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public variable_name(): Variable_nameContext {
+        let localContext = new Variable_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2352, PlSqlParser.RULE_variable_name);
+        let _la: number;
+        try {
+            this.state = 20587;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20579;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2477) {
+                    {
+                    this.state = 20577;
+                    this.match(PlSqlParser.INTRODUCER);
+                    this.state = 20578;
+                    this.char_set_name();
+                    }
+                }
+
+                this.state = 20581;
+                this.id_expression();
+                this.state = 20584;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2924, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20582;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20583;
+                    this.id_expression();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.BINDVAR:
+            case PlSqlParser.COLON:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20586;
+                this.bind_variable();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public index_name(): Index_nameContext {
+        let localContext = new Index_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2354, PlSqlParser.RULE_index_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20589;
+            this.identifier();
+            this.state = 20592;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2926, this.context) ) {
+            case 1:
+                {
+                this.state = 20590;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20591;
+                this.id_expression();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public cursor_name(): Cursor_nameContext {
+        let localContext = new Cursor_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2356, PlSqlParser.RULE_cursor_name);
+        try {
+            this.state = 20596;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.LEFT_PAREN:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20594;
+                this.general_element(0);
+                }
+                break;
+            case PlSqlParser.BINDVAR:
+            case PlSqlParser.COLON:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20595;
+                this.bind_variable();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public record_name(): Record_nameContext {
+        let localContext = new Record_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2358, PlSqlParser.RULE_record_name);
+        try {
+            this.state = 20600;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20598;
+                this.identifier();
+                }
+                break;
+            case PlSqlParser.BINDVAR:
+            case PlSqlParser.COLON:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20599;
+                this.bind_variable();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public link_name(): Link_nameContext {
+        let localContext = new Link_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2360, PlSqlParser.RULE_link_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20602;
+            this.database();
+            this.state = 20607;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2929, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20603;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20604;
+                    this.domain();
+                    }
+                    }
+                }
+                this.state = 20609;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2929, this.context);
+            }
+            this.state = 20612;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2930, this.context) ) {
+            case 1:
+                {
+                this.state = 20610;
+                this.match(PlSqlParser.AT_SIGN);
+                this.state = 20611;
+                this.connection_qualifier();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public local_link_name(): Local_link_nameContext {
+        let localContext = new Local_link_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2362, PlSqlParser.RULE_local_link_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20614;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public connection_qualifier(): Connection_qualifierContext {
+        let localContext = new Connection_qualifierContext(this.context, this.state);
+        this.enterRule(localContext, 2364, PlSqlParser.RULE_connection_qualifier);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20616;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_name(): Column_nameContext {
+        let localContext = new Column_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2366, PlSqlParser.RULE_column_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20618;
+            this.identifier();
+            this.state = 20623;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2931, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20619;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20620;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20625;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2931, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public tableview_name(): Tableview_nameContext {
+        let localContext = new Tableview_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2368, PlSqlParser.RULE_tableview_name);
+        try {
+            this.state = 20640;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2935, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20626;
+                this.identifier();
+                this.state = 20629;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2932, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20627;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20628;
+                    this.id_expression();
+                    }
+                    break;
+                }
+                this.state = 20634;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2933, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20631;
+                    this.match(PlSqlParser.AT_SIGN);
+                    this.state = 20632;
+                    this.link_name();
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 20633;
+                    this.partition_extension_clause();
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20636;
+                this.xmltable();
+                this.state = 20638;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2934, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20637;
+                    this.outer_join_sign();
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public xmltable(): XmltableContext {
+        let localContext = new XmltableContext(this.context, this.state);
+        this.enterRule(localContext, 2370, PlSqlParser.RULE_xmltable);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20642;
+            this.match(PlSqlParser.XMLTABLE);
+            this.state = 20643;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20647;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2936, this.context) ) {
+            case 1:
+                {
+                this.state = 20644;
+                this.xml_namespaces_clause();
+                this.state = 20645;
+                this.match(PlSqlParser.COMMA);
+                }
+                break;
+            }
+            this.state = 20649;
+            this.concatenation(0);
+            this.state = 20651;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1354) {
+                {
+                this.state = 20650;
+                this.xml_passing_clause();
+                }
+            }
+
+            this.state = 20657;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1587) {
+                {
+                this.state = 20653;
+                this.match(PlSqlParser.RETURNING);
+                this.state = 20654;
+                this.match(PlSqlParser.SEQUENCE);
+                this.state = 20655;
+                this.match(PlSqlParser.BY);
+                this.state = 20656;
+                this.match(PlSqlParser.REF);
+                }
+            }
+
+            this.state = 20668;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 238) {
+                {
+                this.state = 20659;
+                this.match(PlSqlParser.COLUMNS);
+                this.state = 20660;
+                this.xml_table_column();
+                this.state = 20665;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 20661;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20662;
+                    this.xml_table_column();
+                    }
+                    }
+                    this.state = 20667;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+            }
+
+            this.state = 20670;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 20673;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2941, this.context) ) {
+            case 1:
+                {
+                this.state = 20671;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20672;
+                this.general_element_part();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public char_set_name(): Char_set_nameContext {
+        let localContext = new Char_set_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2372, PlSqlParser.RULE_char_set_name);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20675;
+            this.id_expression();
+            this.state = 20680;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2942, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20676;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20677;
+                    this.id_expression();
+                    }
+                    }
+                }
+                this.state = 20682;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2942, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public synonym_name(): Synonym_nameContext {
+        let localContext = new Synonym_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2374, PlSqlParser.RULE_synonym_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20683;
+            this.identifier();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public schema_object_name(): Schema_object_nameContext {
+        let localContext = new Schema_object_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2376, PlSqlParser.RULE_schema_object_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20685;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public dir_object_name(): Dir_object_nameContext {
+        let localContext = new Dir_object_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2378, PlSqlParser.RULE_dir_object_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20687;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public user_object_name(): User_object_nameContext {
+        let localContext = new User_object_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2380, PlSqlParser.RULE_user_object_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20689;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public grant_object_name(): Grant_object_nameContext {
+        let localContext = new Grant_object_nameContext(this.context, this.state);
+        this.enterRule(localContext, 2382, PlSqlParser.RULE_grant_object_name);
+        let _la: number;
+        try {
+            this.state = 20715;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2944, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20691;
+                this.tableview_name();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20692;
+                this.match(PlSqlParser.USER);
+                this.state = 20693;
+                this.user_object_name();
+                this.state = 20698;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 20694;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20695;
+                    this.user_object_name();
+                    }
+                    }
+                    this.state = 20700;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 20701;
+                this.match(PlSqlParser.DIRECTORY);
+                this.state = 20702;
+                this.dir_object_name();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 20703;
+                this.match(PlSqlParser.EDITION);
+                this.state = 20704;
+                this.schema_object_name();
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 20705;
+                this.match(PlSqlParser.MINING);
+                this.state = 20706;
+                this.match(PlSqlParser.MODEL);
+                this.state = 20707;
+                this.schema_object_name();
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 20708;
+                this.match(PlSqlParser.JAVA);
+                this.state = 20709;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 1572 || _la === 1715)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 20710;
+                this.schema_object_name();
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 20711;
+                this.match(PlSqlParser.SQL);
+                this.state = 20712;
+                this.match(PlSqlParser.TRANSLATION);
+                this.state = 20713;
+                this.match(PlSqlParser.PROFILE);
+                this.state = 20714;
+                this.schema_object_name();
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public column_list(): Column_listContext {
+        let localContext = new Column_listContext(this.context, this.state);
+        this.enterRule(localContext, 2384, PlSqlParser.RULE_column_list);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20717;
+            this.column_name();
+            this.state = 20722;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2945, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20718;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20719;
+                    this.column_name();
+                    }
+                    }
+                }
+                this.state = 20724;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2945, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public paren_column_list(): Paren_column_listContext {
+        let localContext = new Paren_column_listContext(this.context, this.state);
+        this.enterRule(localContext, 2386, PlSqlParser.RULE_paren_column_list);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20725;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20726;
+            this.column_list();
+            this.state = 20727;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public keep_clause(): Keep_clauseContext {
+        let localContext = new Keep_clauseContext(this.context, this.state);
+        this.enterRule(localContext, 2388, PlSqlParser.RULE_keep_clause);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20729;
+            this.match(PlSqlParser.KEEP);
+            this.state = 20730;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20731;
+            this.match(PlSqlParser.DENSE_RANK);
+            this.state = 20732;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 599 || _la === 826)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 20735;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.PARTITION:
+                {
+                this.state = 20733;
+                this.query_partition_clause();
+                }
+                break;
+            case PlSqlParser.ORDER:
+                {
+                this.state = 20734;
+                this.order_by_clause();
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 20737;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 20739;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2947, this.context) ) {
+            case 1:
+                {
+                this.state = 20738;
+                this.over_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_argument(): Function_argumentContext {
+        let localContext = new Function_argumentContext(this.context, this.state);
+        this.enterRule(localContext, 2390, PlSqlParser.RULE_function_argument);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20741;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20750;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2949, this.context) ) {
+            case 1:
+                {
+                this.state = 20742;
+                this.argument();
+                this.state = 20747;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 20743;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20744;
+                    this.argument();
+                    }
+                    }
+                    this.state = 20749;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            }
+            this.state = 20752;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 20754;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2950, this.context) ) {
+            case 1:
+                {
+                this.state = 20753;
+                this.keep_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_argument_analytic(): Function_argument_analyticContext {
+        let localContext = new Function_argument_analyticContext(this.context, this.state);
+        this.enterRule(localContext, 2392, PlSqlParser.RULE_function_argument_analytic);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20756;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20771;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2954, this.context) ) {
+            case 1:
+                {
+                this.state = 20757;
+                this.argument();
+                this.state = 20759;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 693 || _la === 1573) {
+                    {
+                    this.state = 20758;
+                    this.respect_or_ignore_nulls();
+                    }
+                }
+
+                this.state = 20768;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 20761;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20762;
+                    this.argument();
+                    this.state = 20764;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 693 || _la === 1573) {
+                        {
+                        this.state = 20763;
+                        this.respect_or_ignore_nulls();
+                        }
+                    }
+
+                    }
+                    }
+                    this.state = 20770;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            }
+            this.state = 20773;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 20775;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2955, this.context) ) {
+            case 1:
+                {
+                this.state = 20774;
+                this.keep_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public function_argument_modeling(): Function_argument_modelingContext {
+        let localContext = new Function_argument_modelingContext(this.context, this.state);
+        this.enterRule(localContext, 2394, PlSqlParser.RULE_function_argument_modeling);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20777;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20778;
+            this.column_name();
+            this.state = 20791;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2455) {
+                {
+                this.state = 20779;
+                this.match(PlSqlParser.COMMA);
+                this.state = 20782;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNSIGNED_INTEGER:
+                case PlSqlParser.APPROXIMATE_NUM_LIT:
+                    {
+                    this.state = 20780;
+                    this.numeric();
+                    }
+                    break;
+                case PlSqlParser.NULL_:
+                    {
+                    this.state = 20781;
+                    this.match(PlSqlParser.NULL_);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 20789;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2455) {
+                    {
+                    this.state = 20784;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20787;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                    case PlSqlParser.APPROXIMATE_NUM_LIT:
+                        {
+                        this.state = 20785;
+                        this.numeric();
+                        }
+                        break;
+                    case PlSqlParser.NULL_:
+                        {
+                        this.state = 20786;
+                        this.match(PlSqlParser.NULL_);
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                }
+
+                }
+            }
+
+            this.state = 20793;
+            this.match(PlSqlParser.USING);
+            this.state = 20813;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2963, this.context) ) {
+            case 1:
+                {
+                this.state = 20794;
+                this.tableview_name();
+                this.state = 20795;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 20796;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            case 2:
+                {
+                this.state = 20798;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            case 3:
+                {
+                this.state = 20799;
+                this.expression();
+                this.state = 20801;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                    {
+                    this.state = 20800;
+                    this.column_alias();
+                    }
+                }
+
+                this.state = 20810;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 2455) {
+                    {
+                    {
+                    this.state = 20803;
+                    this.match(PlSqlParser.COMMA);
+                    this.state = 20804;
+                    this.expression();
+                    this.state = 20806;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967294) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4285922239) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4026531767) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4123000063) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294959103) !== 0) || ((((_la - 161)) & ~0x1F) === 0 && ((1 << (_la - 161)) & 3221209071) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & 4294967165) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & 4290772479) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 4286578601) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & 4294967295) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4294967295) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 4294963071) !== 0) || ((((_la - 387)) & ~0x1F) === 0 && ((1 << (_la - 387)) & 4160487411) !== 0) || ((((_la - 419)) & ~0x1F) === 0 && ((1 << (_la - 419)) & 4218941407) !== 0) || ((((_la - 454)) & ~0x1F) === 0 && ((1 << (_la - 454)) & 4293885699) !== 0) || ((((_la - 486)) & ~0x1F) === 0 && ((1 << (_la - 486)) & 4271898271) !== 0) || ((((_la - 518)) & ~0x1F) === 0 && ((1 << (_la - 518)) & 4286578431) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & 4294967295) !== 0) || ((((_la - 582)) & ~0x1F) === 0 && ((1 << (_la - 582)) & 4292870143) !== 0) || ((((_la - 614)) & ~0x1F) === 0 && ((1 << (_la - 614)) & 4294934399) !== 0) || ((((_la - 646)) & ~0x1F) === 0 && ((1 << (_la - 646)) & 4026265577) !== 0) || ((((_la - 678)) & ~0x1F) === 0 && ((1 << (_la - 678)) & 4294901503) !== 0) || ((((_la - 710)) & ~0x1F) === 0 && ((1 << (_la - 710)) & 3758096127) !== 0) || ((((_la - 742)) & ~0x1F) === 0 && ((1 << (_la - 742)) & 4294932479) !== 0) || ((((_la - 774)) & ~0x1F) === 0 && ((1 << (_la - 774)) & 4294961083) !== 0) || ((((_la - 806)) & ~0x1F) === 0 && ((1 << (_la - 806)) & 3749707775) !== 0) || ((((_la - 838)) & ~0x1F) === 0 && ((1 << (_la - 838)) & 4092592127) !== 0) || ((((_la - 871)) & ~0x1F) === 0 && ((1 << (_la - 871)) & 3758094335) !== 0) || ((((_la - 903)) & ~0x1F) === 0 && ((1 << (_la - 903)) & 4294967295) !== 0) || ((((_la - 935)) & ~0x1F) === 0 && ((1 << (_la - 935)) & 4290772991) !== 0) || ((((_la - 967)) & ~0x1F) === 0 && ((1 << (_la - 967)) & 4294965247) !== 0) || ((((_la - 999)) & ~0x1F) === 0 && ((1 << (_la - 999)) & 4294967167) !== 0) || ((((_la - 1031)) & ~0x1F) === 0 && ((1 << (_la - 1031)) & 3221225471) !== 0) || ((((_la - 1063)) & ~0x1F) === 0 && ((1 << (_la - 1063)) & 4093636575) !== 0) || ((((_la - 1095)) & ~0x1F) === 0 && ((1 << (_la - 1095)) & 4269801407) !== 0) || ((((_la - 1127)) & ~0x1F) === 0 && ((1 << (_la - 1127)) & 4294966783) !== 0) || ((((_la - 1159)) & ~0x1F) === 0 && ((1 << (_la - 1159)) & 3204448255) !== 0) || ((((_la - 1191)) & ~0x1F) === 0 && ((1 << (_la - 1191)) & 3221176319) !== 0) || ((((_la - 1223)) & ~0x1F) === 0 && ((1 << (_la - 1223)) & 4261412735) !== 0) || ((((_la - 1255)) & ~0x1F) === 0 && ((1 << (_la - 1255)) & 3488087983) !== 0) || ((((_la - 1287)) & ~0x1F) === 0 && ((1 << (_la - 1287)) & 2143027199) !== 0) || ((((_la - 1319)) & ~0x1F) === 0 && ((1 << (_la - 1319)) & 4278059007) !== 0) || ((((_la - 1351)) & ~0x1F) === 0 && ((1 << (_la - 1351)) & 1676673023) !== 0) || ((((_la - 1387)) & ~0x1F) === 0 && ((1 << (_la - 1387)) & 4294966271) !== 0) || ((((_la - 1419)) & ~0x1F) === 0 && ((1 << (_la - 1419)) & 4261412863) !== 0) || ((((_la - 1451)) & ~0x1F) === 0 && ((1 << (_la - 1451)) & 4294967263) !== 0) || ((((_la - 1483)) & ~0x1F) === 0 && ((1 << (_la - 1483)) & 4223664127) !== 0) || ((((_la - 1515)) & ~0x1F) === 0 && ((1 << (_la - 1515)) & 4294967295) !== 0) || ((((_la - 1547)) & ~0x1F) === 0 && ((1 << (_la - 1547)) & 4261412735) !== 0) || ((((_la - 1579)) & ~0x1F) === 0 && ((1 << (_la - 1579)) & 4294963199) !== 0) || ((((_la - 1611)) & ~0x1F) === 0 && ((1 << (_la - 1611)) & 4294967295) !== 0) || ((((_la - 1643)) & ~0x1F) === 0 && ((1 << (_la - 1643)) & 4294762431) !== 0) || ((((_la - 1675)) & ~0x1F) === 0 && ((1 << (_la - 1675)) & 4093640567) !== 0) || ((((_la - 1707)) & ~0x1F) === 0 && ((1 << (_la - 1707)) & 4294967295) !== 0) || ((((_la - 1741)) & ~0x1F) === 0 && ((1 << (_la - 1741)) & 4294967295) !== 0) || ((((_la - 1773)) & ~0x1F) === 0 && ((1 << (_la - 1773)) & 4261412863) !== 0) || ((((_la - 1805)) & ~0x1F) === 0 && ((1 << (_la - 1805)) & 4294967295) !== 0) || ((((_la - 1837)) & ~0x1F) === 0 && ((1 << (_la - 1837)) & 4294967295) !== 0) || ((((_la - 1869)) & ~0x1F) === 0 && ((1 << (_la - 1869)) & 4294967295) !== 0) || ((((_la - 1901)) & ~0x1F) === 0 && ((1 << (_la - 1901)) & 4294967295) !== 0) || ((((_la - 1933)) & ~0x1F) === 0 && ((1 << (_la - 1933)) & 4294967295) !== 0) || ((((_la - 1965)) & ~0x1F) === 0 && ((1 << (_la - 1965)) & 4294967295) !== 0) || ((((_la - 1997)) & ~0x1F) === 0 && ((1 << (_la - 1997)) & 4294967295) !== 0) || ((((_la - 2029)) & ~0x1F) === 0 && ((1 << (_la - 2029)) & 4294967295) !== 0) || ((((_la - 2061)) & ~0x1F) === 0 && ((1 << (_la - 2061)) & 4294967295) !== 0) || ((((_la - 2093)) & ~0x1F) === 0 && ((1 << (_la - 2093)) & 3221224375) !== 0) || ((((_la - 2125)) & ~0x1F) === 0 && ((1 << (_la - 2125)) & 4227596287) !== 0) || ((((_la - 2157)) & ~0x1F) === 0 && ((1 << (_la - 2157)) & 3825205247) !== 0) || ((((_la - 2189)) & ~0x1F) === 0 && ((1 << (_la - 2189)) & 4293910527) !== 0) || ((((_la - 2221)) & ~0x1F) === 0 && ((1 << (_la - 2221)) & 4294967295) !== 0) || ((((_la - 2253)) & ~0x1F) === 0 && ((1 << (_la - 2253)) & 4294953919) !== 0) || ((((_la - 2285)) & ~0x1F) === 0 && ((1 << (_la - 2285)) & 4126932983) !== 0) || ((((_la - 2318)) & ~0x1F) === 0 && ((1 << (_la - 2318)) & 4294901759) !== 0) || ((((_la - 2351)) & ~0x1F) === 0 && ((1 << (_la - 2351)) & 4294933375) !== 0) || ((((_la - 2383)) & ~0x1F) === 0 && ((1 << (_la - 2383)) & 4281335767) !== 0) || ((((_la - 2415)) & ~0x1F) === 0 && ((1 << (_la - 2415)) & 3372220415) !== 0) || _la === 2477 || _la === 2482) {
+                        {
+                        this.state = 20805;
+                        this.column_alias();
+                        }
+                    }
+
+                    }
+                    }
+                    this.state = 20812;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                }
+                break;
+            }
+            this.state = 20815;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            this.state = 20817;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2964, this.context) ) {
+            case 1:
+                {
+                this.state = 20816;
+                this.keep_clause();
+                }
+                break;
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public respect_or_ignore_nulls(): Respect_or_ignore_nullsContext {
+        let localContext = new Respect_or_ignore_nullsContext(this.context, this.state);
+        this.enterRule(localContext, 2396, PlSqlParser.RULE_respect_or_ignore_nulls);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20819;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 693 || _la === 1573)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            this.state = 20820;
+            this.match(PlSqlParser.NULLS);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public argument(): ArgumentContext {
+        let localContext = new ArgumentContext(this.context, this.state);
+        this.enterRule(localContext, 2398, PlSqlParser.RULE_argument);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20826;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2965, this.context) ) {
+            case 1:
+                {
+                this.state = 20822;
+                this.identifier();
+                this.state = 20823;
+                this.match(PlSqlParser.EQUALS_OP);
+                this.state = 20824;
+                this.match(PlSqlParser.GREATER_THAN_OP);
+                }
+                break;
+            }
+            this.state = 20828;
+            this.expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public type_spec(): Type_specContext {
+        let localContext = new Type_specContext(this.context, this.state);
+        this.enterRule(localContext, 2400, PlSqlParser.RULE_type_spec);
+        let _la: number;
+        try {
+            this.state = 20838;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2968, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20830;
+                this.datatype();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20832;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2966, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20831;
+                    this.match(PlSqlParser.REF);
+                    }
+                    break;
+                }
+                this.state = 20834;
+                this.type_name();
+                this.state = 20836;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2967, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20835;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 1383 || _la === 1384)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public datatype(): DatatypeContext {
+        let localContext = new DatatypeContext(this.context, this.state);
+        this.enterRule(localContext, 2402, PlSqlParser.RULE_datatype);
+        let _la: number;
+        try {
+            this.state = 20871;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INT:
+            case PlSqlParser.LONG:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NATURALN:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.RAW:
+            case PlSqlParser.REAL:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20840;
+                this.native_datatype_element();
+                this.state = 20842;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2969, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20841;
+                    this.precision_part();
+                    }
+                    break;
+                }
+                this.state = 20853;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2971, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20844;
+                    this.match(PlSqlParser.WITH);
+                    this.state = 20846;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 874) {
+                        {
+                        this.state = 20845;
+                        this.match(PlSqlParser.LOCAL);
+                        }
+                    }
+
+                    this.state = 20848;
+                    this.match(PlSqlParser.TIME);
+                    this.state = 20849;
+                    this.match(PlSqlParser.ZONE);
+                    }
+                    break;
+                case 2:
+                    {
+                    this.state = 20850;
+                    this.match(PlSqlParser.CHARACTER);
+                    this.state = 20851;
+                    this.match(PlSqlParser.SET);
+                    this.state = 20852;
+                    this.char_set_name();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.INTERVAL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20855;
+                this.match(PlSqlParser.INTERVAL);
+                this.state = 20856;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 365 || _la === 2360)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 20861;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 2449) {
+                    {
+                    this.state = 20857;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 20858;
+                    this.expression();
+                    this.state = 20859;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                }
+
+                this.state = 20863;
+                this.match(PlSqlParser.TO);
+                this.state = 20864;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 986 || _la === 1638)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 20869;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2973, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20865;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 20866;
+                    this.expression();
+                    this.state = 20867;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public precision_part(): Precision_partContext {
+        let localContext = new Precision_partContext(this.context, this.state);
+        this.enterRule(localContext, 2404, PlSqlParser.RULE_precision_part);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20873;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 20876;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+                {
+                this.state = 20874;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.ASTERISK:
+                {
+                this.state = 20875;
+                this.match(PlSqlParser.ASTERISK);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 20883;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2455) {
+                {
+                this.state = 20878;
+                this.match(PlSqlParser.COMMA);
+                this.state = 20881;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.UNSIGNED_INTEGER:
+                case PlSqlParser.APPROXIMATE_NUM_LIT:
+                    {
+                    this.state = 20879;
+                    this.numeric();
+                    }
+                    break;
+                case PlSqlParser.MINUS_SIGN:
+                    {
+                    this.state = 20880;
+                    this.numeric_negative();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+            }
+
+            this.state = 20886;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 163 || _la === 196) {
+                {
+                this.state = 20885;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 163 || _la === 196)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+            }
+
+            this.state = 20888;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public native_datatype_element(): Native_datatype_elementContext {
+        let localContext = new Native_datatype_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2406, PlSqlParser.RULE_native_datatype_element);
+        try {
+            this.state = 20955;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.BINARY_INTEGER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 20890;
+                this.match(PlSqlParser.BINARY_INTEGER);
+                }
+                break;
+            case PlSqlParser.PLS_INTEGER:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 20891;
+                this.match(PlSqlParser.PLS_INTEGER);
+                }
+                break;
+            case PlSqlParser.NATURAL:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 20892;
+                this.match(PlSqlParser.NATURAL);
+                }
+                break;
+            case PlSqlParser.BINARY_FLOAT:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 20893;
+                this.match(PlSqlParser.BINARY_FLOAT);
+                }
+                break;
+            case PlSqlParser.BINARY_DOUBLE:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 20894;
+                this.match(PlSqlParser.BINARY_DOUBLE);
+                }
+                break;
+            case PlSqlParser.NATURALN:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 20895;
+                this.match(PlSqlParser.NATURALN);
+                }
+                break;
+            case PlSqlParser.POSITIVE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 20896;
+                this.match(PlSqlParser.POSITIVE);
+                }
+                break;
+            case PlSqlParser.POSITIVEN:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 20897;
+                this.match(PlSqlParser.POSITIVEN);
+                }
+                break;
+            case PlSqlParser.SIGNTYPE:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 20898;
+                this.match(PlSqlParser.SIGNTYPE);
+                }
+                break;
+            case PlSqlParser.SIMPLE_INTEGER:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 20899;
+                this.match(PlSqlParser.SIMPLE_INTEGER);
+                }
+                break;
+            case PlSqlParser.NVARCHAR2:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 20900;
+                this.match(PlSqlParser.NVARCHAR2);
+                }
+                break;
+            case PlSqlParser.DEC:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 20901;
+                this.match(PlSqlParser.DEC);
+                }
+                break;
+            case PlSqlParser.INTEGER:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 20902;
+                this.match(PlSqlParser.INTEGER);
+                }
+                break;
+            case PlSqlParser.INT:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 20903;
+                this.match(PlSqlParser.INT);
+                }
+                break;
+            case PlSqlParser.NUMERIC:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 20904;
+                this.match(PlSqlParser.NUMERIC);
+                }
+                break;
+            case PlSqlParser.SMALLINT:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 20905;
+                this.match(PlSqlParser.SMALLINT);
+                }
+                break;
+            case PlSqlParser.NUMBER:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 20906;
+                this.match(PlSqlParser.NUMBER);
+                }
+                break;
+            case PlSqlParser.DECIMAL:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 20907;
+                this.match(PlSqlParser.DECIMAL);
+                }
+                break;
+            case PlSqlParser.DOUBLE:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 20908;
+                this.match(PlSqlParser.DOUBLE);
+                this.state = 20910;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2979, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20909;
+                    this.match(PlSqlParser.PRECISION);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.FLOAT:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 20912;
+                this.match(PlSqlParser.FLOAT);
+                }
+                break;
+            case PlSqlParser.REAL:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 20913;
+                this.match(PlSqlParser.REAL);
+                }
+                break;
+            case PlSqlParser.NCHAR:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 20914;
+                this.match(PlSqlParser.NCHAR);
+                }
+                break;
+            case PlSqlParser.LONG:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 20915;
+                this.match(PlSqlParser.LONG);
+                this.state = 20917;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2980, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20916;
+                    this.match(PlSqlParser.RAW);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.CHAR:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 20919;
+                this.match(PlSqlParser.CHAR);
+                }
+                break;
+            case PlSqlParser.CHARACTER:
+                this.enterOuterAlt(localContext, 25);
+                {
+                this.state = 20920;
+                this.match(PlSqlParser.CHARACTER);
+                this.state = 20922;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2981, this.context) ) {
+                case 1:
+                    {
+                    this.state = 20921;
+                    this.match(PlSqlParser.VARYING);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.VARCHAR2:
+                this.enterOuterAlt(localContext, 26);
+                {
+                this.state = 20924;
+                this.match(PlSqlParser.VARCHAR2);
+                }
+                break;
+            case PlSqlParser.VARCHAR:
+                this.enterOuterAlt(localContext, 27);
+                {
+                this.state = 20925;
+                this.match(PlSqlParser.VARCHAR);
+                }
+                break;
+            case PlSqlParser.STRING:
+                this.enterOuterAlt(localContext, 28);
+                {
+                this.state = 20926;
+                this.match(PlSqlParser.STRING);
+                }
+                break;
+            case PlSqlParser.RAW:
+                this.enterOuterAlt(localContext, 29);
+                {
+                this.state = 20927;
+                this.match(PlSqlParser.RAW);
+                }
+                break;
+            case PlSqlParser.BOOLEAN:
+                this.enterOuterAlt(localContext, 30);
+                {
+                this.state = 20928;
+                this.match(PlSqlParser.BOOLEAN);
+                }
+                break;
+            case PlSqlParser.DATE:
+                this.enterOuterAlt(localContext, 31);
+                {
+                this.state = 20929;
+                this.match(PlSqlParser.DATE);
+                }
+                break;
+            case PlSqlParser.ROWID:
+                this.enterOuterAlt(localContext, 32);
+                {
+                this.state = 20930;
+                this.match(PlSqlParser.ROWID);
+                }
+                break;
+            case PlSqlParser.UROWID:
+                this.enterOuterAlt(localContext, 33);
+                {
+                this.state = 20931;
+                this.match(PlSqlParser.UROWID);
+                }
+                break;
+            case PlSqlParser.YEAR:
+                this.enterOuterAlt(localContext, 34);
+                {
+                this.state = 20932;
+                this.match(PlSqlParser.YEAR);
+                }
+                break;
+            case PlSqlParser.MONTH:
+                this.enterOuterAlt(localContext, 35);
+                {
+                this.state = 20933;
+                this.match(PlSqlParser.MONTH);
+                }
+                break;
+            case PlSqlParser.DAY:
+                this.enterOuterAlt(localContext, 36);
+                {
+                this.state = 20934;
+                this.match(PlSqlParser.DAY);
+                }
+                break;
+            case PlSqlParser.HOUR:
+                this.enterOuterAlt(localContext, 37);
+                {
+                this.state = 20935;
+                this.match(PlSqlParser.HOUR);
+                }
+                break;
+            case PlSqlParser.MINUTE:
+                this.enterOuterAlt(localContext, 38);
+                {
+                this.state = 20936;
+                this.match(PlSqlParser.MINUTE);
+                }
+                break;
+            case PlSqlParser.SECOND:
+                this.enterOuterAlt(localContext, 39);
+                {
+                this.state = 20937;
+                this.match(PlSqlParser.SECOND);
+                }
+                break;
+            case PlSqlParser.SDO_GEOMETRY:
+                this.enterOuterAlt(localContext, 40);
+                {
+                this.state = 20938;
+                this.match(PlSqlParser.SDO_GEOMETRY);
+                }
+                break;
+            case PlSqlParser.TIMEZONE_HOUR:
+                this.enterOuterAlt(localContext, 41);
+                {
+                this.state = 20939;
+                this.match(PlSqlParser.TIMEZONE_HOUR);
+                }
+                break;
+            case PlSqlParser.TIMEZONE_MINUTE:
+                this.enterOuterAlt(localContext, 42);
+                {
+                this.state = 20940;
+                this.match(PlSqlParser.TIMEZONE_MINUTE);
+                }
+                break;
+            case PlSqlParser.TIMEZONE_REGION:
+                this.enterOuterAlt(localContext, 43);
+                {
+                this.state = 20941;
+                this.match(PlSqlParser.TIMEZONE_REGION);
+                }
+                break;
+            case PlSqlParser.TIMEZONE_ABBR:
+                this.enterOuterAlt(localContext, 44);
+                {
+                this.state = 20942;
+                this.match(PlSqlParser.TIMEZONE_ABBR);
+                }
+                break;
+            case PlSqlParser.TIMESTAMP:
+                this.enterOuterAlt(localContext, 45);
+                {
+                this.state = 20943;
+                this.match(PlSqlParser.TIMESTAMP);
+                }
+                break;
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                this.enterOuterAlt(localContext, 46);
+                {
+                this.state = 20944;
+                this.match(PlSqlParser.TIMESTAMP_UNCONSTRAINED);
+                }
+                break;
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                this.enterOuterAlt(localContext, 47);
+                {
+                this.state = 20945;
+                this.match(PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED);
+                }
+                break;
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                this.enterOuterAlt(localContext, 48);
+                {
+                this.state = 20946;
+                this.match(PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED);
+                }
+                break;
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                this.enterOuterAlt(localContext, 49);
+                {
+                this.state = 20947;
+                this.match(PlSqlParser.YMINTERVAL_UNCONSTRAINED);
+                }
+                break;
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                this.enterOuterAlt(localContext, 50);
+                {
+                this.state = 20948;
+                this.match(PlSqlParser.DSINTERVAL_UNCONSTRAINED);
+                }
+                break;
+            case PlSqlParser.BFILE:
+                this.enterOuterAlt(localContext, 51);
+                {
+                this.state = 20949;
+                this.match(PlSqlParser.BFILE);
+                }
+                break;
+            case PlSqlParser.BLOB:
+                this.enterOuterAlt(localContext, 52);
+                {
+                this.state = 20950;
+                this.match(PlSqlParser.BLOB);
+                }
+                break;
+            case PlSqlParser.CLOB:
+                this.enterOuterAlt(localContext, 53);
+                {
+                this.state = 20951;
+                this.match(PlSqlParser.CLOB);
+                }
+                break;
+            case PlSqlParser.NCLOB:
+                this.enterOuterAlt(localContext, 54);
+                {
+                this.state = 20952;
+                this.match(PlSqlParser.NCLOB);
+                }
+                break;
+            case PlSqlParser.MLSLABEL:
+                this.enterOuterAlt(localContext, 55);
+                {
+                this.state = 20953;
+                this.match(PlSqlParser.MLSLABEL);
+                }
+                break;
+            case PlSqlParser.XMLTYPE:
+                this.enterOuterAlt(localContext, 56);
+                {
+                this.state = 20954;
+                this.match(PlSqlParser.XMLTYPE);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public bind_variable(): Bind_variableContext {
+        let localContext = new Bind_variableContext(this.context, this.state);
+        this.enterRule(localContext, 2408, PlSqlParser.RULE_bind_variable);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20960;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.BINDVAR:
+                {
+                this.state = 20957;
+                this.match(PlSqlParser.BINDVAR);
+                }
+                break;
+            case PlSqlParser.COLON:
+                {
+                this.state = 20958;
+                this.match(PlSqlParser.COLON);
+                this.state = 20959;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.state = 20970;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2986, this.context) ) {
+            case 1:
+                {
+                this.state = 20963;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 734) {
+                    {
+                    this.state = 20962;
+                    this.match(PlSqlParser.INDICATOR);
+                    }
+                }
+
+                this.state = 20968;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.BINDVAR:
+                    {
+                    this.state = 20965;
+                    this.match(PlSqlParser.BINDVAR);
+                    }
+                    break;
+                case PlSqlParser.COLON:
+                    {
+                    this.state = 20966;
+                    this.match(PlSqlParser.COLON);
+                    this.state = 20967;
+                    this.match(PlSqlParser.UNSIGNED_INTEGER);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            }
+            this.state = 20976;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2987, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 20972;
+                    this.match(PlSqlParser.PERIOD);
+                    this.state = 20973;
+                    this.general_element_part();
+                    }
+                    }
+                }
+                this.state = 20978;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2987, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public general_element(): General_elementContext;
+    public general_element(_p: number): General_elementContext;
+    public general_element(_p?: number): General_elementContext {
+        if (_p === undefined) {
+            _p = 0;
+        }
+
+        let parentContext = this.context;
+        let parentState = this.state;
+        let localContext = new General_elementContext(this.context, parentState);
+        let previousContext = localContext;
+        let _startState = 2410;
+        this.enterRecursionRule(localContext, 2410, PlSqlParser.RULE_general_element, _p);
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 20985;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.DELIMITED_ID:
+            case PlSqlParser.INTRODUCER:
+            case PlSqlParser.REGULAR_ID:
+                {
+                this.state = 20980;
+                this.general_element_part();
+                }
+                break;
+            case PlSqlParser.LEFT_PAREN:
+                {
+                this.state = 20981;
+                this.match(PlSqlParser.LEFT_PAREN);
+                this.state = 20982;
+                this.general_element(0);
+                this.state = 20983;
+                this.match(PlSqlParser.RIGHT_PAREN);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+            this.context!.stop = this.tokenStream.LT(-1);
+            this.state = 20996;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2990, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    if (this.parseListeners != null) {
+                        this.triggerExitRuleEvent();
+                    }
+                    previousContext = localContext;
+                    {
+                    {
+                    localContext = new General_elementContext(parentContext, parentState);
+                    this.pushNewRecursionContext(localContext, _startState, PlSqlParser.RULE_general_element);
+                    this.state = 20987;
+                    if (!(this.precpred(this.context, 2))) {
+                        throw this.createFailedPredicateException("this.precpred(this.context, 2)");
+                    }
+                    this.state = 20990;
+                    this.errorHandler.sync(this);
+                    alternative = 1;
+                    do {
+                        switch (alternative) {
+                        case 1:
+                            {
+                            {
+                            this.state = 20988;
+                            this.match(PlSqlParser.PERIOD);
+                            this.state = 20989;
+                            this.general_element_part();
+                            }
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        this.state = 20992;
+                        this.errorHandler.sync(this);
+                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 2989, this.context);
+                    } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
+                    }
+                    }
+                }
+                this.state = 20998;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2990, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(parentContext);
+        }
+        return localContext;
+    }
+    public general_element_part(): General_element_partContext {
+        let localContext = new General_element_partContext(this.context, this.state);
+        this.enterRule(localContext, 2412, PlSqlParser.RULE_general_element_part);
+        let _la: number;
+        try {
+            let alternative: number;
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21001;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2477) {
+                {
+                this.state = 20999;
+                this.match(PlSqlParser.INTRODUCER);
+                this.state = 21000;
+                this.char_set_name();
+                }
+            }
+
+            this.state = 21003;
+            this.id_expression();
+            this.state = 21006;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2992, this.context) ) {
+            case 1:
+                {
+                this.state = 21004;
+                this.match(PlSqlParser.AT_SIGN);
+                this.state = 21005;
+                this.link_name();
+                }
+                break;
+            }
+            this.state = 21011;
+            this.errorHandler.sync(this);
+            alternative = this.interpreter.adaptivePredict(this.tokenStream, 2993, this.context);
+            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
+                if (alternative === 1) {
+                    {
+                    {
+                    this.state = 21008;
+                    this.function_argument();
+                    }
+                    }
+                }
+                this.state = 21013;
+                this.errorHandler.sync(this);
+                alternative = this.interpreter.adaptivePredict(this.tokenStream, 2993, this.context);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public table_element(): Table_elementContext {
+        let localContext = new Table_elementContext(this.context, this.state);
+        this.enterRule(localContext, 2414, PlSqlParser.RULE_table_element);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21016;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2477) {
+                {
+                this.state = 21014;
+                this.match(PlSqlParser.INTRODUCER);
+                this.state = 21015;
+                this.char_set_name();
+                }
+            }
+
+            this.state = 21018;
+            this.id_expression();
+            this.state = 21023;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while (_la === 2442) {
+                {
+                {
+                this.state = 21019;
+                this.match(PlSqlParser.PERIOD);
+                this.state = 21020;
+                this.id_expression();
+                }
+                }
+                this.state = 21025;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public object_privilege(): Object_privilegeContext {
+        let localContext = new Object_privilegeContext(this.context, this.state);
+        this.enterRule(localContext, 2416, PlSqlParser.RULE_object_privilege);
+        try {
+            this.state = 21062;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 2997, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 21026;
+                this.match(PlSqlParser.ALL);
+                this.state = 21028;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 2996, this.context) ) {
+                case 1:
+                    {
+                    this.state = 21027;
+                    this.match(PlSqlParser.PRIVILEGES);
+                    }
+                    break;
+                }
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 21030;
+                this.match(PlSqlParser.ALTER);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 21031;
+                this.match(PlSqlParser.DEBUG);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 21032;
+                this.match(PlSqlParser.DELETE);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 21033;
+                this.match(PlSqlParser.EXECUTE);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 21034;
+                this.match(PlSqlParser.FLASHBACK);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 21035;
+                this.match(PlSqlParser.FLASHBACK);
+                this.state = 21036;
+                this.match(PlSqlParser.ARCHIVE);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 21037;
+                this.match(PlSqlParser.INDEX);
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 21038;
+                this.match(PlSqlParser.INHERIT);
+                this.state = 21039;
+                this.match(PlSqlParser.PRIVILEGES);
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 21040;
+                this.match(PlSqlParser.INHERIT);
+                this.state = 21041;
+                this.match(PlSqlParser.REMOTE);
+                this.state = 21042;
+                this.match(PlSqlParser.PRIVILEGES);
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 21043;
+                this.match(PlSqlParser.INSERT);
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 21044;
+                this.match(PlSqlParser.KEEP);
+                this.state = 21045;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 21046;
+                this.match(PlSqlParser.MERGE);
+                this.state = 21047;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 21048;
+                this.match(PlSqlParser.ON);
+                this.state = 21049;
+                this.match(PlSqlParser.COMMIT);
+                this.state = 21050;
+                this.match(PlSqlParser.REFRESH);
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 21051;
+                this.match(PlSqlParser.QUERY);
+                this.state = 21052;
+                this.match(PlSqlParser.REWRITE);
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 21053;
+                this.match(PlSqlParser.READ);
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 21054;
+                this.match(PlSqlParser.REFERENCES);
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 21055;
+                this.match(PlSqlParser.SELECT);
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 21056;
+                this.match(PlSqlParser.TRANSLATE);
+                this.state = 21057;
+                this.match(PlSqlParser.SQL);
+                }
+                break;
+            case 20:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 21058;
+                this.match(PlSqlParser.UNDER);
+                }
+                break;
+            case 21:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 21059;
+                this.match(PlSqlParser.UPDATE);
+                }
+                break;
+            case 22:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 21060;
+                this.match(PlSqlParser.USE);
+                }
+                break;
+            case 23:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 21061;
+                this.match(PlSqlParser.WRITE);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public system_privilege(): System_privilegeContext {
+        let localContext = new System_privilegeContext(this.context, this.state);
+        this.enterRule(localContext, 2418, PlSqlParser.RULE_system_privilege);
+        let _la: number;
+        try {
+            this.state = 21390;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 3024, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 21064;
+                this.match(PlSqlParser.ALL);
+                this.state = 21065;
+                this.match(PlSqlParser.PRIVILEGES);
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 21066;
+                this.match(PlSqlParser.ADVISOR);
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 21067;
+                this.match(PlSqlParser.ADMINISTER);
+                this.state = 21069;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21068;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21071;
+                this.match(PlSqlParser.SQL);
+                this.state = 21072;
+                this.match(PlSqlParser.TUNING);
+                this.state = 21073;
+                this.match(PlSqlParser.SET);
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 21074;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21075;
+                this.match(PlSqlParser.ANY);
+                this.state = 21076;
+                this.match(PlSqlParser.SQL);
+                this.state = 21077;
+                this.match(PlSqlParser.PROFILE);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 21078;
+                this.match(PlSqlParser.ADMINISTER);
+                this.state = 21079;
+                this.match(PlSqlParser.SQL);
+                this.state = 21080;
+                this.match(PlSqlParser.MANAGEMENT);
+                this.state = 21081;
+                this.match(PlSqlParser.OBJECT);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 21082;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21084;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21083;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21086;
+                this.match(PlSqlParser.CLUSTER);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 21087;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21088;
+                this.match(PlSqlParser.ANY);
+                this.state = 21089;
+                this.match(PlSqlParser.CLUSTER);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 21090;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21091;
+                this.match(PlSqlParser.ANY);
+                this.state = 21092;
+                this.match(PlSqlParser.CONTEXT);
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 21093;
+                this.match(PlSqlParser.EXEMPT);
+                this.state = 21094;
+                this.match(PlSqlParser.REDACTION);
+                this.state = 21095;
+                this.match(PlSqlParser.POLICY);
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 21096;
+                this.match(PlSqlParser.ALTER);
+                this.state = 21097;
+                this.match(PlSqlParser.DATABASE);
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 21098;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21100;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1475) {
+                    {
+                    this.state = 21099;
+                    this.match(PlSqlParser.PUBLIC);
+                    }
+                }
+
+                this.state = 21102;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 21103;
+                this.match(PlSqlParser.LINK);
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 21104;
+                this.match(PlSqlParser.DROP);
+                this.state = 21105;
+                this.match(PlSqlParser.PUBLIC);
+                this.state = 21106;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 21107;
+                this.match(PlSqlParser.LINK);
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 21108;
+                this.match(PlSqlParser.DEBUG);
+                this.state = 21109;
+                this.match(PlSqlParser.CONNECT);
+                this.state = 21110;
+                this.match(PlSqlParser.SESSION);
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 21111;
+                this.match(PlSqlParser.DEBUG);
+                this.state = 21112;
+                this.match(PlSqlParser.ANY);
+                this.state = 21113;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 21114;
+                this.match(PlSqlParser.ANALYZE);
+                this.state = 21115;
+                this.match(PlSqlParser.ANY);
+                this.state = 21116;
+                this.match(PlSqlParser.DICTIONARY);
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 21117;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21119;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21118;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21121;
+                this.match(PlSqlParser.DIMENSION);
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 21122;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21123;
+                this.match(PlSqlParser.ANY);
+                this.state = 21124;
+                this.match(PlSqlParser.DIMENSION);
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 21125;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21126;
+                this.match(PlSqlParser.ANY);
+                this.state = 21127;
+                this.match(PlSqlParser.DIRECTORY);
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 21128;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21129;
+                this.match(PlSqlParser.ANY);
+                this.state = 21130;
+                this.match(PlSqlParser.EDITION);
+                }
+                break;
+            case 20:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 21131;
+                this.match(PlSqlParser.FLASHBACK);
+                this.state = 21136;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.ARCHIVE:
+                    {
+                    this.state = 21132;
+                    this.match(PlSqlParser.ARCHIVE);
+                    this.state = 21133;
+                    this.match(PlSqlParser.ADMINISTER);
+                    }
+                    break;
+                case PlSqlParser.ANY:
+                    {
+                    this.state = 21134;
+                    this.match(PlSqlParser.ANY);
+                    this.state = 21135;
+                    this.match(PlSqlParser.TABLE);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                break;
+            case 21:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 21138;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21139;
+                this.match(PlSqlParser.ANY);
+                this.state = 21140;
+                this.match(PlSqlParser.INDEX);
+                }
+                break;
+            case 22:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 21141;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21143;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21142;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21145;
+                this.match(PlSqlParser.INDEXTYPE);
+                }
+                break;
+            case 23:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 21146;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 543)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21147;
+                this.match(PlSqlParser.ANY);
+                this.state = 21148;
+                this.match(PlSqlParser.INDEXTYPE);
+                }
+                break;
+            case 24:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 21149;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21151;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55 || _la === 561) {
+                    {
+                    this.state = 21150;
+                    _la = this.tokenStream.LA(1);
+                    if(!(_la === 55 || _la === 561)) {
+                    this.errorHandler.recoverInline(this);
+                    }
+                    else {
+                        this.errorHandler.reportMatch(this);
+                        this.consume();
+                    }
+                    }
+                }
+
+                this.state = 21153;
+                this.match(PlSqlParser.JOB);
+                }
+                break;
+            case 25:
+                this.enterOuterAlt(localContext, 25);
+                {
+                this.state = 21154;
+                this.match(PlSqlParser.EXECUTE);
+                this.state = 21155;
+                this.match(PlSqlParser.ANY);
+                this.state = 21156;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 206 || _la === 1466)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 26:
+                this.enterOuterAlt(localContext, 26);
+                {
+                this.state = 21157;
+                this.match(PlSqlParser.MANAGE);
+                this.state = 21158;
+                this.match(PlSqlParser.SCHEDULER);
+                }
+                break;
+            case 27:
+                this.enterOuterAlt(localContext, 27);
+                {
+                this.state = 21159;
+                this.match(PlSqlParser.ADMINISTER);
+                this.state = 21160;
+                this.match(PlSqlParser.KEY);
+                this.state = 21161;
+                this.match(PlSqlParser.MANAGEMENT);
+                }
+                break;
+            case 28:
+                this.enterOuterAlt(localContext, 28);
+                {
+                this.state = 21162;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21164;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21163;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21166;
+                this.match(PlSqlParser.LIBRARY);
+                }
+                break;
+            case 29:
+                this.enterOuterAlt(localContext, 29);
+                {
+                this.state = 21167;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 543)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21168;
+                this.match(PlSqlParser.ANY);
+                this.state = 21169;
+                this.match(PlSqlParser.LIBRARY);
+                }
+                break;
+            case 30:
+                this.enterOuterAlt(localContext, 30);
+                {
+                this.state = 21170;
+                this.match(PlSqlParser.LOGMINING);
+                }
+                break;
+            case 31:
+                this.enterOuterAlt(localContext, 31);
+                {
+                this.state = 21171;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21173;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21172;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21175;
+                this.match(PlSqlParser.MATERIALIZED);
+                this.state = 21176;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 32:
+                this.enterOuterAlt(localContext, 32);
+                {
+                this.state = 21177;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21178;
+                this.match(PlSqlParser.ANY);
+                this.state = 21179;
+                this.match(PlSqlParser.MATERIALIZED);
+                this.state = 21180;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 33:
+                this.enterOuterAlt(localContext, 33);
+                {
+                this.state = 21182;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 643) {
+                    {
+                    this.state = 21181;
+                    this.match(PlSqlParser.GLOBAL);
+                    }
+                }
+
+                this.state = 21184;
+                this.match(PlSqlParser.QUERY);
+                this.state = 21185;
+                this.match(PlSqlParser.REWRITE);
+                }
+                break;
+            case 34:
+                this.enterOuterAlt(localContext, 34);
+                {
+                this.state = 21186;
+                this.match(PlSqlParser.ON);
+                this.state = 21187;
+                this.match(PlSqlParser.COMMIT);
+                this.state = 21188;
+                this.match(PlSqlParser.REFRESH);
+                }
+                break;
+            case 35:
+                this.enterOuterAlt(localContext, 35);
+                {
+                this.state = 21189;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21191;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21190;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21193;
+                this.match(PlSqlParser.MINING);
+                this.state = 21194;
+                this.match(PlSqlParser.MODEL);
+                }
+                break;
+            case 36:
+                this.enterOuterAlt(localContext, 36);
+                {
+                this.state = 21195;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 241 || _la === 469 || _la === 1649)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21196;
+                this.match(PlSqlParser.ANY);
+                this.state = 21197;
+                this.match(PlSqlParser.MINING);
+                this.state = 21198;
+                this.match(PlSqlParser.MODEL);
+                }
+                break;
+            case 37:
+                this.enterOuterAlt(localContext, 37);
+                {
+                this.state = 21199;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21201;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21200;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21203;
+                this.match(PlSqlParser.CUBE);
+                }
+                break;
+            case 38:
+                this.enterOuterAlt(localContext, 38);
+                {
+                this.state = 21204;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 1649 || _la === 2209)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21205;
+                this.match(PlSqlParser.ANY);
+                this.state = 21206;
+                this.match(PlSqlParser.CUBE);
+                }
+                break;
+            case 39:
+                this.enterOuterAlt(localContext, 39);
+                {
+                this.state = 21207;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21209;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21208;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21211;
+                this.match(PlSqlParser.MEASURE);
+                this.state = 21212;
+                this.match(PlSqlParser.FOLDER);
+                }
+                break;
+            case 40:
+                this.enterOuterAlt(localContext, 40);
+                {
+                this.state = 21213;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 403 || _la === 469 || _la === 757)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21214;
+                this.match(PlSqlParser.ANY);
+                this.state = 21215;
+                this.match(PlSqlParser.MEASURE);
+                this.state = 21216;
+                this.match(PlSqlParser.FOLDER);
+                }
+                break;
+            case 41:
+                this.enterOuterAlt(localContext, 41);
+                {
+                this.state = 21217;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21219;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21218;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21221;
+                this.match(PlSqlParser.CUBE);
+                this.state = 21222;
+                this.match(PlSqlParser.DIMENSION);
+                }
+                break;
+            case 42:
+                this.enterOuterAlt(localContext, 42);
+                {
+                this.state = 21223;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 403 || _la === 469 || _la === 757 || _la === 1649 || _la === 2209)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21224;
+                this.match(PlSqlParser.ANY);
+                this.state = 21225;
+                this.match(PlSqlParser.CUBE);
+                this.state = 21226;
+                this.match(PlSqlParser.DIMENSION);
+                }
+                break;
+            case 43:
+                this.enterOuterAlt(localContext, 43);
+                {
+                this.state = 21227;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21229;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21228;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21231;
+                this.match(PlSqlParser.CUBE);
+                this.state = 21232;
+                this.match(PlSqlParser.BUILD);
+                this.state = 21233;
+                this.match(PlSqlParser.PROCESS);
+                }
+                break;
+            case 44:
+                this.enterOuterAlt(localContext, 44);
+                {
+                this.state = 21234;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 469 || _la === 2209)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21235;
+                this.match(PlSqlParser.ANY);
+                this.state = 21236;
+                this.match(PlSqlParser.CUBE);
+                this.state = 21237;
+                this.match(PlSqlParser.BUILD);
+                this.state = 21238;
+                this.match(PlSqlParser.PROCESS);
+                }
+                break;
+            case 45:
+                this.enterOuterAlt(localContext, 45);
+                {
+                this.state = 21239;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21241;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21240;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21243;
+                this.match(PlSqlParser.OPERATOR);
+                }
+                break;
+            case 46:
+                this.enterOuterAlt(localContext, 46);
+                {
+                this.state = 21244;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 543)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21245;
+                this.match(PlSqlParser.ANY);
+                this.state = 21246;
+                this.match(PlSqlParser.OPERATOR);
+                }
+                break;
+            case 47:
+                this.enterOuterAlt(localContext, 47);
+                {
+                this.state = 21247;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21248;
+                this.match(PlSqlParser.ANY);
+                this.state = 21249;
+                this.match(PlSqlParser.OUTLINE);
+                }
+                break;
+            case 48:
+                this.enterOuterAlt(localContext, 48);
+                {
+                this.state = 21250;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21251;
+                this.match(PlSqlParser.PLUGGABLE);
+                this.state = 21252;
+                this.match(PlSqlParser.DATABASE);
+                }
+                break;
+            case 49:
+                this.enterOuterAlt(localContext, 49);
+                {
+                this.state = 21253;
+                this.match(PlSqlParser.SET);
+                this.state = 21254;
+                this.match(PlSqlParser.CONTAINER);
+                }
+                break;
+            case 50:
+                this.enterOuterAlt(localContext, 50);
+                {
+                this.state = 21255;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21257;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21256;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21259;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 51:
+                this.enterOuterAlt(localContext, 51);
+                {
+                this.state = 21260;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 543)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21261;
+                this.match(PlSqlParser.ANY);
+                this.state = 21262;
+                this.match(PlSqlParser.PROCEDURE);
+                }
+                break;
+            case 52:
+                this.enterOuterAlt(localContext, 52);
+                {
+                this.state = 21263;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21264;
+                this.match(PlSqlParser.PROFILE);
+                }
+                break;
+            case 53:
+                this.enterOuterAlt(localContext, 53);
+                {
+                this.state = 21265;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21266;
+                this.match(PlSqlParser.ROLE);
+                }
+                break;
+            case 54:
+                this.enterOuterAlt(localContext, 54);
+                {
+                this.state = 21267;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 648)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21268;
+                this.match(PlSqlParser.ANY);
+                this.state = 21269;
+                this.match(PlSqlParser.ROLE);
+                }
+                break;
+            case 55:
+                this.enterOuterAlt(localContext, 55);
+                {
+                this.state = 21270;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21271;
+                this.match(PlSqlParser.ROLLBACK);
+                this.state = 21272;
+                this.match(PlSqlParser.SEGMENT);
+                }
+                break;
+            case 56:
+                this.enterOuterAlt(localContext, 56);
+                {
+                this.state = 21273;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21275;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21274;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21277;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 57:
+                this.enterOuterAlt(localContext, 57);
+                {
+                this.state = 21278;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 1649)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21279;
+                this.match(PlSqlParser.ANY);
+                this.state = 21280;
+                this.match(PlSqlParser.SEQUENCE);
+                }
+                break;
+            case 58:
+                this.enterOuterAlt(localContext, 58);
+                {
+                this.state = 21281;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 1578)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21282;
+                this.match(PlSqlParser.SESSION);
+                }
+                break;
+            case 59:
+                this.enterOuterAlt(localContext, 59);
+                {
+                this.state = 21283;
+                this.match(PlSqlParser.ALTER);
+                this.state = 21284;
+                this.match(PlSqlParser.RESOURCE);
+                this.state = 21285;
+                this.match(PlSqlParser.COST);
+                }
+                break;
+            case 60:
+                this.enterOuterAlt(localContext, 60);
+                {
+                this.state = 21286;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21288;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21287;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21290;
+                this.match(PlSqlParser.SQL);
+                this.state = 21291;
+                this.match(PlSqlParser.TRANSLATION);
+                this.state = 21292;
+                this.match(PlSqlParser.PROFILE);
+                }
+                break;
+            case 61:
+                this.enterOuterAlt(localContext, 61);
+                {
+                this.state = 21293;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 2243)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21294;
+                this.match(PlSqlParser.ANY);
+                this.state = 21295;
+                this.match(PlSqlParser.SQL);
+                this.state = 21296;
+                this.match(PlSqlParser.TRANSLATION);
+                this.state = 21297;
+                this.match(PlSqlParser.PROFILE);
+                }
+                break;
+            case 62:
+                this.enterOuterAlt(localContext, 62);
+                {
+                this.state = 21298;
+                this.match(PlSqlParser.TRANSLATE);
+                this.state = 21299;
+                this.match(PlSqlParser.ANY);
+                this.state = 21300;
+                this.match(PlSqlParser.SQL);
+                }
+                break;
+            case 63:
+                this.enterOuterAlt(localContext, 63);
+                {
+                this.state = 21301;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21303;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21302;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21305;
+                this.match(PlSqlParser.SYNONYM);
+                }
+                break;
+            case 64:
+                this.enterOuterAlt(localContext, 64);
+                {
+                this.state = 21306;
+                this.match(PlSqlParser.DROP);
+                this.state = 21307;
+                this.match(PlSqlParser.ANY);
+                this.state = 21308;
+                this.match(PlSqlParser.SYNONYM);
+                }
+                break;
+            case 65:
+                this.enterOuterAlt(localContext, 65);
+                {
+                this.state = 21309;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21310;
+                this.match(PlSqlParser.PUBLIC);
+                this.state = 21311;
+                this.match(PlSqlParser.SYNONYM);
+                }
+                break;
+            case 66:
+                this.enterOuterAlt(localContext, 66);
+                {
+                this.state = 21312;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21314;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21313;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21316;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 67:
+                this.enterOuterAlt(localContext, 67);
+                {
+                this.state = 21317;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 102 || _la === 241 || _la === 403 || _la === 469 || _la === 757 || _la === 882 || _la === 1507 || _la === 1649 || _la === 2209)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21318;
+                this.match(PlSqlParser.ANY);
+                this.state = 21319;
+                this.match(PlSqlParser.TABLE);
+                }
+                break;
+            case 68:
+                this.enterOuterAlt(localContext, 68);
+                {
+                this.state = 21320;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469 || _la === 906 || _la === 2187)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21321;
+                this.match(PlSqlParser.TABLESPACE);
+                }
+                break;
+            case 69:
+                this.enterOuterAlt(localContext, 69);
+                {
+                this.state = 21322;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21324;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21323;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21326;
+                this.match(PlSqlParser.TRIGGER);
+                }
+                break;
+            case 70:
+                this.enterOuterAlt(localContext, 70);
+                {
+                this.state = 21327;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21328;
+                this.match(PlSqlParser.ANY);
+                this.state = 21329;
+                this.match(PlSqlParser.TRIGGER);
+                }
+                break;
+            case 71:
+                this.enterOuterAlt(localContext, 71);
+                {
+                this.state = 21330;
+                this.match(PlSqlParser.ADMINISTER);
+                this.state = 21331;
+                this.match(PlSqlParser.DATABASE);
+                this.state = 21332;
+                this.match(PlSqlParser.TRIGGER);
+                }
+                break;
+            case 72:
+                this.enterOuterAlt(localContext, 72);
+                {
+                this.state = 21333;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21335;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21334;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21337;
+                this.match(PlSqlParser.TYPE);
+                }
+                break;
+            case 73:
+                this.enterOuterAlt(localContext, 73);
+                {
+                this.state = 21338;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 469 || _la === 543 || _la === 2179)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21339;
+                this.match(PlSqlParser.ANY);
+                this.state = 21340;
+                this.match(PlSqlParser.TYPE);
+                }
+                break;
+            case 74:
+                this.enterOuterAlt(localContext, 74);
+                {
+                this.state = 21341;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 42 || _la === 321 || _la === 469)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21342;
+                this.match(PlSqlParser.USER);
+                }
+                break;
+            case 75:
+                this.enterOuterAlt(localContext, 75);
+                {
+                this.state = 21343;
+                this.match(PlSqlParser.CREATE);
+                this.state = 21345;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21344;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21347;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 76:
+                this.enterOuterAlt(localContext, 76);
+                {
+                this.state = 21348;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 469 || _la === 947 || _la === 2179)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21349;
+                this.match(PlSqlParser.ANY);
+                this.state = 21350;
+                this.match(PlSqlParser.VIEW);
+                }
+                break;
+            case 77:
+                this.enterOuterAlt(localContext, 77);
+                {
+                this.state = 21351;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 46 || _la === 85)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21352;
+                this.match(PlSqlParser.ANY);
+                }
+                break;
+            case 78:
+                this.enterOuterAlt(localContext, 78);
+                {
+                this.state = 21353;
+                this.match(PlSqlParser.BECOME);
+                this.state = 21354;
+                this.match(PlSqlParser.USER);
+                }
+                break;
+            case 79:
+                this.enterOuterAlt(localContext, 79);
+                {
+                this.state = 21355;
+                this.match(PlSqlParser.CHANGE);
+                this.state = 21356;
+                this.match(PlSqlParser.NOTIFICATION);
+                }
+                break;
+            case 80:
+                this.enterOuterAlt(localContext, 80);
+                {
+                this.state = 21357;
+                this.match(PlSqlParser.EXEMPT);
+                this.state = 21358;
+                this.match(PlSqlParser.ACCESS);
+                this.state = 21359;
+                this.match(PlSqlParser.POLICY);
+                }
+                break;
+            case 81:
+                this.enterOuterAlt(localContext, 81);
+                {
+                this.state = 21360;
+                this.match(PlSqlParser.FORCE);
+                this.state = 21362;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 55) {
+                    {
+                    this.state = 21361;
+                    this.match(PlSqlParser.ANY);
+                    }
+                }
+
+                this.state = 21364;
+                this.match(PlSqlParser.TRANSACTION);
+                }
+                break;
+            case 82:
+                this.enterOuterAlt(localContext, 82);
+                {
+                this.state = 21365;
+                this.match(PlSqlParser.GRANT);
+                this.state = 21366;
+                this.match(PlSqlParser.ANY);
+                this.state = 21368;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1240) {
+                    {
+                    this.state = 21367;
+                    this.match(PlSqlParser.OBJECT);
+                    }
+                }
+
+                this.state = 21370;
+                this.match(PlSqlParser.PRIVILEGE);
+                }
+                break;
+            case 83:
+                this.enterOuterAlt(localContext, 83);
+                {
+                this.state = 21371;
+                this.match(PlSqlParser.INHERIT);
+                this.state = 21372;
+                this.match(PlSqlParser.ANY);
+                this.state = 21373;
+                this.match(PlSqlParser.PRIVILEGES);
+                }
+                break;
+            case 84:
+                this.enterOuterAlt(localContext, 84);
+                {
+                this.state = 21374;
+                this.match(PlSqlParser.KEEP);
+                this.state = 21375;
+                this.match(PlSqlParser.DATE);
+                this.state = 21376;
+                this.match(PlSqlParser.TIME);
+                }
+                break;
+            case 85:
+                this.enterOuterAlt(localContext, 85);
+                {
+                this.state = 21377;
+                this.match(PlSqlParser.KEEP);
+                this.state = 21378;
+                this.match(PlSqlParser.SYSGUID);
+                }
+                break;
+            case 86:
+                this.enterOuterAlt(localContext, 86);
+                {
+                this.state = 21379;
+                this.match(PlSqlParser.PURGE);
+                this.state = 21380;
+                this.match(PlSqlParser.DBA_RECYCLEBIN);
+                }
+                break;
+            case 87:
+                this.enterOuterAlt(localContext, 87);
+                {
+                this.state = 21381;
+                this.match(PlSqlParser.RESUMABLE);
+                }
+                break;
+            case 88:
+                this.enterOuterAlt(localContext, 88);
+                {
+                this.state = 21382;
+                this.match(PlSqlParser.SELECT);
+                this.state = 21383;
+                this.match(PlSqlParser.ANY);
+                this.state = 21384;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 421 || _la === 2149)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                }
+                break;
+            case 89:
+                this.enterOuterAlt(localContext, 89);
+                {
+                this.state = 21385;
+                this.match(PlSqlParser.SYSBACKUP);
+                }
+                break;
+            case 90:
+                this.enterOuterAlt(localContext, 90);
+                {
+                this.state = 21386;
+                this.match(PlSqlParser.SYSDBA);
+                }
+                break;
+            case 91:
+                this.enterOuterAlt(localContext, 91);
+                {
+                this.state = 21387;
+                this.match(PlSqlParser.SYSDG);
+                }
+                break;
+            case 92:
+                this.enterOuterAlt(localContext, 92);
+                {
+                this.state = 21388;
+                this.match(PlSqlParser.SYSKM);
+                }
+                break;
+            case 93:
+                this.enterOuterAlt(localContext, 93);
+                {
+                this.state = 21389;
+                this.match(PlSqlParser.SYSOPER);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public constant(): ConstantContext {
+        let localContext = new ConstantContext(this.context, this.state);
+        this.enterRule(localContext, 2420, PlSqlParser.RULE_constant);
+        let _la: number;
+        try {
+            this.state = 21455;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.TIMESTAMP:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 21392;
+                this.match(PlSqlParser.TIMESTAMP);
+                this.state = 21395;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 21393;
+                    this.quoted_string();
+                    }
+                    break;
+                case PlSqlParser.BINDVAR:
+                case PlSqlParser.COLON:
+                    {
+                    this.state = 21394;
+                    this.bind_variable();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 21401;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 3026, this.context) ) {
+                case 1:
+                    {
+                    this.state = 21397;
+                    this.match(PlSqlParser.AT);
+                    this.state = 21398;
+                    this.match(PlSqlParser.TIME);
+                    this.state = 21399;
+                    this.match(PlSqlParser.ZONE);
+                    this.state = 21400;
+                    this.quoted_string();
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.INTERVAL:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 21403;
+                this.match(PlSqlParser.INTERVAL);
+                this.state = 21407;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+                case PlSqlParser.CHAR_STRING:
+                    {
+                    this.state = 21404;
+                    this.quoted_string();
+                    }
+                    break;
+                case PlSqlParser.BINDVAR:
+                case PlSqlParser.COLON:
+                    {
+                    this.state = 21405;
+                    this.bind_variable();
+                    }
+                    break;
+                case PlSqlParser.ABORT:
+                case PlSqlParser.ABS:
+                case PlSqlParser.ABSENT:
+                case PlSqlParser.ACCESS:
+                case PlSqlParser.ACCESSED:
+                case PlSqlParser.ACCESSIBLE:
+                case PlSqlParser.ACCOUNT:
+                case PlSqlParser.ACL:
+                case PlSqlParser.ACOS:
+                case PlSqlParser.ACROSS:
+                case PlSqlParser.ACTION:
+                case PlSqlParser.ACTIONS:
+                case PlSqlParser.ACTIVATE:
+                case PlSqlParser.ACTIVE:
+                case PlSqlParser.ACTIVE_COMPONENT:
+                case PlSqlParser.ACTIVE_DATA:
+                case PlSqlParser.ACTIVE_FUNCTION:
+                case PlSqlParser.ACTIVE_TAG:
+                case PlSqlParser.ACTIVITY:
+                case PlSqlParser.ADAPTIVE_PLAN:
+                case PlSqlParser.ADD:
+                case PlSqlParser.ADD_COLUMN:
+                case PlSqlParser.ADD_GROUP:
+                case PlSqlParser.ADD_MONTHS:
+                case PlSqlParser.ADJ_DATE:
+                case PlSqlParser.ADMIN:
+                case PlSqlParser.ADMINISTER:
+                case PlSqlParser.ADMINISTRATOR:
+                case PlSqlParser.ADVANCED:
+                case PlSqlParser.ADVISE:
+                case PlSqlParser.ADVISOR:
+                case PlSqlParser.AFD_DISKSTRING:
+                case PlSqlParser.AFTER:
+                case PlSqlParser.AGENT:
+                case PlSqlParser.AGGREGATE:
+                case PlSqlParser.A_LETTER:
+                case PlSqlParser.ALIAS:
+                case PlSqlParser.ALLOCATE:
+                case PlSqlParser.ALLOW:
+                case PlSqlParser.ALL_ROWS:
+                case PlSqlParser.ALTERNATE:
+                case PlSqlParser.ALWAYS:
+                case PlSqlParser.ANALYTIC:
+                case PlSqlParser.ANALYZE:
+                case PlSqlParser.ANCESTOR:
+                case PlSqlParser.ANCILLARY:
+                case PlSqlParser.AND_EQUAL:
+                case PlSqlParser.ANOMALY:
+                case PlSqlParser.ANSI_REARCH:
+                case PlSqlParser.ANTIJOIN:
+                case PlSqlParser.ANYSCHEMA:
+                case PlSqlParser.APPEND:
+                case PlSqlParser.APPENDCHILDXML:
+                case PlSqlParser.APPEND_VALUES:
+                case PlSqlParser.APPLICATION:
+                case PlSqlParser.APPLY:
+                case PlSqlParser.APPROX_COUNT_DISTINCT:
+                case PlSqlParser.ARCHIVAL:
+                case PlSqlParser.ARCHIVE:
+                case PlSqlParser.ARCHIVED:
+                case PlSqlParser.ARCHIVELOG:
+                case PlSqlParser.ARRAY:
+                case PlSqlParser.ASCII:
+                case PlSqlParser.ASCIISTR:
+                case PlSqlParser.ASIN:
+                case PlSqlParser.ASIS:
+                case PlSqlParser.ASSEMBLY:
+                case PlSqlParser.ASSIGN:
+                case PlSqlParser.ASSOCIATE:
+                case PlSqlParser.ASYNC:
+                case PlSqlParser.ASYNCHRONOUS:
+                case PlSqlParser.ATAN2:
+                case PlSqlParser.ATAN:
+                case PlSqlParser.AT:
+                case PlSqlParser.ATTRIBUTE:
+                case PlSqlParser.ATTRIBUTES:
+                case PlSqlParser.AUDIT:
+                case PlSqlParser.AUTHENTICATED:
+                case PlSqlParser.AUTHENTICATION:
+                case PlSqlParser.AUTHID:
+                case PlSqlParser.AUTHORIZATION:
+                case PlSqlParser.AUTOALLOCATE:
+                case PlSqlParser.AUTO:
+                case PlSqlParser.AUTOEXTEND:
+                case PlSqlParser.AUTO_LOGIN:
+                case PlSqlParser.AUTOMATIC:
+                case PlSqlParser.AUTONOMOUS_TRANSACTION:
+                case PlSqlParser.AUTO_REOPTIMIZE:
+                case PlSqlParser.AVAILABILITY:
+                case PlSqlParser.AVRO:
+                case PlSqlParser.BACKGROUND:
+                case PlSqlParser.BACKINGFILE:
+                case PlSqlParser.BACKUP:
+                case PlSqlParser.BACKUPS:
+                case PlSqlParser.BASIC:
+                case PlSqlParser.BASICFILE:
+                case PlSqlParser.BATCH:
+                case PlSqlParser.BATCHSIZE:
+                case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.BECOME:
+                case PlSqlParser.BEFORE:
+                case PlSqlParser.BEGIN:
+                case PlSqlParser.BEGINNING:
+                case PlSqlParser.BEGIN_OUTLINE_DATA:
+                case PlSqlParser.BEHALF:
+                case PlSqlParser.BEQUEATH:
+                case PlSqlParser.BFILE:
+                case PlSqlParser.BFILENAME:
+                case PlSqlParser.BIGFILE:
+                case PlSqlParser.BINARY:
+                case PlSqlParser.BINARY_DOUBLE:
+                case PlSqlParser.BINARY_DOUBLE_INFINITY:
+                case PlSqlParser.BINARY_DOUBLE_NAN:
+                case PlSqlParser.BINARY_FLOAT:
+                case PlSqlParser.BINARY_FLOAT_INFINITY:
+                case PlSqlParser.BINARY_FLOAT_NAN:
+                case PlSqlParser.BINARY_INTEGER:
+                case PlSqlParser.BIND_AWARE:
+                case PlSqlParser.BINDING:
+                case PlSqlParser.BIN_TO_NUM:
+                case PlSqlParser.BITAND:
+                case PlSqlParser.BITMAP_AND:
+                case PlSqlParser.BITMAP:
+                case PlSqlParser.BITMAPS:
+                case PlSqlParser.BITMAP_TREE:
+                case PlSqlParser.BITS:
+                case PlSqlParser.BLOB:
+                case PlSqlParser.BLOCK:
+                case PlSqlParser.BLOCK_RANGE:
+                case PlSqlParser.BLOCKS:
+                case PlSqlParser.BLOCKSIZE:
+                case PlSqlParser.BODY:
+                case PlSqlParser.BOOLEAN:
+                case PlSqlParser.BOTH:
+                case PlSqlParser.BOUND:
+                case PlSqlParser.BRANCH:
+                case PlSqlParser.BREADTH:
+                case PlSqlParser.BROADCAST:
+                case PlSqlParser.BSON:
+                case PlSqlParser.BUFFER:
+                case PlSqlParser.BUFFER_CACHE:
+                case PlSqlParser.BUFFER_POOL:
+                case PlSqlParser.BUILD:
+                case PlSqlParser.BULK:
+                case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+                case PlSqlParser.BYPASS_UJVC:
+                case PlSqlParser.BYTE:
+                case PlSqlParser.BYTES:
+                case PlSqlParser.CACHE:
+                case PlSqlParser.CACHE_CB:
+                case PlSqlParser.CACHE_INSTANCES:
+                case PlSqlParser.CACHE_TEMP_TABLE:
+                case PlSqlParser.CACHING:
+                case PlSqlParser.CALCULATED:
+                case PlSqlParser.CALLBACK:
+                case PlSqlParser.CALL:
+                case PlSqlParser.CANCEL:
+                case PlSqlParser.CAPACITY:
+                case PlSqlParser.CAPTION:
+                case PlSqlParser.CARDINALITY:
+                case PlSqlParser.CASCADE:
+                case PlSqlParser.CASE:
+                case PlSqlParser.CAST:
+                case PlSqlParser.CASESENSITIVE:
+                case PlSqlParser.CATEGORY:
+                case PlSqlParser.CDBDEFAULT:
+                case PlSqlParser.CEIL:
+                case PlSqlParser.CELL_FLASH_CACHE:
+                case PlSqlParser.CERTIFICATE:
+                case PlSqlParser.CFILE:
+                case PlSqlParser.CHAINED:
+                case PlSqlParser.CHANGE:
+                case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+                case PlSqlParser.CHARACTER:
+                case PlSqlParser.CHARACTERSET:
+                case PlSqlParser.CHAR:
+                case PlSqlParser.CHAR_CS:
+                case PlSqlParser.CHARTOROWID:
+                case PlSqlParser.CHECK_ACL_REWRITE:
+                case PlSqlParser.CHECKPOINT:
+                case PlSqlParser.CHILD:
+                case PlSqlParser.CHOOSE:
+                case PlSqlParser.CHR:
+                case PlSqlParser.CHUNK:
+                case PlSqlParser.CLASS:
+                case PlSqlParser.CLASSIFICATION:
+                case PlSqlParser.CLASSIFIER:
+                case PlSqlParser.CLAUSE:
+                case PlSqlParser.CLEAN:
+                case PlSqlParser.CLEANUP:
+                case PlSqlParser.CLEAR:
+                case PlSqlParser.C_LETTER:
+                case PlSqlParser.CLIENT:
+                case PlSqlParser.CLOB:
+                case PlSqlParser.CLONE:
+                case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+                case PlSqlParser.CLOSE:
+                case PlSqlParser.CLUSTER_BY_ROWID:
+                case PlSqlParser.CLUSTER:
+                case PlSqlParser.CLUSTER_DETAILS:
+                case PlSqlParser.CLUSTER_DISTANCE:
+                case PlSqlParser.CLUSTER_ID:
+                case PlSqlParser.CLUSTERING:
+                case PlSqlParser.CLUSTERING_FACTOR:
+                case PlSqlParser.CLUSTER_PROBABILITY:
+                case PlSqlParser.CLUSTER_SET:
+                case PlSqlParser.COALESCE:
+                case PlSqlParser.COALESCE_SQ:
+                case PlSqlParser.COARSE:
+                case PlSqlParser.CO_AUTH_IND:
+                case PlSqlParser.COLD:
+                case PlSqlParser.COLLECT:
+                case PlSqlParser.COLUMNAR:
+                case PlSqlParser.COLUMN_AUTH_INDICATOR:
+                case PlSqlParser.COLUMN:
+                case PlSqlParser.COLUMNS:
+                case PlSqlParser.COLUMN_STATS:
+                case PlSqlParser.COLUMN_VALUE:
+                case PlSqlParser.COMMENT:
+                case PlSqlParser.COMMIT:
+                case PlSqlParser.COMMITTED:
+                case PlSqlParser.COMMON:
+                case PlSqlParser.COMMON_DATA:
+                case PlSqlParser.COMPACT:
+                case PlSqlParser.COMPATIBILITY:
+                case PlSqlParser.COMPILE:
+                case PlSqlParser.COMPLETE:
+                case PlSqlParser.COMPLIANCE:
+                case PlSqlParser.COMPONENT:
+                case PlSqlParser.COMPONENTS:
+                case PlSqlParser.COMPOSE:
+                case PlSqlParser.COMPOSITE:
+                case PlSqlParser.COMPOSITE_LIMIT:
+                case PlSqlParser.COMPOUND:
+                case PlSqlParser.COMPUTE:
+                case PlSqlParser.CONCAT:
+                case PlSqlParser.CON_DBID_TO_ID:
+                case PlSqlParser.CONDITIONAL:
+                case PlSqlParser.CONDITION:
+                case PlSqlParser.CONFIRM:
+                case PlSqlParser.CONFORMING:
+                case PlSqlParser.CON_GUID_TO_ID:
+                case PlSqlParser.CON_ID:
+                case PlSqlParser.CON_NAME_TO_ID:
+                case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.CONNECT_BY_COST_BASED:
+                case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.CONNECT_BY_FILTERING:
+                case PlSqlParser.CONNECT_BY_ISCYCLE:
+                case PlSqlParser.CONNECT_BY_ISLEAF:
+                case PlSqlParser.CONNECT_BY_ROOT:
+                case PlSqlParser.CONNECT_TIME:
+                case PlSqlParser.CONSIDER:
+                case PlSqlParser.CONSISTENT:
+                case PlSqlParser.CONSTANT:
+                case PlSqlParser.CONST:
+                case PlSqlParser.CONSTRAINT:
+                case PlSqlParser.CONSTRAINTS:
+                case PlSqlParser.CONSTRUCTOR:
+                case PlSqlParser.CONTAINER:
+                case PlSqlParser.CONTAINERS:
+                case PlSqlParser.CONTAINERS_DEFAULT:
+                case PlSqlParser.CONTAINER_DATA:
+                case PlSqlParser.CONTAINER_MAP:
+                case PlSqlParser.CONTENT:
+                case PlSqlParser.CONTENTS:
+                case PlSqlParser.CONTEXT:
+                case PlSqlParser.CONTINUE:
+                case PlSqlParser.CONTROLFILE:
+                case PlSqlParser.CON_UID_TO_ID:
+                case PlSqlParser.CONVERT:
+                case PlSqlParser.CONVERSION:
+                case PlSqlParser.COOKIE:
+                case PlSqlParser.COPY:
+                case PlSqlParser.CORR_K:
+                case PlSqlParser.CORR_S:
+                case PlSqlParser.CORRUPTION:
+                case PlSqlParser.CORRUPT_XID_ALL:
+                case PlSqlParser.CORRUPT_XID:
+                case PlSqlParser.COS:
+                case PlSqlParser.COSH:
+                case PlSqlParser.COST:
+                case PlSqlParser.COST_XML_QUERY_REWRITE:
+                case PlSqlParser.COUNT:
+                case PlSqlParser.COUNTED:
+                case PlSqlParser.COVAR_POP:
+                case PlSqlParser.COVAR_SAMP:
+                case PlSqlParser.CPU_COSTING:
+                case PlSqlParser.CPU_PER_CALL:
+                case PlSqlParser.CPU_PER_SESSION:
+                case PlSqlParser.CRASH:
+                case PlSqlParser.CREATE_FILE_DEST:
+                case PlSqlParser.CREATE_STORED_OUTLINES:
+                case PlSqlParser.CREATION:
+                case PlSqlParser.CREDENTIAL:
+                case PlSqlParser.CRITICAL:
+                case PlSqlParser.CROSS:
+                case PlSqlParser.CROSSEDITION:
+                case PlSqlParser.CSCONVERT:
+                case PlSqlParser.CSV:
+                case PlSqlParser.CUBE_AJ:
+                case PlSqlParser.CUBE:
+                case PlSqlParser.CUBE_GB:
+                case PlSqlParser.CUBE_SJ:
+                case PlSqlParser.CUME_DISTM:
+                case PlSqlParser.CURRENT:
+                case PlSqlParser.CURRENT_DATE:
+                case PlSqlParser.CURRENT_SCHEMA:
+                case PlSqlParser.CURRENT_TIME:
+                case PlSqlParser.CURRENT_TIMESTAMP:
+                case PlSqlParser.CURRENT_USER:
+                case PlSqlParser.CURRENTV:
+                case PlSqlParser.CURSOR:
+                case PlSqlParser.CURSOR_SHARING_EXACT:
+                case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+                case PlSqlParser.CUSTOMDATUM:
+                case PlSqlParser.CV:
+                case PlSqlParser.CYCLE:
+                case PlSqlParser.DANGLING:
+                case PlSqlParser.DATABASE:
+                case PlSqlParser.DATA:
+                case PlSqlParser.DATAFILE:
+                case PlSqlParser.DATAFILES:
+                case PlSqlParser.DATAMOVEMENT:
+                case PlSqlParser.DATAOBJNO:
+                case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+                case PlSqlParser.DATAOBJ_TO_PARTITION:
+                case PlSqlParser.DATAPUMP:
+                case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+                case PlSqlParser.DATE:
+                case PlSqlParser.DATE_FORMAT:
+                case PlSqlParser.DATE_MODE:
+                case PlSqlParser.DAY:
+                case PlSqlParser.DAYS:
+                case PlSqlParser.DBA:
+                case PlSqlParser.DBA_RECYCLEBIN:
+                case PlSqlParser.DBLINK:
+                case PlSqlParser.DBMS_STATS:
+                case PlSqlParser.DB_ROLE_CHANGE:
+                case PlSqlParser.DBTIMEZONE:
+                case PlSqlParser.DB_UNIQUE_NAME:
+                case PlSqlParser.DB_VERSION:
+                case PlSqlParser.DDL:
+                case PlSqlParser.DEALLOCATE:
+                case PlSqlParser.DEBUG:
+                case PlSqlParser.DEBUGGER:
+                case PlSqlParser.DEC:
+                case PlSqlParser.DECIMAL:
+                case PlSqlParser.DECLARE:
+                case PlSqlParser.DECOMPOSE:
+                case PlSqlParser.DECORRELATE:
+                case PlSqlParser.DECR:
+                case PlSqlParser.DECREMENT:
+                case PlSqlParser.DECRYPT:
+                case PlSqlParser.DEDUPLICATE:
+                case PlSqlParser.DEFAULTS:
+                case PlSqlParser.DEFAULT_COLLATION:
+                case PlSqlParser.DEFAULT_CREDENTIAL:
+                case PlSqlParser.DEFERRABLE:
+                case PlSqlParser.DEFERRED:
+                case PlSqlParser.DEFINED:
+                case PlSqlParser.DEFINE:
+                case PlSqlParser.DEFINER:
+                case PlSqlParser.DEGREE:
+                case PlSqlParser.DELAY:
+                case PlSqlParser.DELEGATE:
+                case PlSqlParser.DELETE_ALL:
+                case PlSqlParser.DELETE:
+                case PlSqlParser.DELETEXML:
+                case PlSqlParser.DEMAND:
+                case PlSqlParser.DENSE_RANKM:
+                case PlSqlParser.DEPENDENT:
+                case PlSqlParser.DEPRECATE:
+                case PlSqlParser.DEPTH:
+                case PlSqlParser.DEQUEUE:
+                case PlSqlParser.DEREF:
+                case PlSqlParser.DEREF_NO_REWRITE:
+                case PlSqlParser.DESCRIPTION:
+                case PlSqlParser.DESTROY:
+                case PlSqlParser.DETACHED:
+                case PlSqlParser.DETECTED:
+                case PlSqlParser.DETERMINES:
+                case PlSqlParser.DETERMINISTIC:
+                case PlSqlParser.DICTIONARY:
+                case PlSqlParser.DIMENSION:
+                case PlSqlParser.DIMENSIONS:
+                case PlSqlParser.DIRECT_LOAD:
+                case PlSqlParser.DIRECTORY:
+                case PlSqlParser.DIRECT_PATH:
+                case PlSqlParser.DISABLE_ALL:
+                case PlSqlParser.DISABLE:
+                case PlSqlParser.DISABLED:
+                case PlSqlParser.DISABLE_PARALLEL_DML:
+                case PlSqlParser.DISABLE_PRESET:
+                case PlSqlParser.DISABLE_RPKE:
+                case PlSqlParser.DISALLOW:
+                case PlSqlParser.DISASSOCIATE:
+                case PlSqlParser.DISCARD:
+                case PlSqlParser.DISCONNECT:
+                case PlSqlParser.DISK:
+                case PlSqlParser.DISKGROUP:
+                case PlSqlParser.DISKS:
+                case PlSqlParser.DISMOUNT:
+                case PlSqlParser.DISTINGUISHED:
+                case PlSqlParser.DISTRIBUTED:
+                case PlSqlParser.DISTRIBUTE:
+                case PlSqlParser.DML:
+                case PlSqlParser.DML_UPDATE:
+                case PlSqlParser.DOCFIDELITY:
+                case PlSqlParser.DOCUMENT:
+                case PlSqlParser.DOMAIN_INDEX_FILTER:
+                case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+                case PlSqlParser.DOMAIN_INDEX_SORT:
+                case PlSqlParser.DOUBLE:
+                case PlSqlParser.DOWNGRADE:
+                case PlSqlParser.DRIVING_SITE:
+                case PlSqlParser.DROP_COLUMN:
+                case PlSqlParser.DROP_GROUP:
+                case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.DUMP:
+                case PlSqlParser.DUPLICATE:
+                case PlSqlParser.DV:
+                case PlSqlParser.DYNAMIC:
+                case PlSqlParser.DYNAMIC_SAMPLING:
+                case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+                case PlSqlParser.E_LETTER:
+                case PlSqlParser.EACH:
+                case PlSqlParser.EDITIONABLE:
+                case PlSqlParser.EDITION:
+                case PlSqlParser.EDITIONING:
+                case PlSqlParser.EDITIONS:
+                case PlSqlParser.ELEMENT:
+                case PlSqlParser.ELIM_GROUPBY:
+                case PlSqlParser.ELIMINATE_JOIN:
+                case PlSqlParser.ELIMINATE_OBY:
+                case PlSqlParser.ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.EM:
+                case PlSqlParser.EMPTY_BLOB:
+                case PlSqlParser.EMPTY_CLOB:
+                case PlSqlParser.EMPTY_:
+                case PlSqlParser.ENABLE_ALL:
+                case PlSqlParser.ENABLE:
+                case PlSqlParser.ENABLED:
+                case PlSqlParser.ENABLE_PARALLEL_DML:
+                case PlSqlParser.ENABLE_PRESET:
+                case PlSqlParser.ENCLOSED:
+                case PlSqlParser.ENCODING:
+                case PlSqlParser.ENCRYPT:
+                case PlSqlParser.ENCRYPTION:
+                case PlSqlParser.END_OUTLINE_DATA:
+                case PlSqlParser.ENFORCED:
+                case PlSqlParser.ENFORCE:
+                case PlSqlParser.ENQUEUE:
+                case PlSqlParser.ENTERPRISE:
+                case PlSqlParser.ENTITYESCAPING:
+                case PlSqlParser.ENTRY:
+                case PlSqlParser.EQUIPART:
+                case PlSqlParser.ERR:
+                case PlSqlParser.ERROR_ARGUMENT:
+                case PlSqlParser.ERROR:
+                case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+                case PlSqlParser.ERRORS:
+                case PlSqlParser.ERROR_INDEX:
+                case PlSqlParser.ERROR_CODE:
+                case PlSqlParser.ESCAPE:
+                case PlSqlParser.ESTIMATE:
+                case PlSqlParser.EVAL:
+                case PlSqlParser.EVALNAME:
+                case PlSqlParser.EVALUATE:
+                case PlSqlParser.EVALUATION:
+                case PlSqlParser.EVENTS:
+                case PlSqlParser.EVERY:
+                case PlSqlParser.EXCEPT:
+                case PlSqlParser.EXCEPTION:
+                case PlSqlParser.EXCEPTION_INIT:
+                case PlSqlParser.EXCEPTIONS:
+                case PlSqlParser.EXCHANGE:
+                case PlSqlParser.EXCLUDE:
+                case PlSqlParser.EXCLUDING:
+                case PlSqlParser.EXEC:
+                case PlSqlParser.EXECUTE:
+                case PlSqlParser.EXEMPT:
+                case PlSqlParser.EXISTING:
+                case PlSqlParser.EXISTS:
+                case PlSqlParser.EXISTSNODE:
+                case PlSqlParser.EXIT:
+                case PlSqlParser.EXPAND_GSET_TO_UNION:
+                case PlSqlParser.EXPAND_TABLE:
+                case PlSqlParser.EXP:
+                case PlSqlParser.EXPIRE:
+                case PlSqlParser.EXPLAIN:
+                case PlSqlParser.EXPLOSION:
+                case PlSqlParser.EXPORT:
+                case PlSqlParser.EXPR_CORR_CHECK:
+                case PlSqlParser.EXPRESS:
+                case PlSqlParser.EXTENDS:
+                case PlSqlParser.EXTENT:
+                case PlSqlParser.EXTENTS:
+                case PlSqlParser.EXTERNAL:
+                case PlSqlParser.EXTERNALLY:
+                case PlSqlParser.EXTRACTCLOBXML:
+                case PlSqlParser.EXTRACT:
+                case PlSqlParser.EXTRACTVALUE:
+                case PlSqlParser.EXTRA:
+                case PlSqlParser.FACILITY:
+                case PlSqlParser.FACT:
+                case PlSqlParser.FACTOR:
+                case PlSqlParser.FACTORIZE_JOIN:
+                case PlSqlParser.FAILED:
+                case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+                case PlSqlParser.FAILGROUP:
+                case PlSqlParser.FAILOVER:
+                case PlSqlParser.FAILURE:
+                case PlSqlParser.FALSE:
+                case PlSqlParser.FAMILY:
+                case PlSqlParser.FAR:
+                case PlSqlParser.FAST:
+                case PlSqlParser.FASTSTART:
+                case PlSqlParser.FBTSCAN:
+                case PlSqlParser.FEATURE:
+                case PlSqlParser.FEATURE_DETAILS:
+                case PlSqlParser.FEATURE_ID:
+                case PlSqlParser.FEATURE_SET:
+                case PlSqlParser.FEATURE_VALUE:
+                case PlSqlParser.FETCH:
+                case PlSqlParser.FIELD:
+                case PlSqlParser.FIELDS:
+                case PlSqlParser.FILE:
+                case PlSqlParser.FILE_NAME_CONVERT:
+                case PlSqlParser.FILEGROUP:
+                case PlSqlParser.FILESTORE:
+                case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+                case PlSqlParser.FILTER:
+                case PlSqlParser.FINAL:
+                case PlSqlParser.FINE:
+                case PlSqlParser.FINISH:
+                case PlSqlParser.FIRST:
+                case PlSqlParser.FIRSTM:
+                case PlSqlParser.FIRST_ROWS:
+                case PlSqlParser.FIRST_VALUE:
+                case PlSqlParser.FIXED_VIEW_DATA:
+                case PlSqlParser.FLAGGER:
+                case PlSqlParser.FLASHBACK:
+                case PlSqlParser.FLASH_CACHE:
+                case PlSqlParser.FLOAT:
+                case PlSqlParser.FLOB:
+                case PlSqlParser.FLEX:
+                case PlSqlParser.FLOOR:
+                case PlSqlParser.FLUSH:
+                case PlSqlParser.FOLDER:
+                case PlSqlParser.FOLLOWING:
+                case PlSqlParser.FOLLOWS:
+                case PlSqlParser.FORALL:
+                case PlSqlParser.FORCE:
+                case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+                case PlSqlParser.FOREIGN:
+                case PlSqlParser.FOREVER:
+                case PlSqlParser.FORMAT:
+                case PlSqlParser.FORWARD:
+                case PlSqlParser.FRAGMENT_NUMBER:
+                case PlSqlParser.FREELIST:
+                case PlSqlParser.FREELISTS:
+                case PlSqlParser.FREEPOOLS:
+                case PlSqlParser.FRESH:
+                case PlSqlParser.FROM_TZ:
+                case PlSqlParser.FULL:
+                case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.FUNCTION:
+                case PlSqlParser.FUNCTIONS:
+                case PlSqlParser.FTP:
+                case PlSqlParser.G_LETTER:
+                case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.GATHER_PLAN_STATISTICS:
+                case PlSqlParser.GBY_CONC_ROLLUP:
+                case PlSqlParser.GBY_PUSHDOWN:
+                case PlSqlParser.GENERATED:
+                case PlSqlParser.GET:
+                case PlSqlParser.GLOBAL:
+                case PlSqlParser.GLOBALLY:
+                case PlSqlParser.GLOBAL_NAME:
+                case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+                case PlSqlParser.GROUP_BY:
+                case PlSqlParser.GROUP_ID:
+                case PlSqlParser.GROUPING:
+                case PlSqlParser.GROUPING_ID:
+                case PlSqlParser.GROUPS:
+                case PlSqlParser.GUARANTEED:
+                case PlSqlParser.GUARANTEE:
+                case PlSqlParser.GUARD:
+                case PlSqlParser.HALF_YEARS:
+                case PlSqlParser.HASH_AJ:
+                case PlSqlParser.HASH:
+                case PlSqlParser.HASHKEYS:
+                case PlSqlParser.HASH_SJ:
+                case PlSqlParser.HEADER:
+                case PlSqlParser.HEAP:
+                case PlSqlParser.HELP:
+                case PlSqlParser.HEXTORAW:
+                case PlSqlParser.HEXTOREF:
+                case PlSqlParser.HIDDEN_KEYWORD:
+                case PlSqlParser.HIDE:
+                case PlSqlParser.HIER_ORDER:
+                case PlSqlParser.HIERARCHICAL:
+                case PlSqlParser.HIERARCHY:
+                case PlSqlParser.HIGH:
+                case PlSqlParser.HINTSET_BEGIN:
+                case PlSqlParser.HINTSET_END:
+                case PlSqlParser.HOT:
+                case PlSqlParser.HOUR:
+                case PlSqlParser.HOURS:
+                case PlSqlParser.HTTP:
+                case PlSqlParser.HWM_BROKERED:
+                case PlSqlParser.HYBRID:
+                case PlSqlParser.H_LETTER:
+                case PlSqlParser.IDENTIFIER:
+                case PlSqlParser.IDENTITY:
+                case PlSqlParser.IDGENERATORS:
+                case PlSqlParser.ID:
+                case PlSqlParser.IDLE_TIME:
+                case PlSqlParser.IF:
+                case PlSqlParser.IGNORE:
+                case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+                case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+                case PlSqlParser.IGNORE_WHERE_CLAUSE:
+                case PlSqlParser.ILM:
+                case PlSqlParser.IMMEDIATE:
+                case PlSqlParser.IMPACT:
+                case PlSqlParser.IMPORT:
+                case PlSqlParser.INACTIVE:
+                case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+                case PlSqlParser.INCLUDE:
+                case PlSqlParser.INCLUDE_VERSION:
+                case PlSqlParser.INCLUDING:
+                case PlSqlParser.INCREMENTAL:
+                case PlSqlParser.INCREMENT:
+                case PlSqlParser.INCR:
+                case PlSqlParser.INDENT:
+                case PlSqlParser.INDEX_ASC:
+                case PlSqlParser.INDEX_COMBINE:
+                case PlSqlParser.INDEX_DESC:
+                case PlSqlParser.INDEXED:
+                case PlSqlParser.INDEXES:
+                case PlSqlParser.INDEX_FFS:
+                case PlSqlParser.INDEX_FILTER:
+                case PlSqlParser.INDEXING:
+                case PlSqlParser.INDEX_JOIN:
+                case PlSqlParser.INDEX_ROWS:
+                case PlSqlParser.INDEX_RRS:
+                case PlSqlParser.INDEX_RS_ASC:
+                case PlSqlParser.INDEX_RS_DESC:
+                case PlSqlParser.INDEX_RS:
+                case PlSqlParser.INDEX_SCAN:
+                case PlSqlParser.INDEX_SKIP_SCAN:
+                case PlSqlParser.INDEX_SS_ASC:
+                case PlSqlParser.INDEX_SS_DESC:
+                case PlSqlParser.INDEX_SS:
+                case PlSqlParser.INDEX_STATS:
+                case PlSqlParser.INDEXTYPE:
+                case PlSqlParser.INDEXTYPES:
+                case PlSqlParser.INDICATOR:
+                case PlSqlParser.INDICES:
+                case PlSqlParser.INFINITE:
+                case PlSqlParser.INFORMATIONAL:
+                case PlSqlParser.INHERIT:
+                case PlSqlParser.INITCAP:
+                case PlSqlParser.INITIAL:
+                case PlSqlParser.INITIALIZED:
+                case PlSqlParser.INITIALLY:
+                case PlSqlParser.INITRANS:
+                case PlSqlParser.INLINE:
+                case PlSqlParser.INLINE_XMLTYPE_NT:
+                case PlSqlParser.INMEMORY:
+                case PlSqlParser.IN_MEMORY_METADATA:
+                case PlSqlParser.INMEMORY_PRUNING:
+                case PlSqlParser.INNER:
+                case PlSqlParser.INOUT:
+                case PlSqlParser.INPLACE:
+                case PlSqlParser.INSERTCHILDXMLAFTER:
+                case PlSqlParser.INSERTCHILDXMLBEFORE:
+                case PlSqlParser.INSERTCHILDXML:
+                case PlSqlParser.INSERTXMLAFTER:
+                case PlSqlParser.INSERTXMLBEFORE:
+                case PlSqlParser.INSTANCE:
+                case PlSqlParser.INSTANCES:
+                case PlSqlParser.INSTANTIABLE:
+                case PlSqlParser.INSTANTLY:
+                case PlSqlParser.INSTEAD:
+                case PlSqlParser.INSTR2:
+                case PlSqlParser.INSTR4:
+                case PlSqlParser.INSTRB:
+                case PlSqlParser.INSTRC:
+                case PlSqlParser.INSTR:
+                case PlSqlParser.INTEGER:
+                case PlSqlParser.INTERLEAVED:
+                case PlSqlParser.INTERMEDIATE:
+                case PlSqlParser.INTERNAL_CONVERT:
+                case PlSqlParser.INTERNAL_USE:
+                case PlSqlParser.INTERPRETED:
+                case PlSqlParser.INTERVAL:
+                case PlSqlParser.INT:
+                case PlSqlParser.INTERNAL:
+                case PlSqlParser.INVALIDATE:
+                case PlSqlParser.INVALIDATION:
+                case PlSqlParser.INVISIBLE:
+                case PlSqlParser.IN_XQUERY:
+                case PlSqlParser.IS_LEAF:
+                case PlSqlParser.ISOLATION:
+                case PlSqlParser.ISOLATION_LEVEL:
+                case PlSqlParser.ITEMS:
+                case PlSqlParser.ITERATE:
+                case PlSqlParser.ITERATION_NUMBER:
+                case PlSqlParser.JAVA:
+                case PlSqlParser.JOB:
+                case PlSqlParser.JOIN:
+                case PlSqlParser.JSON_ARRAYAGG:
+                case PlSqlParser.JSON_ARRAY:
+                case PlSqlParser.JSON_EQUAL:
+                case PlSqlParser.JSON_EXISTS2:
+                case PlSqlParser.JSON_EXISTS:
+                case PlSqlParser.JSONGET:
+                case PlSqlParser.JSON:
+                case PlSqlParser.JSON_OBJECTAGG:
+                case PlSqlParser.JSON_OBJECT:
+                case PlSqlParser.JSONPARSE:
+                case PlSqlParser.JSON_QUERY:
+                case PlSqlParser.JSON_SERIALIZE:
+                case PlSqlParser.JSON_TABLE:
+                case PlSqlParser.JSON_TEXTCONTAINS2:
+                case PlSqlParser.JSON_TEXTCONTAINS:
+                case PlSqlParser.JSON_TRANSFORM:
+                case PlSqlParser.JSON_VALUE:
+                case PlSqlParser.K_LETTER:
+                case PlSqlParser.KEEP_DUPLICATES:
+                case PlSqlParser.KEEP:
+                case PlSqlParser.KERBEROS:
+                case PlSqlParser.KEY:
+                case PlSqlParser.KEY_LENGTH:
+                case PlSqlParser.KEYSIZE:
+                case PlSqlParser.KEYS:
+                case PlSqlParser.KEYSTORE:
+                case PlSqlParser.KILL:
+                case PlSqlParser.LABEL:
+                case PlSqlParser.LANGUAGE:
+                case PlSqlParser.LAST_DAY:
+                case PlSqlParser.LAST:
+                case PlSqlParser.LAST_VALUE:
+                case PlSqlParser.LATERAL:
+                case PlSqlParser.LAX:
+                case PlSqlParser.LAYER:
+                case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+                case PlSqlParser.LDAP_REGISTRATION:
+                case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+                case PlSqlParser.LEAF:
+                case PlSqlParser.LEAD_CDB:
+                case PlSqlParser.LEAD_CDB_URI:
+                case PlSqlParser.LEADING:
+                case PlSqlParser.LEFT:
+                case PlSqlParser.LENGTH2:
+                case PlSqlParser.LENGTH4:
+                case PlSqlParser.LENGTHB:
+                case PlSqlParser.LENGTHC:
+                case PlSqlParser.LENGTH:
+                case PlSqlParser.LESS:
+                case PlSqlParser.LEVEL:
+                case PlSqlParser.LEVEL_NAME:
+                case PlSqlParser.LEVELS:
+                case PlSqlParser.LIBRARY:
+                case PlSqlParser.LIFECYCLE:
+                case PlSqlParser.LIFE:
+                case PlSqlParser.LIFETIME:
+                case PlSqlParser.LIKE2:
+                case PlSqlParser.LIKE4:
+                case PlSqlParser.LIKEC:
+                case PlSqlParser.LIKE_EXPAND:
+                case PlSqlParser.LIMIT:
+                case PlSqlParser.LINEAR:
+                case PlSqlParser.LINES:
+                case PlSqlParser.LINK:
+                case PlSqlParser.LIST:
+                case PlSqlParser.LN:
+                case PlSqlParser.LNNVL:
+                case PlSqlParser.LOAD:
+                case PlSqlParser.LOB:
+                case PlSqlParser.LOBNVL:
+                case PlSqlParser.LOBS:
+                case PlSqlParser.LOCAL_INDEXES:
+                case PlSqlParser.LOCAL:
+                case PlSqlParser.LOCALTIME:
+                case PlSqlParser.LOCALTIMESTAMP:
+                case PlSqlParser.LOCATION:
+                case PlSqlParser.LOCATOR:
+                case PlSqlParser.LOCKDOWN:
+                case PlSqlParser.LOCKED:
+                case PlSqlParser.LOCKING:
+                case PlSqlParser.LOGFILE:
+                case PlSqlParser.LOGFILES:
+                case PlSqlParser.LOGGING:
+                case PlSqlParser.LOGICAL:
+                case PlSqlParser.LOGICAL_READS_PER_CALL:
+                case PlSqlParser.LOGICAL_READS_PER_SESSION:
+                case PlSqlParser.LOG:
+                case PlSqlParser.LOGMINING:
+                case PlSqlParser.LOGOFF:
+                case PlSqlParser.LOGON:
+                case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+                case PlSqlParser.LONG:
+                case PlSqlParser.LOOP:
+                case PlSqlParser.LOST:
+                case PlSqlParser.LOWER:
+                case PlSqlParser.LOW:
+                case PlSqlParser.LPAD:
+                case PlSqlParser.LTRIM:
+                case PlSqlParser.M_LETTER:
+                case PlSqlParser.MAIN:
+                case PlSqlParser.MAKE_REF:
+                case PlSqlParser.MANAGED:
+                case PlSqlParser.MANAGE:
+                case PlSqlParser.MANAGEMENT:
+                case PlSqlParser.MANAGER:
+                case PlSqlParser.MANDATORY:
+                case PlSqlParser.MANUAL:
+                case PlSqlParser.MAP:
+                case PlSqlParser.MAPPING:
+                case PlSqlParser.MASK:
+                case PlSqlParser.MASTER:
+                case PlSqlParser.MATCHED:
+                case PlSqlParser.MATCHES:
+                case PlSqlParser.MATCH:
+                case PlSqlParser.MATCH_NUMBER:
+                case PlSqlParser.MATCH_RECOGNIZE:
+                case PlSqlParser.MATERIALIZED:
+                case PlSqlParser.MATERIALIZE:
+                case PlSqlParser.MAXARCHLOGS:
+                case PlSqlParser.MAXDATAFILES:
+                case PlSqlParser.MAXEXTENTS:
+                case PlSqlParser.MAXIMIZE:
+                case PlSqlParser.MAXINSTANCES:
+                case PlSqlParser.MAXLOGFILES:
+                case PlSqlParser.MAXLOGHISTORY:
+                case PlSqlParser.MAXLOGMEMBERS:
+                case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+                case PlSqlParser.MAXSIZE:
+                case PlSqlParser.MAXTRANS:
+                case PlSqlParser.MAXVALUE:
+                case PlSqlParser.MEASURE:
+                case PlSqlParser.MEASURES:
+                case PlSqlParser.MEDIUM:
+                case PlSqlParser.MEMBER:
+                case PlSqlParser.MEMBER_CAPTION:
+                case PlSqlParser.MEMBER_DESCRIPTION:
+                case PlSqlParser.MEMBER_NAME:
+                case PlSqlParser.MEMBER_UNIQUE_NAME:
+                case PlSqlParser.MEMCOMPRESS:
+                case PlSqlParser.MEMORY:
+                case PlSqlParser.MERGEACTIONS:
+                case PlSqlParser.MERGE_AJ:
+                case PlSqlParser.MERGE_CONST_ON:
+                case PlSqlParser.MERGE:
+                case PlSqlParser.MERGE_SJ:
+                case PlSqlParser.METADATA:
+                case PlSqlParser.METHOD:
+                case PlSqlParser.MIGRATE:
+                case PlSqlParser.MIGRATION:
+                case PlSqlParser.MINEXTENTS:
+                case PlSqlParser.MINIMIZE:
+                case PlSqlParser.MINIMUM:
+                case PlSqlParser.MINING:
+                case PlSqlParser.MINUS_NULL:
+                case PlSqlParser.MINUTE:
+                case PlSqlParser.MINUTES:
+                case PlSqlParser.MINVALUE:
+                case PlSqlParser.MIRRORCOLD:
+                case PlSqlParser.MIRRORHOT:
+                case PlSqlParser.MIRROR:
+                case PlSqlParser.MISSING:
+                case PlSqlParser.MISMATCH:
+                case PlSqlParser.MLSLABEL:
+                case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+                case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+                case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+                case PlSqlParser.MODEL_MIN_ANALYSIS:
+                case PlSqlParser.MODEL:
+                case PlSqlParser.MODEL_NB:
+                case PlSqlParser.MODEL_NO_ANALYSIS:
+                case PlSqlParser.MODEL_PBY:
+                case PlSqlParser.MODEL_PUSH_REF:
+                case PlSqlParser.MODEL_SV:
+                case PlSqlParser.MODIFICATION:
+                case PlSqlParser.MODIFY_COLUMN_TYPE:
+                case PlSqlParser.MODIFY:
+                case PlSqlParser.MOD:
+                case PlSqlParser.MODULE:
+                case PlSqlParser.MONITORING:
+                case PlSqlParser.MONITOR:
+                case PlSqlParser.MONTH:
+                case PlSqlParser.MONTHS_BETWEEN:
+                case PlSqlParser.MONTHS:
+                case PlSqlParser.MOUNT:
+                case PlSqlParser.MOUNTPATH:
+                case PlSqlParser.MOUNTPOINT:
+                case PlSqlParser.MOVEMENT:
+                case PlSqlParser.MOVE:
+                case PlSqlParser.MULTIDIMENSIONAL:
+                case PlSqlParser.MULTISET:
+                case PlSqlParser.MV_MERGE:
+                case PlSqlParser.NAMED:
+                case PlSqlParser.NAME:
+                case PlSqlParser.NAMESPACE:
+                case PlSqlParser.NAN_:
+                case PlSqlParser.NANVL:
+                case PlSqlParser.NATIONAL:
+                case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NATIVE:
+                case PlSqlParser.NATURAL:
+                case PlSqlParser.NAV:
+                case PlSqlParser.NCHAR_CS:
+                case PlSqlParser.NCHAR:
+                case PlSqlParser.NCHR:
+                case PlSqlParser.NCLOB:
+                case PlSqlParser.NEEDED:
+                case PlSqlParser.NEG:
+                case PlSqlParser.NESTED:
+                case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+                case PlSqlParser.NESTED_TABLE_GET_REFS:
+                case PlSqlParser.NESTED_TABLE_ID:
+                case PlSqlParser.NESTED_TABLE_SET_REFS:
+                case PlSqlParser.NESTED_TABLE_SET_SETID:
+                case PlSqlParser.NETWORK:
+                case PlSqlParser.NEVER:
+                case PlSqlParser.NEW:
+                case PlSqlParser.NEWLINE_:
+                case PlSqlParser.NEW_TIME:
+                case PlSqlParser.NEXT_DAY:
+                case PlSqlParser.NEXT:
+                case PlSqlParser.NL_AJ:
+                case PlSqlParser.NLJ_BATCHING:
+                case PlSqlParser.NLJ_INDEX_FILTER:
+                case PlSqlParser.NLJ_INDEX_SCAN:
+                case PlSqlParser.NLJ_PREFETCH:
+                case PlSqlParser.NLS_CALENDAR:
+                case PlSqlParser.NLS_CHARACTERSET:
+                case PlSqlParser.NLS_CHARSET_DECL_LEN:
+                case PlSqlParser.NLS_CHARSET_ID:
+                case PlSqlParser.NLS_CHARSET_NAME:
+                case PlSqlParser.NLS_COMP:
+                case PlSqlParser.NLS_CURRENCY:
+                case PlSqlParser.NLS_DATE_FORMAT:
+                case PlSqlParser.NLS_DATE_LANGUAGE:
+                case PlSqlParser.NLS_INITCAP:
+                case PlSqlParser.NLS_ISO_CURRENCY:
+                case PlSqlParser.NL_SJ:
+                case PlSqlParser.NLS_LANG:
+                case PlSqlParser.NLS_LANGUAGE:
+                case PlSqlParser.NLS_LENGTH_SEMANTICS:
+                case PlSqlParser.NLS_LOWER:
+                case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+                case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+                case PlSqlParser.NLS_SORT:
+                case PlSqlParser.NLSSORT:
+                case PlSqlParser.NLS_SPECIAL_CHARS:
+                case PlSqlParser.NLS_TERRITORY:
+                case PlSqlParser.NLS_UPPER:
+                case PlSqlParser.NO_ACCESS:
+                case PlSqlParser.NO_ADAPTIVE_PLAN:
+                case PlSqlParser.NO_ANSI_REARCH:
+                case PlSqlParser.NOAPPEND:
+                case PlSqlParser.NOARCHIVELOG:
+                case PlSqlParser.NOAUDIT:
+                case PlSqlParser.NO_AUTO_REOPTIMIZE:
+                case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+                case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+                case PlSqlParser.NO_BIND_AWARE:
+                case PlSqlParser.NO_BUFFER:
+                case PlSqlParser.NOCACHE:
+                case PlSqlParser.NO_CARTESIAN:
+                case PlSqlParser.NO_CHECK_ACL_REWRITE:
+                case PlSqlParser.NO_CLUSTER_BY_ROWID:
+                case PlSqlParser.NO_CLUSTERING:
+                case PlSqlParser.NO_COALESCE_SQ:
+                case PlSqlParser.NO_COMMON_DATA:
+                case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+                case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+                case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+                case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+                case PlSqlParser.NO_CONNECT_BY_FILTERING:
+                case PlSqlParser.NOCOPY:
+                case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_CPU_COSTING:
+                case PlSqlParser.NOCPU_COSTING:
+                case PlSqlParser.NOCYCLE:
+                case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+                case PlSqlParser.NO_DECORRELATE:
+                case PlSqlParser.NODELAY:
+                case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+                case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+                case PlSqlParser.NO_ELIM_GROUPBY:
+                case PlSqlParser.NO_ELIMINATE_JOIN:
+                case PlSqlParser.NO_ELIMINATE_OBY:
+                case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+                case PlSqlParser.NOENTITYESCAPING:
+                case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+                case PlSqlParser.NO_EXPAND:
+                case PlSqlParser.NO_EXPAND_TABLE:
+                case PlSqlParser.NO_FACT:
+                case PlSqlParser.NO_FACTORIZE_JOIN:
+                case PlSqlParser.NO_FILTERING:
+                case PlSqlParser.NOFORCE:
+                case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+                case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+                case PlSqlParser.NO_GBY_PUSHDOWN:
+                case PlSqlParser.NOGUARANTEE:
+                case PlSqlParser.NO_INDEX_FFS:
+                case PlSqlParser.NO_INDEX:
+                case PlSqlParser.NO_INDEX_SS:
+                case PlSqlParser.NO_INMEMORY:
+                case PlSqlParser.NO_INMEMORY_PRUNING:
+                case PlSqlParser.NOKEEP:
+                case PlSqlParser.NO_LOAD:
+                case PlSqlParser.NOLOCAL:
+                case PlSqlParser.NOLOGGING:
+                case PlSqlParser.NOMAPPING:
+                case PlSqlParser.NOMAXVALUE:
+                case PlSqlParser.NO_MERGE:
+                case PlSqlParser.NOMINIMIZE:
+                case PlSqlParser.NOMINVALUE:
+                case PlSqlParser.NO_MODEL_PUSH_REF:
+                case PlSqlParser.NO_MONITORING:
+                case PlSqlParser.NOMONITORING:
+                case PlSqlParser.NO_MONITOR:
+                case PlSqlParser.NO_MULTIMV_REWRITE:
+                case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+                case PlSqlParser.NONBLOCKING:
+                case PlSqlParser.NONEDITIONABLE:
+                case PlSqlParser.NONE:
+                case PlSqlParser.NONPARTITIONED:
+                case PlSqlParser.NO_NLJ_BATCHING:
+                case PlSqlParser.NO_NLJ_PREFETCH:
+                case PlSqlParser.NO:
+                case PlSqlParser.NONSCHEMA:
+                case PlSqlParser.NO_OBJECT_LINK:
+                case PlSqlParser.NOORDER:
+                case PlSqlParser.NO_ORDER_ROLLUPS:
+                case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+                case PlSqlParser.NOOVERRIDE:
+                case PlSqlParser.NO_PARALLEL_INDEX:
+                case PlSqlParser.NOPARALLEL_INDEX:
+                case PlSqlParser.NO_PARALLEL:
+                case PlSqlParser.NOPARALLEL:
+                case PlSqlParser.NO_PARTIAL_COMMIT:
+                case PlSqlParser.NO_PARTIAL_JOIN:
+                case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.NOPARTITION:
+                case PlSqlParser.NO_PLACE_DISTINCT:
+                case PlSqlParser.NO_PLACE_GROUP_BY:
+                case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+                case PlSqlParser.NO_PQ_MAP:
+                case PlSqlParser.NOPROMPT:
+                case PlSqlParser.NO_PQ_REPLICATE:
+                case PlSqlParser.NO_PQ_SKEW:
+                case PlSqlParser.NO_PRUNE_GSETS:
+                case PlSqlParser.NO_PULL_PRED:
+                case PlSqlParser.NO_PUSH_PRED:
+                case PlSqlParser.NO_PUSH_SUBQ:
+                case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+                case PlSqlParser.NO_PX_JOIN_FILTER:
+                case PlSqlParser.NO_QKN_BUFF:
+                case PlSqlParser.NO_QUERY_TRANSFORMATION:
+                case PlSqlParser.NO_REF_CASCADE:
+                case PlSqlParser.NORELOCATE:
+                case PlSqlParser.NORELY:
+                case PlSqlParser.NOREPAIR:
+                case PlSqlParser.NOREPLAY:
+                case PlSqlParser.NORESETLOGS:
+                case PlSqlParser.NO_RESULT_CACHE:
+                case PlSqlParser.NOREVERSE:
+                case PlSqlParser.NO_REWRITE:
+                case PlSqlParser.NOREWRITE:
+                case PlSqlParser.NORMAL:
+                case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+                case PlSqlParser.NOROWDEPENDENCIES:
+                case PlSqlParser.NOSCHEMACHECK:
+                case PlSqlParser.NOSEGMENT:
+                case PlSqlParser.NO_SEMIJOIN:
+                case PlSqlParser.NO_SEMI_TO_INNER:
+                case PlSqlParser.NO_SET_TO_JOIN:
+                case PlSqlParser.NOSORT:
+                case PlSqlParser.NO_SQL_TRANSLATION:
+                case PlSqlParser.NO_SQL_TUNE:
+                case PlSqlParser.NO_STAR_TRANSFORMATION:
+                case PlSqlParser.NO_STATEMENT_QUEUING:
+                case PlSqlParser.NO_STATS_GSETS:
+                case PlSqlParser.NOSTRICT:
+                case PlSqlParser.NO_SUBQUERY_PRUNING:
+                case PlSqlParser.NO_SUBSTRB_PAD:
+                case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+                case PlSqlParser.NOSWITCH:
+                case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.NO_TEMP_TABLE:
+                case PlSqlParser.NOTHING:
+                case PlSqlParser.NOTIFICATION:
+                case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.NO_UNNEST:
+                case PlSqlParser.NO_USE_CUBE:
+                case PlSqlParser.NO_USE_HASH_AGGREGATION:
+                case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.NO_USE_HASH:
+                case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+                case PlSqlParser.NO_USE_MERGE:
+                case PlSqlParser.NO_USE_NL:
+                case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+                case PlSqlParser.NOVALIDATE:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.NO_VECTOR_TRANSFORM:
+                case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+                case PlSqlParser.NO_XML_DML_REWRITE:
+                case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.NO_XMLINDEX_REWRITE:
+                case PlSqlParser.NO_XML_QUERY_REWRITE:
+                case PlSqlParser.NO_ZONEMAP:
+                case PlSqlParser.NTH_VALUE:
+                case PlSqlParser.NULLIF:
+                case PlSqlParser.NULLS:
+                case PlSqlParser.NUMBER:
+                case PlSqlParser.NUMERIC:
+                case PlSqlParser.NUM_INDEX_KEYS:
+                case PlSqlParser.NUMTODSINTERVAL:
+                case PlSqlParser.NUMTOYMINTERVAL:
+                case PlSqlParser.NVARCHAR2:
+                case PlSqlParser.NVL2:
+                case PlSqlParser.OBJECT2XML:
+                case PlSqlParser.OBJECT:
+                case PlSqlParser.OBJ_ID:
+                case PlSqlParser.OBJNO:
+                case PlSqlParser.OBJNO_REUSE:
+                case PlSqlParser.OCCURENCES:
+                case PlSqlParser.OFFLINE:
+                case PlSqlParser.OFF:
+                case PlSqlParser.OFFSET:
+                case PlSqlParser.OIDINDEX:
+                case PlSqlParser.OID:
+                case PlSqlParser.OLAP:
+                case PlSqlParser.OLD:
+                case PlSqlParser.OLD_PUSH_PRED:
+                case PlSqlParser.OLS:
+                case PlSqlParser.OLTP:
+                case PlSqlParser.OMIT:
+                case PlSqlParser.ONE:
+                case PlSqlParser.ONLINE:
+                case PlSqlParser.ONLY:
+                case PlSqlParser.OPAQUE:
+                case PlSqlParser.OPAQUE_TRANSFORM:
+                case PlSqlParser.OPAQUE_XCANONICAL:
+                case PlSqlParser.OPCODE:
+                case PlSqlParser.OPEN:
+                case PlSqlParser.OPERATIONS:
+                case PlSqlParser.OPERATOR:
+                case PlSqlParser.OPT_ESTIMATE:
+                case PlSqlParser.OPTIMAL:
+                case PlSqlParser.OPTIMIZE:
+                case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+                case PlSqlParser.OPTIMIZER_GOAL:
+                case PlSqlParser.OPT_PARAM:
+                case PlSqlParser.ORA_BRANCH:
+                case PlSqlParser.ORA_CHECK_ACL:
+                case PlSqlParser.ORA_CHECK_PRIVILEGE:
+                case PlSqlParser.ORA_CLUSTERING:
+                case PlSqlParser.ORADATA:
+                case PlSqlParser.ORC:
+                case PlSqlParser.ORADEBUG:
+                case PlSqlParser.ORA_DST_AFFECTED:
+                case PlSqlParser.ORA_DST_CONVERT:
+                case PlSqlParser.ORA_DST_ERROR:
+                case PlSqlParser.ORA_GET_ACLIDS:
+                case PlSqlParser.ORA_GET_PRIVILEGES:
+                case PlSqlParser.ORA_HASH:
+                case PlSqlParser.ORA_INVOKING_USERID:
+                case PlSqlParser.ORA_INVOKING_USER:
+                case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+                case PlSqlParser.ORA_INVOKING_XS_USER:
+                case PlSqlParser.ORA_RAWCOMPARE:
+                case PlSqlParser.ORA_RAWCONCAT:
+                case PlSqlParser.ORA_ROWSCN:
+                case PlSqlParser.ORA_ROWSCN_RAW:
+                case PlSqlParser.ORA_ROWVERSION:
+                case PlSqlParser.ORA_TABVERSION:
+                case PlSqlParser.ORA_WRITE_TIME:
+                case PlSqlParser.ORDERED:
+                case PlSqlParser.ORDERED_PREDICATES:
+                case PlSqlParser.ORDINALITY:
+                case PlSqlParser.OR_EXPAND:
+                case PlSqlParser.ORGANIZATION:
+                case PlSqlParser.OR_PREDICATES:
+                case PlSqlParser.OSERROR:
+                case PlSqlParser.OTHER:
+                case PlSqlParser.OUTER_JOIN_TO_ANTI:
+                case PlSqlParser.OUTER_JOIN_TO_INNER:
+                case PlSqlParser.OUTER:
+                case PlSqlParser.OUTLINE_LEAF:
+                case PlSqlParser.OUTLINE:
+                case PlSqlParser.OUT_OF_LINE:
+                case PlSqlParser.OUT:
+                case PlSqlParser.OVERFLOW_NOMOVE:
+                case PlSqlParser.OVERFLOW_:
+                case PlSqlParser.OVERLAPS:
+                case PlSqlParser.OVER:
+                case PlSqlParser.OVERRIDE:
+                case PlSqlParser.OVERRIDING:
+                case PlSqlParser.OWNER:
+                case PlSqlParser.OWNERSHIP:
+                case PlSqlParser.OWN:
+                case PlSqlParser.P_LETTER:
+                case PlSqlParser.PACKAGE:
+                case PlSqlParser.PACKAGES:
+                case PlSqlParser.PARALLEL_ENABLE:
+                case PlSqlParser.PARALLEL_INDEX:
+                case PlSqlParser.PARALLEL:
+                case PlSqlParser.PARAMETERS:
+                case PlSqlParser.PARAM:
+                case PlSqlParser.PARENT:
+                case PlSqlParser.PARENT_LEVEL_NAME:
+                case PlSqlParser.PARENT_UNIQUE_NAME:
+                case PlSqlParser.PARITY:
+                case PlSqlParser.PARTIAL_JOIN:
+                case PlSqlParser.PARTIALLY:
+                case PlSqlParser.PARTIAL:
+                case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+                case PlSqlParser.PARTITION_HASH:
+                case PlSqlParser.PARTITION_LIST:
+                case PlSqlParser.PARTITION:
+                case PlSqlParser.PARTITION_RANGE:
+                case PlSqlParser.PARTITIONS:
+                case PlSqlParser.PARTNUMINST:
+                case PlSqlParser.PASSING:
+                case PlSqlParser.PASSWORD_GRACE_TIME:
+                case PlSqlParser.PASSWORD_LIFE_TIME:
+                case PlSqlParser.PASSWORD_LOCK_TIME:
+                case PlSqlParser.PASSWORD:
+                case PlSqlParser.PASSWORD_REUSE_MAX:
+                case PlSqlParser.PASSWORD_REUSE_TIME:
+                case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+                case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+                case PlSqlParser.PAST:
+                case PlSqlParser.PATCH:
+                case PlSqlParser.PATH:
+                case PlSqlParser.PATH_PREFIX:
+                case PlSqlParser.PATHS:
+                case PlSqlParser.PATTERN:
+                case PlSqlParser.PBL_HS_BEGIN:
+                case PlSqlParser.PBL_HS_END:
+                case PlSqlParser.PCTINCREASE:
+                case PlSqlParser.PCTTHRESHOLD:
+                case PlSqlParser.PCTUSED:
+                case PlSqlParser.PCTVERSION:
+                case PlSqlParser.PENDING:
+                case PlSqlParser.PERCENT_KEYWORD:
+                case PlSqlParser.PERCENT_RANKM:
+                case PlSqlParser.PERFORMANCE:
+                case PlSqlParser.PERIOD_KEYWORD:
+                case PlSqlParser.PERMANENT:
+                case PlSqlParser.PERMISSION:
+                case PlSqlParser.PERMUTE:
+                case PlSqlParser.PER:
+                case PlSqlParser.PFILE:
+                case PlSqlParser.PHYSICAL:
+                case PlSqlParser.PIKEY:
+                case PlSqlParser.PIPELINED:
+                case PlSqlParser.PIV_GB:
+                case PlSqlParser.PIVOT:
+                case PlSqlParser.PIV_SSF:
+                case PlSqlParser.PLACE_DISTINCT:
+                case PlSqlParser.PLACE_GROUP_BY:
+                case PlSqlParser.PLAN:
+                case PlSqlParser.PLSCOPE_SETTINGS:
+                case PlSqlParser.PLS_INTEGER:
+                case PlSqlParser.PLSQL_CCFLAGS:
+                case PlSqlParser.PLSQL_CODE_TYPE:
+                case PlSqlParser.PLSQL_DEBUG:
+                case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+                case PlSqlParser.PLSQL_WARNINGS:
+                case PlSqlParser.PLUGGABLE:
+                case PlSqlParser.PMEM:
+                case PlSqlParser.POINT:
+                case PlSqlParser.POLICY:
+                case PlSqlParser.POOL_16K:
+                case PlSqlParser.POOL_2K:
+                case PlSqlParser.POOL_32K:
+                case PlSqlParser.POOL_4K:
+                case PlSqlParser.POOL_8K:
+                case PlSqlParser.POSITION:
+                case PlSqlParser.POSITIVEN:
+                case PlSqlParser.POSITIVE:
+                case PlSqlParser.POST_TRANSACTION:
+                case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+                case PlSqlParser.POWERMULTISET:
+                case PlSqlParser.POWER:
+                case PlSqlParser.PQ_CONCURRENT_UNION:
+                case PlSqlParser.PQ_DISTRIBUTE:
+                case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+                case PlSqlParser.PQ_FILTER:
+                case PlSqlParser.PQ_MAP:
+                case PlSqlParser.PQ_NOMAP:
+                case PlSqlParser.PQ_REPLICATE:
+                case PlSqlParser.PQ_SKEW:
+                case PlSqlParser.PRAGMA:
+                case PlSqlParser.PREBUILT:
+                case PlSqlParser.PRECEDES:
+                case PlSqlParser.PRECEDING:
+                case PlSqlParser.PRECISION:
+                case PlSqlParser.PRECOMPUTE_SUBQUERY:
+                case PlSqlParser.PREDICATE_REORDERS:
+                case PlSqlParser.PRELOAD:
+                case PlSqlParser.PREPARE:
+                case PlSqlParser.PRESENTNNV:
+                case PlSqlParser.PRESENT:
+                case PlSqlParser.PRESENTV:
+                case PlSqlParser.PRESERVE_OID:
+                case PlSqlParser.PRESERVE:
+                case PlSqlParser.PRETTY:
+                case PlSqlParser.PREVIOUS:
+                case PlSqlParser.PREV:
+                case PlSqlParser.PRIMARY:
+                case PlSqlParser.PRINTBLOBTOCLOB:
+                case PlSqlParser.PRIORITY:
+                case PlSqlParser.PRIVATE:
+                case PlSqlParser.PRIVATE_SGA:
+                case PlSqlParser.PRIVILEGED:
+                case PlSqlParser.PRIVILEGE:
+                case PlSqlParser.PRIVILEGES:
+                case PlSqlParser.PROCEDURAL:
+                case PlSqlParser.PROCEDURE:
+                case PlSqlParser.PROCESS:
+                case PlSqlParser.PROFILE:
+                case PlSqlParser.PROGRAM:
+                case PlSqlParser.PROJECT:
+                case PlSqlParser.PROPAGATE:
+                case PlSqlParser.PROPERTY:
+                case PlSqlParser.PROTECTED:
+                case PlSqlParser.PROTECTION:
+                case PlSqlParser.PROTOCOL:
+                case PlSqlParser.PROXY:
+                case PlSqlParser.PRUNING:
+                case PlSqlParser.PUBLIC:
+                case PlSqlParser.PULL_PRED:
+                case PlSqlParser.PURGE:
+                case PlSqlParser.PUSH_PRED:
+                case PlSqlParser.PUSH_SUBQ:
+                case PlSqlParser.PX_FAULT_TOLERANCE:
+                case PlSqlParser.PX_GRANULE:
+                case PlSqlParser.PX_JOIN_FILTER:
+                case PlSqlParser.QB_NAME:
+                case PlSqlParser.QUARTERS:
+                case PlSqlParser.QUERY_BLOCK:
+                case PlSqlParser.QUERY:
+                case PlSqlParser.QUEUE_CURR:
+                case PlSqlParser.QUEUE:
+                case PlSqlParser.QUEUE_ROWP:
+                case PlSqlParser.QUIESCE:
+                case PlSqlParser.QUORUM:
+                case PlSqlParser.QUOTA:
+                case PlSqlParser.QUOTAGROUP:
+                case PlSqlParser.RAISE:
+                case PlSqlParser.RANDOM_LOCAL:
+                case PlSqlParser.RANDOM:
+                case PlSqlParser.RANGE:
+                case PlSqlParser.RANKM:
+                case PlSqlParser.RAPIDLY:
+                case PlSqlParser.RAW:
+                case PlSqlParser.RAWTOHEX:
+                case PlSqlParser.RAWTONHEX:
+                case PlSqlParser.RBA:
+                case PlSqlParser.RBO_OUTLINE:
+                case PlSqlParser.RDBA:
+                case PlSqlParser.READ:
+                case PlSqlParser.READS:
+                case PlSqlParser.REALM:
+                case PlSqlParser.REAL:
+                case PlSqlParser.REBALANCE:
+                case PlSqlParser.REBUILD:
+                case PlSqlParser.RECORD:
+                case PlSqlParser.RECORDS:
+                case PlSqlParser.RECORDS_PER_BLOCK:
+                case PlSqlParser.RECOVERABLE:
+                case PlSqlParser.RECOVER:
+                case PlSqlParser.RECOVERY:
+                case PlSqlParser.RECYCLEBIN:
+                case PlSqlParser.RECYCLE:
+                case PlSqlParser.REDACTION:
+                case PlSqlParser.REDEFINE:
+                case PlSqlParser.REDO:
+                case PlSqlParser.REDUCED:
+                case PlSqlParser.REDUNDANCY:
+                case PlSqlParser.REF_CASCADE_CURSOR:
+                case PlSqlParser.REFERENCED:
+                case PlSqlParser.REFERENCE:
+                case PlSqlParser.REFERENCES:
+                case PlSqlParser.REFERENCING:
+                case PlSqlParser.REF:
+                case PlSqlParser.REFRESH:
+                case PlSqlParser.REFTOHEX:
+                case PlSqlParser.REGEXP_COUNT:
+                case PlSqlParser.REGEXP_INSTR:
+                case PlSqlParser.REGEXP_LIKE:
+                case PlSqlParser.REGEXP_REPLACE:
+                case PlSqlParser.REGEXP_SUBSTR:
+                case PlSqlParser.REGISTER:
+                case PlSqlParser.REGR_AVGX:
+                case PlSqlParser.REGR_AVGY:
+                case PlSqlParser.REGR_COUNT:
+                case PlSqlParser.REGR_INTERCEPT:
+                case PlSqlParser.REGR_R2:
+                case PlSqlParser.REGR_SLOPE:
+                case PlSqlParser.REGR_SXX:
+                case PlSqlParser.REGR_SXY:
+                case PlSqlParser.REGR_SYY:
+                case PlSqlParser.REGULAR:
+                case PlSqlParser.REJECT:
+                case PlSqlParser.REKEY:
+                case PlSqlParser.RELATIONAL:
+                case PlSqlParser.RELOCATE:
+                case PlSqlParser.RELY:
+                case PlSqlParser.REMAINDER:
+                case PlSqlParser.REMOTE:
+                case PlSqlParser.REMOTE_MAPPED:
+                case PlSqlParser.REMOVE:
+                case PlSqlParser.RENAME:
+                case PlSqlParser.REPAIR:
+                case PlSqlParser.REPEAT:
+                case PlSqlParser.REPLACE:
+                case PlSqlParser.REPLICATION:
+                case PlSqlParser.REQUIRED:
+                case PlSqlParser.RESETLOGS:
+                case PlSqlParser.RESET:
+                case PlSqlParser.RESIZE:
+                case PlSqlParser.RESOLVE:
+                case PlSqlParser.RESOLVER:
+                case PlSqlParser.RESPECT:
+                case PlSqlParser.RESTART:
+                case PlSqlParser.RESTORE_AS_INTERVALS:
+                case PlSqlParser.RESTORE:
+                case PlSqlParser.RESTRICT_ALL_REF_CONS:
+                case PlSqlParser.RESTRICTED:
+                case PlSqlParser.RESTRICT_REFERENCES:
+                case PlSqlParser.RESTRICT:
+                case PlSqlParser.RESULT_CACHE:
+                case PlSqlParser.RESULT:
+                case PlSqlParser.RESUMABLE:
+                case PlSqlParser.RESUME:
+                case PlSqlParser.RETENTION:
+                case PlSqlParser.RETRY_ON_ROW_CHANGE:
+                case PlSqlParser.RETURNING:
+                case PlSqlParser.RETURN:
+                case PlSqlParser.REUSE:
+                case PlSqlParser.REVERSE:
+                case PlSqlParser.REWRITE_OR_ERROR:
+                case PlSqlParser.REWRITE:
+                case PlSqlParser.RIGHT:
+                case PlSqlParser.ROLE:
+                case PlSqlParser.ROLESET:
+                case PlSqlParser.ROLES:
+                case PlSqlParser.ROLLBACK:
+                case PlSqlParser.ROLLING:
+                case PlSqlParser.ROLLUP:
+                case PlSqlParser.ROWDEPENDENCIES:
+                case PlSqlParser.ROWID_MAPPING_TABLE:
+                case PlSqlParser.ROWID:
+                case PlSqlParser.ROWIDTOCHAR:
+                case PlSqlParser.ROWIDTONCHAR:
+                case PlSqlParser.ROW_LENGTH:
+                case PlSqlParser.ROWNUM:
+                case PlSqlParser.ROW:
+                case PlSqlParser.ROWS:
+                case PlSqlParser.RPAD:
+                case PlSqlParser.RTRIM:
+                case PlSqlParser.RULE:
+                case PlSqlParser.RULES:
+                case PlSqlParser.RUNNING:
+                case PlSqlParser.SALT:
+                case PlSqlParser.SAMPLE:
+                case PlSqlParser.SAVE_AS_INTERVALS:
+                case PlSqlParser.SAVEPOINT:
+                case PlSqlParser.SAVE:
+                case PlSqlParser.SB4:
+                case PlSqlParser.SCALE_ROWS:
+                case PlSqlParser.SCALE:
+                case PlSqlParser.SCAN_INSTANCES:
+                case PlSqlParser.SCAN:
+                case PlSqlParser.SCHEDULER:
+                case PlSqlParser.SCHEMACHECK:
+                case PlSqlParser.SCHEMA:
+                case PlSqlParser.SCN_ASCENDING:
+                case PlSqlParser.SCN:
+                case PlSqlParser.SCOPE:
+                case PlSqlParser.SCRUB:
+                case PlSqlParser.SD_ALL:
+                case PlSqlParser.SD_INHIBIT:
+                case PlSqlParser.SDO_GEOM_MBR:
+                case PlSqlParser.SDO_GEOMETRY:
+                case PlSqlParser.SD_SHOW:
+                case PlSqlParser.SEARCH:
+                case PlSqlParser.SECOND:
+                case PlSqlParser.SECONDS:
+                case PlSqlParser.SECRET:
+                case PlSqlParser.SECUREFILE_DBA:
+                case PlSqlParser.SECUREFILE:
+                case PlSqlParser.SECURITY:
+                case PlSqlParser.SEED:
+                case PlSqlParser.SEG_BLOCK:
+                case PlSqlParser.SEG_FILE:
+                case PlSqlParser.SEGMENT:
+                case PlSqlParser.SELECTIVITY:
+                case PlSqlParser.SELF:
+                case PlSqlParser.SEMIJOIN_DRIVER:
+                case PlSqlParser.SEMIJOIN:
+                case PlSqlParser.SEMI_TO_INNER:
+                case PlSqlParser.SEQUENCED:
+                case PlSqlParser.SEQUENCE:
+                case PlSqlParser.SEQUENTIAL:
+                case PlSqlParser.SEQ:
+                case PlSqlParser.SERIALIZABLE:
+                case PlSqlParser.SERIALLY_REUSABLE:
+                case PlSqlParser.SERIAL:
+                case PlSqlParser.SERVERERROR:
+                case PlSqlParser.SERVICE_NAME_CONVERT:
+                case PlSqlParser.SERVICE:
+                case PlSqlParser.SERVICES:
+                case PlSqlParser.SESSION_CACHED_CURSORS:
+                case PlSqlParser.SESSION:
+                case PlSqlParser.SESSIONS_PER_USER:
+                case PlSqlParser.SESSIONTIMEZONE:
+                case PlSqlParser.SESSIONTZNAME:
+                case PlSqlParser.SET:
+                case PlSqlParser.SETS:
+                case PlSqlParser.SETTINGS:
+                case PlSqlParser.SET_TO_JOIN:
+                case PlSqlParser.SEVERE:
+                case PlSqlParser.SHARDSPACE:
+                case PlSqlParser.SHARED_POOL:
+                case PlSqlParser.SHARED:
+                case PlSqlParser.SHARING:
+                case PlSqlParser.SHELFLIFE:
+                case PlSqlParser.SHOW:
+                case PlSqlParser.SHRINK:
+                case PlSqlParser.SHUTDOWN:
+                case PlSqlParser.SIBLINGS:
+                case PlSqlParser.SID:
+                case PlSqlParser.SITE:
+                case PlSqlParser.SIGNAL_COMPONENT:
+                case PlSqlParser.SIGNAL_FUNCTION:
+                case PlSqlParser.SIGN:
+                case PlSqlParser.SIGNTYPE:
+                case PlSqlParser.SIMPLE_INTEGER:
+                case PlSqlParser.SIMPLE:
+                case PlSqlParser.SINGLE:
+                case PlSqlParser.SINGLETASK:
+                case PlSqlParser.SINH:
+                case PlSqlParser.SIN:
+                case PlSqlParser.SKIP_EXT_OPTIMIZER:
+                case PlSqlParser.SKIP_:
+                case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+                case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+                case PlSqlParser.SMALLFILE:
+                case PlSqlParser.SMALLINT:
+                case PlSqlParser.SNAPSHOT:
+                case PlSqlParser.SOME:
+                case PlSqlParser.SORT:
+                case PlSqlParser.SOUNDEX:
+                case PlSqlParser.SOURCE_FILE_DIRECTORY:
+                case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+                case PlSqlParser.SOURCE:
+                case PlSqlParser.SPACE_KEYWORD:
+                case PlSqlParser.SPECIFICATION:
+                case PlSqlParser.SPFILE:
+                case PlSqlParser.SPLIT:
+                case PlSqlParser.SPREADSHEET:
+                case PlSqlParser.SQLDATA:
+                case PlSqlParser.SQLERROR:
+                case PlSqlParser.SQLLDR:
+                case PlSqlParser.SQL:
+                case PlSqlParser.FILE_EXT:
+                case PlSqlParser.SQL_MACRO:
+                case PlSqlParser.SQL_TRACE:
+                case PlSqlParser.SQL_TRANSLATION_PROFILE:
+                case PlSqlParser.SQRT:
+                case PlSqlParser.STALE:
+                case PlSqlParser.STANDALONE:
+                case PlSqlParser.STANDARD:
+                case PlSqlParser.STANDARD_HASH:
+                case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+                case PlSqlParser.STANDBYS:
+                case PlSqlParser.STANDBY:
+                case PlSqlParser.STAR:
+                case PlSqlParser.STAR_TRANSFORMATION:
+                case PlSqlParser.STARTUP:
+                case PlSqlParser.STATEMENT_ID:
+                case PlSqlParser.STATEMENT_QUEUING:
+                case PlSqlParser.STATEMENTS:
+                case PlSqlParser.STATEMENT:
+                case PlSqlParser.STATE:
+                case PlSqlParser.STATIC:
+                case PlSqlParser.STATISTICS:
+                case PlSqlParser.STATS_BINOMIAL_TEST:
+                case PlSqlParser.STATS_CROSSTAB:
+                case PlSqlParser.STATS_F_TEST:
+                case PlSqlParser.STATS_KS_TEST:
+                case PlSqlParser.STATS_MODE:
+                case PlSqlParser.STATS_MW_TEST:
+                case PlSqlParser.STATS_ONE_WAY_ANOVA:
+                case PlSqlParser.STATS_T_TEST_INDEP:
+                case PlSqlParser.STATS_T_TEST_INDEPU:
+                case PlSqlParser.STATS_T_TEST_ONE:
+                case PlSqlParser.STATS_T_TEST_PAIRED:
+                case PlSqlParser.STATS_WSR_TEST:
+                case PlSqlParser.STDDEV_POP:
+                case PlSqlParser.STDDEV_SAMP:
+                case PlSqlParser.STOP:
+                case PlSqlParser.STORAGE:
+                case PlSqlParser.STORE:
+                case PlSqlParser.STREAMS:
+                case PlSqlParser.STREAM:
+                case PlSqlParser.STRICT:
+                case PlSqlParser.STRING:
+                case PlSqlParser.STRIPE_COLUMNS:
+                case PlSqlParser.STRIPE_WIDTH:
+                case PlSqlParser.STRIP:
+                case PlSqlParser.STRUCTURE:
+                case PlSqlParser.SUBMULTISET:
+                case PlSqlParser.SUBPARTITION_REL:
+                case PlSqlParser.SUBPARTITIONS:
+                case PlSqlParser.SUBPARTITION:
+                case PlSqlParser.SUBQUERIES:
+                case PlSqlParser.SUBQUERY_PRUNING:
+                case PlSqlParser.SUBSCRIBE:
+                case PlSqlParser.SUBSET:
+                case PlSqlParser.SUBSTITUTABLE:
+                case PlSqlParser.SUBSTR2:
+                case PlSqlParser.SUBSTR4:
+                case PlSqlParser.SUBSTRB:
+                case PlSqlParser.SUBSTRC:
+                case PlSqlParser.SUBTYPE:
+                case PlSqlParser.SUCCESSFUL:
+                case PlSqlParser.SUCCESS:
+                case PlSqlParser.SUMMARY:
+                case PlSqlParser.SUPPLEMENTAL:
+                case PlSqlParser.SUSPEND:
+                case PlSqlParser.SWAP_JOIN_INPUTS:
+                case PlSqlParser.SWITCHOVER:
+                case PlSqlParser.SWITCH:
+                case PlSqlParser.SYNCHRONOUS:
+                case PlSqlParser.SYNC:
+                case PlSqlParser.SYS:
+                case PlSqlParser.SYSASM:
+                case PlSqlParser.SYS_AUDIT:
+                case PlSqlParser.SYSAUX:
+                case PlSqlParser.SYSBACKUP:
+                case PlSqlParser.SYS_CHECKACL:
+                case PlSqlParser.SYS_CHECK_PRIVILEGE:
+                case PlSqlParser.SYS_CONNECT_BY_PATH:
+                case PlSqlParser.SYS_CONTEXT:
+                case PlSqlParser.SYSDATE:
+                case PlSqlParser.SYSDBA:
+                case PlSqlParser.SYS_DBURIGEN:
+                case PlSqlParser.SYSDG:
+                case PlSqlParser.SYS_DL_CURSOR:
+                case PlSqlParser.SYS_DM_RXFORM_CHR:
+                case PlSqlParser.SYS_DM_RXFORM_NUM:
+                case PlSqlParser.SYS_DOM_COMPARE:
+                case PlSqlParser.SYS_DST_PRIM2SEC:
+                case PlSqlParser.SYS_DST_SEC2PRIM:
+                case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+                case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+                case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+                case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+                case PlSqlParser.SYS_EXTPDTXT:
+                case PlSqlParser.SYS_EXTRACT_UTC:
+                case PlSqlParser.SYS_FBT_INSDEL:
+                case PlSqlParser.SYS_FILTER_ACLS:
+                case PlSqlParser.SYS_FNMATCHES:
+                case PlSqlParser.SYS_FNREPLACE:
+                case PlSqlParser.SYS_GET_ACLIDS:
+                case PlSqlParser.SYS_GET_COL_ACLIDS:
+                case PlSqlParser.SYS_GET_PRIVILEGES:
+                case PlSqlParser.SYS_GETTOKENID:
+                case PlSqlParser.SYS_GETXTIVAL:
+                case PlSqlParser.SYS_GUID:
+                case PlSqlParser.SYSGUID:
+                case PlSqlParser.SYSKM:
+                case PlSqlParser.SYS_MAKE_XMLNODEID:
+                case PlSqlParser.SYS_MAKEXML:
+                case PlSqlParser.SYS_MKXMLATTR:
+                case PlSqlParser.SYS_MKXTI:
+                case PlSqlParser.SYSOBJ:
+                case PlSqlParser.SYS_OP_ADT2BIN:
+                case PlSqlParser.SYS_OP_ADTCONS:
+                case PlSqlParser.SYS_OP_ALSCRVAL:
+                case PlSqlParser.SYS_OP_ATG:
+                case PlSqlParser.SYS_OP_BIN2ADT:
+                case PlSqlParser.SYS_OP_BITVEC:
+                case PlSqlParser.SYS_OP_BL2R:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+                case PlSqlParser.SYS_OP_BLOOM_FILTER:
+                case PlSqlParser.SYS_OP_C2C:
+                case PlSqlParser.SYS_OP_CAST:
+                case PlSqlParser.SYS_OP_CEG:
+                case PlSqlParser.SYS_OP_CL2C:
+                case PlSqlParser.SYS_OP_COMBINED_HASH:
+                case PlSqlParser.SYS_OP_COMP:
+                case PlSqlParser.SYS_OP_CONVERT:
+                case PlSqlParser.SYS_OP_COUNTCHG:
+                case PlSqlParser.SYS_OP_CSCONV:
+                case PlSqlParser.SYS_OP_CSCONVTEST:
+                case PlSqlParser.SYS_OP_CSR:
+                case PlSqlParser.SYS_OP_CSX_PATCH:
+                case PlSqlParser.SYS_OP_CYCLED_SEQ:
+                case PlSqlParser.SYS_OP_DECOMP:
+                case PlSqlParser.SYS_OP_DESCEND:
+                case PlSqlParser.SYS_OP_DISTINCT:
+                case PlSqlParser.SYS_OP_DRA:
+                case PlSqlParser.SYS_OP_DUMP:
+                case PlSqlParser.SYS_OP_DV_CHECK:
+                case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+                case PlSqlParser.SYSOPER:
+                case PlSqlParser.SYS_OP_EXTRACT:
+                case PlSqlParser.SYS_OP_GROUPING:
+                case PlSqlParser.SYS_OP_GUID:
+                case PlSqlParser.SYS_OP_HASH:
+                case PlSqlParser.SYS_OP_IIX:
+                case PlSqlParser.SYS_OP_ITR:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+                case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+                case PlSqlParser.SYS_OP_LBID:
+                case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2ID:
+                case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+                case PlSqlParser.SYS_OP_LOBLOC2TYP:
+                case PlSqlParser.SYS_OP_LSVI:
+                case PlSqlParser.SYS_OP_LVL:
+                case PlSqlParser.SYS_OP_MAKEOID:
+                case PlSqlParser.SYS_OP_MAP_NONNULL:
+                case PlSqlParser.SYS_OP_MSR:
+                case PlSqlParser.SYS_OP_NICOMBINE:
+                case PlSqlParser.SYS_OP_NIEXTRACT:
+                case PlSqlParser.SYS_OP_NII:
+                case PlSqlParser.SYS_OP_NIX:
+                case PlSqlParser.SYS_OP_NOEXPAND:
+                case PlSqlParser.SYS_OP_NTCIMG:
+                case PlSqlParser.SYS_OP_NUMTORAW:
+                case PlSqlParser.SYS_OP_OIDVALUE:
+                case PlSqlParser.SYS_OP_OPNSIZE:
+                case PlSqlParser.SYS_OP_PAR_1:
+                case PlSqlParser.SYS_OP_PARGID_1:
+                case PlSqlParser.SYS_OP_PARGID:
+                case PlSqlParser.SYS_OP_PAR:
+                case PlSqlParser.SYS_OP_PART_ID:
+                case PlSqlParser.SYS_OP_PIVOT:
+                case PlSqlParser.SYS_OP_R2O:
+                case PlSqlParser.SYS_OP_RAWTONUM:
+                case PlSqlParser.SYS_OP_RDTM:
+                case PlSqlParser.SYS_OP_REF:
+                case PlSqlParser.SYS_OP_RMTD:
+                case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+                case PlSqlParser.SYS_OP_RPB:
+                case PlSqlParser.SYS_OPTLOBPRBSC:
+                case PlSqlParser.SYS_OP_TOSETID:
+                case PlSqlParser.SYS_OP_TPR:
+                case PlSqlParser.SYS_OP_TRTB:
+                case PlSqlParser.SYS_OPTXICMP:
+                case PlSqlParser.SYS_OPTXQCASTASNQ:
+                case PlSqlParser.SYS_OP_UNDESCEND:
+                case PlSqlParser.SYS_OP_VECAND:
+                case PlSqlParser.SYS_OP_VECBIT:
+                case PlSqlParser.SYS_OP_VECOR:
+                case PlSqlParser.SYS_OP_VECXOR:
+                case PlSqlParser.SYS_OP_VERSION:
+                case PlSqlParser.SYS_OP_VREF:
+                case PlSqlParser.SYS_OP_VVD:
+                case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+                case PlSqlParser.SYS_OP_XPTHATG:
+                case PlSqlParser.SYS_OP_XPTHIDX:
+                case PlSqlParser.SYS_OP_XPTHOP:
+                case PlSqlParser.SYS_OP_XTXT2SQLT:
+                case PlSqlParser.SYS_OP_ZONE_ID:
+                case PlSqlParser.SYS_ORDERKEY_DEPTH:
+                case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+                case PlSqlParser.SYS_ORDERKEY_PARENT:
+                case PlSqlParser.SYS_PARALLEL_TXN:
+                case PlSqlParser.SYS_PATHID_IS_ATTR:
+                case PlSqlParser.SYS_PATHID_IS_NMSPC:
+                case PlSqlParser.SYS_PATHID_LASTNAME:
+                case PlSqlParser.SYS_PATHID_LASTNMSPC:
+                case PlSqlParser.SYS_PATH_REVERSE:
+                case PlSqlParser.SYS_PXQEXTRACT:
+                case PlSqlParser.SYS_RAW_TO_XSID:
+                case PlSqlParser.SYS_RID_ORDER:
+                case PlSqlParser.SYS_ROW_DELTA:
+                case PlSqlParser.SYS_SC_2_XMLT:
+                case PlSqlParser.SYS_SYNRCIREDO:
+                case PlSqlParser.SYSTEM_DEFINED:
+                case PlSqlParser.SYSTEM:
+                case PlSqlParser.SYSTIMESTAMP:
+                case PlSqlParser.SYS_TYPEID:
+                case PlSqlParser.SYS_UMAKEXML:
+                case PlSqlParser.SYS_XMLANALYZE:
+                case PlSqlParser.SYS_XMLCONTAINS:
+                case PlSqlParser.SYS_XMLCONV:
+                case PlSqlParser.SYS_XMLEXNSURI:
+                case PlSqlParser.SYS_XMLGEN:
+                case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+                case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+                case PlSqlParser.SYS_XMLINSTR:
+                case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETCID:
+                case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+                case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+                case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+                case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+                case PlSqlParser.SYS_XMLNODEID_GETRID:
+                case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+                case PlSqlParser.SYS_XMLNODEID_GETTID:
+                case PlSqlParser.SYS_XMLNODEID:
+                case PlSqlParser.SYS_XMLT_2_SC:
+                case PlSqlParser.SYS_XMLTRANSLATE:
+                case PlSqlParser.SYS_XMLTYPE2SQL:
+                case PlSqlParser.SYS_XQ_ASQLCNV:
+                case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+                case PlSqlParser.SYS_XQBASEURI:
+                case PlSqlParser.SYS_XQCASTABLEERRH:
+                case PlSqlParser.SYS_XQCODEP2STR:
+                case PlSqlParser.SYS_XQCODEPEQ:
+                case PlSqlParser.SYS_XQCON2SEQ:
+                case PlSqlParser.SYS_XQCONCAT:
+                case PlSqlParser.SYS_XQDELETE:
+                case PlSqlParser.SYS_XQDFLTCOLATION:
+                case PlSqlParser.SYS_XQDOC:
+                case PlSqlParser.SYS_XQDOCURI:
+                case PlSqlParser.SYS_XQDURDIV:
+                case PlSqlParser.SYS_XQED4URI:
+                case PlSqlParser.SYS_XQENDSWITH:
+                case PlSqlParser.SYS_XQERRH:
+                case PlSqlParser.SYS_XQERR:
+                case PlSqlParser.SYS_XQESHTMLURI:
+                case PlSqlParser.SYS_XQEXLOBVAL:
+                case PlSqlParser.SYS_XQEXSTWRP:
+                case PlSqlParser.SYS_XQEXTRACT:
+                case PlSqlParser.SYS_XQEXTRREF:
+                case PlSqlParser.SYS_XQEXVAL:
+                case PlSqlParser.SYS_XQFB2STR:
+                case PlSqlParser.SYS_XQFNBOOL:
+                case PlSqlParser.SYS_XQFNCMP:
+                case PlSqlParser.SYS_XQFNDATIM:
+                case PlSqlParser.SYS_XQFNLNAME:
+                case PlSqlParser.SYS_XQFNNM:
+                case PlSqlParser.SYS_XQFNNSURI:
+                case PlSqlParser.SYS_XQFNPREDTRUTH:
+                case PlSqlParser.SYS_XQFNQNM:
+                case PlSqlParser.SYS_XQFNROOT:
+                case PlSqlParser.SYS_XQFORMATNUM:
+                case PlSqlParser.SYS_XQFTCONTAIN:
+                case PlSqlParser.SYS_XQFUNCR:
+                case PlSqlParser.SYS_XQGETCONTENT:
+                case PlSqlParser.SYS_XQINDXOF:
+                case PlSqlParser.SYS_XQINSERT:
+                case PlSqlParser.SYS_XQINSPFX:
+                case PlSqlParser.SYS_XQIRI2URI:
+                case PlSqlParser.SYS_XQLANG:
+                case PlSqlParser.SYS_XQLLNMFRMQNM:
+                case PlSqlParser.SYS_XQMKNODEREF:
+                case PlSqlParser.SYS_XQNILLED:
+                case PlSqlParser.SYS_XQNODENAME:
+                case PlSqlParser.SYS_XQNORMSPACE:
+                case PlSqlParser.SYS_XQNORMUCODE:
+                case PlSqlParser.SYS_XQ_NRNG:
+                case PlSqlParser.SYS_XQNSP4PFX:
+                case PlSqlParser.SYS_XQNSPFRMQNM:
+                case PlSqlParser.SYS_XQPFXFRMQNM:
+                case PlSqlParser.SYS_XQ_PKSQL2XML:
+                case PlSqlParser.SYS_XQPOLYABS:
+                case PlSqlParser.SYS_XQPOLYADD:
+                case PlSqlParser.SYS_XQPOLYCEL:
+                case PlSqlParser.SYS_XQPOLYCSTBL:
+                case PlSqlParser.SYS_XQPOLYCST:
+                case PlSqlParser.SYS_XQPOLYDIV:
+                case PlSqlParser.SYS_XQPOLYFLR:
+                case PlSqlParser.SYS_XQPOLYMOD:
+                case PlSqlParser.SYS_XQPOLYMUL:
+                case PlSqlParser.SYS_XQPOLYRND:
+                case PlSqlParser.SYS_XQPOLYSQRT:
+                case PlSqlParser.SYS_XQPOLYSUB:
+                case PlSqlParser.SYS_XQPOLYUMUS:
+                case PlSqlParser.SYS_XQPOLYUPLS:
+                case PlSqlParser.SYS_XQPOLYVEQ:
+                case PlSqlParser.SYS_XQPOLYVGE:
+                case PlSqlParser.SYS_XQPOLYVGT:
+                case PlSqlParser.SYS_XQPOLYVLE:
+                case PlSqlParser.SYS_XQPOLYVLT:
+                case PlSqlParser.SYS_XQPOLYVNE:
+                case PlSqlParser.SYS_XQREF2VAL:
+                case PlSqlParser.SYS_XQRENAME:
+                case PlSqlParser.SYS_XQREPLACE:
+                case PlSqlParser.SYS_XQRESVURI:
+                case PlSqlParser.SYS_XQRNDHALF2EVN:
+                case PlSqlParser.SYS_XQRSLVQNM:
+                case PlSqlParser.SYS_XQRYENVPGET:
+                case PlSqlParser.SYS_XQRYVARGET:
+                case PlSqlParser.SYS_XQRYWRP:
+                case PlSqlParser.SYS_XQSEQ2CON4XC:
+                case PlSqlParser.SYS_XQSEQ2CON:
+                case PlSqlParser.SYS_XQSEQDEEPEQ:
+                case PlSqlParser.SYS_XQSEQINSB:
+                case PlSqlParser.SYS_XQSEQRM:
+                case PlSqlParser.SYS_XQSEQRVS:
+                case PlSqlParser.SYS_XQSEQSUB:
+                case PlSqlParser.SYS_XQSEQTYPMATCH:
+                case PlSqlParser.SYS_XQSTARTSWITH:
+                case PlSqlParser.SYS_XQSTATBURI:
+                case PlSqlParser.SYS_XQSTR2CODEP:
+                case PlSqlParser.SYS_XQSTRJOIN:
+                case PlSqlParser.SYS_XQSUBSTRAFT:
+                case PlSqlParser.SYS_XQSUBSTRBEF:
+                case PlSqlParser.SYS_XQTOKENIZE:
+                case PlSqlParser.SYS_XQTREATAS:
+                case PlSqlParser.SYS_XQ_UPKXML2SQL:
+                case PlSqlParser.SYS_XQXFORM:
+                case PlSqlParser.SYS_XSID_TO_RAW:
+                case PlSqlParser.SYS_ZMAP_FILTER:
+                case PlSqlParser.SYS_ZMAP_REFRESH:
+                case PlSqlParser.T_LETTER:
+                case PlSqlParser.TABLE_LOOKUP_BY_NL:
+                case PlSqlParser.TABLESPACE_NO:
+                case PlSqlParser.TABLESPACE:
+                case PlSqlParser.TABLES:
+                case PlSqlParser.TABLE_STATS:
+                case PlSqlParser.TABLE:
+                case PlSqlParser.TABNO:
+                case PlSqlParser.TAG:
+                case PlSqlParser.TANH:
+                case PlSqlParser.TAN:
+                case PlSqlParser.TBLORIDXPARTNUM:
+                case PlSqlParser.TEMPFILE:
+                case PlSqlParser.TEMPLATE:
+                case PlSqlParser.TEMPLATE_TABLE:
+                case PlSqlParser.TEMPORARY:
+                case PlSqlParser.TEMP_TABLE:
+                case PlSqlParser.TEST:
+                case PlSqlParser.TEXT:
+                case PlSqlParser.THAN:
+                case PlSqlParser.THEN:
+                case PlSqlParser.THE:
+                case PlSqlParser.THREAD:
+                case PlSqlParser.THROUGH:
+                case PlSqlParser.TIER:
+                case PlSqlParser.TIES:
+                case PlSqlParser.TIMEOUT:
+                case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP:
+                case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+                case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+                case PlSqlParser.TIMES:
+                case PlSqlParser.TIME:
+                case PlSqlParser.TIMEZONE:
+                case PlSqlParser.TIMEZONE_ABBR:
+                case PlSqlParser.TIMEZONE_HOUR:
+                case PlSqlParser.TIMEZONE_MINUTE:
+                case PlSqlParser.TIMEZONE_OFFSET:
+                case PlSqlParser.TIMEZONE_REGION:
+                case PlSqlParser.TIME_ZONE:
+                case PlSqlParser.TIMING:
+                case PlSqlParser.TIV_GB:
+                case PlSqlParser.TIV_SSF:
+                case PlSqlParser.TO_ACLID:
+                case PlSqlParser.TO_BINARY_DOUBLE:
+                case PlSqlParser.TO_BINARY_FLOAT:
+                case PlSqlParser.TO_BLOB:
+                case PlSqlParser.TO_CLOB:
+                case PlSqlParser.TO_DSINTERVAL:
+                case PlSqlParser.TO_LOB:
+                case PlSqlParser.TO_MULTI_BYTE:
+                case PlSqlParser.TO_NCHAR:
+                case PlSqlParser.TO_NCLOB:
+                case PlSqlParser.TO_NUMBER:
+                case PlSqlParser.TOPLEVEL:
+                case PlSqlParser.TO_SINGLE_BYTE:
+                case PlSqlParser.TO_TIMESTAMP:
+                case PlSqlParser.TO_TIMESTAMP_TZ:
+                case PlSqlParser.TO_TIME:
+                case PlSqlParser.TO_TIME_TZ:
+                case PlSqlParser.TO_YMINTERVAL:
+                case PlSqlParser.TRACE:
+                case PlSqlParser.TRACING:
+                case PlSqlParser.TRACKING:
+                case PlSqlParser.TRAILING:
+                case PlSqlParser.TRANSACTION:
+                case PlSqlParser.TRANSFORM:
+                case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+                case PlSqlParser.TRANSITIONAL:
+                case PlSqlParser.TRANSITION:
+                case PlSqlParser.TRANSLATE:
+                case PlSqlParser.TRANSLATION:
+                case PlSqlParser.TREAT:
+                case PlSqlParser.TRIGGERS:
+                case PlSqlParser.TRIGGER:
+                case PlSqlParser.TRUE:
+                case PlSqlParser.TRUNCATE:
+                case PlSqlParser.TRUNC:
+                case PlSqlParser.TRUSTED:
+                case PlSqlParser.TRUST:
+                case PlSqlParser.TUNING:
+                case PlSqlParser.TX:
+                case PlSqlParser.TYPES:
+                case PlSqlParser.TYPE:
+                case PlSqlParser.TZ_OFFSET:
+                case PlSqlParser.UB2:
+                case PlSqlParser.UBA:
+                case PlSqlParser.UCS2:
+                case PlSqlParser.UDF:
+                case PlSqlParser.UID:
+                case PlSqlParser.UNARCHIVED:
+                case PlSqlParser.UNBOUNDED:
+                case PlSqlParser.UNBOUND:
+                case PlSqlParser.UNCONDITIONAL:
+                case PlSqlParser.UNDER:
+                case PlSqlParser.UNDO:
+                case PlSqlParser.UNDROP:
+                case PlSqlParser.UNIFORM:
+                case PlSqlParser.UNISTR:
+                case PlSqlParser.UNLIMITED:
+                case PlSqlParser.UNLOAD:
+                case PlSqlParser.UNLOCK:
+                case PlSqlParser.UNMATCHED:
+                case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+                case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+                case PlSqlParser.UNNEST_SEMIJ_VIEW:
+                case PlSqlParser.UNNEST:
+                case PlSqlParser.UNPACKED:
+                case PlSqlParser.UNPIVOT:
+                case PlSqlParser.UNPLUG:
+                case PlSqlParser.UNPROTECTED:
+                case PlSqlParser.UNQUIESCE:
+                case PlSqlParser.UNRECOVERABLE:
+                case PlSqlParser.UNRESTRICTED:
+                case PlSqlParser.UNSUBSCRIBE:
+                case PlSqlParser.UNTIL:
+                case PlSqlParser.UNUSABLE:
+                case PlSqlParser.UNUSED:
+                case PlSqlParser.UPDATABLE:
+                case PlSqlParser.UPDATED:
+                case PlSqlParser.UPDATEXML:
+                case PlSqlParser.UPD_INDEXES:
+                case PlSqlParser.UPD_JOININDEX:
+                case PlSqlParser.UPGRADE:
+                case PlSqlParser.UPPER:
+                case PlSqlParser.UPSERT:
+                case PlSqlParser.UROWID:
+                case PlSqlParser.USABLE:
+                case PlSqlParser.USAGE:
+                case PlSqlParser.USE_ANTI:
+                case PlSqlParser.USE_CONCAT:
+                case PlSqlParser.USE_CUBE:
+                case PlSqlParser.USE_HASH_AGGREGATION:
+                case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+                case PlSqlParser.USE_HASH:
+                case PlSqlParser.USE_HIDDEN_PARTITIONS:
+                case PlSqlParser.USE_INVISIBLE_INDEXES:
+                case PlSqlParser.USE_MERGE_CARTESIAN:
+                case PlSqlParser.USE_MERGE:
+                case PlSqlParser.USE_NL:
+                case PlSqlParser.USE_NL_WITH_INDEX:
+                case PlSqlParser.USE_PRIVATE_OUTLINES:
+                case PlSqlParser.USER_DATA:
+                case PlSqlParser.USER_DEFINED:
+                case PlSqlParser.USERENV:
+                case PlSqlParser.USERGROUP:
+                case PlSqlParser.USER_RECYCLEBIN:
+                case PlSqlParser.USERS:
+                case PlSqlParser.USER_TABLESPACES:
+                case PlSqlParser.USER:
+                case PlSqlParser.USE_SEMI:
+                case PlSqlParser.USE_STORED_OUTLINES:
+                case PlSqlParser.USE_TTT_FOR_GSETS:
+                case PlSqlParser.USE:
+                case PlSqlParser.USE_VECTOR_AGGREGATION:
+                case PlSqlParser.USE_WEAK_NAME_RESL:
+                case PlSqlParser.USING_NO_EXPAND:
+                case PlSqlParser.USING_NLS_COMP:
+                case PlSqlParser.USING:
+                case PlSqlParser.UTF16BE:
+                case PlSqlParser.UTF16LE:
+                case PlSqlParser.UTF32:
+                case PlSqlParser.UTF8:
+                case PlSqlParser.V1:
+                case PlSqlParser.V2:
+                case PlSqlParser.VALIDATE:
+                case PlSqlParser.VALIDATE_CONVERSION:
+                case PlSqlParser.VALIDATION:
+                case PlSqlParser.VALID_TIME_END:
+                case PlSqlParser.VALUE:
+                case PlSqlParser.VARCHAR2:
+                case PlSqlParser.VARCHAR:
+                case PlSqlParser.VARIABLE:
+                case PlSqlParser.VAR_POP:
+                case PlSqlParser.VARRAYS:
+                case PlSqlParser.VARRAY:
+                case PlSqlParser.VAR_SAMP:
+                case PlSqlParser.VARYING:
+                case PlSqlParser.VECTOR_READ_TRACE:
+                case PlSqlParser.VECTOR_READ:
+                case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+                case PlSqlParser.VECTOR_TRANSFORM_FACT:
+                case PlSqlParser.VECTOR_TRANSFORM:
+                case PlSqlParser.VERIFIER:
+                case PlSqlParser.VERIFY:
+                case PlSqlParser.VERSIONING:
+                case PlSqlParser.VERSIONS_ENDSCN:
+                case PlSqlParser.VERSIONS_ENDTIME:
+                case PlSqlParser.VERSIONS_OPERATION:
+                case PlSqlParser.VERSIONS_STARTSCN:
+                case PlSqlParser.VERSIONS_STARTTIME:
+                case PlSqlParser.VERSIONS:
+                case PlSqlParser.VERSIONS_XID:
+                case PlSqlParser.VERSION:
+                case PlSqlParser.VIOLATION:
+                case PlSqlParser.VIRTUAL:
+                case PlSqlParser.VISIBILITY:
+                case PlSqlParser.VISIBLE:
+                case PlSqlParser.VOLUME:
+                case PlSqlParser.VSIZE:
+                case PlSqlParser.WAIT:
+                case PlSqlParser.WALLET:
+                case PlSqlParser.WARNING:
+                case PlSqlParser.WEEKS:
+                case PlSqlParser.WEEK:
+                case PlSqlParser.WELLFORMED:
+                case PlSqlParser.WHENEVER:
+                case PlSqlParser.WHEN:
+                case PlSqlParser.WHILE:
+                case PlSqlParser.WHITESPACE:
+                case PlSqlParser.WIDTH_BUCKET:
+                case PlSqlParser.WITHIN:
+                case PlSqlParser.WITHOUT:
+                case PlSqlParser.WITH_PLSQL:
+                case PlSqlParser.WORK:
+                case PlSqlParser.WRAPPED:
+                case PlSqlParser.WRAPPER:
+                case PlSqlParser.WRITE:
+                case PlSqlParser.XDB_FASTPATH_INSERT:
+                case PlSqlParser.X_DYN_PRUNE:
+                case PlSqlParser.XID:
+                case PlSqlParser.XML2OBJECT:
+                case PlSqlParser.XMLAGG:
+                case PlSqlParser.XMLATTRIBUTES:
+                case PlSqlParser.XMLCAST:
+                case PlSqlParser.XMLCDATA:
+                case PlSqlParser.XMLCOLATTVAL:
+                case PlSqlParser.XMLCOMMENT:
+                case PlSqlParser.XMLCONCAT:
+                case PlSqlParser.XMLDIFF:
+                case PlSqlParser.XML_DML_RWT_STMT:
+                case PlSqlParser.XMLELEMENT:
+                case PlSqlParser.XMLEXISTS2:
+                case PlSqlParser.XMLEXISTS:
+                case PlSqlParser.XMLFOREST:
+                case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+                case PlSqlParser.XMLINDEX_REWRITE:
+                case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+                case PlSqlParser.XMLISNODE:
+                case PlSqlParser.XMLISVALID:
+                case PlSqlParser.XMLNAMESPACES:
+                case PlSqlParser.XMLPARSE:
+                case PlSqlParser.XMLPATCH:
+                case PlSqlParser.XMLPI:
+                case PlSqlParser.XMLQUERYVAL:
+                case PlSqlParser.XMLQUERY:
+                case PlSqlParser.XMLROOT:
+                case PlSqlParser.XMLSCHEMA:
+                case PlSqlParser.XMLSERIALIZE:
+                case PlSqlParser.XMLTABLE:
+                case PlSqlParser.XMLTRANSFORMBLOB:
+                case PlSqlParser.XMLTRANSFORM:
+                case PlSqlParser.XMLTYPE:
+                case PlSqlParser.XML:
+                case PlSqlParser.XPATHTABLE:
+                case PlSqlParser.XS_SYS_CONTEXT:
+                case PlSqlParser.XS:
+                case PlSqlParser.YEARS:
+                case PlSqlParser.YEAR:
+                case PlSqlParser.YES:
+                case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+                case PlSqlParser.ZONEMAP:
+                case PlSqlParser.ZONE:
+                case PlSqlParser.PREDICTION:
+                case PlSqlParser.PREDICTION_BOUNDS:
+                case PlSqlParser.PREDICTION_COST:
+                case PlSqlParser.PREDICTION_DETAILS:
+                case PlSqlParser.PREDICTION_PROBABILITY:
+                case PlSqlParser.PREDICTION_SET:
+                case PlSqlParser.BLOCKCHAIN:
+                case PlSqlParser.COLLATE:
+                case PlSqlParser.COLLATION:
+                case PlSqlParser.DEFINITION:
+                case PlSqlParser.DUPLICATED:
+                case PlSqlParser.EXTENDED:
+                case PlSqlParser.HASHING:
+                case PlSqlParser.IDLE:
+                case PlSqlParser.IMMUTABLE:
+                case PlSqlParser.ORACLE_DATAPUMP:
+                case PlSqlParser.ORACLE_HDFS:
+                case PlSqlParser.ORACLE_HIVE:
+                case PlSqlParser.ORACLE_LOADER:
+                case PlSqlParser.SHARDED:
+                case PlSqlParser.ISOLATE:
+                case PlSqlParser.ROOT:
+                case PlSqlParser.UNITE:
+                case PlSqlParser.ALGORITHM:
+                case PlSqlParser.CUME_DIST:
+                case PlSqlParser.DENSE_RANK:
+                case PlSqlParser.LISTAGG:
+                case PlSqlParser.PERCENT_RANK:
+                case PlSqlParser.PERCENTILE_CONT:
+                case PlSqlParser.PERCENTILE_DISC:
+                case PlSqlParser.RANK:
+                case PlSqlParser.AVG:
+                case PlSqlParser.CORR:
+                case PlSqlParser.COVAR_:
+                case PlSqlParser.LAG:
+                case PlSqlParser.LEAD:
+                case PlSqlParser.MAX:
+                case PlSqlParser.MEDIAN:
+                case PlSqlParser.MEMOPTIMIZE:
+                case PlSqlParser.MIN:
+                case PlSqlParser.NTILE:
+                case PlSqlParser.NVL:
+                case PlSqlParser.RATIO_TO_REPORT:
+                case PlSqlParser.REGR_:
+                case PlSqlParser.ROUND:
+                case PlSqlParser.ROW_NUMBER:
+                case PlSqlParser.SUBSTR:
+                case PlSqlParser.TO_CHAR:
+                case PlSqlParser.TRIM:
+                case PlSqlParser.SUM:
+                case PlSqlParser.STDDEV:
+                case PlSqlParser.VAR_:
+                case PlSqlParser.VARIANCE:
+                case PlSqlParser.LEAST:
+                case PlSqlParser.GREATEST:
+                case PlSqlParser.TO_DATE:
+                case PlSqlParser.CHARSETID:
+                case PlSqlParser.CHARSETFORM:
+                case PlSqlParser.DURATION:
+                case PlSqlParser.EXTEND:
+                case PlSqlParser.MAXLEN:
+                case PlSqlParser.PERSISTABLE:
+                case PlSqlParser.POLYMORPHIC:
+                case PlSqlParser.STRUCT:
+                case PlSqlParser.TDO:
+                case PlSqlParser.WM_CONCAT:
+                case PlSqlParser.PERIOD:
+                case PlSqlParser.DELIMITED_ID:
+                case PlSqlParser.INTRODUCER:
+                case PlSqlParser.REGULAR_ID:
+                    {
+                    this.state = 21406;
+                    this.general_element_part();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                this.state = 21409;
+                _la = this.tokenStream.LA(1);
+                if(!(_la === 365 || _la === 680 || _la === 959 || _la === 986 || _la === 1638 || _la === 2360)) {
+                this.errorHandler.recoverInline(this);
+                }
+                else {
+                    this.errorHandler.reportMatch(this);
+                    this.consume();
+                }
+                this.state = 21423;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 3031, this.context) ) {
+                case 1:
+                    {
+                    this.state = 21410;
+                    this.match(PlSqlParser.LEFT_PAREN);
+                    this.state = 21413;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.UNSIGNED_INTEGER:
+                        {
+                        this.state = 21411;
+                        this.match(PlSqlParser.UNSIGNED_INTEGER);
+                        }
+                        break;
+                    case PlSqlParser.BINDVAR:
+                    case PlSqlParser.COLON:
+                        {
+                        this.state = 21412;
+                        this.bind_variable();
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    this.state = 21420;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                    if (_la === 2455) {
+                        {
+                        this.state = 21415;
+                        this.match(PlSqlParser.COMMA);
+                        this.state = 21418;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                        case PlSqlParser.UNSIGNED_INTEGER:
+                            {
+                            this.state = 21416;
+                            this.match(PlSqlParser.UNSIGNED_INTEGER);
+                            }
+                            break;
+                        case PlSqlParser.BINDVAR:
+                        case PlSqlParser.COLON:
+                            {
+                            this.state = 21417;
+                            this.bind_variable();
+                            }
+                            break;
+                        default:
+                            throw new antlr.NoViableAltException(this);
+                        }
+                        }
+                    }
+
+                    this.state = 21422;
+                    this.match(PlSqlParser.RIGHT_PAREN);
+                    }
+                    break;
+                }
+                this.state = 21441;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 3035, this.context) ) {
+                case 1:
+                    {
+                    this.state = 21425;
+                    this.match(PlSqlParser.TO);
+                    this.state = 21439;
+                    this.errorHandler.sync(this);
+                    switch (this.tokenStream.LA(1)) {
+                    case PlSqlParser.MONTH:
+                        {
+                        this.state = 21426;
+                        this.match(PlSqlParser.MONTH);
+                        }
+                        break;
+                    case PlSqlParser.DAY:
+                        {
+                        this.state = 21427;
+                        this.match(PlSqlParser.DAY);
+                        }
+                        break;
+                    case PlSqlParser.HOUR:
+                        {
+                        this.state = 21428;
+                        this.match(PlSqlParser.HOUR);
+                        }
+                        break;
+                    case PlSqlParser.MINUTE:
+                        {
+                        this.state = 21429;
+                        this.match(PlSqlParser.MINUTE);
+                        }
+                        break;
+                    case PlSqlParser.SECOND:
+                        {
+                        this.state = 21430;
+                        this.match(PlSqlParser.SECOND);
+                        this.state = 21437;
+                        this.errorHandler.sync(this);
+                        switch (this.interpreter.adaptivePredict(this.tokenStream, 3033, this.context) ) {
+                        case 1:
+                            {
+                            this.state = 21431;
+                            this.match(PlSqlParser.LEFT_PAREN);
+                            this.state = 21434;
+                            this.errorHandler.sync(this);
+                            switch (this.tokenStream.LA(1)) {
+                            case PlSqlParser.UNSIGNED_INTEGER:
+                                {
+                                this.state = 21432;
+                                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                                }
+                                break;
+                            case PlSqlParser.BINDVAR:
+                            case PlSqlParser.COLON:
+                                {
+                                this.state = 21433;
+                                this.bind_variable();
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                            }
+                            this.state = 21436;
+                            this.match(PlSqlParser.RIGHT_PAREN);
+                            }
+                            break;
+                        }
+                        }
+                        break;
+                    default:
+                        throw new antlr.NoViableAltException(this);
+                    }
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.UNSIGNED_INTEGER:
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 21443;
+                this.numeric();
+                }
+                break;
+            case PlSqlParser.DATE:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 21444;
+                this.match(PlSqlParser.DATE);
+                this.state = 21445;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.NATIONAL_CHAR_STRING_LIT:
+            case PlSqlParser.CHAR_STRING:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 21446;
+                this.quoted_string();
+                }
+                break;
+            case PlSqlParser.NULL_:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 21447;
+                this.match(PlSqlParser.NULL_);
+                }
+                break;
+            case PlSqlParser.TRUE:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 21448;
+                this.match(PlSqlParser.TRUE);
+                }
+                break;
+            case PlSqlParser.FALSE:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 21449;
+                this.match(PlSqlParser.FALSE);
+                }
+                break;
+            case PlSqlParser.DBTIMEZONE:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 21450;
+                this.match(PlSqlParser.DBTIMEZONE);
+                }
+                break;
+            case PlSqlParser.SESSIONTIMEZONE:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 21451;
+                this.match(PlSqlParser.SESSIONTIMEZONE);
+                }
+                break;
+            case PlSqlParser.MINVALUE:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 21452;
+                this.match(PlSqlParser.MINVALUE);
+                }
+                break;
+            case PlSqlParser.MAXVALUE:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 21453;
+                this.match(PlSqlParser.MAXVALUE);
+                }
+                break;
+            case PlSqlParser.DEFAULT:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 21454;
+                this.match(PlSqlParser.DEFAULT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public numeric(): NumericContext {
+        let localContext = new NumericContext(this.context, this.state);
+        this.enterRule(localContext, 2422, PlSqlParser.RULE_numeric);
+        try {
+            this.state = 21462;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.UNSIGNED_INTEGER:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 21457;
+                this.match(PlSqlParser.UNSIGNED_INTEGER);
+                this.state = 21459;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 3037, this.context) ) {
+                case 1:
+                    {
+                    this.state = 21458;
+                    this.match(PlSqlParser.PERIOD);
+                    }
+                    break;
+                }
+                }
+                break;
+            case PlSqlParser.APPROXIMATE_NUM_LIT:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 21461;
+                this.match(PlSqlParser.APPROXIMATE_NUM_LIT);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public numeric_negative(): Numeric_negativeContext {
+        let localContext = new Numeric_negativeContext(this.context, this.state);
+        this.enterRule(localContext, 2424, PlSqlParser.RULE_numeric_negative);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21464;
+            this.match(PlSqlParser.MINUS_SIGN);
+            this.state = 21465;
+            this.numeric();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public quoted_string(): Quoted_stringContext {
+        let localContext = new Quoted_stringContext(this.context, this.state);
+        this.enterRule(localContext, 2426, PlSqlParser.RULE_quoted_string);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21467;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 2438 || _la === 2445)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public identifier(): IdentifierContext {
+        let localContext = new IdentifierContext(this.context, this.state);
+        this.enterRule(localContext, 2428, PlSqlParser.RULE_identifier);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21471;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 2477) {
+                {
+                this.state = 21469;
+                this.match(PlSqlParser.INTRODUCER);
+                this.state = 21470;
+                this.char_set_name();
+                }
+            }
+
+            this.state = 21473;
+            this.id_expression();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public id_expression(): Id_expressionContext {
+        let localContext = new Id_expressionContext(this.context, this.state);
+        this.enterRule(localContext, 2430, PlSqlParser.RULE_id_expression);
+        try {
+            this.state = 21477;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+            case PlSqlParser.ABORT:
+            case PlSqlParser.ABS:
+            case PlSqlParser.ABSENT:
+            case PlSqlParser.ACCESS:
+            case PlSqlParser.ACCESSED:
+            case PlSqlParser.ACCESSIBLE:
+            case PlSqlParser.ACCOUNT:
+            case PlSqlParser.ACL:
+            case PlSqlParser.ACOS:
+            case PlSqlParser.ACROSS:
+            case PlSqlParser.ACTION:
+            case PlSqlParser.ACTIONS:
+            case PlSqlParser.ACTIVATE:
+            case PlSqlParser.ACTIVE:
+            case PlSqlParser.ACTIVE_COMPONENT:
+            case PlSqlParser.ACTIVE_DATA:
+            case PlSqlParser.ACTIVE_FUNCTION:
+            case PlSqlParser.ACTIVE_TAG:
+            case PlSqlParser.ACTIVITY:
+            case PlSqlParser.ADAPTIVE_PLAN:
+            case PlSqlParser.ADD:
+            case PlSqlParser.ADD_COLUMN:
+            case PlSqlParser.ADD_GROUP:
+            case PlSqlParser.ADD_MONTHS:
+            case PlSqlParser.ADJ_DATE:
+            case PlSqlParser.ADMIN:
+            case PlSqlParser.ADMINISTER:
+            case PlSqlParser.ADMINISTRATOR:
+            case PlSqlParser.ADVANCED:
+            case PlSqlParser.ADVISE:
+            case PlSqlParser.ADVISOR:
+            case PlSqlParser.AFD_DISKSTRING:
+            case PlSqlParser.AFTER:
+            case PlSqlParser.AGENT:
+            case PlSqlParser.AGGREGATE:
+            case PlSqlParser.A_LETTER:
+            case PlSqlParser.ALIAS:
+            case PlSqlParser.ALLOCATE:
+            case PlSqlParser.ALLOW:
+            case PlSqlParser.ALL_ROWS:
+            case PlSqlParser.ALTERNATE:
+            case PlSqlParser.ALWAYS:
+            case PlSqlParser.ANALYTIC:
+            case PlSqlParser.ANALYZE:
+            case PlSqlParser.ANCESTOR:
+            case PlSqlParser.ANCILLARY:
+            case PlSqlParser.AND_EQUAL:
+            case PlSqlParser.ANOMALY:
+            case PlSqlParser.ANSI_REARCH:
+            case PlSqlParser.ANTIJOIN:
+            case PlSqlParser.ANYSCHEMA:
+            case PlSqlParser.APPEND:
+            case PlSqlParser.APPENDCHILDXML:
+            case PlSqlParser.APPEND_VALUES:
+            case PlSqlParser.APPLICATION:
+            case PlSqlParser.APPLY:
+            case PlSqlParser.APPROX_COUNT_DISTINCT:
+            case PlSqlParser.ARCHIVAL:
+            case PlSqlParser.ARCHIVE:
+            case PlSqlParser.ARCHIVED:
+            case PlSqlParser.ARCHIVELOG:
+            case PlSqlParser.ARRAY:
+            case PlSqlParser.ASCII:
+            case PlSqlParser.ASCIISTR:
+            case PlSqlParser.ASIN:
+            case PlSqlParser.ASIS:
+            case PlSqlParser.ASSEMBLY:
+            case PlSqlParser.ASSIGN:
+            case PlSqlParser.ASSOCIATE:
+            case PlSqlParser.ASYNC:
+            case PlSqlParser.ASYNCHRONOUS:
+            case PlSqlParser.ATAN2:
+            case PlSqlParser.ATAN:
+            case PlSqlParser.AT:
+            case PlSqlParser.ATTRIBUTE:
+            case PlSqlParser.ATTRIBUTES:
+            case PlSqlParser.AUDIT:
+            case PlSqlParser.AUTHENTICATED:
+            case PlSqlParser.AUTHENTICATION:
+            case PlSqlParser.AUTHID:
+            case PlSqlParser.AUTHORIZATION:
+            case PlSqlParser.AUTOALLOCATE:
+            case PlSqlParser.AUTO:
+            case PlSqlParser.AUTOEXTEND:
+            case PlSqlParser.AUTO_LOGIN:
+            case PlSqlParser.AUTOMATIC:
+            case PlSqlParser.AUTONOMOUS_TRANSACTION:
+            case PlSqlParser.AUTO_REOPTIMIZE:
+            case PlSqlParser.AVAILABILITY:
+            case PlSqlParser.AVRO:
+            case PlSqlParser.BACKGROUND:
+            case PlSqlParser.BACKINGFILE:
+            case PlSqlParser.BACKUP:
+            case PlSqlParser.BACKUPS:
+            case PlSqlParser.BASIC:
+            case PlSqlParser.BASICFILE:
+            case PlSqlParser.BATCH:
+            case PlSqlParser.BATCHSIZE:
+            case PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.BECOME:
+            case PlSqlParser.BEFORE:
+            case PlSqlParser.BEGIN:
+            case PlSqlParser.BEGINNING:
+            case PlSqlParser.BEGIN_OUTLINE_DATA:
+            case PlSqlParser.BEHALF:
+            case PlSqlParser.BEQUEATH:
+            case PlSqlParser.BFILE:
+            case PlSqlParser.BFILENAME:
+            case PlSqlParser.BIGFILE:
+            case PlSqlParser.BINARY:
+            case PlSqlParser.BINARY_DOUBLE:
+            case PlSqlParser.BINARY_DOUBLE_INFINITY:
+            case PlSqlParser.BINARY_DOUBLE_NAN:
+            case PlSqlParser.BINARY_FLOAT:
+            case PlSqlParser.BINARY_FLOAT_INFINITY:
+            case PlSqlParser.BINARY_FLOAT_NAN:
+            case PlSqlParser.BINARY_INTEGER:
+            case PlSqlParser.BIND_AWARE:
+            case PlSqlParser.BINDING:
+            case PlSqlParser.BIN_TO_NUM:
+            case PlSqlParser.BITAND:
+            case PlSqlParser.BITMAP_AND:
+            case PlSqlParser.BITMAP:
+            case PlSqlParser.BITMAPS:
+            case PlSqlParser.BITMAP_TREE:
+            case PlSqlParser.BITS:
+            case PlSqlParser.BLOB:
+            case PlSqlParser.BLOCK:
+            case PlSqlParser.BLOCK_RANGE:
+            case PlSqlParser.BLOCKS:
+            case PlSqlParser.BLOCKSIZE:
+            case PlSqlParser.BODY:
+            case PlSqlParser.BOOLEAN:
+            case PlSqlParser.BOTH:
+            case PlSqlParser.BOUND:
+            case PlSqlParser.BRANCH:
+            case PlSqlParser.BREADTH:
+            case PlSqlParser.BROADCAST:
+            case PlSqlParser.BSON:
+            case PlSqlParser.BUFFER:
+            case PlSqlParser.BUFFER_CACHE:
+            case PlSqlParser.BUFFER_POOL:
+            case PlSqlParser.BUILD:
+            case PlSqlParser.BULK:
+            case PlSqlParser.BYPASS_RECURSIVE_CHECK:
+            case PlSqlParser.BYPASS_UJVC:
+            case PlSqlParser.BYTE:
+            case PlSqlParser.BYTES:
+            case PlSqlParser.CACHE:
+            case PlSqlParser.CACHE_CB:
+            case PlSqlParser.CACHE_INSTANCES:
+            case PlSqlParser.CACHE_TEMP_TABLE:
+            case PlSqlParser.CACHING:
+            case PlSqlParser.CALCULATED:
+            case PlSqlParser.CALLBACK:
+            case PlSqlParser.CALL:
+            case PlSqlParser.CANCEL:
+            case PlSqlParser.CAPACITY:
+            case PlSqlParser.CAPTION:
+            case PlSqlParser.CARDINALITY:
+            case PlSqlParser.CASCADE:
+            case PlSqlParser.CASE:
+            case PlSqlParser.CAST:
+            case PlSqlParser.CASESENSITIVE:
+            case PlSqlParser.CATEGORY:
+            case PlSqlParser.CDBDEFAULT:
+            case PlSqlParser.CEIL:
+            case PlSqlParser.CELL_FLASH_CACHE:
+            case PlSqlParser.CERTIFICATE:
+            case PlSqlParser.CFILE:
+            case PlSqlParser.CHAINED:
+            case PlSqlParser.CHANGE:
+            case PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX:
+            case PlSqlParser.CHARACTER:
+            case PlSqlParser.CHARACTERSET:
+            case PlSqlParser.CHAR:
+            case PlSqlParser.CHAR_CS:
+            case PlSqlParser.CHARTOROWID:
+            case PlSqlParser.CHECK_ACL_REWRITE:
+            case PlSqlParser.CHECKPOINT:
+            case PlSqlParser.CHILD:
+            case PlSqlParser.CHOOSE:
+            case PlSqlParser.CHR:
+            case PlSqlParser.CHUNK:
+            case PlSqlParser.CLASS:
+            case PlSqlParser.CLASSIFICATION:
+            case PlSqlParser.CLASSIFIER:
+            case PlSqlParser.CLAUSE:
+            case PlSqlParser.CLEAN:
+            case PlSqlParser.CLEANUP:
+            case PlSqlParser.CLEAR:
+            case PlSqlParser.C_LETTER:
+            case PlSqlParser.CLIENT:
+            case PlSqlParser.CLOB:
+            case PlSqlParser.CLONE:
+            case PlSqlParser.CLOSE_CACHED_OPEN_CURSORS:
+            case PlSqlParser.CLOSE:
+            case PlSqlParser.CLUSTER_BY_ROWID:
+            case PlSqlParser.CLUSTER:
+            case PlSqlParser.CLUSTER_DETAILS:
+            case PlSqlParser.CLUSTER_DISTANCE:
+            case PlSqlParser.CLUSTER_ID:
+            case PlSqlParser.CLUSTERING:
+            case PlSqlParser.CLUSTERING_FACTOR:
+            case PlSqlParser.CLUSTER_PROBABILITY:
+            case PlSqlParser.CLUSTER_SET:
+            case PlSqlParser.COALESCE:
+            case PlSqlParser.COALESCE_SQ:
+            case PlSqlParser.COARSE:
+            case PlSqlParser.CO_AUTH_IND:
+            case PlSqlParser.COLD:
+            case PlSqlParser.COLLECT:
+            case PlSqlParser.COLUMNAR:
+            case PlSqlParser.COLUMN_AUTH_INDICATOR:
+            case PlSqlParser.COLUMN:
+            case PlSqlParser.COLUMNS:
+            case PlSqlParser.COLUMN_STATS:
+            case PlSqlParser.COLUMN_VALUE:
+            case PlSqlParser.COMMENT:
+            case PlSqlParser.COMMIT:
+            case PlSqlParser.COMMITTED:
+            case PlSqlParser.COMMON:
+            case PlSqlParser.COMMON_DATA:
+            case PlSqlParser.COMPACT:
+            case PlSqlParser.COMPATIBILITY:
+            case PlSqlParser.COMPILE:
+            case PlSqlParser.COMPLETE:
+            case PlSqlParser.COMPLIANCE:
+            case PlSqlParser.COMPONENT:
+            case PlSqlParser.COMPONENTS:
+            case PlSqlParser.COMPOSE:
+            case PlSqlParser.COMPOSITE:
+            case PlSqlParser.COMPOSITE_LIMIT:
+            case PlSqlParser.COMPOUND:
+            case PlSqlParser.COMPUTE:
+            case PlSqlParser.CONCAT:
+            case PlSqlParser.CON_DBID_TO_ID:
+            case PlSqlParser.CONDITIONAL:
+            case PlSqlParser.CONDITION:
+            case PlSqlParser.CONFIRM:
+            case PlSqlParser.CONFORMING:
+            case PlSqlParser.CON_GUID_TO_ID:
+            case PlSqlParser.CON_ID:
+            case PlSqlParser.CON_NAME_TO_ID:
+            case PlSqlParser.CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.CONNECT_BY_COST_BASED:
+            case PlSqlParser.CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.CONNECT_BY_FILTERING:
+            case PlSqlParser.CONNECT_BY_ISCYCLE:
+            case PlSqlParser.CONNECT_BY_ISLEAF:
+            case PlSqlParser.CONNECT_BY_ROOT:
+            case PlSqlParser.CONNECT_TIME:
+            case PlSqlParser.CONSIDER:
+            case PlSqlParser.CONSISTENT:
+            case PlSqlParser.CONSTANT:
+            case PlSqlParser.CONST:
+            case PlSqlParser.CONSTRAINT:
+            case PlSqlParser.CONSTRAINTS:
+            case PlSqlParser.CONSTRUCTOR:
+            case PlSqlParser.CONTAINER:
+            case PlSqlParser.CONTAINERS:
+            case PlSqlParser.CONTAINERS_DEFAULT:
+            case PlSqlParser.CONTAINER_DATA:
+            case PlSqlParser.CONTAINER_MAP:
+            case PlSqlParser.CONTENT:
+            case PlSqlParser.CONTENTS:
+            case PlSqlParser.CONTEXT:
+            case PlSqlParser.CONTINUE:
+            case PlSqlParser.CONTROLFILE:
+            case PlSqlParser.CON_UID_TO_ID:
+            case PlSqlParser.CONVERT:
+            case PlSqlParser.CONVERSION:
+            case PlSqlParser.COOKIE:
+            case PlSqlParser.COPY:
+            case PlSqlParser.CORR_K:
+            case PlSqlParser.CORR_S:
+            case PlSqlParser.CORRUPTION:
+            case PlSqlParser.CORRUPT_XID_ALL:
+            case PlSqlParser.CORRUPT_XID:
+            case PlSqlParser.COS:
+            case PlSqlParser.COSH:
+            case PlSqlParser.COST:
+            case PlSqlParser.COST_XML_QUERY_REWRITE:
+            case PlSqlParser.COUNT:
+            case PlSqlParser.COUNTED:
+            case PlSqlParser.COVAR_POP:
+            case PlSqlParser.COVAR_SAMP:
+            case PlSqlParser.CPU_COSTING:
+            case PlSqlParser.CPU_PER_CALL:
+            case PlSqlParser.CPU_PER_SESSION:
+            case PlSqlParser.CRASH:
+            case PlSqlParser.CREATE_FILE_DEST:
+            case PlSqlParser.CREATE_STORED_OUTLINES:
+            case PlSqlParser.CREATION:
+            case PlSqlParser.CREDENTIAL:
+            case PlSqlParser.CRITICAL:
+            case PlSqlParser.CROSS:
+            case PlSqlParser.CROSSEDITION:
+            case PlSqlParser.CSCONVERT:
+            case PlSqlParser.CSV:
+            case PlSqlParser.CUBE_AJ:
+            case PlSqlParser.CUBE:
+            case PlSqlParser.CUBE_GB:
+            case PlSqlParser.CUBE_SJ:
+            case PlSqlParser.CUME_DISTM:
+            case PlSqlParser.CURRENT:
+            case PlSqlParser.CURRENT_DATE:
+            case PlSqlParser.CURRENT_SCHEMA:
+            case PlSqlParser.CURRENT_TIME:
+            case PlSqlParser.CURRENT_TIMESTAMP:
+            case PlSqlParser.CURRENT_USER:
+            case PlSqlParser.CURRENTV:
+            case PlSqlParser.CURSOR:
+            case PlSqlParser.CURSOR_SHARING_EXACT:
+            case PlSqlParser.CURSOR_SPECIFIC_SEGMENT:
+            case PlSqlParser.CUSTOMDATUM:
+            case PlSqlParser.CV:
+            case PlSqlParser.CYCLE:
+            case PlSqlParser.DANGLING:
+            case PlSqlParser.DATABASE:
+            case PlSqlParser.DATA:
+            case PlSqlParser.DATAFILE:
+            case PlSqlParser.DATAFILES:
+            case PlSqlParser.DATAMOVEMENT:
+            case PlSqlParser.DATAOBJNO:
+            case PlSqlParser.DATAOBJ_TO_MAT_PARTITION:
+            case PlSqlParser.DATAOBJ_TO_PARTITION:
+            case PlSqlParser.DATAPUMP:
+            case PlSqlParser.DATA_SECURITY_REWRITE_LIMIT:
+            case PlSqlParser.DATE:
+            case PlSqlParser.DATE_FORMAT:
+            case PlSqlParser.DATE_MODE:
+            case PlSqlParser.DAY:
+            case PlSqlParser.DAYS:
+            case PlSqlParser.DBA:
+            case PlSqlParser.DBA_RECYCLEBIN:
+            case PlSqlParser.DBLINK:
+            case PlSqlParser.DBMS_STATS:
+            case PlSqlParser.DB_ROLE_CHANGE:
+            case PlSqlParser.DBTIMEZONE:
+            case PlSqlParser.DB_UNIQUE_NAME:
+            case PlSqlParser.DB_VERSION:
+            case PlSqlParser.DDL:
+            case PlSqlParser.DEALLOCATE:
+            case PlSqlParser.DEBUG:
+            case PlSqlParser.DEBUGGER:
+            case PlSqlParser.DEC:
+            case PlSqlParser.DECIMAL:
+            case PlSqlParser.DECLARE:
+            case PlSqlParser.DECOMPOSE:
+            case PlSqlParser.DECORRELATE:
+            case PlSqlParser.DECR:
+            case PlSqlParser.DECREMENT:
+            case PlSqlParser.DECRYPT:
+            case PlSqlParser.DEDUPLICATE:
+            case PlSqlParser.DEFAULTS:
+            case PlSqlParser.DEFAULT_COLLATION:
+            case PlSqlParser.DEFAULT_CREDENTIAL:
+            case PlSqlParser.DEFERRABLE:
+            case PlSqlParser.DEFERRED:
+            case PlSqlParser.DEFINED:
+            case PlSqlParser.DEFINE:
+            case PlSqlParser.DEFINER:
+            case PlSqlParser.DEGREE:
+            case PlSqlParser.DELAY:
+            case PlSqlParser.DELEGATE:
+            case PlSqlParser.DELETE_ALL:
+            case PlSqlParser.DELETE:
+            case PlSqlParser.DELETEXML:
+            case PlSqlParser.DEMAND:
+            case PlSqlParser.DENSE_RANKM:
+            case PlSqlParser.DEPENDENT:
+            case PlSqlParser.DEPRECATE:
+            case PlSqlParser.DEPTH:
+            case PlSqlParser.DEQUEUE:
+            case PlSqlParser.DEREF:
+            case PlSqlParser.DEREF_NO_REWRITE:
+            case PlSqlParser.DESCRIPTION:
+            case PlSqlParser.DESTROY:
+            case PlSqlParser.DETACHED:
+            case PlSqlParser.DETECTED:
+            case PlSqlParser.DETERMINES:
+            case PlSqlParser.DETERMINISTIC:
+            case PlSqlParser.DICTIONARY:
+            case PlSqlParser.DIMENSION:
+            case PlSqlParser.DIMENSIONS:
+            case PlSqlParser.DIRECT_LOAD:
+            case PlSqlParser.DIRECTORY:
+            case PlSqlParser.DIRECT_PATH:
+            case PlSqlParser.DISABLE_ALL:
+            case PlSqlParser.DISABLE:
+            case PlSqlParser.DISABLED:
+            case PlSqlParser.DISABLE_PARALLEL_DML:
+            case PlSqlParser.DISABLE_PRESET:
+            case PlSqlParser.DISABLE_RPKE:
+            case PlSqlParser.DISALLOW:
+            case PlSqlParser.DISASSOCIATE:
+            case PlSqlParser.DISCARD:
+            case PlSqlParser.DISCONNECT:
+            case PlSqlParser.DISK:
+            case PlSqlParser.DISKGROUP:
+            case PlSqlParser.DISKS:
+            case PlSqlParser.DISMOUNT:
+            case PlSqlParser.DISTINGUISHED:
+            case PlSqlParser.DISTRIBUTED:
+            case PlSqlParser.DISTRIBUTE:
+            case PlSqlParser.DML:
+            case PlSqlParser.DML_UPDATE:
+            case PlSqlParser.DOCFIDELITY:
+            case PlSqlParser.DOCUMENT:
+            case PlSqlParser.DOMAIN_INDEX_FILTER:
+            case PlSqlParser.DOMAIN_INDEX_NO_SORT:
+            case PlSqlParser.DOMAIN_INDEX_SORT:
+            case PlSqlParser.DOUBLE:
+            case PlSqlParser.DOWNGRADE:
+            case PlSqlParser.DRIVING_SITE:
+            case PlSqlParser.DROP_COLUMN:
+            case PlSqlParser.DROP_GROUP:
+            case PlSqlParser.DSINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.DUMP:
+            case PlSqlParser.DUPLICATE:
+            case PlSqlParser.DV:
+            case PlSqlParser.DYNAMIC:
+            case PlSqlParser.DYNAMIC_SAMPLING:
+            case PlSqlParser.DYNAMIC_SAMPLING_EST_CDN:
+            case PlSqlParser.E_LETTER:
+            case PlSqlParser.EACH:
+            case PlSqlParser.EDITIONABLE:
+            case PlSqlParser.EDITION:
+            case PlSqlParser.EDITIONING:
+            case PlSqlParser.EDITIONS:
+            case PlSqlParser.ELEMENT:
+            case PlSqlParser.ELIM_GROUPBY:
+            case PlSqlParser.ELIMINATE_JOIN:
+            case PlSqlParser.ELIMINATE_OBY:
+            case PlSqlParser.ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.EM:
+            case PlSqlParser.EMPTY_BLOB:
+            case PlSqlParser.EMPTY_CLOB:
+            case PlSqlParser.EMPTY_:
+            case PlSqlParser.ENABLE_ALL:
+            case PlSqlParser.ENABLE:
+            case PlSqlParser.ENABLED:
+            case PlSqlParser.ENABLE_PARALLEL_DML:
+            case PlSqlParser.ENABLE_PRESET:
+            case PlSqlParser.ENCLOSED:
+            case PlSqlParser.ENCODING:
+            case PlSqlParser.ENCRYPT:
+            case PlSqlParser.ENCRYPTION:
+            case PlSqlParser.END_OUTLINE_DATA:
+            case PlSqlParser.ENFORCED:
+            case PlSqlParser.ENFORCE:
+            case PlSqlParser.ENQUEUE:
+            case PlSqlParser.ENTERPRISE:
+            case PlSqlParser.ENTITYESCAPING:
+            case PlSqlParser.ENTRY:
+            case PlSqlParser.EQUIPART:
+            case PlSqlParser.ERR:
+            case PlSqlParser.ERROR_ARGUMENT:
+            case PlSqlParser.ERROR:
+            case PlSqlParser.ERROR_ON_OVERLAP_TIME:
+            case PlSqlParser.ERRORS:
+            case PlSqlParser.ERROR_INDEX:
+            case PlSqlParser.ERROR_CODE:
+            case PlSqlParser.ESCAPE:
+            case PlSqlParser.ESTIMATE:
+            case PlSqlParser.EVAL:
+            case PlSqlParser.EVALNAME:
+            case PlSqlParser.EVALUATE:
+            case PlSqlParser.EVALUATION:
+            case PlSqlParser.EVENTS:
+            case PlSqlParser.EVERY:
+            case PlSqlParser.EXCEPT:
+            case PlSqlParser.EXCEPTION:
+            case PlSqlParser.EXCEPTION_INIT:
+            case PlSqlParser.EXCEPTIONS:
+            case PlSqlParser.EXCHANGE:
+            case PlSqlParser.EXCLUDE:
+            case PlSqlParser.EXCLUDING:
+            case PlSqlParser.EXEC:
+            case PlSqlParser.EXECUTE:
+            case PlSqlParser.EXEMPT:
+            case PlSqlParser.EXISTING:
+            case PlSqlParser.EXISTS:
+            case PlSqlParser.EXISTSNODE:
+            case PlSqlParser.EXIT:
+            case PlSqlParser.EXPAND_GSET_TO_UNION:
+            case PlSqlParser.EXPAND_TABLE:
+            case PlSqlParser.EXP:
+            case PlSqlParser.EXPIRE:
+            case PlSqlParser.EXPLAIN:
+            case PlSqlParser.EXPLOSION:
+            case PlSqlParser.EXPORT:
+            case PlSqlParser.EXPR_CORR_CHECK:
+            case PlSqlParser.EXPRESS:
+            case PlSqlParser.EXTENDS:
+            case PlSqlParser.EXTENT:
+            case PlSqlParser.EXTENTS:
+            case PlSqlParser.EXTERNAL:
+            case PlSqlParser.EXTERNALLY:
+            case PlSqlParser.EXTRACTCLOBXML:
+            case PlSqlParser.EXTRACT:
+            case PlSqlParser.EXTRACTVALUE:
+            case PlSqlParser.EXTRA:
+            case PlSqlParser.FACILITY:
+            case PlSqlParser.FACT:
+            case PlSqlParser.FACTOR:
+            case PlSqlParser.FACTORIZE_JOIN:
+            case PlSqlParser.FAILED:
+            case PlSqlParser.FAILED_LOGIN_ATTEMPTS:
+            case PlSqlParser.FAILGROUP:
+            case PlSqlParser.FAILOVER:
+            case PlSqlParser.FAILURE:
+            case PlSqlParser.FALSE:
+            case PlSqlParser.FAMILY:
+            case PlSqlParser.FAR:
+            case PlSqlParser.FAST:
+            case PlSqlParser.FASTSTART:
+            case PlSqlParser.FBTSCAN:
+            case PlSqlParser.FEATURE:
+            case PlSqlParser.FEATURE_DETAILS:
+            case PlSqlParser.FEATURE_ID:
+            case PlSqlParser.FEATURE_SET:
+            case PlSqlParser.FEATURE_VALUE:
+            case PlSqlParser.FETCH:
+            case PlSqlParser.FIELD:
+            case PlSqlParser.FIELDS:
+            case PlSqlParser.FILE:
+            case PlSqlParser.FILE_NAME_CONVERT:
+            case PlSqlParser.FILEGROUP:
+            case PlSqlParser.FILESTORE:
+            case PlSqlParser.FILESYSTEM_LIKE_LOGGING:
+            case PlSqlParser.FILTER:
+            case PlSqlParser.FINAL:
+            case PlSqlParser.FINE:
+            case PlSqlParser.FINISH:
+            case PlSqlParser.FIRST:
+            case PlSqlParser.FIRSTM:
+            case PlSqlParser.FIRST_ROWS:
+            case PlSqlParser.FIRST_VALUE:
+            case PlSqlParser.FIXED_VIEW_DATA:
+            case PlSqlParser.FLAGGER:
+            case PlSqlParser.FLASHBACK:
+            case PlSqlParser.FLASH_CACHE:
+            case PlSqlParser.FLOAT:
+            case PlSqlParser.FLOB:
+            case PlSqlParser.FLEX:
+            case PlSqlParser.FLOOR:
+            case PlSqlParser.FLUSH:
+            case PlSqlParser.FOLDER:
+            case PlSqlParser.FOLLOWING:
+            case PlSqlParser.FOLLOWS:
+            case PlSqlParser.FORALL:
+            case PlSqlParser.FORCE:
+            case PlSqlParser.FORCE_XML_QUERY_REWRITE:
+            case PlSqlParser.FOREIGN:
+            case PlSqlParser.FOREVER:
+            case PlSqlParser.FORMAT:
+            case PlSqlParser.FORWARD:
+            case PlSqlParser.FRAGMENT_NUMBER:
+            case PlSqlParser.FREELIST:
+            case PlSqlParser.FREELISTS:
+            case PlSqlParser.FREEPOOLS:
+            case PlSqlParser.FRESH:
+            case PlSqlParser.FROM_TZ:
+            case PlSqlParser.FULL:
+            case PlSqlParser.FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.FUNCTION:
+            case PlSqlParser.FUNCTIONS:
+            case PlSqlParser.FTP:
+            case PlSqlParser.G_LETTER:
+            case PlSqlParser.GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.GATHER_PLAN_STATISTICS:
+            case PlSqlParser.GBY_CONC_ROLLUP:
+            case PlSqlParser.GBY_PUSHDOWN:
+            case PlSqlParser.GENERATED:
+            case PlSqlParser.GET:
+            case PlSqlParser.GLOBAL:
+            case PlSqlParser.GLOBALLY:
+            case PlSqlParser.GLOBAL_NAME:
+            case PlSqlParser.GLOBAL_TOPIC_ENABLED:
+            case PlSqlParser.GROUP_BY:
+            case PlSqlParser.GROUP_ID:
+            case PlSqlParser.GROUPING:
+            case PlSqlParser.GROUPING_ID:
+            case PlSqlParser.GROUPS:
+            case PlSqlParser.GUARANTEED:
+            case PlSqlParser.GUARANTEE:
+            case PlSqlParser.GUARD:
+            case PlSqlParser.HALF_YEARS:
+            case PlSqlParser.HASH_AJ:
+            case PlSqlParser.HASH:
+            case PlSqlParser.HASHKEYS:
+            case PlSqlParser.HASH_SJ:
+            case PlSqlParser.HEADER:
+            case PlSqlParser.HEAP:
+            case PlSqlParser.HELP:
+            case PlSqlParser.HEXTORAW:
+            case PlSqlParser.HEXTOREF:
+            case PlSqlParser.HIDDEN_KEYWORD:
+            case PlSqlParser.HIDE:
+            case PlSqlParser.HIER_ORDER:
+            case PlSqlParser.HIERARCHICAL:
+            case PlSqlParser.HIERARCHY:
+            case PlSqlParser.HIGH:
+            case PlSqlParser.HINTSET_BEGIN:
+            case PlSqlParser.HINTSET_END:
+            case PlSqlParser.HOT:
+            case PlSqlParser.HOUR:
+            case PlSqlParser.HOURS:
+            case PlSqlParser.HTTP:
+            case PlSqlParser.HWM_BROKERED:
+            case PlSqlParser.HYBRID:
+            case PlSqlParser.H_LETTER:
+            case PlSqlParser.IDENTIFIER:
+            case PlSqlParser.IDENTITY:
+            case PlSqlParser.IDGENERATORS:
+            case PlSqlParser.ID:
+            case PlSqlParser.IDLE_TIME:
+            case PlSqlParser.IF:
+            case PlSqlParser.IGNORE:
+            case PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS:
+            case PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX:
+            case PlSqlParser.IGNORE_WHERE_CLAUSE:
+            case PlSqlParser.ILM:
+            case PlSqlParser.IMMEDIATE:
+            case PlSqlParser.IMPACT:
+            case PlSqlParser.IMPORT:
+            case PlSqlParser.INACTIVE:
+            case PlSqlParser.INACTIVE_ACCOUNT_TIME:
+            case PlSqlParser.INCLUDE:
+            case PlSqlParser.INCLUDE_VERSION:
+            case PlSqlParser.INCLUDING:
+            case PlSqlParser.INCREMENTAL:
+            case PlSqlParser.INCREMENT:
+            case PlSqlParser.INCR:
+            case PlSqlParser.INDENT:
+            case PlSqlParser.INDEX_ASC:
+            case PlSqlParser.INDEX_COMBINE:
+            case PlSqlParser.INDEX_DESC:
+            case PlSqlParser.INDEXED:
+            case PlSqlParser.INDEXES:
+            case PlSqlParser.INDEX_FFS:
+            case PlSqlParser.INDEX_FILTER:
+            case PlSqlParser.INDEXING:
+            case PlSqlParser.INDEX_JOIN:
+            case PlSqlParser.INDEX_ROWS:
+            case PlSqlParser.INDEX_RRS:
+            case PlSqlParser.INDEX_RS_ASC:
+            case PlSqlParser.INDEX_RS_DESC:
+            case PlSqlParser.INDEX_RS:
+            case PlSqlParser.INDEX_SCAN:
+            case PlSqlParser.INDEX_SKIP_SCAN:
+            case PlSqlParser.INDEX_SS_ASC:
+            case PlSqlParser.INDEX_SS_DESC:
+            case PlSqlParser.INDEX_SS:
+            case PlSqlParser.INDEX_STATS:
+            case PlSqlParser.INDEXTYPE:
+            case PlSqlParser.INDEXTYPES:
+            case PlSqlParser.INDICATOR:
+            case PlSqlParser.INDICES:
+            case PlSqlParser.INFINITE:
+            case PlSqlParser.INFORMATIONAL:
+            case PlSqlParser.INHERIT:
+            case PlSqlParser.INITCAP:
+            case PlSqlParser.INITIAL:
+            case PlSqlParser.INITIALIZED:
+            case PlSqlParser.INITIALLY:
+            case PlSqlParser.INITRANS:
+            case PlSqlParser.INLINE:
+            case PlSqlParser.INLINE_XMLTYPE_NT:
+            case PlSqlParser.INMEMORY:
+            case PlSqlParser.IN_MEMORY_METADATA:
+            case PlSqlParser.INMEMORY_PRUNING:
+            case PlSqlParser.INNER:
+            case PlSqlParser.INOUT:
+            case PlSqlParser.INPLACE:
+            case PlSqlParser.INSERTCHILDXMLAFTER:
+            case PlSqlParser.INSERTCHILDXMLBEFORE:
+            case PlSqlParser.INSERTCHILDXML:
+            case PlSqlParser.INSERTXMLAFTER:
+            case PlSqlParser.INSERTXMLBEFORE:
+            case PlSqlParser.INSTANCE:
+            case PlSqlParser.INSTANCES:
+            case PlSqlParser.INSTANTIABLE:
+            case PlSqlParser.INSTANTLY:
+            case PlSqlParser.INSTEAD:
+            case PlSqlParser.INSTR2:
+            case PlSqlParser.INSTR4:
+            case PlSqlParser.INSTRB:
+            case PlSqlParser.INSTRC:
+            case PlSqlParser.INSTR:
+            case PlSqlParser.INTEGER:
+            case PlSqlParser.INTERLEAVED:
+            case PlSqlParser.INTERMEDIATE:
+            case PlSqlParser.INTERNAL_CONVERT:
+            case PlSqlParser.INTERNAL_USE:
+            case PlSqlParser.INTERPRETED:
+            case PlSqlParser.INTERVAL:
+            case PlSqlParser.INT:
+            case PlSqlParser.INTERNAL:
+            case PlSqlParser.INVALIDATE:
+            case PlSqlParser.INVALIDATION:
+            case PlSqlParser.INVISIBLE:
+            case PlSqlParser.IN_XQUERY:
+            case PlSqlParser.IS_LEAF:
+            case PlSqlParser.ISOLATION:
+            case PlSqlParser.ISOLATION_LEVEL:
+            case PlSqlParser.ITEMS:
+            case PlSqlParser.ITERATE:
+            case PlSqlParser.ITERATION_NUMBER:
+            case PlSqlParser.JAVA:
+            case PlSqlParser.JOB:
+            case PlSqlParser.JOIN:
+            case PlSqlParser.JSON_ARRAYAGG:
+            case PlSqlParser.JSON_ARRAY:
+            case PlSqlParser.JSON_EQUAL:
+            case PlSqlParser.JSON_EXISTS2:
+            case PlSqlParser.JSON_EXISTS:
+            case PlSqlParser.JSONGET:
+            case PlSqlParser.JSON:
+            case PlSqlParser.JSON_OBJECTAGG:
+            case PlSqlParser.JSON_OBJECT:
+            case PlSqlParser.JSONPARSE:
+            case PlSqlParser.JSON_QUERY:
+            case PlSqlParser.JSON_SERIALIZE:
+            case PlSqlParser.JSON_TABLE:
+            case PlSqlParser.JSON_TEXTCONTAINS2:
+            case PlSqlParser.JSON_TEXTCONTAINS:
+            case PlSqlParser.JSON_TRANSFORM:
+            case PlSqlParser.JSON_VALUE:
+            case PlSqlParser.K_LETTER:
+            case PlSqlParser.KEEP_DUPLICATES:
+            case PlSqlParser.KEEP:
+            case PlSqlParser.KERBEROS:
+            case PlSqlParser.KEY:
+            case PlSqlParser.KEY_LENGTH:
+            case PlSqlParser.KEYSIZE:
+            case PlSqlParser.KEYS:
+            case PlSqlParser.KEYSTORE:
+            case PlSqlParser.KILL:
+            case PlSqlParser.LABEL:
+            case PlSqlParser.LANGUAGE:
+            case PlSqlParser.LAST_DAY:
+            case PlSqlParser.LAST:
+            case PlSqlParser.LAST_VALUE:
+            case PlSqlParser.LATERAL:
+            case PlSqlParser.LAX:
+            case PlSqlParser.LAYER:
+            case PlSqlParser.LDAP_REGISTRATION_ENABLED:
+            case PlSqlParser.LDAP_REGISTRATION:
+            case PlSqlParser.LDAP_REG_SYNC_INTERVAL:
+            case PlSqlParser.LEAF:
+            case PlSqlParser.LEAD_CDB:
+            case PlSqlParser.LEAD_CDB_URI:
+            case PlSqlParser.LEADING:
+            case PlSqlParser.LEFT:
+            case PlSqlParser.LENGTH2:
+            case PlSqlParser.LENGTH4:
+            case PlSqlParser.LENGTHB:
+            case PlSqlParser.LENGTHC:
+            case PlSqlParser.LENGTH:
+            case PlSqlParser.LESS:
+            case PlSqlParser.LEVEL:
+            case PlSqlParser.LEVEL_NAME:
+            case PlSqlParser.LEVELS:
+            case PlSqlParser.LIBRARY:
+            case PlSqlParser.LIFECYCLE:
+            case PlSqlParser.LIFE:
+            case PlSqlParser.LIFETIME:
+            case PlSqlParser.LIKE2:
+            case PlSqlParser.LIKE4:
+            case PlSqlParser.LIKEC:
+            case PlSqlParser.LIKE_EXPAND:
+            case PlSqlParser.LIMIT:
+            case PlSqlParser.LINEAR:
+            case PlSqlParser.LINES:
+            case PlSqlParser.LINK:
+            case PlSqlParser.LIST:
+            case PlSqlParser.LN:
+            case PlSqlParser.LNNVL:
+            case PlSqlParser.LOAD:
+            case PlSqlParser.LOB:
+            case PlSqlParser.LOBNVL:
+            case PlSqlParser.LOBS:
+            case PlSqlParser.LOCAL_INDEXES:
+            case PlSqlParser.LOCAL:
+            case PlSqlParser.LOCALTIME:
+            case PlSqlParser.LOCALTIMESTAMP:
+            case PlSqlParser.LOCATION:
+            case PlSqlParser.LOCATOR:
+            case PlSqlParser.LOCKDOWN:
+            case PlSqlParser.LOCKED:
+            case PlSqlParser.LOCKING:
+            case PlSqlParser.LOGFILE:
+            case PlSqlParser.LOGFILES:
+            case PlSqlParser.LOGGING:
+            case PlSqlParser.LOGICAL:
+            case PlSqlParser.LOGICAL_READS_PER_CALL:
+            case PlSqlParser.LOGICAL_READS_PER_SESSION:
+            case PlSqlParser.LOG:
+            case PlSqlParser.LOGMINING:
+            case PlSqlParser.LOGOFF:
+            case PlSqlParser.LOGON:
+            case PlSqlParser.LOG_READ_ONLY_VIOLATIONS:
+            case PlSqlParser.LONG:
+            case PlSqlParser.LOOP:
+            case PlSqlParser.LOST:
+            case PlSqlParser.LOWER:
+            case PlSqlParser.LOW:
+            case PlSqlParser.LPAD:
+            case PlSqlParser.LTRIM:
+            case PlSqlParser.M_LETTER:
+            case PlSqlParser.MAIN:
+            case PlSqlParser.MAKE_REF:
+            case PlSqlParser.MANAGED:
+            case PlSqlParser.MANAGE:
+            case PlSqlParser.MANAGEMENT:
+            case PlSqlParser.MANAGER:
+            case PlSqlParser.MANDATORY:
+            case PlSqlParser.MANUAL:
+            case PlSqlParser.MAP:
+            case PlSqlParser.MAPPING:
+            case PlSqlParser.MASK:
+            case PlSqlParser.MASTER:
+            case PlSqlParser.MATCHED:
+            case PlSqlParser.MATCHES:
+            case PlSqlParser.MATCH:
+            case PlSqlParser.MATCH_NUMBER:
+            case PlSqlParser.MATCH_RECOGNIZE:
+            case PlSqlParser.MATERIALIZED:
+            case PlSqlParser.MATERIALIZE:
+            case PlSqlParser.MAXARCHLOGS:
+            case PlSqlParser.MAXDATAFILES:
+            case PlSqlParser.MAXEXTENTS:
+            case PlSqlParser.MAXIMIZE:
+            case PlSqlParser.MAXINSTANCES:
+            case PlSqlParser.MAXLOGFILES:
+            case PlSqlParser.MAXLOGHISTORY:
+            case PlSqlParser.MAXLOGMEMBERS:
+            case PlSqlParser.MAX_SHARED_TEMP_SIZE:
+            case PlSqlParser.MAXSIZE:
+            case PlSqlParser.MAXTRANS:
+            case PlSqlParser.MAXVALUE:
+            case PlSqlParser.MEASURE:
+            case PlSqlParser.MEASURES:
+            case PlSqlParser.MEDIUM:
+            case PlSqlParser.MEMBER:
+            case PlSqlParser.MEMBER_CAPTION:
+            case PlSqlParser.MEMBER_DESCRIPTION:
+            case PlSqlParser.MEMBER_NAME:
+            case PlSqlParser.MEMBER_UNIQUE_NAME:
+            case PlSqlParser.MEMCOMPRESS:
+            case PlSqlParser.MEMORY:
+            case PlSqlParser.MERGEACTIONS:
+            case PlSqlParser.MERGE_AJ:
+            case PlSqlParser.MERGE_CONST_ON:
+            case PlSqlParser.MERGE:
+            case PlSqlParser.MERGE_SJ:
+            case PlSqlParser.METADATA:
+            case PlSqlParser.METHOD:
+            case PlSqlParser.MIGRATE:
+            case PlSqlParser.MIGRATION:
+            case PlSqlParser.MINEXTENTS:
+            case PlSqlParser.MINIMIZE:
+            case PlSqlParser.MINIMUM:
+            case PlSqlParser.MINING:
+            case PlSqlParser.MINUS_NULL:
+            case PlSqlParser.MINUTE:
+            case PlSqlParser.MINUTES:
+            case PlSqlParser.MINVALUE:
+            case PlSqlParser.MIRRORCOLD:
+            case PlSqlParser.MIRRORHOT:
+            case PlSqlParser.MIRROR:
+            case PlSqlParser.MISSING:
+            case PlSqlParser.MISMATCH:
+            case PlSqlParser.MLSLABEL:
+            case PlSqlParser.MODEL_COMPILE_SUBQUERY:
+            case PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS:
+            case PlSqlParser.MODEL_DYNAMIC_SUBQUERY:
+            case PlSqlParser.MODEL_MIN_ANALYSIS:
+            case PlSqlParser.MODEL:
+            case PlSqlParser.MODEL_NB:
+            case PlSqlParser.MODEL_NO_ANALYSIS:
+            case PlSqlParser.MODEL_PBY:
+            case PlSqlParser.MODEL_PUSH_REF:
+            case PlSqlParser.MODEL_SV:
+            case PlSqlParser.MODIFICATION:
+            case PlSqlParser.MODIFY_COLUMN_TYPE:
+            case PlSqlParser.MODIFY:
+            case PlSqlParser.MOD:
+            case PlSqlParser.MODULE:
+            case PlSqlParser.MONITORING:
+            case PlSqlParser.MONITOR:
+            case PlSqlParser.MONTH:
+            case PlSqlParser.MONTHS_BETWEEN:
+            case PlSqlParser.MONTHS:
+            case PlSqlParser.MOUNT:
+            case PlSqlParser.MOUNTPATH:
+            case PlSqlParser.MOUNTPOINT:
+            case PlSqlParser.MOVEMENT:
+            case PlSqlParser.MOVE:
+            case PlSqlParser.MULTIDIMENSIONAL:
+            case PlSqlParser.MULTISET:
+            case PlSqlParser.MV_MERGE:
+            case PlSqlParser.NAMED:
+            case PlSqlParser.NAME:
+            case PlSqlParser.NAMESPACE:
+            case PlSqlParser.NAN_:
+            case PlSqlParser.NANVL:
+            case PlSqlParser.NATIONAL:
+            case PlSqlParser.NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NATIVE:
+            case PlSqlParser.NATURAL:
+            case PlSqlParser.NAV:
+            case PlSqlParser.NCHAR_CS:
+            case PlSqlParser.NCHAR:
+            case PlSqlParser.NCHR:
+            case PlSqlParser.NCLOB:
+            case PlSqlParser.NEEDED:
+            case PlSqlParser.NEG:
+            case PlSqlParser.NESTED:
+            case PlSqlParser.NESTED_TABLE_FAST_INSERT:
+            case PlSqlParser.NESTED_TABLE_GET_REFS:
+            case PlSqlParser.NESTED_TABLE_ID:
+            case PlSqlParser.NESTED_TABLE_SET_REFS:
+            case PlSqlParser.NESTED_TABLE_SET_SETID:
+            case PlSqlParser.NETWORK:
+            case PlSqlParser.NEVER:
+            case PlSqlParser.NEW:
+            case PlSqlParser.NEWLINE_:
+            case PlSqlParser.NEW_TIME:
+            case PlSqlParser.NEXT_DAY:
+            case PlSqlParser.NEXT:
+            case PlSqlParser.NL_AJ:
+            case PlSqlParser.NLJ_BATCHING:
+            case PlSqlParser.NLJ_INDEX_FILTER:
+            case PlSqlParser.NLJ_INDEX_SCAN:
+            case PlSqlParser.NLJ_PREFETCH:
+            case PlSqlParser.NLS_CALENDAR:
+            case PlSqlParser.NLS_CHARACTERSET:
+            case PlSqlParser.NLS_CHARSET_DECL_LEN:
+            case PlSqlParser.NLS_CHARSET_ID:
+            case PlSqlParser.NLS_CHARSET_NAME:
+            case PlSqlParser.NLS_COMP:
+            case PlSqlParser.NLS_CURRENCY:
+            case PlSqlParser.NLS_DATE_FORMAT:
+            case PlSqlParser.NLS_DATE_LANGUAGE:
+            case PlSqlParser.NLS_INITCAP:
+            case PlSqlParser.NLS_ISO_CURRENCY:
+            case PlSqlParser.NL_SJ:
+            case PlSqlParser.NLS_LANG:
+            case PlSqlParser.NLS_LANGUAGE:
+            case PlSqlParser.NLS_LENGTH_SEMANTICS:
+            case PlSqlParser.NLS_LOWER:
+            case PlSqlParser.NLS_NCHAR_CONV_EXCP:
+            case PlSqlParser.NLS_NUMERIC_CHARACTERS:
+            case PlSqlParser.NLS_SORT:
+            case PlSqlParser.NLSSORT:
+            case PlSqlParser.NLS_SPECIAL_CHARS:
+            case PlSqlParser.NLS_TERRITORY:
+            case PlSqlParser.NLS_UPPER:
+            case PlSqlParser.NO_ACCESS:
+            case PlSqlParser.NO_ADAPTIVE_PLAN:
+            case PlSqlParser.NO_ANSI_REARCH:
+            case PlSqlParser.NOAPPEND:
+            case PlSqlParser.NOARCHIVELOG:
+            case PlSqlParser.NOAUDIT:
+            case PlSqlParser.NO_AUTO_REOPTIMIZE:
+            case PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE:
+            case PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID:
+            case PlSqlParser.NO_BIND_AWARE:
+            case PlSqlParser.NO_BUFFER:
+            case PlSqlParser.NOCACHE:
+            case PlSqlParser.NO_CARTESIAN:
+            case PlSqlParser.NO_CHECK_ACL_REWRITE:
+            case PlSqlParser.NO_CLUSTER_BY_ROWID:
+            case PlSqlParser.NO_CLUSTERING:
+            case PlSqlParser.NO_COALESCE_SQ:
+            case PlSqlParser.NO_COMMON_DATA:
+            case PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY:
+            case PlSqlParser.NO_CONNECT_BY_COMBINE_SW:
+            case PlSqlParser.NO_CONNECT_BY_COST_BASED:
+            case PlSqlParser.NO_CONNECT_BY_ELIM_DUPS:
+            case PlSqlParser.NO_CONNECT_BY_FILTERING:
+            case PlSqlParser.NOCOPY:
+            case PlSqlParser.NO_COST_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_CPU_COSTING:
+            case PlSqlParser.NOCPU_COSTING:
+            case PlSqlParser.NOCYCLE:
+            case PlSqlParser.NO_DATA_SECURITY_REWRITE:
+            case PlSqlParser.NO_DECORRELATE:
+            case PlSqlParser.NODELAY:
+            case PlSqlParser.NO_DOMAIN_INDEX_FILTER:
+            case PlSqlParser.NO_DST_UPGRADE_INSERT_CONV:
+            case PlSqlParser.NO_ELIM_GROUPBY:
+            case PlSqlParser.NO_ELIMINATE_JOIN:
+            case PlSqlParser.NO_ELIMINATE_OBY:
+            case PlSqlParser.NO_ELIMINATE_OUTER_JOIN:
+            case PlSqlParser.NOENTITYESCAPING:
+            case PlSqlParser.NO_EXPAND_GSET_TO_UNION:
+            case PlSqlParser.NO_EXPAND:
+            case PlSqlParser.NO_EXPAND_TABLE:
+            case PlSqlParser.NO_FACT:
+            case PlSqlParser.NO_FACTORIZE_JOIN:
+            case PlSqlParser.NO_FILTERING:
+            case PlSqlParser.NOFORCE:
+            case PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER:
+            case PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS:
+            case PlSqlParser.NO_GBY_PUSHDOWN:
+            case PlSqlParser.NOGUARANTEE:
+            case PlSqlParser.NO_INDEX_FFS:
+            case PlSqlParser.NO_INDEX:
+            case PlSqlParser.NO_INDEX_SS:
+            case PlSqlParser.NO_INMEMORY:
+            case PlSqlParser.NO_INMEMORY_PRUNING:
+            case PlSqlParser.NOKEEP:
+            case PlSqlParser.NO_LOAD:
+            case PlSqlParser.NOLOCAL:
+            case PlSqlParser.NOLOGGING:
+            case PlSqlParser.NOMAPPING:
+            case PlSqlParser.NOMAXVALUE:
+            case PlSqlParser.NO_MERGE:
+            case PlSqlParser.NOMINIMIZE:
+            case PlSqlParser.NOMINVALUE:
+            case PlSqlParser.NO_MODEL_PUSH_REF:
+            case PlSqlParser.NO_MONITORING:
+            case PlSqlParser.NOMONITORING:
+            case PlSqlParser.NO_MONITOR:
+            case PlSqlParser.NO_MULTIMV_REWRITE:
+            case PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN:
+            case PlSqlParser.NONBLOCKING:
+            case PlSqlParser.NONEDITIONABLE:
+            case PlSqlParser.NONE:
+            case PlSqlParser.NONPARTITIONED:
+            case PlSqlParser.NO_NLJ_BATCHING:
+            case PlSqlParser.NO_NLJ_PREFETCH:
+            case PlSqlParser.NO:
+            case PlSqlParser.NONSCHEMA:
+            case PlSqlParser.NO_OBJECT_LINK:
+            case PlSqlParser.NOORDER:
+            case PlSqlParser.NO_ORDER_ROLLUPS:
+            case PlSqlParser.NO_OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.NO_OUTER_JOIN_TO_INNER:
+            case PlSqlParser.NOOVERRIDE:
+            case PlSqlParser.NO_PARALLEL_INDEX:
+            case PlSqlParser.NOPARALLEL_INDEX:
+            case PlSqlParser.NO_PARALLEL:
+            case PlSqlParser.NOPARALLEL:
+            case PlSqlParser.NO_PARTIAL_COMMIT:
+            case PlSqlParser.NO_PARTIAL_JOIN:
+            case PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.NOPARTITION:
+            case PlSqlParser.NO_PLACE_DISTINCT:
+            case PlSqlParser.NO_PLACE_GROUP_BY:
+            case PlSqlParser.NO_PQ_CONCURRENT_UNION:
+            case PlSqlParser.NO_PQ_MAP:
+            case PlSqlParser.NOPROMPT:
+            case PlSqlParser.NO_PQ_REPLICATE:
+            case PlSqlParser.NO_PQ_SKEW:
+            case PlSqlParser.NO_PRUNE_GSETS:
+            case PlSqlParser.NO_PULL_PRED:
+            case PlSqlParser.NO_PUSH_PRED:
+            case PlSqlParser.NO_PUSH_SUBQ:
+            case PlSqlParser.NO_PX_FAULT_TOLERANCE:
+            case PlSqlParser.NO_PX_JOIN_FILTER:
+            case PlSqlParser.NO_QKN_BUFF:
+            case PlSqlParser.NO_QUERY_TRANSFORMATION:
+            case PlSqlParser.NO_REF_CASCADE:
+            case PlSqlParser.NORELOCATE:
+            case PlSqlParser.NORELY:
+            case PlSqlParser.NOREPAIR:
+            case PlSqlParser.NOREPLAY:
+            case PlSqlParser.NORESETLOGS:
+            case PlSqlParser.NO_RESULT_CACHE:
+            case PlSqlParser.NOREVERSE:
+            case PlSqlParser.NO_REWRITE:
+            case PlSqlParser.NOREWRITE:
+            case PlSqlParser.NORMAL:
+            case PlSqlParser.NO_ROOT_SW_FOR_LOCAL:
+            case PlSqlParser.NOROWDEPENDENCIES:
+            case PlSqlParser.NOSCHEMACHECK:
+            case PlSqlParser.NOSEGMENT:
+            case PlSqlParser.NO_SEMIJOIN:
+            case PlSqlParser.NO_SEMI_TO_INNER:
+            case PlSqlParser.NO_SET_TO_JOIN:
+            case PlSqlParser.NOSORT:
+            case PlSqlParser.NO_SQL_TRANSLATION:
+            case PlSqlParser.NO_SQL_TUNE:
+            case PlSqlParser.NO_STAR_TRANSFORMATION:
+            case PlSqlParser.NO_STATEMENT_QUEUING:
+            case PlSqlParser.NO_STATS_GSETS:
+            case PlSqlParser.NOSTRICT:
+            case PlSqlParser.NO_SUBQUERY_PRUNING:
+            case PlSqlParser.NO_SUBSTRB_PAD:
+            case PlSqlParser.NO_SWAP_JOIN_INPUTS:
+            case PlSqlParser.NOSWITCH:
+            case PlSqlParser.NO_TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.NO_TEMP_TABLE:
+            case PlSqlParser.NOTHING:
+            case PlSqlParser.NOTIFICATION:
+            case PlSqlParser.NO_TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.NO_UNNEST:
+            case PlSqlParser.NO_USE_CUBE:
+            case PlSqlParser.NO_USE_HASH_AGGREGATION:
+            case PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.NO_USE_HASH:
+            case PlSqlParser.NO_USE_INVISIBLE_INDEXES:
+            case PlSqlParser.NO_USE_MERGE:
+            case PlSqlParser.NO_USE_NL:
+            case PlSqlParser.NO_USE_VECTOR_AGGREGATION:
+            case PlSqlParser.NOVALIDATE:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.NO_VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.NO_VECTOR_TRANSFORM:
+            case PlSqlParser.NO_XDB_FASTPATH_INSERT:
+            case PlSqlParser.NO_XML_DML_REWRITE:
+            case PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.NO_XMLINDEX_REWRITE:
+            case PlSqlParser.NO_XML_QUERY_REWRITE:
+            case PlSqlParser.NO_ZONEMAP:
+            case PlSqlParser.NTH_VALUE:
+            case PlSqlParser.NULLIF:
+            case PlSqlParser.NULLS:
+            case PlSqlParser.NUMBER:
+            case PlSqlParser.NUMERIC:
+            case PlSqlParser.NUM_INDEX_KEYS:
+            case PlSqlParser.NUMTODSINTERVAL:
+            case PlSqlParser.NUMTOYMINTERVAL:
+            case PlSqlParser.NVARCHAR2:
+            case PlSqlParser.NVL2:
+            case PlSqlParser.OBJECT2XML:
+            case PlSqlParser.OBJECT:
+            case PlSqlParser.OBJ_ID:
+            case PlSqlParser.OBJNO:
+            case PlSqlParser.OBJNO_REUSE:
+            case PlSqlParser.OCCURENCES:
+            case PlSqlParser.OFFLINE:
+            case PlSqlParser.OFF:
+            case PlSqlParser.OFFSET:
+            case PlSqlParser.OIDINDEX:
+            case PlSqlParser.OID:
+            case PlSqlParser.OLAP:
+            case PlSqlParser.OLD:
+            case PlSqlParser.OLD_PUSH_PRED:
+            case PlSqlParser.OLS:
+            case PlSqlParser.OLTP:
+            case PlSqlParser.OMIT:
+            case PlSqlParser.ONE:
+            case PlSqlParser.ONLINE:
+            case PlSqlParser.ONLY:
+            case PlSqlParser.OPAQUE:
+            case PlSqlParser.OPAQUE_TRANSFORM:
+            case PlSqlParser.OPAQUE_XCANONICAL:
+            case PlSqlParser.OPCODE:
+            case PlSqlParser.OPEN:
+            case PlSqlParser.OPERATIONS:
+            case PlSqlParser.OPERATOR:
+            case PlSqlParser.OPT_ESTIMATE:
+            case PlSqlParser.OPTIMAL:
+            case PlSqlParser.OPTIMIZE:
+            case PlSqlParser.OPTIMIZER_FEATURES_ENABLE:
+            case PlSqlParser.OPTIMIZER_GOAL:
+            case PlSqlParser.OPT_PARAM:
+            case PlSqlParser.ORA_BRANCH:
+            case PlSqlParser.ORA_CHECK_ACL:
+            case PlSqlParser.ORA_CHECK_PRIVILEGE:
+            case PlSqlParser.ORA_CLUSTERING:
+            case PlSqlParser.ORADATA:
+            case PlSqlParser.ORC:
+            case PlSqlParser.ORADEBUG:
+            case PlSqlParser.ORA_DST_AFFECTED:
+            case PlSqlParser.ORA_DST_CONVERT:
+            case PlSqlParser.ORA_DST_ERROR:
+            case PlSqlParser.ORA_GET_ACLIDS:
+            case PlSqlParser.ORA_GET_PRIVILEGES:
+            case PlSqlParser.ORA_HASH:
+            case PlSqlParser.ORA_INVOKING_USERID:
+            case PlSqlParser.ORA_INVOKING_USER:
+            case PlSqlParser.ORA_INVOKING_XS_USER_GUID:
+            case PlSqlParser.ORA_INVOKING_XS_USER:
+            case PlSqlParser.ORA_RAWCOMPARE:
+            case PlSqlParser.ORA_RAWCONCAT:
+            case PlSqlParser.ORA_ROWSCN:
+            case PlSqlParser.ORA_ROWSCN_RAW:
+            case PlSqlParser.ORA_ROWVERSION:
+            case PlSqlParser.ORA_TABVERSION:
+            case PlSqlParser.ORA_WRITE_TIME:
+            case PlSqlParser.ORDERED:
+            case PlSqlParser.ORDERED_PREDICATES:
+            case PlSqlParser.ORDINALITY:
+            case PlSqlParser.OR_EXPAND:
+            case PlSqlParser.ORGANIZATION:
+            case PlSqlParser.OR_PREDICATES:
+            case PlSqlParser.OSERROR:
+            case PlSqlParser.OTHER:
+            case PlSqlParser.OUTER_JOIN_TO_ANTI:
+            case PlSqlParser.OUTER_JOIN_TO_INNER:
+            case PlSqlParser.OUTER:
+            case PlSqlParser.OUTLINE_LEAF:
+            case PlSqlParser.OUTLINE:
+            case PlSqlParser.OUT_OF_LINE:
+            case PlSqlParser.OUT:
+            case PlSqlParser.OVERFLOW_NOMOVE:
+            case PlSqlParser.OVERFLOW_:
+            case PlSqlParser.OVERLAPS:
+            case PlSqlParser.OVER:
+            case PlSqlParser.OVERRIDE:
+            case PlSqlParser.OVERRIDING:
+            case PlSqlParser.OWNER:
+            case PlSqlParser.OWNERSHIP:
+            case PlSqlParser.OWN:
+            case PlSqlParser.P_LETTER:
+            case PlSqlParser.PACKAGE:
+            case PlSqlParser.PACKAGES:
+            case PlSqlParser.PARALLEL_ENABLE:
+            case PlSqlParser.PARALLEL_INDEX:
+            case PlSqlParser.PARALLEL:
+            case PlSqlParser.PARAMETERS:
+            case PlSqlParser.PARAM:
+            case PlSqlParser.PARENT:
+            case PlSqlParser.PARENT_LEVEL_NAME:
+            case PlSqlParser.PARENT_UNIQUE_NAME:
+            case PlSqlParser.PARITY:
+            case PlSqlParser.PARTIAL_JOIN:
+            case PlSqlParser.PARTIALLY:
+            case PlSqlParser.PARTIAL:
+            case PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN:
+            case PlSqlParser.PARTITION_HASH:
+            case PlSqlParser.PARTITION_LIST:
+            case PlSqlParser.PARTITION:
+            case PlSqlParser.PARTITION_RANGE:
+            case PlSqlParser.PARTITIONS:
+            case PlSqlParser.PARTNUMINST:
+            case PlSqlParser.PASSING:
+            case PlSqlParser.PASSWORD_GRACE_TIME:
+            case PlSqlParser.PASSWORD_LIFE_TIME:
+            case PlSqlParser.PASSWORD_LOCK_TIME:
+            case PlSqlParser.PASSWORD:
+            case PlSqlParser.PASSWORD_REUSE_MAX:
+            case PlSqlParser.PASSWORD_REUSE_TIME:
+            case PlSqlParser.PASSWORD_ROLLOVER_TIME:
+            case PlSqlParser.PASSWORD_VERIFY_FUNCTION:
+            case PlSqlParser.PAST:
+            case PlSqlParser.PATCH:
+            case PlSqlParser.PATH:
+            case PlSqlParser.PATH_PREFIX:
+            case PlSqlParser.PATHS:
+            case PlSqlParser.PATTERN:
+            case PlSqlParser.PBL_HS_BEGIN:
+            case PlSqlParser.PBL_HS_END:
+            case PlSqlParser.PCTINCREASE:
+            case PlSqlParser.PCTTHRESHOLD:
+            case PlSqlParser.PCTUSED:
+            case PlSqlParser.PCTVERSION:
+            case PlSqlParser.PENDING:
+            case PlSqlParser.PERCENT_KEYWORD:
+            case PlSqlParser.PERCENT_RANKM:
+            case PlSqlParser.PERFORMANCE:
+            case PlSqlParser.PERIOD_KEYWORD:
+            case PlSqlParser.PERMANENT:
+            case PlSqlParser.PERMISSION:
+            case PlSqlParser.PERMUTE:
+            case PlSqlParser.PER:
+            case PlSqlParser.PFILE:
+            case PlSqlParser.PHYSICAL:
+            case PlSqlParser.PIKEY:
+            case PlSqlParser.PIPELINED:
+            case PlSqlParser.PIV_GB:
+            case PlSqlParser.PIVOT:
+            case PlSqlParser.PIV_SSF:
+            case PlSqlParser.PLACE_DISTINCT:
+            case PlSqlParser.PLACE_GROUP_BY:
+            case PlSqlParser.PLAN:
+            case PlSqlParser.PLSCOPE_SETTINGS:
+            case PlSqlParser.PLS_INTEGER:
+            case PlSqlParser.PLSQL_CCFLAGS:
+            case PlSqlParser.PLSQL_CODE_TYPE:
+            case PlSqlParser.PLSQL_DEBUG:
+            case PlSqlParser.PLSQL_OPTIMIZE_LEVEL:
+            case PlSqlParser.PLSQL_WARNINGS:
+            case PlSqlParser.PLUGGABLE:
+            case PlSqlParser.PMEM:
+            case PlSqlParser.POINT:
+            case PlSqlParser.POLICY:
+            case PlSqlParser.POOL_16K:
+            case PlSqlParser.POOL_2K:
+            case PlSqlParser.POOL_32K:
+            case PlSqlParser.POOL_4K:
+            case PlSqlParser.POOL_8K:
+            case PlSqlParser.POSITION:
+            case PlSqlParser.POSITIVEN:
+            case PlSqlParser.POSITIVE:
+            case PlSqlParser.POST_TRANSACTION:
+            case PlSqlParser.POWERMULTISET_BY_CARDINALITY:
+            case PlSqlParser.POWERMULTISET:
+            case PlSqlParser.POWER:
+            case PlSqlParser.PQ_CONCURRENT_UNION:
+            case PlSqlParser.PQ_DISTRIBUTE:
+            case PlSqlParser.PQ_DISTRIBUTE_WINDOW:
+            case PlSqlParser.PQ_FILTER:
+            case PlSqlParser.PQ_MAP:
+            case PlSqlParser.PQ_NOMAP:
+            case PlSqlParser.PQ_REPLICATE:
+            case PlSqlParser.PQ_SKEW:
+            case PlSqlParser.PRAGMA:
+            case PlSqlParser.PREBUILT:
+            case PlSqlParser.PRECEDES:
+            case PlSqlParser.PRECEDING:
+            case PlSqlParser.PRECISION:
+            case PlSqlParser.PRECOMPUTE_SUBQUERY:
+            case PlSqlParser.PREDICATE_REORDERS:
+            case PlSqlParser.PRELOAD:
+            case PlSqlParser.PREPARE:
+            case PlSqlParser.PRESENTNNV:
+            case PlSqlParser.PRESENT:
+            case PlSqlParser.PRESENTV:
+            case PlSqlParser.PRESERVE_OID:
+            case PlSqlParser.PRESERVE:
+            case PlSqlParser.PRETTY:
+            case PlSqlParser.PREVIOUS:
+            case PlSqlParser.PREV:
+            case PlSqlParser.PRIMARY:
+            case PlSqlParser.PRINTBLOBTOCLOB:
+            case PlSqlParser.PRIORITY:
+            case PlSqlParser.PRIVATE:
+            case PlSqlParser.PRIVATE_SGA:
+            case PlSqlParser.PRIVILEGED:
+            case PlSqlParser.PRIVILEGE:
+            case PlSqlParser.PRIVILEGES:
+            case PlSqlParser.PROCEDURAL:
+            case PlSqlParser.PROCEDURE:
+            case PlSqlParser.PROCESS:
+            case PlSqlParser.PROFILE:
+            case PlSqlParser.PROGRAM:
+            case PlSqlParser.PROJECT:
+            case PlSqlParser.PROPAGATE:
+            case PlSqlParser.PROPERTY:
+            case PlSqlParser.PROTECTED:
+            case PlSqlParser.PROTECTION:
+            case PlSqlParser.PROTOCOL:
+            case PlSqlParser.PROXY:
+            case PlSqlParser.PRUNING:
+            case PlSqlParser.PUBLIC:
+            case PlSqlParser.PULL_PRED:
+            case PlSqlParser.PURGE:
+            case PlSqlParser.PUSH_PRED:
+            case PlSqlParser.PUSH_SUBQ:
+            case PlSqlParser.PX_FAULT_TOLERANCE:
+            case PlSqlParser.PX_GRANULE:
+            case PlSqlParser.PX_JOIN_FILTER:
+            case PlSqlParser.QB_NAME:
+            case PlSqlParser.QUARTERS:
+            case PlSqlParser.QUERY_BLOCK:
+            case PlSqlParser.QUERY:
+            case PlSqlParser.QUEUE_CURR:
+            case PlSqlParser.QUEUE:
+            case PlSqlParser.QUEUE_ROWP:
+            case PlSqlParser.QUIESCE:
+            case PlSqlParser.QUORUM:
+            case PlSqlParser.QUOTA:
+            case PlSqlParser.QUOTAGROUP:
+            case PlSqlParser.RAISE:
+            case PlSqlParser.RANDOM_LOCAL:
+            case PlSqlParser.RANDOM:
+            case PlSqlParser.RANGE:
+            case PlSqlParser.RANKM:
+            case PlSqlParser.RAPIDLY:
+            case PlSqlParser.RAW:
+            case PlSqlParser.RAWTOHEX:
+            case PlSqlParser.RAWTONHEX:
+            case PlSqlParser.RBA:
+            case PlSqlParser.RBO_OUTLINE:
+            case PlSqlParser.RDBA:
+            case PlSqlParser.READ:
+            case PlSqlParser.READS:
+            case PlSqlParser.REALM:
+            case PlSqlParser.REAL:
+            case PlSqlParser.REBALANCE:
+            case PlSqlParser.REBUILD:
+            case PlSqlParser.RECORD:
+            case PlSqlParser.RECORDS:
+            case PlSqlParser.RECORDS_PER_BLOCK:
+            case PlSqlParser.RECOVERABLE:
+            case PlSqlParser.RECOVER:
+            case PlSqlParser.RECOVERY:
+            case PlSqlParser.RECYCLEBIN:
+            case PlSqlParser.RECYCLE:
+            case PlSqlParser.REDACTION:
+            case PlSqlParser.REDEFINE:
+            case PlSqlParser.REDO:
+            case PlSqlParser.REDUCED:
+            case PlSqlParser.REDUNDANCY:
+            case PlSqlParser.REF_CASCADE_CURSOR:
+            case PlSqlParser.REFERENCED:
+            case PlSqlParser.REFERENCE:
+            case PlSqlParser.REFERENCES:
+            case PlSqlParser.REFERENCING:
+            case PlSqlParser.REF:
+            case PlSqlParser.REFRESH:
+            case PlSqlParser.REFTOHEX:
+            case PlSqlParser.REGEXP_COUNT:
+            case PlSqlParser.REGEXP_INSTR:
+            case PlSqlParser.REGEXP_LIKE:
+            case PlSqlParser.REGEXP_REPLACE:
+            case PlSqlParser.REGEXP_SUBSTR:
+            case PlSqlParser.REGISTER:
+            case PlSqlParser.REGR_AVGX:
+            case PlSqlParser.REGR_AVGY:
+            case PlSqlParser.REGR_COUNT:
+            case PlSqlParser.REGR_INTERCEPT:
+            case PlSqlParser.REGR_R2:
+            case PlSqlParser.REGR_SLOPE:
+            case PlSqlParser.REGR_SXX:
+            case PlSqlParser.REGR_SXY:
+            case PlSqlParser.REGR_SYY:
+            case PlSqlParser.REGULAR:
+            case PlSqlParser.REJECT:
+            case PlSqlParser.REKEY:
+            case PlSqlParser.RELATIONAL:
+            case PlSqlParser.RELOCATE:
+            case PlSqlParser.RELY:
+            case PlSqlParser.REMAINDER:
+            case PlSqlParser.REMOTE:
+            case PlSqlParser.REMOTE_MAPPED:
+            case PlSqlParser.REMOVE:
+            case PlSqlParser.RENAME:
+            case PlSqlParser.REPAIR:
+            case PlSqlParser.REPEAT:
+            case PlSqlParser.REPLACE:
+            case PlSqlParser.REPLICATION:
+            case PlSqlParser.REQUIRED:
+            case PlSqlParser.RESETLOGS:
+            case PlSqlParser.RESET:
+            case PlSqlParser.RESIZE:
+            case PlSqlParser.RESOLVE:
+            case PlSqlParser.RESOLVER:
+            case PlSqlParser.RESPECT:
+            case PlSqlParser.RESTART:
+            case PlSqlParser.RESTORE_AS_INTERVALS:
+            case PlSqlParser.RESTORE:
+            case PlSqlParser.RESTRICT_ALL_REF_CONS:
+            case PlSqlParser.RESTRICTED:
+            case PlSqlParser.RESTRICT_REFERENCES:
+            case PlSqlParser.RESTRICT:
+            case PlSqlParser.RESULT_CACHE:
+            case PlSqlParser.RESULT:
+            case PlSqlParser.RESUMABLE:
+            case PlSqlParser.RESUME:
+            case PlSqlParser.RETENTION:
+            case PlSqlParser.RETRY_ON_ROW_CHANGE:
+            case PlSqlParser.RETURNING:
+            case PlSqlParser.RETURN:
+            case PlSqlParser.REUSE:
+            case PlSqlParser.REVERSE:
+            case PlSqlParser.REWRITE_OR_ERROR:
+            case PlSqlParser.REWRITE:
+            case PlSqlParser.RIGHT:
+            case PlSqlParser.ROLE:
+            case PlSqlParser.ROLESET:
+            case PlSqlParser.ROLES:
+            case PlSqlParser.ROLLBACK:
+            case PlSqlParser.ROLLING:
+            case PlSqlParser.ROLLUP:
+            case PlSqlParser.ROWDEPENDENCIES:
+            case PlSqlParser.ROWID_MAPPING_TABLE:
+            case PlSqlParser.ROWID:
+            case PlSqlParser.ROWIDTOCHAR:
+            case PlSqlParser.ROWIDTONCHAR:
+            case PlSqlParser.ROW_LENGTH:
+            case PlSqlParser.ROWNUM:
+            case PlSqlParser.ROW:
+            case PlSqlParser.ROWS:
+            case PlSqlParser.RPAD:
+            case PlSqlParser.RTRIM:
+            case PlSqlParser.RULE:
+            case PlSqlParser.RULES:
+            case PlSqlParser.RUNNING:
+            case PlSqlParser.SALT:
+            case PlSqlParser.SAMPLE:
+            case PlSqlParser.SAVE_AS_INTERVALS:
+            case PlSqlParser.SAVEPOINT:
+            case PlSqlParser.SAVE:
+            case PlSqlParser.SB4:
+            case PlSqlParser.SCALE_ROWS:
+            case PlSqlParser.SCALE:
+            case PlSqlParser.SCAN_INSTANCES:
+            case PlSqlParser.SCAN:
+            case PlSqlParser.SCHEDULER:
+            case PlSqlParser.SCHEMACHECK:
+            case PlSqlParser.SCHEMA:
+            case PlSqlParser.SCN_ASCENDING:
+            case PlSqlParser.SCN:
+            case PlSqlParser.SCOPE:
+            case PlSqlParser.SCRUB:
+            case PlSqlParser.SD_ALL:
+            case PlSqlParser.SD_INHIBIT:
+            case PlSqlParser.SDO_GEOM_MBR:
+            case PlSqlParser.SDO_GEOMETRY:
+            case PlSqlParser.SD_SHOW:
+            case PlSqlParser.SEARCH:
+            case PlSqlParser.SECOND:
+            case PlSqlParser.SECONDS:
+            case PlSqlParser.SECRET:
+            case PlSqlParser.SECUREFILE_DBA:
+            case PlSqlParser.SECUREFILE:
+            case PlSqlParser.SECURITY:
+            case PlSqlParser.SEED:
+            case PlSqlParser.SEG_BLOCK:
+            case PlSqlParser.SEG_FILE:
+            case PlSqlParser.SEGMENT:
+            case PlSqlParser.SELECTIVITY:
+            case PlSqlParser.SELF:
+            case PlSqlParser.SEMIJOIN_DRIVER:
+            case PlSqlParser.SEMIJOIN:
+            case PlSqlParser.SEMI_TO_INNER:
+            case PlSqlParser.SEQUENCED:
+            case PlSqlParser.SEQUENCE:
+            case PlSqlParser.SEQUENTIAL:
+            case PlSqlParser.SEQ:
+            case PlSqlParser.SERIALIZABLE:
+            case PlSqlParser.SERIALLY_REUSABLE:
+            case PlSqlParser.SERIAL:
+            case PlSqlParser.SERVERERROR:
+            case PlSqlParser.SERVICE_NAME_CONVERT:
+            case PlSqlParser.SERVICE:
+            case PlSqlParser.SERVICES:
+            case PlSqlParser.SESSION_CACHED_CURSORS:
+            case PlSqlParser.SESSION:
+            case PlSqlParser.SESSIONS_PER_USER:
+            case PlSqlParser.SESSIONTIMEZONE:
+            case PlSqlParser.SESSIONTZNAME:
+            case PlSqlParser.SET:
+            case PlSqlParser.SETS:
+            case PlSqlParser.SETTINGS:
+            case PlSqlParser.SET_TO_JOIN:
+            case PlSqlParser.SEVERE:
+            case PlSqlParser.SHARDSPACE:
+            case PlSqlParser.SHARED_POOL:
+            case PlSqlParser.SHARED:
+            case PlSqlParser.SHARING:
+            case PlSqlParser.SHELFLIFE:
+            case PlSqlParser.SHOW:
+            case PlSqlParser.SHRINK:
+            case PlSqlParser.SHUTDOWN:
+            case PlSqlParser.SIBLINGS:
+            case PlSqlParser.SID:
+            case PlSqlParser.SITE:
+            case PlSqlParser.SIGNAL_COMPONENT:
+            case PlSqlParser.SIGNAL_FUNCTION:
+            case PlSqlParser.SIGN:
+            case PlSqlParser.SIGNTYPE:
+            case PlSqlParser.SIMPLE_INTEGER:
+            case PlSqlParser.SIMPLE:
+            case PlSqlParser.SINGLE:
+            case PlSqlParser.SINGLETASK:
+            case PlSqlParser.SINH:
+            case PlSqlParser.SIN:
+            case PlSqlParser.SKIP_EXT_OPTIMIZER:
+            case PlSqlParser.SKIP_:
+            case PlSqlParser.SKIP_UNQ_UNUSABLE_IDX:
+            case PlSqlParser.SKIP_UNUSABLE_INDEXES:
+            case PlSqlParser.SMALLFILE:
+            case PlSqlParser.SMALLINT:
+            case PlSqlParser.SNAPSHOT:
+            case PlSqlParser.SOME:
+            case PlSqlParser.SORT:
+            case PlSqlParser.SOUNDEX:
+            case PlSqlParser.SOURCE_FILE_DIRECTORY:
+            case PlSqlParser.SOURCE_FILE_NAME_CONVERT:
+            case PlSqlParser.SOURCE:
+            case PlSqlParser.SPACE_KEYWORD:
+            case PlSqlParser.SPECIFICATION:
+            case PlSqlParser.SPFILE:
+            case PlSqlParser.SPLIT:
+            case PlSqlParser.SPREADSHEET:
+            case PlSqlParser.SQLDATA:
+            case PlSqlParser.SQLERROR:
+            case PlSqlParser.SQLLDR:
+            case PlSqlParser.SQL:
+            case PlSqlParser.FILE_EXT:
+            case PlSqlParser.SQL_MACRO:
+            case PlSqlParser.SQL_TRACE:
+            case PlSqlParser.SQL_TRANSLATION_PROFILE:
+            case PlSqlParser.SQRT:
+            case PlSqlParser.STALE:
+            case PlSqlParser.STANDALONE:
+            case PlSqlParser.STANDARD:
+            case PlSqlParser.STANDARD_HASH:
+            case PlSqlParser.STANDBY_MAX_DATA_DELAY:
+            case PlSqlParser.STANDBYS:
+            case PlSqlParser.STANDBY:
+            case PlSqlParser.STAR:
+            case PlSqlParser.STAR_TRANSFORMATION:
+            case PlSqlParser.STARTUP:
+            case PlSqlParser.STATEMENT_ID:
+            case PlSqlParser.STATEMENT_QUEUING:
+            case PlSqlParser.STATEMENTS:
+            case PlSqlParser.STATEMENT:
+            case PlSqlParser.STATE:
+            case PlSqlParser.STATIC:
+            case PlSqlParser.STATISTICS:
+            case PlSqlParser.STATS_BINOMIAL_TEST:
+            case PlSqlParser.STATS_CROSSTAB:
+            case PlSqlParser.STATS_F_TEST:
+            case PlSqlParser.STATS_KS_TEST:
+            case PlSqlParser.STATS_MODE:
+            case PlSqlParser.STATS_MW_TEST:
+            case PlSqlParser.STATS_ONE_WAY_ANOVA:
+            case PlSqlParser.STATS_T_TEST_INDEP:
+            case PlSqlParser.STATS_T_TEST_INDEPU:
+            case PlSqlParser.STATS_T_TEST_ONE:
+            case PlSqlParser.STATS_T_TEST_PAIRED:
+            case PlSqlParser.STATS_WSR_TEST:
+            case PlSqlParser.STDDEV_POP:
+            case PlSqlParser.STDDEV_SAMP:
+            case PlSqlParser.STOP:
+            case PlSqlParser.STORAGE:
+            case PlSqlParser.STORE:
+            case PlSqlParser.STREAMS:
+            case PlSqlParser.STREAM:
+            case PlSqlParser.STRICT:
+            case PlSqlParser.STRING:
+            case PlSqlParser.STRIPE_COLUMNS:
+            case PlSqlParser.STRIPE_WIDTH:
+            case PlSqlParser.STRIP:
+            case PlSqlParser.STRUCTURE:
+            case PlSqlParser.SUBMULTISET:
+            case PlSqlParser.SUBPARTITION_REL:
+            case PlSqlParser.SUBPARTITIONS:
+            case PlSqlParser.SUBPARTITION:
+            case PlSqlParser.SUBQUERIES:
+            case PlSqlParser.SUBQUERY_PRUNING:
+            case PlSqlParser.SUBSCRIBE:
+            case PlSqlParser.SUBSET:
+            case PlSqlParser.SUBSTITUTABLE:
+            case PlSqlParser.SUBSTR2:
+            case PlSqlParser.SUBSTR4:
+            case PlSqlParser.SUBSTRB:
+            case PlSqlParser.SUBSTRC:
+            case PlSqlParser.SUBTYPE:
+            case PlSqlParser.SUCCESSFUL:
+            case PlSqlParser.SUCCESS:
+            case PlSqlParser.SUMMARY:
+            case PlSqlParser.SUPPLEMENTAL:
+            case PlSqlParser.SUSPEND:
+            case PlSqlParser.SWAP_JOIN_INPUTS:
+            case PlSqlParser.SWITCHOVER:
+            case PlSqlParser.SWITCH:
+            case PlSqlParser.SYNCHRONOUS:
+            case PlSqlParser.SYNC:
+            case PlSqlParser.SYS:
+            case PlSqlParser.SYSASM:
+            case PlSqlParser.SYS_AUDIT:
+            case PlSqlParser.SYSAUX:
+            case PlSqlParser.SYSBACKUP:
+            case PlSqlParser.SYS_CHECKACL:
+            case PlSqlParser.SYS_CHECK_PRIVILEGE:
+            case PlSqlParser.SYS_CONNECT_BY_PATH:
+            case PlSqlParser.SYS_CONTEXT:
+            case PlSqlParser.SYSDATE:
+            case PlSqlParser.SYSDBA:
+            case PlSqlParser.SYS_DBURIGEN:
+            case PlSqlParser.SYSDG:
+            case PlSqlParser.SYS_DL_CURSOR:
+            case PlSqlParser.SYS_DM_RXFORM_CHR:
+            case PlSqlParser.SYS_DM_RXFORM_NUM:
+            case PlSqlParser.SYS_DOM_COMPARE:
+            case PlSqlParser.SYS_DST_PRIM2SEC:
+            case PlSqlParser.SYS_DST_SEC2PRIM:
+            case PlSqlParser.SYS_ET_BFILE_TO_RAW:
+            case PlSqlParser.SYS_ET_BLOB_TO_IMAGE:
+            case PlSqlParser.SYS_ET_IMAGE_TO_BLOB:
+            case PlSqlParser.SYS_ET_RAW_TO_BFILE:
+            case PlSqlParser.SYS_EXTPDTXT:
+            case PlSqlParser.SYS_EXTRACT_UTC:
+            case PlSqlParser.SYS_FBT_INSDEL:
+            case PlSqlParser.SYS_FILTER_ACLS:
+            case PlSqlParser.SYS_FNMATCHES:
+            case PlSqlParser.SYS_FNREPLACE:
+            case PlSqlParser.SYS_GET_ACLIDS:
+            case PlSqlParser.SYS_GET_COL_ACLIDS:
+            case PlSqlParser.SYS_GET_PRIVILEGES:
+            case PlSqlParser.SYS_GETTOKENID:
+            case PlSqlParser.SYS_GETXTIVAL:
+            case PlSqlParser.SYS_GUID:
+            case PlSqlParser.SYSGUID:
+            case PlSqlParser.SYSKM:
+            case PlSqlParser.SYS_MAKE_XMLNODEID:
+            case PlSqlParser.SYS_MAKEXML:
+            case PlSqlParser.SYS_MKXMLATTR:
+            case PlSqlParser.SYS_MKXTI:
+            case PlSqlParser.SYSOBJ:
+            case PlSqlParser.SYS_OP_ADT2BIN:
+            case PlSqlParser.SYS_OP_ADTCONS:
+            case PlSqlParser.SYS_OP_ALSCRVAL:
+            case PlSqlParser.SYS_OP_ATG:
+            case PlSqlParser.SYS_OP_BIN2ADT:
+            case PlSqlParser.SYS_OP_BITVEC:
+            case PlSqlParser.SYS_OP_BL2R:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER_LIST:
+            case PlSqlParser.SYS_OP_BLOOM_FILTER:
+            case PlSqlParser.SYS_OP_C2C:
+            case PlSqlParser.SYS_OP_CAST:
+            case PlSqlParser.SYS_OP_CEG:
+            case PlSqlParser.SYS_OP_CL2C:
+            case PlSqlParser.SYS_OP_COMBINED_HASH:
+            case PlSqlParser.SYS_OP_COMP:
+            case PlSqlParser.SYS_OP_CONVERT:
+            case PlSqlParser.SYS_OP_COUNTCHG:
+            case PlSqlParser.SYS_OP_CSCONV:
+            case PlSqlParser.SYS_OP_CSCONVTEST:
+            case PlSqlParser.SYS_OP_CSR:
+            case PlSqlParser.SYS_OP_CSX_PATCH:
+            case PlSqlParser.SYS_OP_CYCLED_SEQ:
+            case PlSqlParser.SYS_OP_DECOMP:
+            case PlSqlParser.SYS_OP_DESCEND:
+            case PlSqlParser.SYS_OP_DISTINCT:
+            case PlSqlParser.SYS_OP_DRA:
+            case PlSqlParser.SYS_OP_DUMP:
+            case PlSqlParser.SYS_OP_DV_CHECK:
+            case PlSqlParser.SYS_OP_ENFORCE_NOT_NULL:
+            case PlSqlParser.SYSOPER:
+            case PlSqlParser.SYS_OP_EXTRACT:
+            case PlSqlParser.SYS_OP_GROUPING:
+            case PlSqlParser.SYS_OP_GUID:
+            case PlSqlParser.SYS_OP_HASH:
+            case PlSqlParser.SYS_OP_IIX:
+            case PlSqlParser.SYS_OP_ITR:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_CREATE:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_FILTER:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED:
+            case PlSqlParser.SYS_OP_KEY_VECTOR_USE:
+            case PlSqlParser.SYS_OP_LBID:
+            case PlSqlParser.SYS_OP_LOBLOC2BLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2CLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2ID:
+            case PlSqlParser.SYS_OP_LOBLOC2NCLOB:
+            case PlSqlParser.SYS_OP_LOBLOC2TYP:
+            case PlSqlParser.SYS_OP_LSVI:
+            case PlSqlParser.SYS_OP_LVL:
+            case PlSqlParser.SYS_OP_MAKEOID:
+            case PlSqlParser.SYS_OP_MAP_NONNULL:
+            case PlSqlParser.SYS_OP_MSR:
+            case PlSqlParser.SYS_OP_NICOMBINE:
+            case PlSqlParser.SYS_OP_NIEXTRACT:
+            case PlSqlParser.SYS_OP_NII:
+            case PlSqlParser.SYS_OP_NIX:
+            case PlSqlParser.SYS_OP_NOEXPAND:
+            case PlSqlParser.SYS_OP_NTCIMG:
+            case PlSqlParser.SYS_OP_NUMTORAW:
+            case PlSqlParser.SYS_OP_OIDVALUE:
+            case PlSqlParser.SYS_OP_OPNSIZE:
+            case PlSqlParser.SYS_OP_PAR_1:
+            case PlSqlParser.SYS_OP_PARGID_1:
+            case PlSqlParser.SYS_OP_PARGID:
+            case PlSqlParser.SYS_OP_PAR:
+            case PlSqlParser.SYS_OP_PART_ID:
+            case PlSqlParser.SYS_OP_PIVOT:
+            case PlSqlParser.SYS_OP_R2O:
+            case PlSqlParser.SYS_OP_RAWTONUM:
+            case PlSqlParser.SYS_OP_RDTM:
+            case PlSqlParser.SYS_OP_REF:
+            case PlSqlParser.SYS_OP_RMTD:
+            case PlSqlParser.SYS_OP_ROWIDTOOBJ:
+            case PlSqlParser.SYS_OP_RPB:
+            case PlSqlParser.SYS_OPTLOBPRBSC:
+            case PlSqlParser.SYS_OP_TOSETID:
+            case PlSqlParser.SYS_OP_TPR:
+            case PlSqlParser.SYS_OP_TRTB:
+            case PlSqlParser.SYS_OPTXICMP:
+            case PlSqlParser.SYS_OPTXQCASTASNQ:
+            case PlSqlParser.SYS_OP_UNDESCEND:
+            case PlSqlParser.SYS_OP_VECAND:
+            case PlSqlParser.SYS_OP_VECBIT:
+            case PlSqlParser.SYS_OP_VECOR:
+            case PlSqlParser.SYS_OP_VECXOR:
+            case PlSqlParser.SYS_OP_VERSION:
+            case PlSqlParser.SYS_OP_VREF:
+            case PlSqlParser.SYS_OP_VVD:
+            case PlSqlParser.SYS_OP_XMLCONS_FOR_CSX:
+            case PlSqlParser.SYS_OP_XPTHATG:
+            case PlSqlParser.SYS_OP_XPTHIDX:
+            case PlSqlParser.SYS_OP_XPTHOP:
+            case PlSqlParser.SYS_OP_XTXT2SQLT:
+            case PlSqlParser.SYS_OP_ZONE_ID:
+            case PlSqlParser.SYS_ORDERKEY_DEPTH:
+            case PlSqlParser.SYS_ORDERKEY_MAXCHILD:
+            case PlSqlParser.SYS_ORDERKEY_PARENT:
+            case PlSqlParser.SYS_PARALLEL_TXN:
+            case PlSqlParser.SYS_PATHID_IS_ATTR:
+            case PlSqlParser.SYS_PATHID_IS_NMSPC:
+            case PlSqlParser.SYS_PATHID_LASTNAME:
+            case PlSqlParser.SYS_PATHID_LASTNMSPC:
+            case PlSqlParser.SYS_PATH_REVERSE:
+            case PlSqlParser.SYS_PXQEXTRACT:
+            case PlSqlParser.SYS_RAW_TO_XSID:
+            case PlSqlParser.SYS_RID_ORDER:
+            case PlSqlParser.SYS_ROW_DELTA:
+            case PlSqlParser.SYS_SC_2_XMLT:
+            case PlSqlParser.SYS_SYNRCIREDO:
+            case PlSqlParser.SYSTEM_DEFINED:
+            case PlSqlParser.SYSTEM:
+            case PlSqlParser.SYSTIMESTAMP:
+            case PlSqlParser.SYS_TYPEID:
+            case PlSqlParser.SYS_UMAKEXML:
+            case PlSqlParser.SYS_XMLANALYZE:
+            case PlSqlParser.SYS_XMLCONTAINS:
+            case PlSqlParser.SYS_XMLCONV:
+            case PlSqlParser.SYS_XMLEXNSURI:
+            case PlSqlParser.SYS_XMLGEN:
+            case PlSqlParser.SYS_XMLI_LOC_ISNODE:
+            case PlSqlParser.SYS_XMLI_LOC_ISTEXT:
+            case PlSqlParser.SYS_XMLINSTR:
+            case PlSqlParser.SYS_XMLLOCATOR_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETCID:
+            case PlSqlParser.SYS_XMLNODEID_GETLOCATOR:
+            case PlSqlParser.SYS_XMLNODEID_GETOKEY:
+            case PlSqlParser.SYS_XMLNODEID_GETPATHID:
+            case PlSqlParser.SYS_XMLNODEID_GETPTRID:
+            case PlSqlParser.SYS_XMLNODEID_GETRID:
+            case PlSqlParser.SYS_XMLNODEID_GETSVAL:
+            case PlSqlParser.SYS_XMLNODEID_GETTID:
+            case PlSqlParser.SYS_XMLNODEID:
+            case PlSqlParser.SYS_XMLT_2_SC:
+            case PlSqlParser.SYS_XMLTRANSLATE:
+            case PlSqlParser.SYS_XMLTYPE2SQL:
+            case PlSqlParser.SYS_XQ_ASQLCNV:
+            case PlSqlParser.SYS_XQ_ATOMCNVCHK:
+            case PlSqlParser.SYS_XQBASEURI:
+            case PlSqlParser.SYS_XQCASTABLEERRH:
+            case PlSqlParser.SYS_XQCODEP2STR:
+            case PlSqlParser.SYS_XQCODEPEQ:
+            case PlSqlParser.SYS_XQCON2SEQ:
+            case PlSqlParser.SYS_XQCONCAT:
+            case PlSqlParser.SYS_XQDELETE:
+            case PlSqlParser.SYS_XQDFLTCOLATION:
+            case PlSqlParser.SYS_XQDOC:
+            case PlSqlParser.SYS_XQDOCURI:
+            case PlSqlParser.SYS_XQDURDIV:
+            case PlSqlParser.SYS_XQED4URI:
+            case PlSqlParser.SYS_XQENDSWITH:
+            case PlSqlParser.SYS_XQERRH:
+            case PlSqlParser.SYS_XQERR:
+            case PlSqlParser.SYS_XQESHTMLURI:
+            case PlSqlParser.SYS_XQEXLOBVAL:
+            case PlSqlParser.SYS_XQEXSTWRP:
+            case PlSqlParser.SYS_XQEXTRACT:
+            case PlSqlParser.SYS_XQEXTRREF:
+            case PlSqlParser.SYS_XQEXVAL:
+            case PlSqlParser.SYS_XQFB2STR:
+            case PlSqlParser.SYS_XQFNBOOL:
+            case PlSqlParser.SYS_XQFNCMP:
+            case PlSqlParser.SYS_XQFNDATIM:
+            case PlSqlParser.SYS_XQFNLNAME:
+            case PlSqlParser.SYS_XQFNNM:
+            case PlSqlParser.SYS_XQFNNSURI:
+            case PlSqlParser.SYS_XQFNPREDTRUTH:
+            case PlSqlParser.SYS_XQFNQNM:
+            case PlSqlParser.SYS_XQFNROOT:
+            case PlSqlParser.SYS_XQFORMATNUM:
+            case PlSqlParser.SYS_XQFTCONTAIN:
+            case PlSqlParser.SYS_XQFUNCR:
+            case PlSqlParser.SYS_XQGETCONTENT:
+            case PlSqlParser.SYS_XQINDXOF:
+            case PlSqlParser.SYS_XQINSERT:
+            case PlSqlParser.SYS_XQINSPFX:
+            case PlSqlParser.SYS_XQIRI2URI:
+            case PlSqlParser.SYS_XQLANG:
+            case PlSqlParser.SYS_XQLLNMFRMQNM:
+            case PlSqlParser.SYS_XQMKNODEREF:
+            case PlSqlParser.SYS_XQNILLED:
+            case PlSqlParser.SYS_XQNODENAME:
+            case PlSqlParser.SYS_XQNORMSPACE:
+            case PlSqlParser.SYS_XQNORMUCODE:
+            case PlSqlParser.SYS_XQ_NRNG:
+            case PlSqlParser.SYS_XQNSP4PFX:
+            case PlSqlParser.SYS_XQNSPFRMQNM:
+            case PlSqlParser.SYS_XQPFXFRMQNM:
+            case PlSqlParser.SYS_XQ_PKSQL2XML:
+            case PlSqlParser.SYS_XQPOLYABS:
+            case PlSqlParser.SYS_XQPOLYADD:
+            case PlSqlParser.SYS_XQPOLYCEL:
+            case PlSqlParser.SYS_XQPOLYCSTBL:
+            case PlSqlParser.SYS_XQPOLYCST:
+            case PlSqlParser.SYS_XQPOLYDIV:
+            case PlSqlParser.SYS_XQPOLYFLR:
+            case PlSqlParser.SYS_XQPOLYMOD:
+            case PlSqlParser.SYS_XQPOLYMUL:
+            case PlSqlParser.SYS_XQPOLYRND:
+            case PlSqlParser.SYS_XQPOLYSQRT:
+            case PlSqlParser.SYS_XQPOLYSUB:
+            case PlSqlParser.SYS_XQPOLYUMUS:
+            case PlSqlParser.SYS_XQPOLYUPLS:
+            case PlSqlParser.SYS_XQPOLYVEQ:
+            case PlSqlParser.SYS_XQPOLYVGE:
+            case PlSqlParser.SYS_XQPOLYVGT:
+            case PlSqlParser.SYS_XQPOLYVLE:
+            case PlSqlParser.SYS_XQPOLYVLT:
+            case PlSqlParser.SYS_XQPOLYVNE:
+            case PlSqlParser.SYS_XQREF2VAL:
+            case PlSqlParser.SYS_XQRENAME:
+            case PlSqlParser.SYS_XQREPLACE:
+            case PlSqlParser.SYS_XQRESVURI:
+            case PlSqlParser.SYS_XQRNDHALF2EVN:
+            case PlSqlParser.SYS_XQRSLVQNM:
+            case PlSqlParser.SYS_XQRYENVPGET:
+            case PlSqlParser.SYS_XQRYVARGET:
+            case PlSqlParser.SYS_XQRYWRP:
+            case PlSqlParser.SYS_XQSEQ2CON4XC:
+            case PlSqlParser.SYS_XQSEQ2CON:
+            case PlSqlParser.SYS_XQSEQDEEPEQ:
+            case PlSqlParser.SYS_XQSEQINSB:
+            case PlSqlParser.SYS_XQSEQRM:
+            case PlSqlParser.SYS_XQSEQRVS:
+            case PlSqlParser.SYS_XQSEQSUB:
+            case PlSqlParser.SYS_XQSEQTYPMATCH:
+            case PlSqlParser.SYS_XQSTARTSWITH:
+            case PlSqlParser.SYS_XQSTATBURI:
+            case PlSqlParser.SYS_XQSTR2CODEP:
+            case PlSqlParser.SYS_XQSTRJOIN:
+            case PlSqlParser.SYS_XQSUBSTRAFT:
+            case PlSqlParser.SYS_XQSUBSTRBEF:
+            case PlSqlParser.SYS_XQTOKENIZE:
+            case PlSqlParser.SYS_XQTREATAS:
+            case PlSqlParser.SYS_XQ_UPKXML2SQL:
+            case PlSqlParser.SYS_XQXFORM:
+            case PlSqlParser.SYS_XSID_TO_RAW:
+            case PlSqlParser.SYS_ZMAP_FILTER:
+            case PlSqlParser.SYS_ZMAP_REFRESH:
+            case PlSqlParser.T_LETTER:
+            case PlSqlParser.TABLE_LOOKUP_BY_NL:
+            case PlSqlParser.TABLESPACE_NO:
+            case PlSqlParser.TABLESPACE:
+            case PlSqlParser.TABLES:
+            case PlSqlParser.TABLE_STATS:
+            case PlSqlParser.TABLE:
+            case PlSqlParser.TABNO:
+            case PlSqlParser.TAG:
+            case PlSqlParser.TANH:
+            case PlSqlParser.TAN:
+            case PlSqlParser.TBLORIDXPARTNUM:
+            case PlSqlParser.TEMPFILE:
+            case PlSqlParser.TEMPLATE:
+            case PlSqlParser.TEMPLATE_TABLE:
+            case PlSqlParser.TEMPORARY:
+            case PlSqlParser.TEMP_TABLE:
+            case PlSqlParser.TEST:
+            case PlSqlParser.TEXT:
+            case PlSqlParser.THAN:
+            case PlSqlParser.THEN:
+            case PlSqlParser.THE:
+            case PlSqlParser.THREAD:
+            case PlSqlParser.THROUGH:
+            case PlSqlParser.TIER:
+            case PlSqlParser.TIES:
+            case PlSqlParser.TIMEOUT:
+            case PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP:
+            case PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED:
+            case PlSqlParser.TIMESTAMP_UNCONSTRAINED:
+            case PlSqlParser.TIMES:
+            case PlSqlParser.TIME:
+            case PlSqlParser.TIMEZONE:
+            case PlSqlParser.TIMEZONE_ABBR:
+            case PlSqlParser.TIMEZONE_HOUR:
+            case PlSqlParser.TIMEZONE_MINUTE:
+            case PlSqlParser.TIMEZONE_OFFSET:
+            case PlSqlParser.TIMEZONE_REGION:
+            case PlSqlParser.TIME_ZONE:
+            case PlSqlParser.TIMING:
+            case PlSqlParser.TIV_GB:
+            case PlSqlParser.TIV_SSF:
+            case PlSqlParser.TO_ACLID:
+            case PlSqlParser.TO_BINARY_DOUBLE:
+            case PlSqlParser.TO_BINARY_FLOAT:
+            case PlSqlParser.TO_BLOB:
+            case PlSqlParser.TO_CLOB:
+            case PlSqlParser.TO_DSINTERVAL:
+            case PlSqlParser.TO_LOB:
+            case PlSqlParser.TO_MULTI_BYTE:
+            case PlSqlParser.TO_NCHAR:
+            case PlSqlParser.TO_NCLOB:
+            case PlSqlParser.TO_NUMBER:
+            case PlSqlParser.TOPLEVEL:
+            case PlSqlParser.TO_SINGLE_BYTE:
+            case PlSqlParser.TO_TIMESTAMP:
+            case PlSqlParser.TO_TIMESTAMP_TZ:
+            case PlSqlParser.TO_TIME:
+            case PlSqlParser.TO_TIME_TZ:
+            case PlSqlParser.TO_YMINTERVAL:
+            case PlSqlParser.TRACE:
+            case PlSqlParser.TRACING:
+            case PlSqlParser.TRACKING:
+            case PlSqlParser.TRAILING:
+            case PlSqlParser.TRANSACTION:
+            case PlSqlParser.TRANSFORM:
+            case PlSqlParser.TRANSFORM_DISTINCT_AGG:
+            case PlSqlParser.TRANSITIONAL:
+            case PlSqlParser.TRANSITION:
+            case PlSqlParser.TRANSLATE:
+            case PlSqlParser.TRANSLATION:
+            case PlSqlParser.TREAT:
+            case PlSqlParser.TRIGGERS:
+            case PlSqlParser.TRIGGER:
+            case PlSqlParser.TRUE:
+            case PlSqlParser.TRUNCATE:
+            case PlSqlParser.TRUNC:
+            case PlSqlParser.TRUSTED:
+            case PlSqlParser.TRUST:
+            case PlSqlParser.TUNING:
+            case PlSqlParser.TX:
+            case PlSqlParser.TYPES:
+            case PlSqlParser.TYPE:
+            case PlSqlParser.TZ_OFFSET:
+            case PlSqlParser.UB2:
+            case PlSqlParser.UBA:
+            case PlSqlParser.UCS2:
+            case PlSqlParser.UDF:
+            case PlSqlParser.UID:
+            case PlSqlParser.UNARCHIVED:
+            case PlSqlParser.UNBOUNDED:
+            case PlSqlParser.UNBOUND:
+            case PlSqlParser.UNCONDITIONAL:
+            case PlSqlParser.UNDER:
+            case PlSqlParser.UNDO:
+            case PlSqlParser.UNDROP:
+            case PlSqlParser.UNIFORM:
+            case PlSqlParser.UNISTR:
+            case PlSqlParser.UNLIMITED:
+            case PlSqlParser.UNLOAD:
+            case PlSqlParser.UNLOCK:
+            case PlSqlParser.UNMATCHED:
+            case PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW:
+            case PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW:
+            case PlSqlParser.UNNEST_SEMIJ_VIEW:
+            case PlSqlParser.UNNEST:
+            case PlSqlParser.UNPACKED:
+            case PlSqlParser.UNPIVOT:
+            case PlSqlParser.UNPLUG:
+            case PlSqlParser.UNPROTECTED:
+            case PlSqlParser.UNQUIESCE:
+            case PlSqlParser.UNRECOVERABLE:
+            case PlSqlParser.UNRESTRICTED:
+            case PlSqlParser.UNSUBSCRIBE:
+            case PlSqlParser.UNTIL:
+            case PlSqlParser.UNUSABLE:
+            case PlSqlParser.UNUSED:
+            case PlSqlParser.UPDATABLE:
+            case PlSqlParser.UPDATED:
+            case PlSqlParser.UPDATEXML:
+            case PlSqlParser.UPD_INDEXES:
+            case PlSqlParser.UPD_JOININDEX:
+            case PlSqlParser.UPGRADE:
+            case PlSqlParser.UPPER:
+            case PlSqlParser.UPSERT:
+            case PlSqlParser.UROWID:
+            case PlSqlParser.USABLE:
+            case PlSqlParser.USAGE:
+            case PlSqlParser.USE_ANTI:
+            case PlSqlParser.USE_CONCAT:
+            case PlSqlParser.USE_CUBE:
+            case PlSqlParser.USE_HASH_AGGREGATION:
+            case PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN:
+            case PlSqlParser.USE_HASH:
+            case PlSqlParser.USE_HIDDEN_PARTITIONS:
+            case PlSqlParser.USE_INVISIBLE_INDEXES:
+            case PlSqlParser.USE_MERGE_CARTESIAN:
+            case PlSqlParser.USE_MERGE:
+            case PlSqlParser.USE_NL:
+            case PlSqlParser.USE_NL_WITH_INDEX:
+            case PlSqlParser.USE_PRIVATE_OUTLINES:
+            case PlSqlParser.USER_DATA:
+            case PlSqlParser.USER_DEFINED:
+            case PlSqlParser.USERENV:
+            case PlSqlParser.USERGROUP:
+            case PlSqlParser.USER_RECYCLEBIN:
+            case PlSqlParser.USERS:
+            case PlSqlParser.USER_TABLESPACES:
+            case PlSqlParser.USER:
+            case PlSqlParser.USE_SEMI:
+            case PlSqlParser.USE_STORED_OUTLINES:
+            case PlSqlParser.USE_TTT_FOR_GSETS:
+            case PlSqlParser.USE:
+            case PlSqlParser.USE_VECTOR_AGGREGATION:
+            case PlSqlParser.USE_WEAK_NAME_RESL:
+            case PlSqlParser.USING_NO_EXPAND:
+            case PlSqlParser.USING_NLS_COMP:
+            case PlSqlParser.USING:
+            case PlSqlParser.UTF16BE:
+            case PlSqlParser.UTF16LE:
+            case PlSqlParser.UTF32:
+            case PlSqlParser.UTF8:
+            case PlSqlParser.V1:
+            case PlSqlParser.V2:
+            case PlSqlParser.VALIDATE:
+            case PlSqlParser.VALIDATE_CONVERSION:
+            case PlSqlParser.VALIDATION:
+            case PlSqlParser.VALID_TIME_END:
+            case PlSqlParser.VALUE:
+            case PlSqlParser.VARCHAR2:
+            case PlSqlParser.VARCHAR:
+            case PlSqlParser.VARIABLE:
+            case PlSqlParser.VAR_POP:
+            case PlSqlParser.VARRAYS:
+            case PlSqlParser.VARRAY:
+            case PlSqlParser.VAR_SAMP:
+            case PlSqlParser.VARYING:
+            case PlSqlParser.VECTOR_READ_TRACE:
+            case PlSqlParser.VECTOR_READ:
+            case PlSqlParser.VECTOR_TRANSFORM_DIMS:
+            case PlSqlParser.VECTOR_TRANSFORM_FACT:
+            case PlSqlParser.VECTOR_TRANSFORM:
+            case PlSqlParser.VERIFIER:
+            case PlSqlParser.VERIFY:
+            case PlSqlParser.VERSIONING:
+            case PlSqlParser.VERSIONS_ENDSCN:
+            case PlSqlParser.VERSIONS_ENDTIME:
+            case PlSqlParser.VERSIONS_OPERATION:
+            case PlSqlParser.VERSIONS_STARTSCN:
+            case PlSqlParser.VERSIONS_STARTTIME:
+            case PlSqlParser.VERSIONS:
+            case PlSqlParser.VERSIONS_XID:
+            case PlSqlParser.VERSION:
+            case PlSqlParser.VIOLATION:
+            case PlSqlParser.VIRTUAL:
+            case PlSqlParser.VISIBILITY:
+            case PlSqlParser.VISIBLE:
+            case PlSqlParser.VOLUME:
+            case PlSqlParser.VSIZE:
+            case PlSqlParser.WAIT:
+            case PlSqlParser.WALLET:
+            case PlSqlParser.WARNING:
+            case PlSqlParser.WEEKS:
+            case PlSqlParser.WEEK:
+            case PlSqlParser.WELLFORMED:
+            case PlSqlParser.WHENEVER:
+            case PlSqlParser.WHEN:
+            case PlSqlParser.WHILE:
+            case PlSqlParser.WHITESPACE:
+            case PlSqlParser.WIDTH_BUCKET:
+            case PlSqlParser.WITHIN:
+            case PlSqlParser.WITHOUT:
+            case PlSqlParser.WITH_PLSQL:
+            case PlSqlParser.WORK:
+            case PlSqlParser.WRAPPED:
+            case PlSqlParser.WRAPPER:
+            case PlSqlParser.WRITE:
+            case PlSqlParser.XDB_FASTPATH_INSERT:
+            case PlSqlParser.X_DYN_PRUNE:
+            case PlSqlParser.XID:
+            case PlSqlParser.XML2OBJECT:
+            case PlSqlParser.XMLAGG:
+            case PlSqlParser.XMLATTRIBUTES:
+            case PlSqlParser.XMLCAST:
+            case PlSqlParser.XMLCDATA:
+            case PlSqlParser.XMLCOLATTVAL:
+            case PlSqlParser.XMLCOMMENT:
+            case PlSqlParser.XMLCONCAT:
+            case PlSqlParser.XMLDIFF:
+            case PlSqlParser.XML_DML_RWT_STMT:
+            case PlSqlParser.XMLELEMENT:
+            case PlSqlParser.XMLEXISTS2:
+            case PlSqlParser.XMLEXISTS:
+            case PlSqlParser.XMLFOREST:
+            case PlSqlParser.XMLINDEX_REWRITE_IN_SELECT:
+            case PlSqlParser.XMLINDEX_REWRITE:
+            case PlSqlParser.XMLINDEX_SEL_IDX_TBL:
+            case PlSqlParser.XMLISNODE:
+            case PlSqlParser.XMLISVALID:
+            case PlSqlParser.XMLNAMESPACES:
+            case PlSqlParser.XMLPARSE:
+            case PlSqlParser.XMLPATCH:
+            case PlSqlParser.XMLPI:
+            case PlSqlParser.XMLQUERYVAL:
+            case PlSqlParser.XMLQUERY:
+            case PlSqlParser.XMLROOT:
+            case PlSqlParser.XMLSCHEMA:
+            case PlSqlParser.XMLSERIALIZE:
+            case PlSqlParser.XMLTABLE:
+            case PlSqlParser.XMLTRANSFORMBLOB:
+            case PlSqlParser.XMLTRANSFORM:
+            case PlSqlParser.XMLTYPE:
+            case PlSqlParser.XML:
+            case PlSqlParser.XPATHTABLE:
+            case PlSqlParser.XS_SYS_CONTEXT:
+            case PlSqlParser.XS:
+            case PlSqlParser.YEARS:
+            case PlSqlParser.YEAR:
+            case PlSqlParser.YES:
+            case PlSqlParser.YMINTERVAL_UNCONSTRAINED:
+            case PlSqlParser.ZONEMAP:
+            case PlSqlParser.ZONE:
+            case PlSqlParser.PREDICTION:
+            case PlSqlParser.PREDICTION_BOUNDS:
+            case PlSqlParser.PREDICTION_COST:
+            case PlSqlParser.PREDICTION_DETAILS:
+            case PlSqlParser.PREDICTION_PROBABILITY:
+            case PlSqlParser.PREDICTION_SET:
+            case PlSqlParser.BLOCKCHAIN:
+            case PlSqlParser.COLLATE:
+            case PlSqlParser.COLLATION:
+            case PlSqlParser.DEFINITION:
+            case PlSqlParser.DUPLICATED:
+            case PlSqlParser.EXTENDED:
+            case PlSqlParser.HASHING:
+            case PlSqlParser.IDLE:
+            case PlSqlParser.IMMUTABLE:
+            case PlSqlParser.ORACLE_DATAPUMP:
+            case PlSqlParser.ORACLE_HDFS:
+            case PlSqlParser.ORACLE_HIVE:
+            case PlSqlParser.ORACLE_LOADER:
+            case PlSqlParser.SHARDED:
+            case PlSqlParser.ISOLATE:
+            case PlSqlParser.ROOT:
+            case PlSqlParser.UNITE:
+            case PlSqlParser.ALGORITHM:
+            case PlSqlParser.CUME_DIST:
+            case PlSqlParser.DENSE_RANK:
+            case PlSqlParser.LISTAGG:
+            case PlSqlParser.PERCENT_RANK:
+            case PlSqlParser.PERCENTILE_CONT:
+            case PlSqlParser.PERCENTILE_DISC:
+            case PlSqlParser.RANK:
+            case PlSqlParser.AVG:
+            case PlSqlParser.CORR:
+            case PlSqlParser.COVAR_:
+            case PlSqlParser.LAG:
+            case PlSqlParser.LEAD:
+            case PlSqlParser.MAX:
+            case PlSqlParser.MEDIAN:
+            case PlSqlParser.MEMOPTIMIZE:
+            case PlSqlParser.MIN:
+            case PlSqlParser.NTILE:
+            case PlSqlParser.NVL:
+            case PlSqlParser.RATIO_TO_REPORT:
+            case PlSqlParser.REGR_:
+            case PlSqlParser.ROUND:
+            case PlSqlParser.ROW_NUMBER:
+            case PlSqlParser.SUBSTR:
+            case PlSqlParser.TO_CHAR:
+            case PlSqlParser.TRIM:
+            case PlSqlParser.SUM:
+            case PlSqlParser.STDDEV:
+            case PlSqlParser.VAR_:
+            case PlSqlParser.VARIANCE:
+            case PlSqlParser.LEAST:
+            case PlSqlParser.GREATEST:
+            case PlSqlParser.TO_DATE:
+            case PlSqlParser.CHARSETID:
+            case PlSqlParser.CHARSETFORM:
+            case PlSqlParser.DURATION:
+            case PlSqlParser.EXTEND:
+            case PlSqlParser.MAXLEN:
+            case PlSqlParser.PERSISTABLE:
+            case PlSqlParser.POLYMORPHIC:
+            case PlSqlParser.STRUCT:
+            case PlSqlParser.TDO:
+            case PlSqlParser.WM_CONCAT:
+            case PlSqlParser.PERIOD:
+            case PlSqlParser.REGULAR_ID:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 21475;
+                this.regular_id();
+                }
+                break;
+            case PlSqlParser.DELIMITED_ID:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 21476;
+                this.match(PlSqlParser.DELIMITED_ID);
+                }
+                break;
+            default:
+                throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public inquiry_directive(): Inquiry_directiveContext {
+        let localContext = new Inquiry_directiveContext(this.context, this.state);
+        this.enterRule(localContext, 2432, PlSqlParser.RULE_inquiry_directive);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21479;
+            this.match(PlSqlParser.INQUIRY_DIRECTIVE);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public outer_join_sign(): Outer_join_signContext {
+        let localContext = new Outer_join_signContext(this.context, this.state);
+        this.enterRule(localContext, 2434, PlSqlParser.RULE_outer_join_sign);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21481;
+            this.match(PlSqlParser.LEFT_PAREN);
+            this.state = 21482;
+            this.match(PlSqlParser.PLUS_SIGN);
+            this.state = 21483;
+            this.match(PlSqlParser.RIGHT_PAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public regular_id(): Regular_idContext {
+        let localContext = new Regular_idContext(this.context, this.state);
+        this.enterRule(localContext, 2436, PlSqlParser.RULE_regular_id);
+        try {
+            this.state = 21616;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 3041, this.context) ) {
+            case 1:
+                this.enterOuterAlt(localContext, 1);
+                {
+                this.state = 21485;
+                this.non_reserved_keywords_pre12c();
+                }
+                break;
+            case 2:
+                this.enterOuterAlt(localContext, 2);
+                {
+                this.state = 21486;
+                this.non_reserved_keywords_in_12c();
+                }
+                break;
+            case 3:
+                this.enterOuterAlt(localContext, 3);
+                {
+                this.state = 21487;
+                this.non_reserved_keywords_in_18c();
+                }
+                break;
+            case 4:
+                this.enterOuterAlt(localContext, 4);
+                {
+                this.state = 21488;
+                this.match(PlSqlParser.REGULAR_ID);
+                }
+                break;
+            case 5:
+                this.enterOuterAlt(localContext, 5);
+                {
+                this.state = 21489;
+                this.match(PlSqlParser.AUDIT);
+                }
+                break;
+            case 6:
+                this.enterOuterAlt(localContext, 6);
+                {
+                this.state = 21490;
+                this.match(PlSqlParser.ITEMS);
+                }
+                break;
+            case 7:
+                this.enterOuterAlt(localContext, 7);
+                {
+                this.state = 21491;
+                this.match(PlSqlParser.BYTES);
+                }
+                break;
+            case 8:
+                this.enterOuterAlt(localContext, 8);
+                {
+                this.state = 21492;
+                this.match(PlSqlParser.LINES);
+                }
+                break;
+            case 9:
+                this.enterOuterAlt(localContext, 9);
+                {
+                this.state = 21493;
+                this.match(PlSqlParser.RECORDS);
+                }
+                break;
+            case 10:
+                this.enterOuterAlt(localContext, 10);
+                {
+                this.state = 21494;
+                this.match(PlSqlParser.NEWLINE_);
+                }
+                break;
+            case 11:
+                this.enterOuterAlt(localContext, 11);
+                {
+                this.state = 21495;
+                this.match(PlSqlParser.FIELD);
+                }
+                break;
+            case 12:
+                this.enterOuterAlt(localContext, 12);
+                {
+                this.state = 21496;
+                this.match(PlSqlParser.MASK);
+                }
+                break;
+            case 13:
+                this.enterOuterAlt(localContext, 13);
+                {
+                this.state = 21497;
+                this.match(PlSqlParser.ABSENT);
+                }
+                break;
+            case 14:
+                this.enterOuterAlt(localContext, 14);
+                {
+                this.state = 21498;
+                this.match(PlSqlParser.A_LETTER);
+                }
+                break;
+            case 15:
+                this.enterOuterAlt(localContext, 15);
+                {
+                this.state = 21499;
+                this.match(PlSqlParser.AGENT);
+                }
+                break;
+            case 16:
+                this.enterOuterAlt(localContext, 16);
+                {
+                this.state = 21500;
+                this.match(PlSqlParser.AGGREGATE);
+                }
+                break;
+            case 17:
+                this.enterOuterAlt(localContext, 17);
+                {
+                this.state = 21501;
+                this.match(PlSqlParser.ANALYZE);
+                }
+                break;
+            case 18:
+                this.enterOuterAlt(localContext, 18);
+                {
+                this.state = 21502;
+                this.match(PlSqlParser.AUTONOMOUS_TRANSACTION);
+                }
+                break;
+            case 19:
+                this.enterOuterAlt(localContext, 19);
+                {
+                this.state = 21503;
+                this.match(PlSqlParser.BACKINGFILE);
+                }
+                break;
+            case 20:
+                this.enterOuterAlt(localContext, 20);
+                {
+                this.state = 21504;
+                this.match(PlSqlParser.BATCH);
+                }
+                break;
+            case 21:
+                this.enterOuterAlt(localContext, 21);
+                {
+                this.state = 21505;
+                this.match(PlSqlParser.BINARY_INTEGER);
+                }
+                break;
+            case 22:
+                this.enterOuterAlt(localContext, 22);
+                {
+                this.state = 21506;
+                this.match(PlSqlParser.BOOLEAN);
+                }
+                break;
+            case 23:
+                this.enterOuterAlt(localContext, 23);
+                {
+                this.state = 21507;
+                this.match(PlSqlParser.C_LETTER);
+                }
+                break;
+            case 24:
+                this.enterOuterAlt(localContext, 24);
+                {
+                this.state = 21508;
+                this.match(PlSqlParser.CHAR);
+                }
+                break;
+            case 25:
+                this.enterOuterAlt(localContext, 25);
+                {
+                this.state = 21509;
+                this.match(PlSqlParser.CHARSETID);
+                }
+                break;
+            case 26:
+                this.enterOuterAlt(localContext, 26);
+                {
+                this.state = 21510;
+                this.match(PlSqlParser.CHARSETFORM);
+                }
+                break;
+            case 27:
+                this.enterOuterAlt(localContext, 27);
+                {
+                this.state = 21511;
+                this.match(PlSqlParser.CLUSTER);
+                }
+                break;
+            case 28:
+                this.enterOuterAlt(localContext, 28);
+                {
+                this.state = 21512;
+                this.match(PlSqlParser.CONSTRUCTOR);
+                }
+                break;
+            case 29:
+                this.enterOuterAlt(localContext, 29);
+                {
+                this.state = 21513;
+                this.match(PlSqlParser.CUSTOMDATUM);
+                }
+                break;
+            case 30:
+                this.enterOuterAlt(localContext, 30);
+                {
+                this.state = 21514;
+                this.match(PlSqlParser.CASESENSITIVE);
+                }
+                break;
+            case 31:
+                this.enterOuterAlt(localContext, 31);
+                {
+                this.state = 21515;
+                this.match(PlSqlParser.COUNTED);
+                }
+                break;
+            case 32:
+                this.enterOuterAlt(localContext, 32);
+                {
+                this.state = 21516;
+                this.match(PlSqlParser.DATE);
+                }
+                break;
+            case 33:
+                this.enterOuterAlt(localContext, 33);
+                {
+                this.state = 21517;
+                this.match(PlSqlParser.DECIMAL);
+                }
+                break;
+            case 34:
+                this.enterOuterAlt(localContext, 34);
+                {
+                this.state = 21518;
+                this.match(PlSqlParser.DELETE);
+                }
+                break;
+            case 35:
+                this.enterOuterAlt(localContext, 35);
+                {
+                this.state = 21519;
+                this.match(PlSqlParser.DEPRECATE);
+                }
+                break;
+            case 36:
+                this.enterOuterAlt(localContext, 36);
+                {
+                this.state = 21520;
+                this.match(PlSqlParser.DETECTED);
+                }
+                break;
+            case 37:
+                this.enterOuterAlt(localContext, 37);
+                {
+                this.state = 21521;
+                this.match(PlSqlParser.DETERMINISTIC);
+                }
+                break;
+            case 38:
+                this.enterOuterAlt(localContext, 38);
+                {
+                this.state = 21522;
+                this.match(PlSqlParser.DISABLED);
+                }
+                break;
+            case 39:
+                this.enterOuterAlt(localContext, 39);
+                {
+                this.state = 21523;
+                this.match(PlSqlParser.DSINTERVAL_UNCONSTRAINED);
+                }
+                break;
+            case 40:
+                this.enterOuterAlt(localContext, 40);
+                {
+                this.state = 21524;
+                this.match(PlSqlParser.DURATION);
+                }
+                break;
+            case 41:
+                this.enterOuterAlt(localContext, 41);
+                {
+                this.state = 21525;
+                this.match(PlSqlParser.E_LETTER);
+                }
+                break;
+            case 42:
+                this.enterOuterAlt(localContext, 42);
+                {
+                this.state = 21526;
+                this.match(PlSqlParser.ENABLED);
+                }
+                break;
+            case 43:
+                this.enterOuterAlt(localContext, 43);
+                {
+                this.state = 21527;
+                this.match(PlSqlParser.ENCLOSED);
+                }
+                break;
+            case 44:
+                this.enterOuterAlt(localContext, 44);
+                {
+                this.state = 21528;
+                this.match(PlSqlParser.ERROR_INDEX);
+                }
+                break;
+            case 45:
+                this.enterOuterAlt(localContext, 45);
+                {
+                this.state = 21529;
+                this.match(PlSqlParser.ERROR_CODE);
+                }
+                break;
+            case 46:
+                this.enterOuterAlt(localContext, 46);
+                {
+                this.state = 21530;
+                this.match(PlSqlParser.ERR);
+                }
+                break;
+            case 47:
+                this.enterOuterAlt(localContext, 47);
+                {
+                this.state = 21531;
+                this.match(PlSqlParser.EXCEPTION);
+                }
+                break;
+            case 48:
+                this.enterOuterAlt(localContext, 48);
+                {
+                this.state = 21532;
+                this.match(PlSqlParser.EXCEPTION_INIT);
+                }
+                break;
+            case 49:
+                this.enterOuterAlt(localContext, 49);
+                {
+                this.state = 21533;
+                this.match(PlSqlParser.EXCEPTIONS);
+                }
+                break;
+            case 50:
+                this.enterOuterAlt(localContext, 50);
+                {
+                this.state = 21534;
+                this.match(PlSqlParser.EXISTS);
+                }
+                break;
+            case 51:
+                this.enterOuterAlt(localContext, 51);
+                {
+                this.state = 21535;
+                this.match(PlSqlParser.EXEC);
+                }
+                break;
+            case 52:
+                this.enterOuterAlt(localContext, 52);
+                {
+                this.state = 21536;
+                this.match(PlSqlParser.EXIT);
+                }
+                break;
+            case 53:
+                this.enterOuterAlt(localContext, 53);
+                {
+                this.state = 21537;
+                this.match(PlSqlParser.EXTEND);
+                }
+                break;
+            case 54:
+                this.enterOuterAlt(localContext, 54);
+                {
+                this.state = 21538;
+                this.match(PlSqlParser.FIELDS);
+                }
+                break;
+            case 55:
+                this.enterOuterAlt(localContext, 55);
+                {
+                this.state = 21539;
+                this.match(PlSqlParser.FILE_EXT);
+                }
+                break;
+            case 56:
+                this.enterOuterAlt(localContext, 56);
+                {
+                this.state = 21540;
+                this.match(PlSqlParser.FILESTORE);
+                }
+                break;
+            case 57:
+                this.enterOuterAlt(localContext, 57);
+                {
+                this.state = 21541;
+                this.match(PlSqlParser.FLOAT);
+                }
+                break;
+            case 58:
+                this.enterOuterAlt(localContext, 58);
+                {
+                this.state = 21542;
+                this.match(PlSqlParser.FORALL);
+                }
+                break;
+            case 59:
+                this.enterOuterAlt(localContext, 59);
+                {
+                this.state = 21543;
+                this.match(PlSqlParser.G_LETTER);
+                }
+                break;
+            case 60:
+                this.enterOuterAlt(localContext, 60);
+                {
+                this.state = 21544;
+                this.match(PlSqlParser.INDICES);
+                }
+                break;
+            case 61:
+                this.enterOuterAlt(localContext, 61);
+                {
+                this.state = 21545;
+                this.match(PlSqlParser.INOUT);
+                }
+                break;
+            case 62:
+                this.enterOuterAlt(localContext, 62);
+                {
+                this.state = 21546;
+                this.match(PlSqlParser.INTEGER);
+                }
+                break;
+            case 63:
+                this.enterOuterAlt(localContext, 63);
+                {
+                this.state = 21547;
+                this.match(PlSqlParser.INTERNAL);
+                }
+                break;
+            case 64:
+                this.enterOuterAlt(localContext, 64);
+                {
+                this.state = 21548;
+                this.match(PlSqlParser.JSON_TRANSFORM);
+                }
+                break;
+            case 65:
+                this.enterOuterAlt(localContext, 65);
+                {
+                this.state = 21549;
+                this.match(PlSqlParser.K_LETTER);
+                }
+                break;
+            case 66:
+                this.enterOuterAlt(localContext, 66);
+                {
+                this.state = 21550;
+                this.match(PlSqlParser.LANGUAGE);
+                }
+                break;
+            case 67:
+                this.enterOuterAlt(localContext, 67);
+                {
+                this.state = 21551;
+                this.match(PlSqlParser.LONG);
+                }
+                break;
+            case 68:
+                this.enterOuterAlt(localContext, 68);
+                {
+                this.state = 21552;
+                this.match(PlSqlParser.LOOP);
+                }
+                break;
+            case 69:
+                this.enterOuterAlt(localContext, 69);
+                {
+                this.state = 21553;
+                this.match(PlSqlParser.MAXLEN);
+                }
+                break;
+            case 70:
+                this.enterOuterAlt(localContext, 70);
+                {
+                this.state = 21554;
+                this.match(PlSqlParser.MOUNTPOINT);
+                }
+                break;
+            case 71:
+                this.enterOuterAlt(localContext, 71);
+                {
+                this.state = 21555;
+                this.match(PlSqlParser.M_LETTER);
+                }
+                break;
+            case 72:
+                this.enterOuterAlt(localContext, 72);
+                {
+                this.state = 21556;
+                this.match(PlSqlParser.MISSING);
+                }
+                break;
+            case 73:
+                this.enterOuterAlt(localContext, 73);
+                {
+                this.state = 21557;
+                this.match(PlSqlParser.MISMATCH);
+                }
+                break;
+            case 74:
+                this.enterOuterAlt(localContext, 74);
+                {
+                this.state = 21558;
+                this.match(PlSqlParser.NUMBER);
+                }
+                break;
+            case 75:
+                this.enterOuterAlt(localContext, 75);
+                {
+                this.state = 21559;
+                this.match(PlSqlParser.ORADATA);
+                }
+                break;
+            case 76:
+                this.enterOuterAlt(localContext, 76);
+                {
+                this.state = 21560;
+                this.match(PlSqlParser.ORC);
+                }
+                break;
+            case 77:
+                this.enterOuterAlt(localContext, 77);
+                {
+                this.state = 21561;
+                this.match(PlSqlParser.OSERROR);
+                }
+                break;
+            case 78:
+                this.enterOuterAlt(localContext, 78);
+                {
+                this.state = 21562;
+                this.match(PlSqlParser.OUT);
+                }
+                break;
+            case 79:
+                this.enterOuterAlt(localContext, 79);
+                {
+                this.state = 21563;
+                this.match(PlSqlParser.OVERRIDING);
+                }
+                break;
+            case 80:
+                this.enterOuterAlt(localContext, 80);
+                {
+                this.state = 21564;
+                this.match(PlSqlParser.P_LETTER);
+                }
+                break;
+            case 81:
+                this.enterOuterAlt(localContext, 81);
+                {
+                this.state = 21565;
+                this.match(PlSqlParser.PARALLEL_ENABLE);
+                }
+                break;
+            case 82:
+                this.enterOuterAlt(localContext, 82);
+                {
+                this.state = 21566;
+                this.match(PlSqlParser.PIPELINED);
+                }
+                break;
+            case 83:
+                this.enterOuterAlt(localContext, 83);
+                {
+                this.state = 21567;
+                this.match(PlSqlParser.PLS_INTEGER);
+                }
+                break;
+            case 84:
+                this.enterOuterAlt(localContext, 84);
+                {
+                this.state = 21568;
+                this.match(PlSqlParser.PMEM);
+                }
+                break;
+            case 85:
+                this.enterOuterAlt(localContext, 85);
+                {
+                this.state = 21569;
+                this.match(PlSqlParser.POSITIVE);
+                }
+                break;
+            case 86:
+                this.enterOuterAlt(localContext, 86);
+                {
+                this.state = 21570;
+                this.match(PlSqlParser.POSITIVEN);
+                }
+                break;
+            case 87:
+                this.enterOuterAlt(localContext, 87);
+                {
+                this.state = 21571;
+                this.match(PlSqlParser.PRAGMA);
+                }
+                break;
+            case 88:
+                this.enterOuterAlt(localContext, 88);
+                {
+                this.state = 21572;
+                this.match(PlSqlParser.PUBLIC);
+                }
+                break;
+            case 89:
+                this.enterOuterAlt(localContext, 89);
+                {
+                this.state = 21573;
+                this.match(PlSqlParser.RAISE);
+                }
+                break;
+            case 90:
+                this.enterOuterAlt(localContext, 90);
+                {
+                this.state = 21574;
+                this.match(PlSqlParser.RAW);
+                }
+                break;
+            case 91:
+                this.enterOuterAlt(localContext, 91);
+                {
+                this.state = 21575;
+                this.match(PlSqlParser.RECORD);
+                }
+                break;
+            case 92:
+                this.enterOuterAlt(localContext, 92);
+                {
+                this.state = 21576;
+                this.match(PlSqlParser.REF);
+                }
+                break;
+            case 93:
+                this.enterOuterAlt(localContext, 93);
+                {
+                this.state = 21577;
+                this.match(PlSqlParser.RENAME);
+                }
+                break;
+            case 94:
+                this.enterOuterAlt(localContext, 94);
+                {
+                this.state = 21578;
+                this.match(PlSqlParser.RESTRICT_REFERENCES);
+                }
+                break;
+            case 95:
+                this.enterOuterAlt(localContext, 95);
+                {
+                this.state = 21579;
+                this.match(PlSqlParser.RESULT);
+                }
+                break;
+            case 96:
+                this.enterOuterAlt(localContext, 96);
+                {
+                this.state = 21580;
+                this.match(PlSqlParser.SDO_GEOMETRY);
+                }
+                break;
+            case 97:
+                this.enterOuterAlt(localContext, 97);
+                {
+                this.state = 21581;
+                this.match(PlSqlParser.SELF);
+                }
+                break;
+            case 98:
+                this.enterOuterAlt(localContext, 98);
+                {
+                this.state = 21582;
+                this.match(PlSqlParser.SERIALLY_REUSABLE);
+                }
+                break;
+            case 99:
+                this.enterOuterAlt(localContext, 99);
+                {
+                this.state = 21583;
+                this.match(PlSqlParser.SET);
+                }
+                break;
+            case 100:
+                this.enterOuterAlt(localContext, 100);
+                {
+                this.state = 21584;
+                this.match(PlSqlParser.SEQ);
+                }
+                break;
+            case 101:
+                this.enterOuterAlt(localContext, 101);
+                {
+                this.state = 21585;
+                this.match(PlSqlParser.SHARDSPACE);
+                }
+                break;
+            case 102:
+                this.enterOuterAlt(localContext, 102);
+                {
+                this.state = 21586;
+                this.match(PlSqlParser.SIGNTYPE);
+                }
+                break;
+            case 103:
+                this.enterOuterAlt(localContext, 103);
+                {
+                this.state = 21587;
+                this.match(PlSqlParser.SIMPLE_INTEGER);
+                }
+                break;
+            case 104:
+                this.enterOuterAlt(localContext, 104);
+                {
+                this.state = 21588;
+                this.match(PlSqlParser.SMALLINT);
+                }
+                break;
+            case 105:
+                this.enterOuterAlt(localContext, 105);
+                {
+                this.state = 21589;
+                this.match(PlSqlParser.STRUCT);
+                }
+                break;
+            case 106:
+                this.enterOuterAlt(localContext, 106);
+                {
+                this.state = 21590;
+                this.match(PlSqlParser.SQLDATA);
+                }
+                break;
+            case 107:
+                this.enterOuterAlt(localContext, 107);
+                {
+                this.state = 21591;
+                this.match(PlSqlParser.SQLERROR);
+                }
+                break;
+            case 108:
+                this.enterOuterAlt(localContext, 108);
+                {
+                this.state = 21592;
+                this.match(PlSqlParser.SUBTYPE);
+                }
+                break;
+            case 109:
+                this.enterOuterAlt(localContext, 109);
+                {
+                this.state = 21593;
+                this.match(PlSqlParser.T_LETTER);
+                }
+                break;
+            case 110:
+                this.enterOuterAlt(localContext, 110);
+                {
+                this.state = 21594;
+                this.match(PlSqlParser.TDO);
+                }
+                break;
+            case 111:
+                this.enterOuterAlt(localContext, 111);
+                {
+                this.state = 21595;
+                this.match(PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED);
+                }
+                break;
+            case 112:
+                this.enterOuterAlt(localContext, 112);
+                {
+                this.state = 21596;
+                this.match(PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED);
+                }
+                break;
+            case 113:
+                this.enterOuterAlt(localContext, 113);
+                {
+                this.state = 21597;
+                this.match(PlSqlParser.TIMESTAMP_UNCONSTRAINED);
+                }
+                break;
+            case 114:
+                this.enterOuterAlt(localContext, 114);
+                {
+                this.state = 21598;
+                this.match(PlSqlParser.TIMEZONE);
+                }
+                break;
+            case 115:
+                this.enterOuterAlt(localContext, 115);
+                {
+                this.state = 21599;
+                this.match(PlSqlParser.TRIGGER);
+                }
+                break;
+            case 116:
+                this.enterOuterAlt(localContext, 116);
+                {
+                this.state = 21600;
+                this.match(PlSqlParser.UDF);
+                }
+                break;
+            case 117:
+                this.enterOuterAlt(localContext, 117);
+                {
+                this.state = 21601;
+                this.match(PlSqlParser.VARCHAR);
+                }
+                break;
+            case 118:
+                this.enterOuterAlt(localContext, 118);
+                {
+                this.state = 21602;
+                this.match(PlSqlParser.VARCHAR2);
+                }
+                break;
+            case 119:
+                this.enterOuterAlt(localContext, 119);
+                {
+                this.state = 21603;
+                this.match(PlSqlParser.VARIABLE);
+                }
+                break;
+            case 120:
+                this.enterOuterAlt(localContext, 120);
+                {
+                this.state = 21604;
+                this.match(PlSqlParser.WARNING);
+                }
+                break;
+            case 121:
+                this.enterOuterAlt(localContext, 121);
+                {
+                this.state = 21605;
+                this.match(PlSqlParser.WHILE);
+                }
+                break;
+            case 122:
+                this.enterOuterAlt(localContext, 122);
+                {
+                this.state = 21606;
+                this.match(PlSqlParser.WM_CONCAT);
+                }
+                break;
+            case 123:
+                this.enterOuterAlt(localContext, 123);
+                {
+                this.state = 21607;
+                this.match(PlSqlParser.XMLAGG);
+                }
+                break;
+            case 124:
+                this.enterOuterAlt(localContext, 124);
+                {
+                this.state = 21608;
+                this.match(PlSqlParser.YMINTERVAL_UNCONSTRAINED);
+                }
+                break;
+            case 125:
+                this.enterOuterAlt(localContext, 125);
+                {
+                this.state = 21609;
+                this.match(PlSqlParser.REGR_);
+                }
+                break;
+            case 126:
+                this.enterOuterAlt(localContext, 126);
+                {
+                this.state = 21610;
+                this.match(PlSqlParser.VAR_);
+                }
+                break;
+            case 127:
+                this.enterOuterAlt(localContext, 127);
+                {
+                this.state = 21611;
+                this.match(PlSqlParser.VALUE);
+                }
+                break;
+            case 128:
+                this.enterOuterAlt(localContext, 128);
+                {
+                this.state = 21612;
+                this.match(PlSqlParser.COVAR_);
+                }
+                break;
+            case 129:
+                this.enterOuterAlt(localContext, 129);
+                {
+                this.state = 21613;
+                this.match(PlSqlParser.DATE_FORMAT);
+                }
+                break;
+            case 130:
+                this.enterOuterAlt(localContext, 130);
+                {
+                this.state = 21614;
+                this.match(PlSqlParser.CSV);
+                }
+                break;
+            case 131:
+                this.enterOuterAlt(localContext, 131);
+                {
+                this.state = 21615;
+                this.match(PlSqlParser.CHARACTERSET);
+                }
+                break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public non_reserved_keywords_in_18c(): Non_reserved_keywords_in_18cContext {
+        let localContext = new Non_reserved_keywords_in_18cContext(this.context, this.state);
+        this.enterRule(localContext, 2438, PlSqlParser.RULE_non_reserved_keywords_in_18c);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21618;
+            _la = this.tokenStream.LA(1);
+            if(!(_la === 2433 || _la === 2434)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public non_reserved_keywords_in_12c(): Non_reserved_keywords_in_12cContext {
+        let localContext = new Non_reserved_keywords_in_12cContext(this.context, this.state);
+        this.enterRule(localContext, 2440, PlSqlParser.RULE_non_reserved_keywords_in_12c);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21620;
+            _la = this.tokenStream.LA(1);
+            if(!(((((_la - 6)) & ~0x1F) === 0 && ((1 << (_la - 6)) & 75523445) !== 0) || ((((_la - 43)) & ~0x1F) === 0 && ((1 << (_la - 43)) & 2153383445) !== 0) || ((((_la - 76)) & ~0x1F) === 0 && ((1 << (_la - 76)) & 161742849) !== 0) || ((((_la - 109)) & ~0x1F) === 0 && ((1 << (_la - 109)) & 134218019) !== 0) || ((((_la - 154)) & ~0x1F) === 0 && ((1 << (_la - 154)) & 1086783489) !== 0) || ((((_la - 207)) & ~0x1F) === 0 && ((1 << (_la - 207)) & 180383) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 242221827) !== 0) || ((((_la - 290)) & ~0x1F) === 0 && ((1 << (_la - 290)) & 14863) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 4633) !== 0) || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & 537397301) !== 0) || ((((_la - 392)) & ~0x1F) === 0 && ((1 << (_la - 392)) & 2172651043) !== 0) || ((((_la - 428)) & ~0x1F) === 0 && ((1 << (_la - 428)) & 1049105) !== 0) || ((((_la - 475)) & ~0x1F) === 0 && ((1 << (_la - 475)) & 75763843) !== 0) || ((((_la - 517)) & ~0x1F) === 0 && ((1 << (_la - 517)) & 268445697) !== 0) || ((((_la - 557)) & ~0x1F) === 0 && ((1 << (_la - 557)) & 1186336833) !== 0) || ((((_la - 591)) & ~0x1F) === 0 && ((1 << (_la - 591)) & 2148016131) !== 0) || ((((_la - 635)) & ~0x1F) === 0 && ((1 << (_la - 635)) & 16777349) !== 0) || ((((_la - 672)) & ~0x1F) === 0 && ((1 << (_la - 672)) & 3288344067) !== 0) || ((((_la - 719)) & ~0x1F) === 0 && ((1 << (_la - 719)) & 1342701569) !== 0) || ((((_la - 752)) & ~0x1F) === 0 && ((1 << (_la - 752)) & 1074266113) !== 0) || ((((_la - 787)) & ~0x1F) === 0 && ((1 << (_la - 787)) & 50331137) !== 0) || ((((_la - 821)) & ~0x1F) === 0 && ((1 << (_la - 821)) & 1208156677) !== 0) || ((((_la - 860)) & ~0x1F) === 0 && ((1 << (_la - 860)) & 1076363265) !== 0) || ((((_la - 896)) & ~0x1F) === 0 && ((1 << (_la - 896)) & 15769601) !== 0) || ((((_la - 930)) & ~0x1F) === 0 && ((1 << (_la - 930)) & 1074274049) !== 0) || ((((_la - 973)) & ~0x1F) === 0 && ((1 << (_la - 973)) & 2131025) !== 0) || _la === 1013 || ((((_la - 1056)) & ~0x1F) === 0 && ((1 << (_la - 1056)) & 3255107907) !== 0) || ((((_la - 1093)) & ~0x1F) === 0 && ((1 << (_la - 1093)) & 7356417) !== 0) || ((((_la - 1133)) & ~0x1F) === 0 && ((1 << (_la - 1133)) & 490209541) !== 0) || ((((_la - 1166)) & ~0x1F) === 0 && ((1 << (_la - 1166)) & 33587489) !== 0) || ((((_la - 1209)) & ~0x1F) === 0 && ((1 << (_la - 1209)) & 265857) !== 0) || ((((_la - 1241)) & ~0x1F) === 0 && ((1 << (_la - 1241)) & 106561) !== 0) || ((((_la - 1278)) & ~0x1F) === 0 && ((1 << (_la - 1278)) & 17809415) !== 0) || ((((_la - 1340)) & ~0x1F) === 0 && ((1 << (_la - 1340)) & 362807507) !== 0) || ((((_la - 1388)) & ~0x1F) === 0 && ((1 << (_la - 1388)) & 4169138201) !== 0) || ((((_la - 1427)) & ~0x1F) === 0 && ((1 << (_la - 1427)) & 444629197) !== 0) || ((((_la - 1459)) & ~0x1F) === 0 && ((1 << (_la - 1459)) & 35709953) !== 0) || ((((_la - 1493)) & ~0x1F) === 0 && ((1 << (_la - 1493)) & 1073872897) !== 0) || ((((_la - 1555)) & ~0x1F) === 0 && ((1 << (_la - 1555)) & 524297) !== 0) || ((((_la - 1596)) & ~0x1F) === 0 && ((1 << (_la - 1596)) & 8650817) !== 0) || ((((_la - 1631)) & ~0x1F) === 0 && ((1 << (_la - 1631)) & 777) !== 0) || ((((_la - 1663)) & ~0x1F) === 0 && ((1 << (_la - 1663)) & 137363477) !== 0) || ((((_la - 1713)) & ~0x1F) === 0 && ((1 << (_la - 1713)) & 5799939) !== 0) || ((((_la - 1745)) & ~0x1F) === 0 && ((1 << (_la - 1745)) & 4194307) !== 0) || ((((_la - 1780)) & ~0x1F) === 0 && ((1 << (_la - 1780)) & 2189951491) !== 0) || ((((_la - 1829)) & ~0x1F) === 0 && ((1 << (_la - 1829)) & 3169) !== 0) || ((((_la - 1862)) & ~0x1F) === 0 && ((1 << (_la - 1862)) & 1019905) !== 0) || _la === 1906 || _la === 1934 || _la === 1945 || ((((_la - 2076)) & ~0x1F) === 0 && ((1 << (_la - 2076)) & 3225421831) !== 0) || ((((_la - 2126)) & ~0x1F) === 0 && ((1 << (_la - 2126)) & 1090519041) !== 0) || ((((_la - 2164)) & ~0x1F) === 0 && ((1 << (_la - 2164)) & 67125505) !== 0) || ((((_la - 2197)) & ~0x1F) === 0 && ((1 << (_la - 2197)) & 286261313) !== 0) || ((((_la - 2232)) & ~0x1F) === 0 && ((1 << (_la - 2232)) & 92196929) !== 0) || ((((_la - 2274)) & ~0x1F) === 0 && ((1 << (_la - 2274)) & 50495503) !== 0) || _la === 2309 || _la === 2314 || ((((_la - 2357)) & ~0x1F) === 0 && ((1 << (_la - 2357)) & 1610547333) !== 0) || ((((_la - 2389)) & ~0x1F) === 0 && ((1 << (_la - 2389)) & 2097165) !== 0) || _la === 2442)) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public non_reserved_keywords_pre12c(): Non_reserved_keywords_pre12cContext {
+        let localContext = new Non_reserved_keywords_pre12cContext(this.context, this.state);
+        this.enterRule(localContext, 2442, PlSqlParser.RULE_non_reserved_keywords_pre12c);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 21622;
+            _la = this.tokenStream.LA(1);
+            if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 3756434102) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 2544019921) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 737671909) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4251379473) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 3204183997) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 3752794355) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & 4101800951) !== 0) || ((((_la - 229)) & ~0x1F) === 0 && ((1 << (_la - 229)) & 2658828255) !== 0) || ((((_la - 262)) & ~0x1F) === 0 && ((1 << (_la - 262)) & 201063521) !== 0) || ((((_la - 294)) & ~0x1F) === 0 && ((1 << (_la - 294)) & 1743780959) !== 0) || ((((_la - 327)) & ~0x1F) === 0 && ((1 << (_la - 327)) & 2818047847) !== 0) || ((((_la - 364)) & ~0x1F) === 0 && ((1 << (_la - 364)) & 3387816947) !== 0) || ((((_la - 396)) & ~0x1F) === 0 && ((1 << (_la - 396)) & 3869498653) !== 0) || ((((_la - 429)) & ~0x1F) === 0 && ((1 << (_la - 429)) & 104258801) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 501976447) !== 0) || ((((_la - 495)) & ~0x1F) === 0 && ((1 << (_la - 495)) & 1329548951) !== 0) || ((((_la - 527)) & ~0x1F) === 0 && ((1 << (_la - 527)) & 3218291957) !== 0) || ((((_la - 559)) & ~0x1F) === 0 && ((1 << (_la - 559)) & 2387770351) !== 0) || ((((_la - 594)) & ~0x1F) === 0 && ((1 << (_la - 594)) & 3888036351) !== 0) || ((((_la - 626)) & ~0x1F) === 0 && ((1 << (_la - 626)) & 4271829495) !== 0) || ((((_la - 660)) & ~0x1F) === 0 && ((1 << (_la - 660)) & 4187983855) !== 0) || ((((_la - 692)) & ~0x1F) === 0 && ((1 << (_la - 692)) & 4093637563) !== 0) || ((((_la - 724)) & ~0x1F) === 0 && ((1 << (_la - 724)) & 3313448959) !== 0) || ((((_la - 756)) & ~0x1F) === 0 && ((1 << (_la - 756)) & 443498493) !== 0) || ((((_la - 788)) & ~0x1F) === 0 && ((1 << (_la - 788)) & 4227858683) !== 0) || ((((_la - 820)) & ~0x1F) === 0 && ((1 << (_la - 820)) & 1878620645) !== 0) || ((((_la - 852)) & ~0x1F) === 0 && ((1 << (_la - 852)) & 2549861567) !== 0) || ((((_la - 884)) & ~0x1F) === 0 && ((1 << (_la - 884)) & 3589989311) !== 0) || ((((_la - 920)) & ~0x1F) === 0 && ((1 << (_la - 920)) & 3749968895) !== 0) || ((((_la - 952)) & ~0x1F) === 0 && ((1 << (_la - 952)) & 1910480607) !== 0) || ((((_la - 984)) & ~0x1F) === 0 && ((1 << (_la - 984)) & 3753900911) !== 0) || ((((_la - 1016)) & ~0x1F) === 0 && ((1 << (_la - 1016)) & 4294967167) !== 0) || ((((_la - 1048)) & ~0x1F) === 0 && ((1 << (_la - 1048)) & 4075724031) !== 0) || ((((_la - 1080)) & ~0x1F) === 0 && ((1 << (_la - 1080)) & 4158642493) !== 0) || ((((_la - 1112)) & ~0x1F) === 0 && ((1 << (_la - 1112)) & 3730833201) !== 0) || ((((_la - 1144)) & ~0x1F) === 0 && ((1 << (_la - 1144)) & 3082574079) !== 0) || ((((_la - 1176)) & ~0x1F) === 0 && ((1 << (_la - 1176)) & 2684313439) !== 0) || ((((_la - 1208)) & ~0x1F) === 0 && ((1 << (_la - 1208)) & 4273455869) !== 0) || ((((_la - 1240)) & ~0x1F) === 0 && ((1 << (_la - 1240)) & 4292132477) !== 0) || ((((_la - 1272)) & ~0x1F) === 0 && ((1 << (_la - 1272)) & 3155157043) !== 0) || ((((_la - 1304)) & ~0x1F) === 0 && ((1 << (_la - 1304)) & 3686711133) !== 0) || ((((_la - 1337)) & ~0x1F) === 0 && ((1 << (_la - 1337)) & 1392507175) !== 0) || ((((_la - 1369)) & ~0x1F) === 0 && ((1 << (_la - 1369)) & 3878951163) !== 0) || ((((_la - 1401)) & ~0x1F) === 0 && ((1 << (_la - 1401)) & 3418895343) !== 0) || ((((_la - 1436)) & ~0x1F) === 0 && ((1 << (_la - 1436)) & 4284661439) !== 0) || ((((_la - 1468)) & ~0x1F) === 0 && ((1 << (_la - 1468)) & 4194234125) !== 0) || ((((_la - 1501)) & ~0x1F) === 0 && ((1 << (_la - 1501)) & 4290747631) !== 0) || ((((_la - 1533)) & ~0x1F) === 0 && ((1 << (_la - 1533)) & 3986685951) !== 0) || ((((_la - 1565)) & ~0x1F) === 0 && ((1 << (_la - 1565)) & 2080226687) !== 0) || ((((_la - 1597)) & ~0x1F) === 0 && ((1 << (_la - 1597)) & 4290641887) !== 0) || ((((_la - 1629)) & ~0x1F) === 0 && ((1 << (_la - 1629)) & 399504283) !== 0) || ((((_la - 1661)) & ~0x1F) === 0 && ((1 << (_la - 1661)) & 3743018921) !== 0) || ((((_la - 1693)) & ~0x1F) === 0 && ((1 << (_la - 1693)) & 3486481657) !== 0) || ((((_la - 1726)) & ~0x1F) === 0 && ((1 << (_la - 1726)) & 4293369147) !== 0) || ((((_la - 1758)) & ~0x1F) === 0 && ((1 << (_la - 1758)) & 1598029311) !== 0) || ((((_la - 1790)) & ~0x1F) === 0 && ((1 << (_la - 1790)) & 4292828927) !== 0) || ((((_la - 1822)) & ~0x1F) === 0 && ((1 << (_la - 1822)) & 4294561663) !== 0) || ((((_la - 1854)) & ~0x1F) === 0 && ((1 << (_la - 1854)) & 4033871615) !== 0) || ((((_la - 1886)) & ~0x1F) === 0 && ((1 << (_la - 1886)) & 4293918719) !== 0) || ((((_la - 1918)) & ~0x1F) === 0 && ((1 << (_la - 1918)) & 4160684031) !== 0) || ((((_la - 1950)) & ~0x1F) === 0 && ((1 << (_la - 1950)) & 4294967295) !== 0) || ((((_la - 1982)) & ~0x1F) === 0 && ((1 << (_la - 1982)) & 4294967295) !== 0) || ((((_la - 2014)) & ~0x1F) === 0 && ((1 << (_la - 2014)) & 4294967295) !== 0) || ((((_la - 2046)) & ~0x1F) === 0 && ((1 << (_la - 2046)) & 1073741823) !== 0) || ((((_la - 2080)) & ~0x1F) === 0 && ((1 << (_la - 2080)) & 1400045439) !== 0) || ((((_la - 2113)) & ~0x1F) === 0 && ((1 << (_la - 2113)) & 3221216255) !== 0) || ((((_la - 2145)) & ~0x1F) === 0 && ((1 << (_la - 2145)) & 3891771295) !== 0) || ((((_la - 2177)) & ~0x1F) === 0 && ((1 << (_la - 2177)) & 4193246781) !== 0) || ((((_la - 2210)) & ~0x1F) === 0 && ((1 << (_la - 2210)) & 4022302591) !== 0) || ((((_la - 2242)) & ~0x1F) === 0 && ((1 << (_la - 2242)) & 4261716043) !== 0) || ((((_la - 2278)) & ~0x1F) === 0 && ((1 << (_la - 2278)) & 2043139071) !== 0) || ((((_la - 2311)) & ~0x1F) === 0 && ((1 << (_la - 2311)) & 4286577589) !== 0) || ((((_la - 2343)) & ~0x1F) === 0 && ((1 << (_la - 2343)) & 1061830527) !== 0) || ((((_la - 2390)) & ~0x1F) === 0 && ((1 << (_la - 2390)) & 4261302265) !== 0) || ((((_la - 2422)) & ~0x1F) === 0 && ((1 << (_la - 2422)) & 61) !== 0))) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public override sempred(localContext: antlr.ParserRuleContext | null, ruleIndex: number, predIndex: number): boolean {
+        switch (ruleIndex) {
+        case 2:
+            return this.terminator_sempred(localContext as TerminatorContext, predIndex);
+        case 364:
+            return this.unified_auditing_sempred(localContext as Unified_auditingContext, predIndex);
+        case 367:
+            return this.audit_direct_path_sempred(localContext as Audit_direct_pathContext, predIndex);
+        case 368:
+            return this.audit_container_clause_sempred(localContext as Audit_container_clauseContext, predIndex);
+        case 374:
+            return this.auditing_on_clause_sempred(localContext as Auditing_on_clauseContext, predIndex);
+        case 378:
+            return this.sql_statement_shortcut_sempred(localContext as Sql_statement_shortcutContext, predIndex);
+        case 410:
+            return this.library_editionable_sempred(localContext as Library_editionableContext, predIndex);
+        case 411:
+            return this.library_debug_sempred(localContext as Library_debugContext, predIndex);
+        case 423:
+            return this.alter_view_editionable_sempred(localContext as Alter_view_editionableContext, predIndex);
+        case 631:
+            return this.external_table_condition_clause_sempred(localContext as External_table_condition_clauseContext, predIndex);
+        case 700:
+            return this.partial_database_recovery_10g_sempred(localContext as Partial_database_recovery_10gContext, predIndex);
+        case 842:
+            return this.period_definition_sempred(localContext as Period_definitionContext, predIndex);
+        case 968:
+            return this.table_ref_aux_sempred(localContext as Table_ref_auxContext, predIndex);
+        case 1043:
+            return this.dml_table_expression_clause_sempred(localContext as Dml_table_expression_clauseContext, predIndex);
+        case 1052:
+            return this.logical_expression_sempred(localContext as Logical_expressionContext, predIndex);
+        case 1056:
+            return this.multiset_expression_sempred(localContext as Multiset_expressionContext, predIndex);
+        case 1057:
+            return this.relational_expression_sempred(localContext as Relational_expressionContext, predIndex);
+        case 1062:
+            return this.concatenation_sempred(localContext as ConcatenationContext, predIndex);
+        case 1069:
+            return this.unary_expression_core_sempred(localContext as Unary_expression_coreContext, predIndex);
+        case 1086:
+            return this.standard_function_sempred(localContext as Standard_functionContext, predIndex);
+        case 1122:
+            return this.string_delimiter_sempred(localContext as String_delimiterContext, predIndex);
+        case 1139:
+            return this.execute_command_sempred(localContext as Execute_commandContext, predIndex);
+        case 1205:
+            return this.general_element_sempred(localContext as General_elementContext, predIndex);
+        }
+        return true;
+    }
+    private terminator_sempred(localContext: TerminatorContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 0:
+            return this.isSolidusSeparator();
+        case 1:
+            return this.isLastUnitSql() && this.isSolidusSeparator();
+        }
+        return true;
+    }
+    private unified_auditing_sempred(localContext: Unified_auditingContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 2:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private audit_direct_path_sempred(localContext: Audit_direct_pathContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 3:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private audit_container_clause_sempred(localContext: Audit_container_clauseContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 4:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private auditing_on_clause_sempred(localContext: Auditing_on_clauseContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 5:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private sql_statement_shortcut_sempred(localContext: Sql_statement_shortcutContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 6:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private library_editionable_sempred(localContext: Library_editionableContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 7:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private library_debug_sempred(localContext: Library_debugContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 8:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private alter_view_editionable_sempred(localContext: Alter_view_editionableContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 9:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private external_table_condition_clause_sempred(localContext: External_table_condition_clauseContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 10:
+            return this.precpred(this.context, 1);
+        }
+        return true;
+    }
+    private partial_database_recovery_10g_sempred(localContext: Partial_database_recovery_10gContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 11:
+            return this.isVersion10();
+        }
+        return true;
+    }
+    private period_definition_sempred(localContext: Period_definitionContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 12:
+            return this.isVersion12();
+        }
+        return true;
+    }
+    private table_ref_aux_sempred(localContext: Table_ref_auxContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 13:
+            return this.isNotStartOfJoin();
+        }
+        return true;
+    }
+    private dml_table_expression_clause_sempred(localContext: Dml_table_expression_clauseContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 14:
+            return this.isVersion11();
+        }
+        return true;
+    }
+    private logical_expression_sempred(localContext: Logical_expressionContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 15:
+            return this.precpred(this.context, 2);
+        case 16:
+            return this.precpred(this.context, 1);
+        }
+        return true;
+    }
+    private multiset_expression_sempred(localContext: Multiset_expressionContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 17:
+            return this.precpred(this.context, 1);
+        }
+        return true;
+    }
+    private relational_expression_sempred(localContext: Relational_expressionContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 18:
+            return this.precpred(this.context, 3);
+        case 19:
+            return this.precpred(this.context, 2);
+        }
+        return true;
+    }
+    private concatenation_sempred(localContext: ConcatenationContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 20:
+            return this.precpred(this.context, 5);
+        case 21:
+            return this.precpred(this.context, 4);
+        case 22:
+            return this.precpred(this.context, 3);
+        case 23:
+            return this.precpred(this.context, 2);
+        case 24:
+            return this.precpred(this.context, 1);
+        }
+        return true;
+    }
+    private unary_expression_core_sempred(localContext: Unary_expression_coreContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 25:
+            return this.IsNotNumericFunction();
+        }
+        return true;
+    }
+    private standard_function_sempred(localContext: Standard_functionContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 26:
+            return this.IsNotNumericFunction();
+        }
+        return true;
+    }
+    private string_delimiter_sempred(localContext: String_delimiterContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 27:
+            return this.precpred(this.context, 3);
+        }
+        return true;
+    }
+    private execute_command_sempred(localContext: Execute_commandContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 28:
+            return this.isLineStart();
+        }
+        return true;
+    }
+    private general_element_sempred(localContext: General_elementContext | null, predIndex: number): boolean {
+        switch (predIndex) {
+        case 29:
+            return this.precpred(this.context, 2);
+        }
+        return true;
+    }
+
+    public static readonly _serializedATN: number[] = [
+        4,1,2484,21625,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,1,0,1,0,3,0,2447,
+        8,0,5,0,2449,8,0,10,0,12,0,2452,9,0,1,0,1,0,1,0,1,0,5,0,2458,8,0,
+        10,0,12,0,2461,9,0,1,0,3,0,2464,8,0,3,0,2466,8,0,1,0,1,0,1,1,1,1,
+        1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,2479,8,1,1,2,1,2,1,2,1,2,1,2,1,2,
+        3,2,2487,8,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,2496,8,3,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
+        4,1,4,1,4,1,4,1,4,3,4,2633,8,4,1,5,1,5,1,5,1,5,1,5,4,5,2640,8,5,
+        11,5,12,5,2641,1,5,3,5,2645,8,5,1,5,3,5,2648,8,5,1,5,1,5,1,5,1,5,
+        1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,
+        3,5,2670,8,5,3,5,2672,8,5,1,5,1,5,1,5,5,5,2677,8,5,10,5,12,5,2680,
+        9,5,1,5,3,5,2683,8,5,1,5,1,5,1,5,3,5,2688,8,5,3,5,2690,8,5,1,6,1,
+        6,1,6,3,6,2695,8,6,1,6,3,6,2698,8,6,1,6,1,6,3,6,2702,8,6,1,6,1,6,
+        1,6,1,6,5,6,2708,8,6,10,6,12,6,2711,9,6,4,6,2713,8,6,11,6,12,6,2714,
+        1,7,1,7,3,7,2719,8,7,1,7,1,7,1,7,3,7,2724,8,7,1,7,1,7,1,7,3,7,2729,
+        8,7,5,7,2731,8,7,10,7,12,7,2734,9,7,1,7,1,7,1,7,3,7,2739,8,7,1,7,
+        1,7,1,7,3,7,2744,8,7,1,7,1,7,1,7,3,7,2749,8,7,5,7,2751,8,7,10,7,
+        12,7,2754,9,7,3,7,2756,8,7,1,8,1,8,1,8,1,8,3,8,2762,8,8,1,9,1,9,
+        1,9,1,9,1,9,1,9,3,9,2770,8,9,1,9,1,9,1,9,1,9,1,9,3,9,2777,8,9,5,
+        9,2779,8,9,10,9,12,9,2782,9,9,1,9,1,9,3,9,2786,8,9,1,9,3,9,2789,
+        8,9,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,
+        5,11,2803,8,11,10,11,12,11,2806,9,11,1,11,1,11,3,11,2810,8,11,1,
+        12,1,12,3,12,2814,8,12,1,12,1,12,1,12,1,12,5,12,2820,8,12,10,12,
+        12,12,2823,9,12,1,12,1,12,1,12,3,12,2828,8,12,1,12,1,12,1,12,1,12,
+        5,12,2834,8,12,10,12,12,12,2837,9,12,4,12,2839,8,12,11,12,12,12,
+        2840,1,12,3,12,2844,8,12,1,12,1,12,3,12,2848,8,12,1,12,3,12,2851,
+        8,12,1,13,1,13,3,13,2855,8,13,1,13,1,13,1,13,1,13,5,13,2861,8,13,
+        10,13,12,13,2864,9,13,1,13,1,13,1,13,3,13,2869,8,13,1,13,1,13,1,
+        13,1,13,5,13,2875,8,13,10,13,12,13,2878,9,13,3,13,2880,8,13,1,13,
+        3,13,2883,8,13,1,14,1,14,1,14,1,14,1,14,1,15,1,15,1,15,4,15,2893,
+        8,15,11,15,12,15,2894,3,15,2897,8,15,1,15,1,15,1,15,1,15,3,15,2903,
+        8,15,1,15,1,15,1,15,3,15,2908,8,15,3,15,2910,8,15,1,16,1,16,1,17,
+        1,17,3,17,2916,8,17,1,17,3,17,2919,8,17,1,18,1,18,1,18,1,18,1,18,
+        1,18,1,18,1,18,5,18,2929,8,18,10,18,12,18,2932,9,18,1,18,1,18,1,
+        18,1,18,1,18,5,18,2939,8,18,10,18,12,18,2942,9,18,3,18,2944,8,18,
+        1,19,1,19,1,19,3,19,2949,8,19,1,19,3,19,2952,8,19,1,19,1,19,1,20,
+        1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,23,1,23,1,23,5,23,2967,8,23,
+        10,23,12,23,2970,9,23,1,23,1,23,1,23,1,23,3,23,2976,8,23,1,23,1,
+        23,1,23,3,23,2981,8,23,5,23,2983,8,23,10,23,12,23,2986,9,23,1,23,
+        1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,5,23,2998,8,23,10,23,
+        12,23,3001,9,23,3,23,3003,8,23,1,24,1,24,1,25,1,25,1,25,1,25,1,25,
+        1,25,1,25,1,25,1,25,5,25,3016,8,25,10,25,12,25,3019,9,25,1,25,1,
+        25,1,25,1,25,1,25,5,25,3026,8,25,10,25,12,25,3029,9,25,1,25,1,25,
+        1,25,1,25,1,25,1,25,1,25,1,25,1,25,5,25,3040,8,25,10,25,12,25,3043,
+        9,25,3,25,3045,8,25,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,
+        1,26,1,26,3,26,3058,8,26,1,27,1,27,1,27,1,27,1,27,1,27,3,27,3066,
+        8,27,1,27,1,27,1,27,1,27,3,27,3072,8,27,1,27,1,27,3,27,3076,8,27,
+        1,28,1,28,1,28,1,28,1,28,3,28,3083,8,28,1,28,1,28,3,28,3087,8,28,
+        1,29,1,29,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,5,30,3100,
+        8,30,10,30,12,30,3103,9,30,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,
+        32,1,32,1,32,1,32,1,32,1,32,5,32,3118,8,32,10,32,12,32,3121,9,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,5,32,3131,8,32,10,32,12,
+        32,3134,9,32,1,32,1,32,1,32,3,32,3139,8,32,1,33,1,33,1,33,1,33,1,
+        33,5,33,3146,8,33,10,33,12,33,3149,9,33,1,33,1,33,1,33,1,33,1,33,
+        5,33,3156,8,33,10,33,12,33,3159,9,33,1,33,3,33,3162,8,33,1,33,1,
+        33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,5,33,3173,8,33,10,33,12,33,
+        3176,9,33,3,33,3178,8,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,3,34,
+        3187,8,34,1,34,1,34,1,34,1,34,1,34,1,34,3,34,3195,8,34,5,34,3197,
+        8,34,10,34,12,34,3200,9,34,1,34,1,34,1,34,1,34,1,34,5,34,3207,8,
+        34,10,34,12,34,3210,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,
+        1,35,5,35,3221,8,35,10,35,12,35,3224,9,35,1,35,1,35,1,35,1,35,1,
+        35,5,35,3231,8,35,10,35,12,35,3234,9,35,1,36,1,36,1,36,1,36,1,36,
+        3,36,3241,8,36,1,36,3,36,3244,8,36,1,36,1,36,3,36,3248,8,36,1,36,
+        3,36,3251,8,36,1,36,3,36,3254,8,36,1,36,3,36,3257,8,36,1,37,1,37,
+        1,37,1,37,1,37,1,37,1,37,1,37,3,37,3267,8,37,1,37,1,37,1,37,1,37,
+        1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
+        3,37,3286,8,37,1,38,1,38,1,39,1,39,1,40,1,40,1,40,1,40,3,40,3296,
+        8,40,1,41,1,41,1,41,1,41,1,41,1,41,3,41,3304,8,41,1,41,1,41,1,41,
+        3,41,3309,8,41,1,41,1,41,1,41,1,41,3,41,3315,8,41,1,42,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,44,
+        1,44,1,44,1,44,3,44,3336,8,44,1,45,1,45,1,46,1,46,1,46,1,47,1,47,
+        3,47,3345,8,47,1,47,3,47,3348,8,47,1,47,1,47,3,47,3352,8,47,3,47,
+        3354,8,47,1,48,1,48,1,48,1,48,1,48,5,48,3361,8,48,10,48,12,48,3364,
+        9,48,1,48,3,48,3367,8,48,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,3,50,3383,8,50,1,50,1,50,1,50,1,50,
+        1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,3397,8,50,3,50,3399,
+        8,50,1,50,3,50,3402,8,50,1,50,1,50,3,50,3406,8,50,1,51,1,51,1,51,
+        1,51,1,51,3,51,3413,8,51,1,51,1,51,1,51,1,51,1,51,3,51,3420,8,51,
+        1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,3429,8,52,1,52,5,52,3432,
+        8,52,10,52,12,52,3435,9,52,1,52,1,52,3,52,3439,8,52,3,52,3441,8,
+        52,1,53,1,53,1,53,1,53,1,53,1,53,3,53,3449,8,53,1,53,1,53,1,53,1,
+        53,1,53,1,53,3,53,3457,8,53,1,53,1,53,3,53,3461,8,53,1,53,1,53,4,
+        53,3465,8,53,11,53,12,53,3466,1,53,1,53,3,53,3471,8,53,1,53,1,53,
+        1,53,3,53,3476,8,53,1,54,1,54,1,55,1,55,1,55,3,55,3483,8,55,1,55,
+        3,55,3486,8,55,1,55,1,55,1,55,1,55,1,55,1,55,5,55,3494,8,55,10,55,
+        12,55,3497,9,55,1,55,1,55,3,55,3501,8,55,1,55,1,55,1,55,1,55,1,55,
+        3,55,3508,8,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,5,55,3517,8,55,
+        10,55,12,55,3520,9,55,1,55,1,55,3,55,3524,8,55,1,55,3,55,3527,8,
+        55,1,55,1,55,3,55,3531,8,55,1,55,1,55,1,55,3,55,3536,8,55,1,56,1,
+        56,1,56,1,56,1,56,1,56,1,56,1,56,1,57,1,57,3,57,3548,8,57,1,58,1,
+        58,1,58,1,58,1,58,1,58,1,58,3,58,3557,8,58,1,58,3,58,3560,8,58,1,
+        58,1,58,1,59,1,59,3,59,3566,8,59,1,59,1,59,1,59,1,59,3,59,3572,8,
+        59,1,60,1,60,1,60,1,60,1,60,1,60,5,60,3580,8,60,10,60,12,60,3583,
+        9,60,1,60,1,60,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,63,1,63,
+        1,63,3,63,3598,8,63,1,63,1,63,1,63,1,64,1,64,1,64,1,65,1,65,1,65,
+        1,65,1,65,5,65,3611,8,65,10,65,12,65,3614,9,65,1,65,1,65,1,66,1,
+        66,1,66,1,66,1,66,1,67,1,67,1,67,3,67,3626,8,67,1,67,1,67,4,67,3630,
+        8,67,11,67,12,67,3631,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,
+        68,1,68,3,68,3644,8,68,1,69,1,69,1,69,1,69,1,69,1,69,1,69,3,69,3653,
+        8,69,1,69,1,69,1,69,3,69,3658,8,69,1,70,1,70,1,70,1,70,1,70,1,70,
+        1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,3674,8,70,3,70,3676,
+        8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,
+        1,71,1,71,3,71,3692,8,71,3,71,3694,8,71,1,72,1,72,1,72,1,72,1,72,
+        1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,
+        1,72,3,72,3715,8,72,3,72,3717,8,72,1,73,1,73,1,73,1,73,1,73,1,73,
+        1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,
+        3737,8,73,3,73,3739,8,73,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,
+        1,74,1,74,1,74,4,74,3752,8,74,11,74,12,74,3753,1,74,1,74,1,74,1,
+        74,1,74,1,74,1,74,3,74,3763,8,74,3,74,3765,8,74,1,75,1,75,1,75,1,
+        75,1,75,1,75,1,75,1,75,1,75,3,75,3776,8,75,1,76,1,76,1,76,5,76,3781,
+        8,76,10,76,12,76,3784,9,76,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,
+        79,1,79,1,79,3,79,3796,8,79,1,79,1,79,1,79,3,79,3801,8,79,1,79,1,
+        79,1,80,1,80,1,80,1,80,1,80,3,80,3810,8,80,1,80,3,80,3813,8,80,1,
+        80,5,80,3816,8,80,10,80,12,80,3819,9,80,1,80,1,80,3,80,3823,8,80,
+        1,81,1,81,1,81,3,81,3828,8,81,1,81,3,81,3831,8,81,1,81,1,81,1,81,
+        1,81,3,81,3837,8,81,1,81,1,81,3,81,3841,8,81,1,81,1,81,5,81,3845,
+        8,81,10,81,12,81,3848,9,81,1,81,1,81,3,81,3852,8,81,1,82,1,82,1,
+        82,3,82,3857,8,82,1,82,3,82,3860,8,82,1,82,1,82,1,82,1,82,1,82,3,
+        82,3867,8,82,1,82,1,82,1,82,5,82,3872,8,82,10,82,12,82,3875,9,82,
+        1,82,1,82,1,82,1,82,4,82,3881,8,82,11,82,12,82,3882,3,82,3885,8,
+        82,3,82,3887,8,82,1,82,1,82,3,82,3891,8,82,1,83,1,83,1,83,1,83,1,
+        83,1,83,1,83,1,83,3,83,3901,8,83,1,84,1,84,1,84,1,84,1,84,1,84,5,
+        84,3909,8,84,10,84,12,84,3912,9,84,1,84,1,84,3,84,3916,8,84,1,84,
+        1,84,1,84,5,84,3921,8,84,10,84,12,84,3924,9,84,1,84,1,84,3,84,3928,
+        8,84,1,84,1,84,1,85,1,85,1,85,1,85,1,85,1,85,5,85,3938,8,85,10,85,
+        12,85,3941,9,85,1,85,1,85,3,85,3945,8,85,1,85,1,85,1,85,1,85,1,85,
+        1,85,1,85,5,85,3954,8,85,10,85,12,85,3957,9,85,1,85,1,85,3,85,3961,
+        8,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,3,86,3976,8,86,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,
+        1,87,3,87,3988,8,87,1,87,1,87,3,87,3992,8,87,1,87,3,87,3995,8,87,
+        1,87,3,87,3998,8,87,1,88,1,88,1,88,1,88,1,88,3,88,4005,8,88,1,88,
+        1,88,3,88,4009,8,88,1,88,3,88,4012,8,88,1,89,1,89,1,89,1,89,1,90,
+        1,90,1,90,1,90,1,90,3,90,4023,8,90,1,90,5,90,4026,8,90,10,90,12,
+        90,4029,9,90,1,90,1,90,3,90,4033,8,90,1,91,1,91,1,91,1,91,1,91,1,
+        91,5,91,4041,8,91,10,91,12,91,4044,9,91,1,91,1,91,3,91,4048,8,91,
+        1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,5,91,4058,8,91,10,91,12,
+        91,4061,9,91,1,91,1,91,3,91,4065,8,91,1,91,3,91,4068,8,91,1,91,1,
+        91,3,91,4072,8,91,1,91,1,91,1,91,3,91,4077,8,91,1,91,1,91,1,92,1,
+        92,1,92,1,92,1,92,1,92,5,92,4087,8,92,10,92,12,92,4090,9,92,1,92,
+        1,92,3,92,4094,8,92,1,92,1,92,1,92,5,92,4099,8,92,10,92,12,92,4102,
+        9,92,1,92,1,92,3,92,4106,8,92,1,92,3,92,4109,8,92,1,92,1,92,1,92,
+        3,92,4114,8,92,1,92,1,92,1,93,1,93,1,93,3,93,4121,8,93,1,93,3,93,
+        4124,8,93,1,93,1,93,1,93,1,93,1,93,1,93,5,93,4132,8,93,10,93,12,
+        93,4135,9,93,1,93,1,93,3,93,4139,8,93,1,93,3,93,4142,8,93,1,93,5,
+        93,4145,8,93,10,93,12,93,4148,9,93,1,93,1,93,3,93,4152,8,93,1,93,
+        3,93,4155,8,93,1,93,1,93,1,93,3,93,4160,8,93,1,94,1,94,1,94,1,94,
+        1,94,4,94,4167,8,94,11,94,12,94,4168,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,3,96,4185,8,96,3,96,4187,
+        8,96,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,3,97,4197,8,97,1,98,
+        1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,100,1,100,1,100,1,100,
+        1,100,4,100,4213,8,100,11,100,12,100,4214,1,101,1,101,1,101,1,101,
+        1,101,3,101,4222,8,101,1,101,1,101,1,101,3,101,4227,8,101,1,102,
+        1,102,1,103,1,103,3,103,4233,8,103,1,103,1,103,1,103,1,103,1,103,
+        1,103,5,103,4241,8,103,10,103,12,103,4244,9,103,1,104,1,104,1,104,
+        1,104,1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,3,105,
+        4259,8,105,1,105,5,105,4262,8,105,10,105,12,105,4265,9,105,1,105,
+        1,105,3,105,4269,8,105,3,105,4271,8,105,1,106,1,106,1,106,3,106,
+        4276,8,106,1,106,3,106,4279,8,106,1,106,1,106,1,106,1,106,1,106,
+        3,106,4286,8,106,1,106,3,106,4289,8,106,1,106,3,106,4292,8,106,1,
+        106,3,106,4295,8,106,1,106,1,106,1,107,1,107,1,107,1,107,5,107,4303,
+        8,107,10,107,12,107,4306,9,107,1,108,1,108,1,108,1,108,1,108,1,109,
+        1,109,1,109,1,109,3,109,4317,8,109,1,109,1,109,3,109,4321,8,109,
+        1,109,3,109,4324,8,109,1,110,1,110,1,110,1,110,1,111,1,111,1,111,
+        3,111,4333,8,111,1,112,1,112,1,112,1,112,5,112,4339,8,112,10,112,
+        12,112,4342,9,112,1,112,1,112,1,112,1,112,1,112,3,112,4349,8,112,
+        1,112,3,112,4352,8,112,1,113,1,113,1,113,1,113,3,113,4358,8,113,
+        1,114,1,114,1,114,3,114,4363,8,114,1,114,4,114,4366,8,114,11,114,
+        12,114,4367,1,114,1,114,3,114,4372,8,114,1,115,1,115,1,115,1,115,
+        1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,
+        1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,
+        1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,3,115,
+        4410,8,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,116,1,116,1,116,1,116,1,116,1,116,
+        1,116,1,116,1,116,1,116,1,116,1,116,3,116,4438,8,116,1,117,1,117,
+        1,117,5,117,4443,8,117,10,117,12,117,4446,9,117,1,117,1,117,3,117,
+        4450,8,117,1,117,1,117,1,118,1,118,1,118,3,118,4457,8,118,1,119,
+        1,119,1,119,1,119,1,119,1,120,1,120,1,120,3,120,4467,8,120,1,120,
+        5,120,4470,8,120,10,120,12,120,4473,9,120,1,121,1,121,1,121,1,122,
+        1,122,1,122,3,122,4481,8,122,1,122,1,122,3,122,4485,8,122,1,123,
+        1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,3,123,4497,
+        8,123,1,123,3,123,4500,8,123,1,124,1,124,3,124,4504,8,124,1,124,
+        3,124,4507,8,124,1,124,5,124,4510,8,124,10,124,12,124,4513,9,124,
+        1,124,1,124,3,124,4517,8,124,1,125,1,125,3,125,4521,8,125,1,125,
+        1,125,1,125,1,125,1,125,1,125,5,125,4529,8,125,10,125,12,125,4532,
+        9,125,1,125,1,125,1,126,1,126,1,126,5,126,4539,8,126,10,126,12,126,
+        4542,9,126,1,127,1,127,1,127,3,127,4547,8,127,1,128,1,128,1,128,
+        1,128,3,128,4553,8,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,
+        5,128,4562,8,128,10,128,12,128,4565,9,128,1,128,1,128,3,128,4569,
+        8,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,5,128,4578,8,128,
+        10,128,12,128,4581,9,128,1,128,1,128,3,128,4585,8,128,3,128,4587,
+        8,128,1,129,1,129,1,129,1,129,1,129,1,129,3,129,4595,8,129,1,130,
+        1,130,1,130,1,130,1,130,1,130,3,130,4603,8,130,1,130,1,130,1,130,
+        3,130,4608,8,130,1,130,3,130,4611,8,130,3,130,4613,8,130,1,131,3,
+        131,4616,8,131,1,131,1,131,1,131,1,131,1,132,1,132,3,132,4624,8,
+        132,1,133,1,133,1,133,3,133,4629,8,133,1,133,3,133,4632,8,133,1,
+        133,1,133,1,133,1,134,1,134,1,134,3,134,4640,8,134,1,134,3,134,4643,
+        8,134,1,134,1,134,1,134,1,135,1,135,1,135,3,135,4651,8,135,1,135,
+        3,135,4654,8,135,1,135,3,135,4657,8,135,1,136,3,136,4660,8,136,1,
+        136,1,136,3,136,4664,8,136,1,136,3,136,4667,8,136,1,136,1,136,1,
+        136,1,136,5,136,4673,8,136,10,136,12,136,4676,9,136,1,136,1,136,
+        3,136,4680,8,136,1,136,5,136,4683,8,136,10,136,12,136,4686,9,136,
+        1,137,1,137,1,137,1,137,3,137,4692,8,137,1,138,1,138,1,138,1,139,
+        1,139,1,139,1,139,1,139,3,139,4702,8,139,1,140,1,140,1,140,1,140,
+        1,140,1,140,1,140,1,140,1,141,1,141,1,141,1,141,4,141,4716,8,141,
+        11,141,12,141,4717,1,141,1,141,1,142,1,142,1,142,3,142,4725,8,142,
+        1,143,1,143,1,143,1,143,1,144,3,144,4732,8,144,1,144,1,144,1,144,
+        3,144,4737,8,144,1,145,1,145,1,145,1,145,1,145,1,145,5,145,4745,
+        8,145,10,145,12,145,4748,9,145,1,145,1,145,3,145,4752,8,145,1,145,
+        1,145,1,145,3,145,4757,8,145,1,145,3,145,4760,8,145,1,145,1,145,
+        1,145,3,145,4765,8,145,1,146,1,146,1,146,1,146,1,146,1,146,5,146,
+        4773,8,146,10,146,12,146,4776,9,146,1,146,1,146,3,146,4780,8,146,
+        1,146,1,146,1,146,1,146,1,146,3,146,4787,8,146,1,146,3,146,4790,
+        8,146,1,146,1,146,1,146,3,146,4795,8,146,1,147,3,147,4798,8,147,
+        1,147,3,147,4801,8,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147,
+        1,147,1,147,1,147,3,147,4813,8,147,1,147,1,147,1,147,5,147,4818,
+        8,147,10,147,12,147,4821,9,147,3,147,4823,8,147,1,147,3,147,4826,
+        8,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147,3,147,4835,8,147,
+        1,147,3,147,4838,8,147,1,147,1,147,1,147,3,147,4843,8,147,1,148,
+        3,148,4846,8,148,1,148,1,148,1,149,1,149,1,149,3,149,4853,8,149,
+        1,149,3,149,4856,8,149,1,150,1,150,1,150,1,150,1,151,3,151,4863,
+        8,151,1,151,4,151,4866,8,151,11,151,12,151,4867,1,151,1,151,3,151,
+        4872,8,151,1,152,1,152,1,152,3,152,4877,8,152,1,153,1,153,1,153,
+        3,153,4882,8,153,1,154,1,154,1,154,1,154,1,154,1,154,3,154,4890,
+        8,154,1,155,1,155,1,155,1,155,1,155,1,155,5,155,4898,8,155,10,155,
+        12,155,4901,9,155,1,155,1,155,3,155,4905,8,155,1,155,1,155,1,155,
+        1,155,1,155,3,155,4912,8,155,1,155,3,155,4915,8,155,1,155,1,155,
+        3,155,4919,8,155,1,155,3,155,4922,8,155,1,155,3,155,4925,8,155,1,
+        155,3,155,4928,8,155,1,156,1,156,1,156,1,156,1,156,1,156,5,156,4936,
+        8,156,10,156,12,156,4939,9,156,1,156,1,156,3,156,4943,8,156,1,156,
+        1,156,1,156,3,156,4948,8,156,1,156,3,156,4951,8,156,1,156,1,156,
+        1,156,3,156,4956,8,156,1,157,1,157,1,157,1,157,1,157,1,157,5,157,
+        4964,8,157,10,157,12,157,4967,9,157,1,157,1,157,3,157,4971,8,157,
+        1,157,1,157,3,157,4975,8,157,1,158,1,158,1,158,1,158,1,158,1,158,
+        5,158,4983,8,158,10,158,12,158,4986,9,158,1,158,1,158,3,158,4990,
+        8,158,1,158,1,158,1,158,1,158,1,158,3,158,4997,8,158,1,158,1,158,
+        1,158,1,158,3,158,5003,8,158,1,158,1,158,3,158,5007,8,158,1,159,
+        3,159,5010,8,159,1,159,3,159,5013,8,159,1,159,1,159,1,159,1,159,
+        1,159,1,159,1,159,1,159,1,159,1,159,3,159,5025,8,159,1,159,1,159,
+        1,159,5,159,5030,8,159,10,159,12,159,5033,9,159,3,159,5035,8,159,
+        1,159,3,159,5038,8,159,1,159,1,159,1,159,1,159,1,159,1,159,3,159,
+        5046,8,159,1,160,1,160,1,160,1,160,1,161,1,161,1,161,1,161,1,161,
+        1,161,5,161,5058,8,161,10,161,12,161,5061,9,161,1,161,1,161,1,162,
+        1,162,3,162,5067,8,162,1,163,1,163,1,163,1,163,1,163,1,163,1,163,
+        1,163,1,163,1,163,3,163,5079,8,163,1,163,1,163,1,163,3,163,5084,
+        8,163,1,164,1,164,1,164,1,164,1,165,1,165,1,165,1,165,4,165,5094,
+        8,165,11,165,12,165,5095,1,166,1,166,1,166,1,166,1,166,1,166,1,166,
+        1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,
+        3,166,5116,8,166,1,166,1,166,1,166,1,166,1,166,3,166,5123,8,166,
+        3,166,5125,8,166,1,166,1,166,3,166,5129,8,166,1,167,1,167,1,167,
+        1,167,4,167,5135,8,167,11,167,12,167,5136,1,167,1,167,1,167,1,167,
+        1,167,1,167,1,167,1,167,1,167,3,167,5148,8,167,1,167,1,167,1,167,
+        1,167,1,167,1,167,1,167,1,167,1,167,3,167,5159,8,167,3,167,5161,
+        8,167,1,168,1,168,1,168,1,168,1,168,3,168,5168,8,168,1,168,1,168,
+        5,168,5172,8,168,10,168,12,168,5175,9,168,1,168,1,168,1,168,3,168,
+        5180,8,168,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,
+        1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,1,169,
+        1,169,3,169,5203,8,169,1,169,1,169,1,169,3,169,5208,8,169,1,169,
+        1,169,1,169,3,169,5213,8,169,1,170,1,170,1,170,1,170,1,171,1,171,
+        1,171,3,171,5222,8,171,1,171,3,171,5225,8,171,1,171,1,171,1,171,
+        1,171,1,171,1,171,3,171,5233,8,171,1,171,5,171,5236,8,171,10,171,
+        12,171,5239,9,171,1,171,3,171,5242,8,171,1,171,3,171,5245,8,171,
+        1,171,3,171,5248,8,171,1,171,3,171,5251,8,171,1,171,3,171,5254,8,
+        171,1,171,3,171,5257,8,171,1,171,3,171,5260,8,171,1,171,3,171,5263,
+        8,171,1,172,1,172,3,172,5267,8,172,1,172,3,172,5270,8,172,1,172,
+        3,172,5273,8,172,1,172,5,172,5276,8,172,10,172,12,172,5279,9,172,
+        1,172,3,172,5282,8,172,1,172,3,172,5285,8,172,1,172,4,172,5288,8,
+        172,11,172,12,172,5289,3,172,5292,8,172,1,173,1,173,1,173,1,174,
+        1,174,1,174,1,175,1,175,1,175,1,175,3,175,5304,8,175,1,175,1,175,
+        3,175,5308,8,175,1,176,1,176,3,176,5312,8,176,1,177,1,177,1,177,
+        1,177,3,177,5318,8,177,1,177,1,177,3,177,5322,8,177,1,177,3,177,
+        5325,8,177,1,177,3,177,5328,8,177,1,178,1,178,1,178,1,178,1,178,
+        1,178,5,178,5336,8,178,10,178,12,178,5339,9,178,1,178,1,178,1,179,
+        1,179,5,179,5345,8,179,10,179,12,179,5348,9,179,1,179,1,179,1,179,
+        1,179,1,179,3,179,5355,8,179,1,179,1,179,1,179,1,179,1,179,3,179,
+        5362,8,179,1,179,5,179,5365,8,179,10,179,12,179,5368,9,179,1,179,
+        1,179,1,179,1,179,1,179,3,179,5375,8,179,1,179,3,179,5378,8,179,
+        1,179,1,179,3,179,5382,8,179,1,179,1,179,1,179,1,179,5,179,5388,
+        8,179,10,179,12,179,5391,9,179,1,179,1,179,1,179,3,179,5396,8,179,
+        1,179,1,179,1,179,1,179,1,179,5,179,5403,8,179,10,179,12,179,5406,
+        9,179,1,179,1,179,1,180,1,180,1,180,3,180,5413,8,180,1,180,1,180,
+        3,180,5417,8,180,1,180,3,180,5420,8,180,1,181,1,181,1,181,3,181,
+        5425,8,181,1,181,1,181,3,181,5429,8,181,1,181,3,181,5432,8,181,1,
+        181,3,181,5435,8,181,1,182,1,182,1,182,1,182,1,182,5,182,5442,8,
+        182,10,182,12,182,5445,9,182,1,182,1,182,1,183,1,183,1,183,3,183,
+        5452,8,183,1,184,1,184,1,184,3,184,5457,8,184,1,185,1,185,1,185,
+        1,185,1,186,1,186,1,186,1,186,1,186,1,187,1,187,1,187,1,187,1,188,
+        1,188,1,188,1,188,1,188,1,189,1,189,1,189,1,189,5,189,5481,8,189,
+        10,189,12,189,5484,9,189,1,190,1,190,1,190,1,190,1,190,1,190,1,190,
+        5,190,5493,8,190,10,190,12,190,5496,9,190,1,190,1,190,1,190,1,190,
+        5,190,5502,8,190,10,190,12,190,5505,9,190,3,190,5507,8,190,1,191,
+        1,191,1,191,1,191,1,191,5,191,5514,8,191,10,191,12,191,5517,9,191,
+        1,191,1,191,1,191,1,192,1,192,1,192,1,192,3,192,5526,8,192,1,192,
+        1,192,1,192,3,192,5531,8,192,1,192,1,192,1,192,1,193,1,193,1,193,
+        1,193,1,193,1,193,3,193,5542,8,193,1,193,3,193,5545,8,193,3,193,
+        5547,8,193,1,194,1,194,1,194,1,194,3,194,5553,8,194,1,194,1,194,
+        1,194,3,194,5558,8,194,1,194,5,194,5561,8,194,10,194,12,194,5564,
+        9,194,3,194,5566,8,194,1,195,1,195,1,195,1,195,3,195,5572,8,195,
+        1,196,1,196,1,196,3,196,5577,8,196,1,196,3,196,5580,8,196,1,196,
+        1,196,1,196,1,196,1,196,3,196,5587,8,196,1,196,1,196,1,196,1,196,
+        3,196,5593,8,196,1,196,5,196,5596,8,196,10,196,12,196,5599,9,196,
+        1,196,1,196,1,196,3,196,5604,8,196,1,196,1,196,1,196,4,196,5609,
+        8,196,11,196,12,196,5610,1,196,3,196,5614,8,196,1,197,1,197,1,197,
+        1,197,5,197,5620,8,197,10,197,12,197,5623,9,197,1,197,5,197,5626,
+        8,197,10,197,12,197,5629,9,197,1,198,1,198,1,198,3,198,5634,8,198,
+        1,198,1,198,3,198,5638,8,198,1,198,3,198,5641,8,198,1,198,3,198,
+        5644,8,198,1,199,1,199,1,199,1,199,1,199,1,199,1,200,1,200,1,200,
+        5,200,5655,8,200,10,200,12,200,5658,9,200,1,201,1,201,1,201,3,201,
+        5663,8,201,1,201,1,201,1,201,1,201,1,201,3,201,5670,8,201,1,201,
+        1,201,1,202,1,202,1,202,1,202,1,202,5,202,5679,8,202,10,202,12,202,
+        5682,9,202,1,202,1,202,1,203,1,203,1,203,3,203,5689,8,203,1,203,
+        1,203,3,203,5693,8,203,1,203,3,203,5696,8,203,1,203,5,203,5699,8,
+        203,10,203,12,203,5702,9,203,1,204,1,204,1,204,1,204,1,204,1,204,
+        1,204,3,204,5711,8,204,1,204,1,204,1,204,3,204,5716,8,204,1,204,
+        5,204,5719,8,204,10,204,12,204,5722,9,204,1,204,1,204,3,204,5726,
+        8,204,1,204,1,204,1,204,3,204,5731,8,204,1,204,1,204,1,204,3,204,
+        5736,8,204,1,204,1,204,1,204,3,204,5741,8,204,1,204,1,204,1,204,
+        3,204,5746,8,204,1,204,1,204,1,204,3,204,5751,8,204,1,204,5,204,
+        5754,8,204,10,204,12,204,5757,9,204,3,204,5759,8,204,1,204,1,204,
+        1,204,1,204,1,204,5,204,5766,8,204,10,204,12,204,5769,9,204,1,204,
+        1,204,3,204,5773,8,204,1,205,1,205,1,205,1,205,1,205,1,205,5,205,
+        5781,8,205,10,205,12,205,5784,9,205,1,205,1,205,3,205,5788,8,205,
+        1,206,1,206,1,206,1,207,1,207,3,207,5795,8,207,1,207,1,207,3,207,
+        5799,8,207,1,208,1,208,1,208,1,208,1,208,1,208,1,208,3,208,5808,
+        8,208,1,208,1,208,1,208,1,208,1,208,3,208,5815,8,208,1,208,1,208,
+        3,208,5819,8,208,1,209,1,209,1,209,1,209,1,209,3,209,5826,8,209,
+        1,209,3,209,5829,8,209,1,209,3,209,5832,8,209,1,209,1,209,1,209,
+        1,209,1,209,1,209,3,209,5840,8,209,1,209,1,209,3,209,5844,8,209,
+        1,209,3,209,5847,8,209,1,210,1,210,1,210,1,210,5,210,5853,8,210,
+        10,210,12,210,5856,9,210,1,211,1,211,1,211,4,211,5861,8,211,11,211,
+        12,211,5862,1,212,1,212,1,212,1,212,5,212,5869,8,212,10,212,12,212,
+        5872,9,212,1,213,1,213,1,213,1,213,5,213,5878,8,213,10,213,12,213,
+        5881,9,213,1,214,1,214,3,214,5885,8,214,1,214,1,214,1,214,1,214,
+        1,214,3,214,5892,8,214,1,214,1,214,1,214,3,214,5897,8,214,1,214,
+        3,214,5900,8,214,1,214,1,214,3,214,5904,8,214,3,214,5906,8,214,1,
+        215,1,215,1,216,1,216,1,216,1,216,1,216,1,216,1,216,3,216,5917,8,
+        216,1,217,1,217,1,217,1,217,1,217,1,217,1,217,5,217,5926,8,217,10,
+        217,12,217,5929,9,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217,
+        1,217,1,217,5,217,5940,8,217,10,217,12,217,5943,9,217,1,217,1,217,
+        3,217,5947,8,217,1,218,1,218,1,219,1,219,1,219,1,219,5,219,5955,
+        8,219,10,219,12,219,5958,9,219,1,220,1,220,1,220,3,220,5963,8,220,
+        1,220,3,220,5966,8,220,1,220,1,220,1,220,3,220,5971,8,220,1,220,
+        1,220,1,220,1,220,1,220,5,220,5978,8,220,10,220,12,220,5981,9,220,
+        3,220,5983,8,220,1,220,5,220,5986,8,220,10,220,12,220,5989,9,220,
+        1,220,3,220,5992,8,220,1,221,1,221,1,221,1,221,1,221,1,221,1,221,
+        1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,
+        1,221,1,221,1,221,1,221,3,221,6016,8,221,3,221,6018,8,221,1,222,
+        1,222,3,222,6022,8,222,1,222,3,222,6025,8,222,1,222,1,222,1,222,
+        3,222,6030,8,222,1,222,3,222,6033,8,222,1,222,5,222,6036,8,222,10,
+        222,12,222,6039,9,222,1,223,1,223,1,223,1,223,1,224,1,224,3,224,
+        6047,8,224,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,
+        3,225,6058,8,225,1,225,3,225,6061,8,225,1,225,3,225,6064,8,225,1,
+        225,3,225,6067,8,225,1,225,1,225,3,225,6071,8,225,1,225,1,225,1,
+        225,1,225,5,225,6077,8,225,10,225,12,225,6080,9,225,4,225,6082,8,
+        225,11,225,12,225,6083,1,225,1,225,1,225,1,225,1,225,1,225,1,225,
+        1,225,5,225,6094,8,225,10,225,12,225,6097,9,225,3,225,6099,8,225,
+        1,226,1,226,1,226,3,226,6104,8,226,1,226,1,226,3,226,6108,8,226,
+        1,226,3,226,6111,8,226,1,227,1,227,1,227,1,227,1,227,1,227,1,227,
+        3,227,6120,8,227,1,228,1,228,1,228,1,228,3,228,6126,8,228,1,228,
+        1,228,1,228,1,228,3,228,6132,8,228,1,228,3,228,6135,8,228,1,228,
+        1,228,3,228,6139,8,228,1,228,1,228,1,229,1,229,1,229,1,229,1,230,
+        1,230,1,230,1,230,1,231,1,231,1,231,3,231,6154,8,231,1,231,3,231,
+        6157,8,231,1,231,3,231,6160,8,231,1,231,1,231,1,231,1,231,3,231,
+        6166,8,231,1,231,1,231,1,231,1,231,3,231,6172,8,231,1,231,5,231,
+        6175,8,231,10,231,12,231,6178,9,231,1,231,1,231,1,231,3,231,6183,
+        8,231,1,232,1,232,1,232,1,232,3,232,6189,8,232,1,232,1,232,1,233,
+        1,233,1,233,1,233,3,233,6197,8,233,4,233,6199,8,233,11,233,12,233,
+        6200,1,233,1,233,1,234,1,234,1,234,1,234,1,234,1,234,1,235,1,235,
+        5,235,6213,8,235,10,235,12,235,6216,9,235,1,236,1,236,1,237,1,237,
+        3,237,6222,8,237,1,237,1,237,1,237,1,237,1,237,3,237,6229,8,237,
+        1,237,1,237,1,237,1,237,3,237,6235,8,237,1,237,3,237,6238,8,237,
+        1,237,1,237,3,237,6242,8,237,1,238,1,238,1,238,3,238,6247,8,238,
+        1,239,1,239,1,239,3,239,6252,8,239,1,239,1,239,1,240,1,240,3,240,
+        6258,8,240,1,240,1,240,1,240,3,240,6263,8,240,1,240,1,240,1,240,
+        3,240,6268,8,240,5,240,6270,8,240,10,240,12,240,6273,9,240,1,240,
+        1,240,3,240,6277,8,240,1,241,1,241,1,241,1,241,3,241,6283,8,241,
+        1,241,1,241,3,241,6287,8,241,1,241,1,241,1,241,3,241,6292,8,241,
+        1,241,1,241,3,241,6296,8,241,5,241,6298,8,241,10,241,12,241,6301,
+        9,241,1,241,1,241,1,241,1,241,1,241,1,241,1,241,1,241,5,241,6311,
+        8,241,10,241,12,241,6314,9,241,1,241,1,241,3,241,6318,8,241,1,241,
+        3,241,6321,8,241,1,242,1,242,3,242,6325,8,242,1,243,1,243,1,243,
+        4,243,6330,8,243,11,243,12,243,6331,1,243,1,243,1,243,1,243,3,243,
+        6338,8,243,3,243,6340,8,243,1,244,1,244,3,244,6344,8,244,1,244,3,
+        244,6347,8,244,1,244,1,244,1,244,1,244,1,244,3,244,6354,8,244,1,
+        245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,3,245,6365,8,
+        245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,3,245,6375,8,
+        245,5,245,6377,8,245,10,245,12,245,6380,9,245,1,245,1,245,3,245,
+        6384,8,245,1,246,1,246,3,246,6388,8,246,1,246,1,246,3,246,6392,8,
+        246,1,246,3,246,6395,8,246,1,247,1,247,1,247,1,247,1,247,1,247,1,
+        247,5,247,6404,8,247,10,247,12,247,6407,9,247,1,247,1,247,3,247,
+        6411,8,247,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248,5,248,
+        6421,8,248,10,248,12,248,6424,9,248,1,248,1,248,1,248,1,248,1,248,
+        5,248,6431,8,248,10,248,12,248,6434,9,248,1,248,1,248,1,248,1,248,
+        1,248,1,248,1,248,5,248,6443,8,248,10,248,12,248,6446,9,248,1,248,
+        1,248,1,248,3,248,6451,8,248,3,248,6453,8,248,1,249,1,249,3,249,
+        6457,8,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,3,249,6466,
+        8,249,1,250,1,250,1,250,5,250,6471,8,250,10,250,12,250,6474,9,250,
+        1,250,1,250,1,250,1,250,1,250,5,250,6481,8,250,10,250,12,250,6484,
+        9,250,3,250,6486,8,250,1,251,1,251,1,251,1,251,1,251,3,251,6493,
+        8,251,1,252,1,252,1,252,1,252,5,252,6499,8,252,10,252,12,252,6502,
+        9,252,1,252,1,252,1,253,1,253,1,253,1,253,5,253,6510,8,253,10,253,
+        12,253,6513,9,253,1,253,1,253,1,254,1,254,3,254,6519,8,254,1,254,
+        1,254,5,254,6523,8,254,10,254,12,254,6526,9,254,1,254,3,254,6529,
+        8,254,1,255,1,255,1,255,1,255,1,255,1,255,5,255,6537,8,255,10,255,
+        12,255,6540,9,255,1,255,1,255,1,255,1,255,1,255,1,255,5,255,6548,
+        8,255,10,255,12,255,6551,9,255,1,255,1,255,3,255,6555,8,255,1,256,
+        1,256,3,256,6559,8,256,1,256,1,256,3,256,6563,8,256,1,256,3,256,
+        6566,8,256,1,256,3,256,6569,8,256,1,257,1,257,1,257,1,257,1,257,
+        1,257,5,257,6577,8,257,10,257,12,257,6580,9,257,1,257,1,257,3,257,
+        6584,8,257,1,257,1,257,1,257,1,257,5,257,6590,8,257,10,257,12,257,
+        6593,9,257,1,257,1,257,1,258,1,258,3,258,6599,8,258,1,258,1,258,
+        5,258,6603,8,258,10,258,12,258,6606,9,258,1,258,3,258,6609,8,258,
+        1,258,3,258,6612,8,258,1,259,1,259,1,259,1,259,1,259,1,259,5,259,
+        6620,8,259,10,259,12,259,6623,9,259,1,259,1,259,1,259,1,259,1,259,
+        1,259,5,259,6631,8,259,10,259,12,259,6634,9,259,1,259,1,259,3,259,
+        6638,8,259,1,260,1,260,3,260,6642,8,260,1,260,1,260,3,260,6646,8,
+        260,1,260,3,260,6649,8,260,1,260,3,260,6652,8,260,1,261,1,261,1,
+        262,1,262,1,262,3,262,6659,8,262,1,262,1,262,1,263,1,263,1,263,1,
+        263,1,263,3,263,6668,8,263,1,264,1,264,1,264,1,264,1,264,1,264,4,
+        264,6676,8,264,11,264,12,264,6677,1,265,1,265,1,265,1,265,1,265,
+        1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,
+        1,265,1,265,1,265,1,265,1,265,3,265,6701,8,265,1,266,1,266,1,267,
+        1,267,1,268,1,268,1,268,1,268,1,268,1,268,1,268,3,268,6714,8,268,
+        1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,
+        1,268,5,268,6728,8,268,10,268,12,268,6731,9,268,1,269,1,269,1,269,
+        1,269,1,269,1,269,1,269,1,269,3,269,6741,8,269,1,270,1,270,1,270,
+        1,270,1,270,1,270,3,270,6749,8,270,1,270,1,270,1,270,1,270,3,270,
+        6755,8,270,1,270,3,270,6758,8,270,1,271,1,271,1,271,3,271,6763,8,
+        271,1,271,1,271,3,271,6767,8,271,1,271,3,271,6770,8,271,1,271,3,
+        271,6773,8,271,1,272,1,272,1,272,3,272,6778,8,272,1,273,1,273,1,
+        273,1,273,4,273,6784,8,273,11,273,12,273,6785,1,273,1,273,1,273,
+        1,273,1,273,1,273,1,273,1,273,1,273,1,273,3,273,6798,8,273,1,274,
+        1,274,1,274,1,274,1,274,1,274,3,274,6806,8,274,1,275,1,275,1,275,
+        1,275,1,275,3,275,6813,8,275,1,275,1,275,1,275,1,276,1,276,1,276,
+        1,276,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,5,277,6830,
+        8,277,10,277,12,277,6833,9,277,1,277,1,277,1,277,1,277,1,277,1,277,
+        1,277,1,277,3,277,6843,8,277,1,277,3,277,6846,8,277,1,278,1,278,
+        1,278,1,278,4,278,6852,8,278,11,278,12,278,6853,1,278,1,278,1,278,
+        1,278,1,278,3,278,6861,8,278,1,278,3,278,6864,8,278,3,278,6866,8,
+        278,1,279,1,279,1,279,1,279,1,279,3,279,6873,8,279,1,280,1,280,1,
+        281,1,281,1,282,1,282,1,283,1,283,1,283,1,283,1,283,1,283,1,283,
+        3,283,6888,8,283,1,283,1,283,1,283,1,283,1,283,1,283,3,283,6896,
+        8,283,1,283,1,283,1,283,1,283,1,283,1,283,1,284,1,284,1,284,1,284,
+        1,284,1,284,3,284,6910,8,284,1,284,1,284,1,284,1,284,1,284,1,284,
+        1,284,1,284,1,284,4,284,6921,8,284,11,284,12,284,6922,1,285,1,285,
+        1,285,1,285,1,285,1,285,1,285,1,285,1,285,1,285,1,285,1,285,1,285,
+        1,285,4,285,6939,8,285,11,285,12,285,6940,1,285,1,285,1,285,5,285,
+        6946,8,285,10,285,12,285,6949,9,285,1,285,1,285,3,285,6953,8,285,
+        1,286,1,286,1,286,1,286,1,286,3,286,6960,8,286,1,286,3,286,6963,
+        8,286,1,287,1,287,1,287,3,287,6968,8,287,1,288,1,288,1,288,1,288,
+        1,289,1,289,1,289,1,289,3,289,6978,8,289,1,290,1,290,1,290,1,290,
+        1,291,1,291,1,291,3,291,6987,8,291,1,291,1,291,1,291,1,292,1,292,
+        1,292,1,293,1,293,1,293,5,293,6998,8,293,10,293,12,293,7001,9,293,
+        1,293,1,293,1,293,1,293,1,293,5,293,7008,8,293,10,293,12,293,7011,
+        9,293,5,293,7013,8,293,10,293,12,293,7016,9,293,3,293,7018,8,293,
+        1,294,1,294,1,294,1,294,3,294,7024,8,294,1,295,1,295,1,295,1,296,
+        1,296,1,296,1,297,1,297,1,297,1,298,1,298,1,298,1,298,1,298,5,298,
+        7040,8,298,10,298,12,298,7043,9,298,3,298,7045,8,298,1,298,3,298,
+        7048,8,298,1,299,1,299,1,299,1,299,1,299,1,299,3,299,7056,8,299,
+        1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,
+        3,299,7069,8,299,3,299,7071,8,299,1,299,1,299,3,299,7075,8,299,1,
+        299,1,299,1,299,1,299,1,299,1,299,3,299,7083,8,299,3,299,7085,8,
+        299,3,299,7087,8,299,3,299,7089,8,299,1,300,1,300,1,300,1,300,5,
+        300,7095,8,300,10,300,12,300,7098,9,300,1,300,1,300,1,301,1,301,
+        1,301,1,301,1,301,1,301,3,301,7108,8,301,1,302,1,302,1,302,1,302,
+        1,302,1,303,1,303,1,303,1,303,3,303,7119,8,303,3,303,7121,8,303,
+        1,304,1,304,1,304,1,304,1,304,1,304,1,304,3,304,7130,8,304,1,305,
+        1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,3,305,7141,8,305,
+        1,306,1,306,1,306,1,306,3,306,7147,8,306,1,306,1,306,1,306,1,306,
+        1,306,3,306,7154,8,306,1,306,1,306,1,306,1,306,1,307,1,307,1,307,
+        1,307,3,307,7164,8,307,1,307,1,307,3,307,7168,8,307,1,308,1,308,
+        1,308,1,309,1,309,1,309,1,309,3,309,7177,8,309,1,309,3,309,7180,
+        8,309,1,310,1,310,1,310,1,310,3,310,7186,8,310,1,310,3,310,7189,
+        8,310,1,310,1,310,1,310,3,310,7194,8,310,1,311,1,311,1,311,1,311,
+        3,311,7200,8,311,1,311,1,311,1,311,1,311,1,311,1,311,3,311,7208,
+        8,311,1,312,1,312,1,312,1,312,3,312,7214,8,312,1,312,1,312,1,312,
+        1,312,3,312,7220,8,312,1,312,1,312,1,312,1,312,1,312,1,312,1,313,
+        1,313,1,313,1,313,3,313,7232,8,313,1,313,1,313,1,313,1,313,1,313,
+        1,313,3,313,7240,8,313,1,314,3,314,7243,8,314,1,314,1,314,1,314,
+        1,314,1,314,1,314,1,314,1,314,1,314,3,314,7254,8,314,1,314,1,314,
+        3,314,7258,8,314,1,315,1,315,1,315,1,315,1,315,1,315,1,315,1,315,
+        1,315,3,315,7269,8,315,1,315,1,315,3,315,7273,8,315,1,316,1,316,
+        1,316,1,316,1,316,1,316,1,316,1,316,1,316,3,316,7284,8,316,1,317,
+        1,317,3,317,7288,8,317,1,317,1,317,1,317,1,317,3,317,7294,8,317,
+        1,317,3,317,7297,8,317,1,317,3,317,7300,8,317,1,317,3,317,7303,8,
+        317,1,317,3,317,7306,8,317,1,317,1,317,3,317,7310,8,317,1,317,3,
+        317,7313,8,317,1,318,1,318,3,318,7317,8,318,1,318,1,318,1,318,1,
+        318,3,318,7323,8,318,1,318,3,318,7326,8,318,1,318,3,318,7329,8,318,
+        1,318,3,318,7332,8,318,1,318,3,318,7335,8,318,1,318,1,318,3,318,
+        7339,8,318,1,318,3,318,7342,8,318,1,319,1,319,1,320,1,320,1,321,
+        1,321,3,321,7350,8,321,1,321,1,321,1,321,3,321,7355,8,321,1,321,
+        3,321,7358,8,321,1,321,1,321,3,321,7362,8,321,1,322,1,322,1,322,
+        1,322,1,322,1,322,3,322,7370,8,322,1,322,1,322,3,322,7374,8,322,
+        1,323,1,323,3,323,7378,8,323,1,323,1,323,1,323,1,323,1,323,1,323,
+        1,323,3,323,7387,8,323,1,323,1,323,1,323,1,323,1,323,1,323,1,323,
+        5,323,7396,8,323,10,323,12,323,7399,9,323,1,323,1,323,1,323,1,323,
+        3,323,7405,8,323,3,323,7407,8,323,1,324,1,324,3,324,7411,8,324,1,
+        324,1,324,1,324,1,324,1,324,1,324,1,324,3,324,7420,8,324,1,324,1,
+        324,3,324,7424,8,324,1,325,1,325,3,325,7428,8,325,1,325,1,325,1,
+        325,1,325,1,325,3,325,7435,8,325,1,325,1,325,1,325,1,325,3,325,7441,
+        8,325,1,326,1,326,3,326,7445,8,326,1,326,1,326,1,326,1,326,1,326,
+        3,326,7452,8,326,1,326,1,326,1,326,1,326,1,326,1,327,1,327,3,327,
+        7461,8,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,
+        1,327,3,327,7473,8,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,
+        1,327,1,327,1,327,5,327,7485,8,327,10,327,12,327,7488,9,327,1,327,
+        3,327,7491,8,327,3,327,7493,8,327,1,327,3,327,7496,8,327,1,328,1,
+        328,1,328,1,328,1,328,3,328,7503,8,328,1,329,1,329,1,329,1,329,1,
+        330,1,330,1,330,1,330,1,331,1,331,1,331,1,331,3,331,7517,8,331,1,
+        332,1,332,1,332,1,332,1,332,1,332,1,332,3,332,7526,8,332,1,332,3,
+        332,7529,8,332,1,332,3,332,7532,8,332,1,332,3,332,7535,8,332,1,333,
+        1,333,1,333,1,333,1,333,1,333,3,333,7543,8,333,1,333,1,333,3,333,
+        7547,8,333,1,334,1,334,1,334,1,334,1,334,1,334,1,334,3,334,7556,
+        8,334,1,334,1,334,3,334,7560,8,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,3,335,7575,8,335,
+        1,335,1,335,1,335,1,335,1,336,1,336,3,336,7583,8,336,1,336,1,336,
+        1,336,1,336,1,336,1,336,1,337,1,337,1,337,1,337,3,337,7595,8,337,
+        1,338,1,338,1,338,1,338,1,339,1,339,1,340,1,340,1,341,1,341,1,342,
+        1,342,1,342,1,342,1,342,3,342,7612,8,342,1,342,3,342,7615,8,342,
+        1,342,1,342,1,342,3,342,7620,8,342,1,342,1,342,1,342,1,342,3,342,
+        7626,8,342,1,342,1,342,3,342,7630,8,342,1,342,1,342,1,342,3,342,
+        7635,8,342,1,342,1,342,1,342,1,342,3,342,7641,8,342,1,342,1,342,
+        3,342,7645,8,342,1,342,3,342,7648,8,342,1,343,1,343,1,343,1,343,
+        1,343,1,343,1,343,1,343,1,343,1,343,5,343,7660,8,343,10,343,12,343,
+        7663,9,343,1,343,1,343,3,343,7667,8,343,1,343,1,343,1,343,1,343,
+        1,343,1,343,1,343,1,343,1,343,1,343,5,343,7679,8,343,10,343,12,343,
+        7682,9,343,1,343,1,343,3,343,7686,8,343,3,343,7688,8,343,1,344,1,
+        344,1,344,1,344,1,344,1,344,1,344,3,344,7697,8,344,1,344,1,344,1,
+        344,1,344,1,344,1,344,3,344,7705,8,344,1,344,3,344,7708,8,344,1,
+        344,3,344,7711,8,344,1,344,3,344,7714,8,344,1,344,3,344,7717,8,344,
+        3,344,7719,8,344,1,345,1,345,3,345,7723,8,345,1,345,1,345,3,345,
+        7727,8,345,1,346,1,346,1,346,5,346,7732,8,346,10,346,12,346,7735,
+        9,346,1,346,1,346,3,346,7739,8,346,1,346,1,346,1,346,3,346,7744,
+        8,346,1,346,5,346,7747,8,346,10,346,12,346,7750,9,346,1,346,3,346,
+        7753,8,346,1,346,3,346,7756,8,346,1,346,1,346,1,346,3,346,7761,8,
+        346,1,346,1,346,1,346,1,346,4,346,7767,8,346,11,346,12,346,7768,
+        1,346,5,346,7772,8,346,10,346,12,346,7775,9,346,3,346,7777,8,346,
+        1,347,1,347,1,348,1,348,3,348,7783,8,348,1,349,1,349,1,349,3,349,
+        7788,8,349,1,350,1,350,1,350,3,350,7793,8,350,1,351,1,351,1,351,
+        1,351,1,351,3,351,7800,8,351,1,351,3,351,7803,8,351,1,352,1,352,
+        1,352,1,352,1,352,1,352,1,352,1,352,1,352,5,352,7814,8,352,10,352,
+        12,352,7817,9,352,1,352,1,352,1,353,1,353,1,353,1,353,5,353,7825,
+        8,353,10,353,12,353,7828,9,353,1,353,1,353,1,353,1,353,5,353,7834,
+        8,353,10,353,12,353,7837,9,353,1,353,1,353,1,353,1,353,5,353,7843,
+        8,353,10,353,12,353,7846,9,353,1,353,1,353,1,353,1,353,5,353,7852,
+        8,353,10,353,12,353,7855,9,353,1,353,1,353,1,353,1,353,5,353,7861,
+        8,353,10,353,12,353,7864,9,353,3,353,7866,8,353,1,353,1,353,1,353,
+        1,353,3,353,7872,8,353,1,353,1,353,1,353,3,353,7877,8,353,3,353,
+        7879,8,353,1,354,1,354,1,355,1,355,1,355,3,355,7886,8,355,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,358,1,358,1,359,1,359,1,360,1,360,1,361,1,361,1,361,1,361,1,362,
+        1,362,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,5,364,7926,8,364,10,364,12,364,7929,9,364,
+        3,364,7931,8,364,1,364,1,364,3,364,7935,8,364,1,364,3,364,7938,8,
+        364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,5,364,7947,8,364,10,
+        364,12,364,7950,9,364,1,364,1,364,1,364,1,364,5,364,7956,8,364,10,
+        364,12,364,7959,9,364,3,364,7961,8,364,3,364,7963,8,364,1,365,1,
+        365,1,366,1,366,1,366,1,366,1,366,1,366,3,366,7973,8,366,1,366,1,
+        366,1,366,3,366,7978,8,366,1,366,1,366,3,366,7982,8,366,1,366,1,
+        366,3,366,7986,8,366,1,366,3,366,7989,8,366,1,366,3,366,7992,8,366,
+        1,367,1,367,1,367,1,367,1,368,1,368,1,368,1,368,1,368,1,369,1,369,
+        1,369,3,369,8006,8,369,3,369,8008,8,369,1,369,1,369,1,369,1,369,
+        3,369,8014,8,369,3,369,8016,8,369,5,369,8018,8,369,10,369,12,369,
+        8021,9,369,1,369,1,369,1,369,3,369,8026,8,369,1,369,1,369,1,369,
+        1,369,3,369,8032,8,369,5,369,8034,8,369,10,369,12,369,8037,9,369,
+        3,369,8039,8,369,1,370,1,370,1,370,1,370,5,370,8045,8,370,10,370,
+        12,370,8048,9,370,1,371,1,371,1,372,1,372,1,372,5,372,8055,8,372,
+        10,372,12,372,8058,9,372,1,372,3,372,8061,8,372,1,372,1,372,1,373,
+        1,373,1,374,1,374,1,374,1,374,1,374,1,374,1,374,1,374,1,374,1,374,
+        1,374,1,374,1,374,3,374,8080,8,374,1,375,1,375,1,375,3,375,8085,
+        8,375,1,375,1,375,1,376,1,376,1,376,3,376,8092,8,376,1,376,1,376,
+        1,377,1,377,1,377,3,377,8099,8,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,378,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,378,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,378,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,378,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,378,1,378,1,378,1,378,1,378,
+        1,378,3,378,8173,8,378,1,379,1,379,1,379,1,379,1,379,3,379,8180,
+        8,379,1,380,1,380,1,380,1,380,1,380,1,380,1,380,3,380,8189,8,380,
+        1,380,1,380,1,380,1,380,1,380,1,380,1,380,3,380,8198,8,380,1,380,
+        1,380,1,380,1,380,5,380,8204,8,380,10,380,12,380,8207,9,380,1,380,
+        1,380,1,380,1,380,3,380,8213,8,380,1,380,1,380,1,380,1,380,1,380,
+        3,380,8220,8,380,1,380,5,380,8223,8,380,10,380,12,380,8226,9,380,
+        1,380,1,380,1,380,1,380,3,380,8232,8,380,1,380,1,380,1,380,1,380,
+        1,380,3,380,8239,8,380,1,380,5,380,8242,8,380,10,380,12,380,8245,
+        9,380,1,380,1,380,1,380,1,380,3,380,8251,8,380,1,380,1,380,1,380,
+        1,380,1,380,3,380,8258,8,380,1,380,5,380,8261,8,380,10,380,12,380,
+        8264,9,380,1,380,1,380,1,380,1,380,3,380,8270,8,380,1,380,1,380,
+        1,380,1,380,1,380,3,380,8277,8,380,1,380,5,380,8280,8,380,10,380,
+        12,380,8283,9,380,1,380,1,380,1,380,1,380,3,380,8289,8,380,1,380,
+        1,380,1,380,1,380,1,380,3,380,8296,8,380,1,380,5,380,8299,8,380,
+        10,380,12,380,8302,9,380,3,380,8304,8,380,1,380,3,380,8307,8,380,
+        1,381,1,381,1,381,1,381,1,381,3,381,8314,8,381,1,381,1,381,3,381,
+        8318,8,381,1,382,1,382,1,382,1,382,1,382,1,382,1,382,3,382,8327,
+        8,382,1,382,1,382,1,383,1,383,1,383,1,383,1,383,5,383,8336,8,383,
+        10,383,12,383,8339,9,383,1,383,1,383,1,383,1,383,1,383,1,383,3,383,
+        8347,8,383,1,383,1,383,3,383,8351,8,383,1,383,1,383,1,383,1,383,
+        1,383,3,383,8358,8,383,3,383,8360,8,383,1,384,1,384,1,384,5,384,
+        8365,8,384,10,384,12,384,8368,9,384,1,385,1,385,1,385,1,385,1,385,
+        3,385,8375,8,385,1,385,1,385,1,385,3,385,8380,8,385,1,385,1,385,
+        3,385,8384,8,385,1,386,1,386,1,386,3,386,8389,8,386,1,386,1,386,
+        1,386,1,386,1,386,3,386,8396,8,386,3,386,8398,8,386,1,386,1,386,
+        3,386,8402,8,386,1,386,3,386,8405,8,386,1,386,3,386,8408,8,386,1,
+        387,1,387,1,387,1,387,1,387,1,388,1,388,3,388,8417,8,388,1,388,1,
+        388,1,388,1,388,3,388,8423,8,388,3,388,8425,8,388,4,388,8427,8,388,
+        11,388,12,388,8428,1,388,1,388,3,388,8433,8,388,1,388,1,388,1,388,
+        3,388,8438,8,388,1,388,1,388,1,388,3,388,8443,8,388,5,388,8445,8,
+        388,10,388,12,388,8448,9,388,1,388,1,388,1,388,3,388,8453,8,388,
+        1,388,1,388,1,388,3,388,8458,8,388,1,388,1,388,1,388,3,388,8463,
+        8,388,1,388,3,388,8466,8,388,1,389,1,389,1,389,1,389,1,390,1,390,
+        1,390,3,390,8475,8,390,1,390,3,390,8478,8,390,1,390,3,390,8481,8,
+        390,1,391,1,391,1,391,1,391,3,391,8487,8,391,1,391,1,391,1,391,1,
+        392,1,392,3,392,8494,8,392,1,392,1,392,1,392,3,392,8499,8,392,5,
+        392,8501,8,392,10,392,12,392,8504,9,392,1,393,1,393,1,393,3,393,
+        8509,8,393,3,393,8511,8,393,1,393,1,393,1,393,1,393,3,393,8517,8,
+        393,3,393,8519,8,393,5,393,8521,8,393,10,393,12,393,8524,9,393,1,
+        393,1,393,1,393,1,393,1,393,1,393,3,393,8532,8,393,1,394,1,394,1,
+        394,1,394,3,394,8538,8,394,1,394,1,394,1,394,1,394,1,394,5,394,8545,
+        8,394,10,394,12,394,8548,9,394,1,394,1,394,1,394,1,394,1,394,1,394,
+        1,394,1,394,1,394,3,394,8559,8,394,1,394,1,394,1,394,1,394,1,394,
+        1,394,3,394,8567,8,394,1,394,1,394,1,394,1,394,1,394,1,394,1,394,
+        3,394,8576,8,394,1,394,3,394,8579,8,394,1,395,1,395,1,395,5,395,
+        8584,8,395,10,395,12,395,8587,9,395,1,395,3,395,8590,8,395,1,395,
+        1,395,1,395,1,395,5,395,8596,8,395,10,395,12,395,8599,9,395,1,396,
+        1,396,1,396,1,396,3,396,8605,8,396,1,396,1,396,1,397,1,397,1,397,
+        1,397,4,397,8613,8,397,11,397,12,397,8614,1,397,1,397,1,397,4,397,
+        8620,8,397,11,397,12,397,8621,1,398,1,398,1,398,3,398,8627,8,398,
+        1,398,1,398,1,398,1,398,1,398,3,398,8634,8,398,1,398,1,398,1,398,
+        1,399,1,399,1,400,1,400,1,401,1,401,1,401,1,401,1,401,1,401,1,401,
+        3,401,8650,8,401,1,401,1,401,1,401,1,401,1,401,3,401,8657,8,401,
+        1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,3,401,8667,8,401,
+        1,401,1,401,1,401,1,401,1,401,4,401,8674,8,401,11,401,12,401,8675,
+        1,401,1,401,1,402,1,402,1,402,1,402,1,402,3,402,8685,8,402,1,402,
+        1,402,1,403,1,403,1,403,1,403,1,403,3,403,8694,8,403,1,403,5,403,
+        8697,8,403,10,403,12,403,8700,9,403,1,403,1,403,3,403,8704,8,403,
+        1,403,3,403,8707,8,403,1,404,1,404,1,404,1,404,1,404,1,404,3,404,
+        8715,8,404,1,404,1,404,1,405,1,405,1,405,1,405,1,406,1,406,1,406,
+        3,406,8726,8,406,1,406,1,406,3,406,8730,8,406,1,406,3,406,8733,8,
+        406,1,406,1,406,1,406,1,406,1,406,1,406,3,406,8741,8,406,1,406,1,
+        406,1,406,1,406,3,406,8747,8,406,3,406,8749,8,406,1,406,1,406,1,
+        406,3,406,8754,8,406,1,406,3,406,8757,8,406,1,406,1,406,1,406,1,
+        406,1,406,3,406,8764,8,406,1,406,1,406,3,406,8768,8,406,1,406,4,
+        406,8771,8,406,11,406,12,406,8772,1,406,3,406,8776,8,406,1,406,1,
+        406,1,406,1,406,1,406,1,406,1,406,1,406,1,406,1,406,1,406,3,406,
+        8789,8,406,1,406,1,406,3,406,8793,8,406,1,407,1,407,1,407,3,407,
+        8798,8,407,1,407,3,407,8801,8,407,1,407,1,407,1,407,1,408,1,408,
+        1,408,1,408,1,408,3,408,8811,8,408,1,408,1,408,3,408,8815,8,408,
+        1,408,1,408,3,408,8819,8,408,1,409,1,409,1,409,3,409,8824,8,409,
+        1,409,1,409,1,410,1,410,1,410,1,411,1,411,1,411,1,412,1,412,1,412,
+        1,412,1,413,1,413,3,413,8840,8,413,1,414,1,414,1,414,3,414,8845,
+        8,414,1,414,1,414,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,
+        3,415,8857,8,415,4,415,8859,8,415,11,415,12,415,8860,1,415,1,415,
+        1,415,1,415,3,415,8867,8,415,1,415,1,415,1,415,1,415,1,415,1,415,
+        1,415,1,415,1,415,1,415,1,415,5,415,8880,8,415,10,415,12,415,8883,
+        9,415,3,415,8885,8,415,3,415,8887,8,415,3,415,8889,8,415,4,415,8891,
+        8,415,11,415,12,415,8892,1,415,3,415,8896,8,415,1,416,1,416,1,416,
+        1,416,1,416,1,416,1,416,1,416,1,416,1,416,1,416,1,416,1,416,1,416,
+        1,416,1,416,5,416,8914,8,416,10,416,12,416,8917,9,416,1,416,1,416,
+        3,416,8921,8,416,1,416,1,416,1,416,3,416,8926,8,416,1,417,1,417,
+        1,417,1,417,1,417,1,417,1,417,4,417,8935,8,417,11,417,12,417,8936,
+        1,417,3,417,8940,8,417,1,417,1,417,1,418,1,418,1,418,1,418,1,418,
+        1,418,4,418,8950,8,418,11,418,12,418,8951,1,419,1,419,1,419,1,419,
+        1,419,4,419,8959,8,419,11,419,12,419,8960,1,420,1,420,1,420,1,420,
+        1,420,1,420,1,420,4,420,8970,8,420,11,420,12,420,8971,1,421,1,421,
+        1,421,1,421,1,421,5,421,8979,8,421,10,421,12,421,8982,9,421,1,421,
+        1,421,3,421,8986,8,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,422,1,422,1,422,1,422,1,422,
+        1,422,1,422,5,422,9008,8,422,10,422,12,422,9011,9,422,1,422,1,422,
+        3,422,9015,8,422,1,422,1,422,1,422,1,422,3,422,9021,8,422,3,422,
+        9023,8,422,1,423,1,423,1,423,1,424,1,424,1,424,3,424,9031,8,424,
+        1,424,3,424,9034,8,424,1,424,3,424,9037,8,424,1,424,3,424,9040,8,
+        424,1,424,1,424,1,424,1,424,3,424,9046,8,424,1,424,1,424,1,424,1,
+        424,3,424,9052,8,424,1,424,1,424,1,424,1,424,3,424,9058,8,424,1,
+        424,1,424,3,424,9062,8,424,3,424,9064,8,424,1,424,3,424,9067,8,424,
+        1,424,1,424,1,424,3,424,9072,8,424,1,424,1,424,3,424,9076,8,424,
+        1,424,1,424,1,424,3,424,9081,8,424,1,424,3,424,9084,8,424,1,425,
+        1,425,1,425,3,425,9089,8,425,1,425,3,425,9092,8,425,1,426,1,426,
+        1,426,3,426,9097,8,426,1,427,1,427,3,427,9101,8,427,1,427,1,427,
+        5,427,9105,8,427,10,427,12,427,9108,9,427,1,427,3,427,9111,8,427,
+        4,427,9113,8,427,11,427,12,427,9114,1,427,1,427,1,428,1,428,1,428,
+        1,428,3,428,9123,8,428,1,428,1,428,1,428,1,428,1,428,1,428,1,428,
+        1,428,1,428,5,428,9134,8,428,10,428,12,428,9137,9,428,1,428,3,428,
+        9140,8,428,1,428,1,428,1,428,1,428,3,428,9146,8,428,1,428,3,428,
+        9149,8,428,1,428,1,428,3,428,9153,8,428,1,428,1,428,1,428,3,428,
+        9158,8,428,4,428,9160,8,428,11,428,12,428,9161,1,428,1,428,5,428,
+        9166,8,428,10,428,12,428,9169,9,428,1,429,1,429,3,429,9173,8,429,
+        1,429,3,429,9176,8,429,1,429,1,429,1,429,1,429,1,429,1,429,3,429,
+        9184,8,429,1,429,3,429,9187,8,429,1,430,1,430,1,430,1,430,1,430,
+        1,430,1,430,3,430,9196,8,430,1,430,1,430,3,430,9200,8,430,3,430,
+        9202,8,430,1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,
+        1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,3,431,9221,8,431,
+        1,431,1,431,1,431,1,431,3,431,9227,8,431,1,431,4,431,9230,8,431,
+        11,431,12,431,9231,1,431,1,431,1,431,3,431,9237,8,431,3,431,9239,
+        8,431,1,432,1,432,3,432,9243,8,432,1,432,1,432,1,432,1,432,1,432,
+        5,432,9250,8,432,10,432,12,432,9253,9,432,1,432,1,432,1,432,1,432,
+        1,432,1,432,1,432,1,432,5,432,9263,8,432,10,432,12,432,9266,9,432,
+        1,432,1,432,1,432,1,432,1,432,1,432,1,432,1,432,3,432,9276,8,432,
+        1,432,3,432,9279,8,432,1,432,3,432,9282,8,432,1,433,3,433,9285,8,
+        433,1,433,1,433,1,433,1,433,1,433,1,433,1,433,4,433,9294,8,433,11,
+        433,12,433,9295,1,434,1,434,1,434,3,434,9301,8,434,1,434,1,434,1,
+        434,1,434,1,434,1,434,1,434,1,434,5,434,9311,8,434,10,434,12,434,
+        9314,9,434,1,434,1,434,3,434,9318,8,434,1,435,1,435,3,435,9322,8,
+        435,1,435,1,435,1,435,1,435,1,435,1,435,3,435,9330,8,435,1,435,1,
+        435,1,435,1,435,1,435,3,435,9337,8,435,1,435,1,435,1,435,3,435,9342,
+        8,435,1,435,1,435,1,435,3,435,9347,8,435,1,436,1,436,1,437,1,437,
+        1,438,1,438,1,438,1,438,1,438,3,438,9358,8,438,1,438,3,438,9361,
+        8,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,
+        3,438,9373,8,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,
+        1,438,1,438,1,438,1,438,1,438,3,438,9388,8,438,1,439,1,439,1,439,
+        3,439,9393,8,439,1,439,1,439,1,439,1,439,3,439,9399,8,439,1,439,
+        1,439,3,439,9403,8,439,1,439,1,439,1,439,1,439,3,439,9409,8,439,
+        1,439,1,439,3,439,9413,8,439,1,439,1,439,1,439,1,439,1,439,5,439,
+        9420,8,439,10,439,12,439,9423,9,439,1,439,1,439,1,439,1,439,5,439,
+        9429,8,439,10,439,12,439,9432,9,439,1,439,1,439,3,439,9436,8,439,
+        1,440,1,440,3,440,9440,8,440,1,440,1,440,3,440,9444,8,440,1,441,
+        1,441,1,441,1,441,3,441,9450,8,441,1,442,1,442,1,443,1,443,1,443,
+        3,443,9457,8,443,1,443,1,443,1,443,1,443,3,443,9463,8,443,1,444,
+        1,444,1,444,1,445,1,445,1,446,1,446,3,446,9472,8,446,1,446,1,446,
+        1,446,3,446,9477,8,446,1,447,1,447,1,447,1,447,1,447,3,447,9484,
+        8,447,1,447,3,447,9487,8,447,1,447,1,447,1,447,1,447,1,447,1,447,
+        1,447,1,447,1,447,1,447,1,447,1,447,1,447,1,447,1,447,5,447,9504,
+        8,447,10,447,12,447,9507,9,447,1,448,1,448,1,448,1,449,1,449,1,450,
+        1,450,1,450,1,450,1,450,1,450,1,450,3,450,9521,8,450,3,450,9523,
+        8,450,1,451,1,451,1,451,1,451,1,451,1,452,1,452,1,452,1,452,1,452,
+        1,452,3,452,9536,8,452,1,452,3,452,9539,8,452,1,452,3,452,9542,8,
+        452,1,452,3,452,9545,8,452,1,453,1,453,1,453,1,453,1,453,1,453,3,
+        453,9553,8,453,1,453,3,453,9556,8,453,1,453,3,453,9559,8,453,1,453,
+        3,453,9562,8,453,1,454,1,454,1,454,1,455,1,455,1,455,1,455,1,455,
+        1,455,1,455,3,455,9574,8,455,1,455,1,455,1,455,1,455,1,455,1,455,
+        1,455,5,455,9583,8,455,10,455,12,455,9586,9,455,3,455,9588,8,455,
+        1,455,4,455,9591,8,455,11,455,12,455,9592,1,455,1,455,3,455,9597,
+        8,455,1,456,1,456,1,456,1,456,1,456,1,456,3,456,9605,8,456,1,456,
+        1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,3,456,
+        9618,8,456,1,457,1,457,3,457,9622,8,457,1,457,1,457,3,457,9626,8,
+        457,1,458,1,458,3,458,9630,8,458,1,458,3,458,9633,8,458,1,458,3,
+        458,9636,8,458,1,458,3,458,9639,8,458,1,458,3,458,9642,8,458,1,459,
+        1,459,1,459,1,459,1,459,1,459,1,459,1,459,3,459,9652,8,459,1,459,
+        3,459,9655,8,459,1,460,1,460,1,461,1,461,1,461,1,461,1,461,3,461,
+        9664,8,461,1,462,1,462,3,462,9668,8,462,1,462,1,462,1,462,1,462,
+        5,462,9674,8,462,10,462,12,462,9677,9,462,1,462,1,462,1,462,1,462,
+        1,462,1,462,1,462,1,462,5,462,9687,8,462,10,462,12,462,9690,9,462,
+        3,462,9692,8,462,3,462,9694,8,462,1,462,1,462,3,462,9698,8,462,1,
+        463,1,463,3,463,9702,8,463,1,463,1,463,1,464,1,464,3,464,9708,8,
+        464,1,464,1,464,1,465,3,465,9713,8,465,1,465,1,465,3,465,9717,8,
+        465,1,465,3,465,9720,8,465,1,465,3,465,9723,8,465,1,466,1,466,1,
+        466,1,466,1,466,5,466,9730,8,466,10,466,12,466,9733,9,466,1,466,
+        1,466,3,466,9737,8,466,1,466,1,466,3,466,9741,8,466,1,466,1,466,
+        3,466,9745,8,466,1,466,3,466,9748,8,466,1,467,1,467,1,467,1,467,
+        1,467,3,467,9755,8,467,1,467,3,467,9758,8,467,3,467,9760,8,467,1,
+        468,1,468,1,468,3,468,9765,8,468,1,469,1,469,1,469,1,470,1,470,1,
+        470,1,470,3,470,9774,8,470,1,470,1,470,1,470,1,470,3,470,9780,8,
+        470,1,470,3,470,9783,8,470,3,470,9785,8,470,1,471,1,471,1,471,1,
+        472,1,472,1,472,1,472,1,472,1,472,1,472,1,472,1,472,1,472,5,472,
+        9800,8,472,10,472,12,472,9803,9,472,1,472,1,472,1,472,5,472,9808,
+        8,472,10,472,12,472,9811,9,472,1,472,1,472,1,472,1,472,1,472,1,472,
+        3,472,9819,8,472,1,472,3,472,9822,8,472,1,472,1,472,1,472,3,472,
+        9827,8,472,1,472,3,472,9830,8,472,1,472,1,472,1,472,1,472,1,472,
+        1,472,1,472,3,472,9839,8,472,1,473,1,473,1,474,1,474,1,474,1,474,
+        1,474,1,474,1,474,1,474,1,474,1,474,1,474,1,474,1,474,1,474,1,474,
+        1,474,3,474,9859,8,474,1,474,1,474,1,474,1,474,3,474,9865,8,474,
+        1,474,1,474,1,474,4,474,9870,8,474,11,474,12,474,9871,1,475,1,475,
+        1,476,1,476,1,476,1,476,1,476,1,476,3,476,9882,8,476,1,476,1,476,
+        1,477,1,477,1,477,1,477,1,477,3,477,9891,8,477,1,477,1,477,1,477,
+        1,477,1,477,1,477,1,477,1,477,1,477,1,477,3,477,9903,8,477,1,477,
+        3,477,9906,8,477,1,477,3,477,9909,8,477,1,478,1,478,1,478,1,478,
+        1,478,1,479,1,479,1,479,3,479,9919,8,479,1,480,1,480,1,480,1,480,
+        1,480,1,480,1,480,3,480,9928,8,480,1,480,1,480,1,480,1,480,5,480,
+        9934,8,480,10,480,12,480,9937,9,480,1,480,1,480,3,480,9941,8,480,
+        1,480,1,480,1,480,1,480,5,480,9947,8,480,10,480,12,480,9950,9,480,
+        1,480,1,480,3,480,9954,8,480,1,480,3,480,9957,8,480,1,481,1,481,
+        1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,4,481,9970,
+        8,481,11,481,12,481,9971,3,481,9974,8,481,1,481,3,481,9977,8,481,
+        1,481,1,481,3,481,9981,8,481,1,481,1,481,1,481,1,481,1,481,1,481,
+        1,481,1,481,3,481,9991,8,481,5,481,9993,8,481,10,481,12,481,9996,
+        9,481,1,481,1,481,3,481,10000,8,481,1,481,4,481,10003,8,481,11,481,
+        12,481,10004,1,481,1,481,3,481,10009,8,481,1,481,3,481,10012,8,481,
+        1,481,3,481,10015,8,481,5,481,10017,8,481,10,481,12,481,10020,9,
+        481,1,482,1,482,1,482,1,482,1,483,1,483,1,483,3,483,10029,8,483,
+        1,484,1,484,1,484,1,484,1,484,1,484,1,484,1,484,3,484,10039,8,484,
+        1,484,3,484,10042,8,484,1,484,3,484,10045,8,484,1,484,1,484,3,484,
+        10049,8,484,1,484,1,484,3,484,10053,8,484,1,485,1,485,1,485,1,485,
+        1,485,1,485,1,485,1,485,1,485,1,485,1,485,3,485,10066,8,485,1,486,
+        1,486,1,486,1,486,1,486,1,487,1,487,3,487,10075,8,487,1,487,1,487,
+        1,487,1,487,1,487,1,487,1,487,1,487,1,487,3,487,10086,8,487,3,487,
+        10088,8,487,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,
+        4,488,10099,8,488,11,488,12,488,10100,1,489,1,489,1,489,3,489,10106,
+        8,489,1,490,1,490,1,490,3,490,10111,8,490,1,491,1,491,1,491,5,491,
+        10116,8,491,10,491,12,491,10119,9,491,1,492,1,492,1,492,1,492,1,
+        492,1,492,1,493,1,493,1,493,1,494,1,494,1,494,1,494,1,494,1,494,
+        3,494,10136,8,494,1,495,1,495,1,495,1,495,3,495,10142,8,495,1,496,
+        1,496,1,496,3,496,10147,8,496,1,496,1,496,1,496,1,496,1,496,1,496,
+        5,496,10155,8,496,10,496,12,496,10158,9,496,1,496,1,496,1,496,3,
+        496,10163,8,496,1,497,1,497,1,497,1,497,5,497,10169,8,497,10,497,
+        12,497,10172,9,497,1,497,1,497,1,497,3,497,10177,8,497,1,497,1,497,
+        3,497,10181,8,497,1,497,3,497,10184,8,497,1,497,1,497,1,498,1,498,
+        1,498,1,498,1,499,1,499,1,499,1,499,3,499,10196,8,499,1,500,1,500,
+        1,500,5,500,10201,8,500,10,500,12,500,10204,9,500,1,501,1,501,1,
+        501,1,501,1,501,5,501,10211,8,501,10,501,12,501,10214,9,501,1,501,
+        1,501,1,502,1,502,1,502,1,502,1,502,1,502,1,502,1,502,1,502,1,502,
+        3,502,10228,8,502,1,502,1,502,1,502,3,502,10233,8,502,1,503,1,503,
+        1,503,1,504,1,504,1,504,1,504,1,504,1,504,5,504,10244,8,504,10,504,
+        12,504,10247,9,504,1,504,1,504,3,504,10251,8,504,1,505,1,505,1,505,
+        1,505,1,505,1,505,3,505,10259,8,505,1,505,1,505,1,505,3,505,10264,
+        8,505,1,505,1,505,1,505,3,505,10269,8,505,1,505,1,505,1,505,3,505,
+        10274,8,505,5,505,10276,8,505,10,505,12,505,10279,9,505,1,505,1,
+        505,3,505,10283,8,505,1,505,1,505,1,505,1,505,1,505,1,505,3,505,
+        10291,8,505,1,505,3,505,10294,8,505,1,505,3,505,10297,8,505,1,505,
+        3,505,10300,8,505,1,505,3,505,10303,8,505,3,505,10305,8,505,1,505,
+        1,505,1,505,1,505,1,505,4,505,10312,8,505,11,505,12,505,10313,5,
+        505,10316,8,505,10,505,12,505,10319,9,505,1,505,1,505,1,505,3,505,
+        10324,8,505,1,505,3,505,10327,8,505,1,505,3,505,10330,8,505,1,505,
+        1,505,1,505,1,505,3,505,10336,8,505,1,505,3,505,10339,8,505,1,505,
+        1,505,1,505,3,505,10344,8,505,1,505,3,505,10347,8,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,3,506,
+        10361,8,506,1,506,1,506,1,507,1,507,3,507,10367,8,507,1,507,1,507,
+        3,507,10371,8,507,1,507,1,507,3,507,10375,8,507,1,508,1,508,1,508,
+        1,508,1,508,1,508,1,508,1,508,1,508,3,508,10386,8,508,1,508,1,508,
+        1,508,1,508,1,508,3,508,10393,8,508,1,508,1,508,1,508,3,508,10398,
+        8,508,1,508,1,508,1,508,3,508,10403,8,508,1,508,1,508,1,508,3,508,
+        10408,8,508,1,508,1,508,1,508,4,508,10413,8,508,11,508,12,508,10414,
+        3,508,10417,8,508,1,509,1,509,1,509,1,509,3,509,10423,8,509,1,510,
+        1,510,1,510,1,510,3,510,10429,8,510,1,510,1,510,1,510,1,510,1,510,
+        3,510,10436,8,510,1,510,1,510,1,510,1,510,1,510,1,510,3,510,10444,
+        8,510,1,511,1,511,1,511,1,511,1,511,1,511,3,511,10452,8,511,1,512,
+        1,512,1,512,1,512,1,512,1,512,3,512,10460,8,512,1,512,1,512,1,512,
+        1,513,1,513,1,513,3,513,10468,8,513,1,513,1,513,1,513,1,513,1,513,
+        1,513,3,513,10476,8,513,1,513,1,513,1,513,1,513,1,513,3,513,10483,
+        8,513,1,514,1,514,1,515,1,515,1,515,1,515,1,515,1,515,1,515,3,515,
+        10494,8,515,1,515,1,515,1,515,1,515,3,515,10500,8,515,5,515,10502,
+        8,515,10,515,12,515,10505,9,515,1,515,1,515,1,515,1,515,1,515,1,
+        515,1,515,1,515,1,515,3,515,10516,8,515,1,515,1,515,1,515,1,515,
+        1,515,3,515,10523,8,515,5,515,10525,8,515,10,515,12,515,10528,9,
+        515,1,515,3,515,10531,8,515,1,515,3,515,10534,8,515,1,515,3,515,
+        10537,8,515,1,516,1,516,3,516,10541,8,516,1,516,1,516,1,516,1,516,
+        1,516,4,516,10548,8,516,11,516,12,516,10549,1,516,3,516,10553,8,
+        516,1,517,1,517,1,517,1,517,1,517,1,517,3,517,10561,8,517,3,517,
+        10563,8,517,1,518,1,518,1,518,1,518,3,518,10569,8,518,1,518,1,518,
+        1,518,1,518,3,518,10575,8,518,1,518,1,518,1,518,3,518,10580,8,518,
+        3,518,10582,8,518,1,519,1,519,1,519,1,519,1,519,1,519,3,519,10590,
+        8,519,1,520,1,520,1,520,1,521,1,521,1,521,1,522,1,522,1,522,3,522,
+        10601,8,522,1,522,3,522,10604,8,522,1,522,1,522,3,522,10608,8,522,
+        1,522,1,522,3,522,10612,8,522,1,522,3,522,10615,8,522,1,522,1,522,
+        1,522,3,522,10620,8,522,1,522,1,522,3,522,10624,8,522,1,523,1,523,
+        3,523,10628,8,523,1,523,1,523,1,523,1,523,1,523,1,523,1,523,3,523,
+        10637,8,523,1,523,1,523,1,523,1,523,3,523,10643,8,523,1,523,1,523,
+        1,523,1,523,3,523,10649,8,523,1,524,1,524,1,524,1,524,3,524,10655,
+        8,524,1,524,3,524,10658,8,524,1,525,1,525,1,525,1,525,1,525,1,525,
+        3,525,10666,8,525,1,525,1,525,3,525,10670,8,525,1,525,1,525,1,525,
+        1,525,3,525,10676,8,525,1,525,1,525,1,525,1,525,3,525,10682,8,525,
+        1,525,1,525,1,525,1,525,3,525,10688,8,525,1,525,1,525,3,525,10692,
+        8,525,3,525,10694,8,525,1,525,1,525,1,525,3,525,10699,8,525,1,525,
+        3,525,10702,8,525,1,525,1,525,3,525,10706,8,525,1,525,1,525,3,525,
+        10710,8,525,1,526,1,526,1,526,1,526,1,526,1,526,3,526,10718,8,526,
+        1,526,1,526,3,526,10722,8,526,1,526,3,526,10725,8,526,1,526,3,526,
+        10728,8,526,1,526,1,526,1,526,1,526,3,526,10734,8,526,1,526,3,526,
+        10737,8,526,1,526,3,526,10740,8,526,1,526,3,526,10743,8,526,1,526,
+        3,526,10746,8,526,1,527,1,527,1,527,1,527,1,527,1,527,1,527,1,527,
+        1,527,1,527,1,527,1,527,1,527,1,527,1,527,5,527,10763,8,527,10,527,
+        12,527,10766,9,527,1,527,1,527,1,528,1,528,3,528,10772,8,528,1,528,
+        1,528,3,528,10776,8,528,1,528,3,528,10779,8,528,1,529,1,529,1,529,
+        1,529,1,529,3,529,10786,8,529,1,529,1,529,1,529,3,529,10791,8,529,
+        1,529,1,529,1,529,1,529,1,529,3,529,10798,8,529,1,529,1,529,1,529,
+        1,529,3,529,10804,8,529,3,529,10806,8,529,1,529,1,529,1,529,1,529,
+        3,529,10812,8,529,1,530,1,530,3,530,10816,8,530,1,530,1,530,3,530,
+        10820,8,530,1,530,1,530,1,530,5,530,10825,8,530,10,530,12,530,10828,
+        9,530,1,531,1,531,1,531,1,531,3,531,10834,8,531,1,531,1,531,3,531,
+        10838,8,531,1,531,1,531,1,531,1,531,5,531,10844,8,531,10,531,12,
+        531,10847,9,531,1,531,1,531,3,531,10851,8,531,1,531,1,531,1,531,
+        1,531,3,531,10857,8,531,1,531,3,531,10860,8,531,1,531,3,531,10863,
+        8,531,1,531,3,531,10866,8,531,1,531,3,531,10869,8,531,1,532,1,532,
+        1,533,1,533,3,533,10875,8,533,1,533,1,533,1,533,1,533,4,533,10881,
+        8,533,11,533,12,533,10882,1,533,1,533,1,534,1,534,1,534,1,534,1,
+        534,1,534,1,534,3,534,10894,8,534,1,535,1,535,3,535,10898,8,535,
+        1,535,1,535,3,535,10902,8,535,1,535,1,535,1,535,5,535,10907,8,535,
+        10,535,12,535,10910,9,535,1,535,3,535,10913,8,535,1,535,1,535,1,
+        535,3,535,10918,8,535,1,536,3,536,10921,8,536,1,536,1,536,1,536,
+        1,536,1,536,1,537,1,537,1,537,1,537,5,537,10932,8,537,10,537,12,
+        537,10935,9,537,1,537,1,537,3,537,10939,8,537,1,537,3,537,10942,
+        8,537,1,538,4,538,10945,8,538,11,538,12,538,10946,1,539,1,539,1,
+        539,1,539,1,539,1,539,1,539,1,539,1,539,1,539,1,539,3,539,10960,
+        8,539,1,539,1,539,3,539,10964,8,539,1,540,1,540,3,540,10968,8,540,
+        1,541,1,541,1,541,1,541,1,541,1,541,1,541,3,541,10977,8,541,1,542,
+        1,542,1,542,3,542,10982,8,542,1,542,1,542,1,542,1,542,1,542,1,542,
+        3,542,10990,8,542,3,542,10992,8,542,1,543,1,543,1,543,1,543,1,544,
+        1,544,1,544,1,544,1,544,1,544,1,544,3,544,11005,8,544,1,545,1,545,
+        1,545,3,545,11010,8,545,1,545,1,545,1,545,1,545,1,545,1,545,3,545,
+        11018,8,545,3,545,11020,8,545,1,546,1,546,1,546,1,546,1,546,1,546,
+        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,548,1,548,1,548,1,548,1,548,1,548,1,548,1,548,1,548,1,548,
+        1,548,1,548,1,548,1,548,1,548,1,548,3,548,11056,8,548,1,548,1,548,
+        3,548,11060,8,548,1,549,1,549,1,549,1,550,1,550,1,550,1,551,1,551,
+        3,551,11070,8,551,1,551,1,551,3,551,11074,8,551,1,551,1,551,3,551,
+        11078,8,551,1,551,3,551,11081,8,551,1,551,1,551,1,551,3,551,11086,
+        8,551,1,551,3,551,11089,8,551,1,552,1,552,1,552,3,552,11094,8,552,
+        1,552,1,552,1,552,1,552,5,552,11100,8,552,10,552,12,552,11103,9,
+        552,1,553,1,553,1,553,1,553,3,553,11109,8,553,1,553,1,553,1,553,
+        1,553,1,553,1,553,1,554,1,554,1,555,1,555,3,555,11121,8,555,1,555,
+        1,555,1,555,1,556,1,556,1,556,1,556,1,556,5,556,11131,8,556,10,556,
+        12,556,11134,9,556,1,556,1,556,3,556,11138,8,556,1,557,1,557,1,557,
+        1,557,5,557,11144,8,557,10,557,12,557,11147,9,557,1,557,1,557,1,
+        558,1,558,1,559,1,559,1,559,1,559,1,559,1,559,1,559,3,559,11160,
+        8,559,1,559,1,559,1,559,3,559,11165,8,559,1,560,1,560,1,560,1,560,
+        1,560,1,560,1,560,1,560,1,560,3,560,11176,8,560,1,560,1,560,3,560,
+        11180,8,560,1,560,1,560,3,560,11184,8,560,3,560,11186,8,560,1,561,
+        1,561,1,562,1,562,1,562,1,562,1,562,1,562,3,562,11196,8,562,1,563,
+        1,563,1,563,1,563,1,563,1,563,1,563,1,563,3,563,11206,8,563,1,564,
+        1,564,1,564,1,564,1,564,1,564,1,564,5,564,11215,8,564,10,564,12,
+        564,11218,9,564,1,564,1,564,1,564,1,564,1,564,1,564,1,564,1,564,
+        1,564,1,564,1,564,5,564,11231,8,564,10,564,12,564,11234,9,564,1,
+        564,1,564,3,564,11238,8,564,3,564,11240,8,564,1,564,1,564,1,564,
+        3,564,11245,8,564,1,564,1,564,1,564,1,564,1,564,3,564,11252,8,564,
+        1,564,1,564,1,564,5,564,11257,8,564,10,564,12,564,11260,9,564,1,
+        564,1,564,1,565,1,565,1,565,1,565,1,565,1,565,1,565,1,565,1,565,
+        1,565,1,565,1,565,1,565,5,565,11277,8,565,10,565,12,565,11280,9,
+        565,1,565,1,565,3,565,11284,8,565,3,565,11286,8,565,1,565,1,565,
+        1,565,3,565,11291,8,565,1,565,1,565,1,565,1,565,1,565,3,565,11298,
+        8,565,1,565,1,565,1,565,5,565,11303,8,565,10,565,12,565,11306,9,
+        565,1,565,1,565,3,565,11310,8,565,1,566,1,566,1,566,1,566,1,566,
+        1,566,1,566,5,566,11319,8,566,10,566,12,566,11322,9,566,1,566,1,
+        566,1,566,3,566,11327,8,566,1,567,1,567,1,567,3,567,11332,8,567,
+        1,567,3,567,11335,8,567,1,567,1,567,1,567,3,567,11340,8,567,1,567,
+        3,567,11343,8,567,5,567,11345,8,567,10,567,12,567,11348,9,567,1,
+        567,1,567,1,568,1,568,1,568,1,568,1,568,1,568,1,568,1,568,5,568,
+        11360,8,568,10,568,12,568,11363,9,568,1,568,1,568,3,568,11367,8,
+        568,1,568,1,568,3,568,11371,8,568,1,568,1,568,1,568,1,568,1,568,
+        1,568,1,568,5,568,11380,8,568,10,568,12,568,11383,9,568,1,568,1,
+        568,3,568,11387,8,568,1,569,1,569,1,570,1,570,1,570,1,570,1,570,
+        1,570,1,570,5,570,11398,8,570,10,570,12,570,11401,9,570,1,570,1,
+        570,1,570,1,570,1,570,1,570,1,570,1,570,1,570,1,570,1,570,5,570,
+        11414,8,570,10,570,12,570,11417,9,570,1,570,1,570,3,570,11421,8,
+        570,3,570,11423,8,570,1,570,1,570,1,570,3,570,11428,8,570,1,570,
+        1,570,1,570,1,570,5,570,11434,8,570,10,570,12,570,11437,9,570,1,
+        570,1,570,1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,1,571,
+        3,571,11450,8,571,1,571,1,571,1,571,1,571,5,571,11456,8,571,10,571,
+        12,571,11459,9,571,1,571,1,571,1,572,1,572,1,572,1,572,1,572,1,572,
+        4,572,11469,8,572,11,572,12,572,11470,1,572,1,572,1,572,1,572,3,
+        572,11477,8,572,1,572,1,572,3,572,11481,8,572,1,573,1,573,1,573,
+        1,573,1,573,1,573,1,573,1,573,1,573,1,573,5,573,11493,8,573,10,573,
+        12,573,11496,9,573,1,573,1,573,3,573,11500,8,573,1,574,1,574,3,574,
+        11504,8,574,1,574,1,574,1,575,1,575,1,575,1,575,1,575,1,575,1,575,
+        1,575,5,575,11516,8,575,10,575,12,575,11519,9,575,3,575,11521,8,
+        575,1,576,1,576,3,576,11525,8,576,1,576,3,576,11528,8,576,1,576,
+        1,576,1,576,1,576,1,576,5,576,11535,8,576,10,576,12,576,11538,9,
+        576,1,576,1,576,1,576,5,576,11543,8,576,10,576,12,576,11546,9,576,
+        1,576,1,576,1,576,5,576,11551,8,576,10,576,12,576,11554,9,576,3,
+        576,11556,8,576,1,576,1,576,1,576,3,576,11561,8,576,3,576,11563,
+        8,576,1,577,1,577,3,577,11567,8,577,1,577,3,577,11570,8,577,1,577,
+        1,577,1,577,1,577,1,577,5,577,11577,8,577,10,577,12,577,11580,9,
+        577,1,577,1,577,1,577,5,577,11585,8,577,10,577,12,577,11588,9,577,
+        1,577,1,577,1,577,5,577,11593,8,577,10,577,12,577,11596,9,577,3,
+        577,11598,8,577,1,577,1,577,1,577,3,577,11603,8,577,3,577,11605,
+        8,577,1,578,1,578,1,578,1,578,1,578,1,578,5,578,11613,8,578,10,578,
+        12,578,11616,9,578,1,578,1,578,1,578,5,578,11621,8,578,10,578,12,
+        578,11624,9,578,1,578,1,578,1,578,5,578,11629,8,578,10,578,12,578,
+        11632,9,578,3,578,11634,8,578,1,578,1,578,1,578,3,578,11639,8,578,
+        1,579,1,579,1,580,1,580,1,580,1,580,1,580,1,580,1,580,5,580,11650,
+        8,580,10,580,12,580,11653,9,580,1,580,1,580,3,580,11657,8,580,1,
+        581,1,581,1,581,1,581,1,581,1,581,1,581,3,581,11666,8,581,1,582,
+        1,582,1,582,1,582,1,582,1,582,1,582,5,582,11675,8,582,10,582,12,
+        582,11678,9,582,1,582,1,582,1,582,1,582,1,582,1,582,1,582,1,582,
+        1,582,5,582,11689,8,582,10,582,12,582,11692,9,582,1,582,1,582,3,
+        582,11696,8,582,1,582,3,582,11699,8,582,1,583,1,583,1,584,1,584,
+        3,584,11705,8,584,1,584,1,584,3,584,11709,8,584,1,585,1,585,3,585,
+        11713,8,585,1,585,1,585,3,585,11717,8,585,1,586,1,586,3,586,11721,
+        8,586,1,586,3,586,11724,8,586,1,587,1,587,1,587,1,587,1,587,1,587,
+        1,587,1,587,5,587,11734,8,587,10,587,12,587,11737,9,587,1,587,1,
+        587,3,587,11741,8,587,1,588,1,588,1,588,1,588,1,588,1,588,1,588,
+        1,589,1,589,1,589,5,589,11753,8,589,10,589,12,589,11756,9,589,1,
+        589,1,589,1,589,1,589,1,589,5,589,11763,8,589,10,589,12,589,11766,
+        9,589,3,589,11768,8,589,1,590,1,590,1,590,1,590,1,590,5,590,11775,
+        8,590,10,590,12,590,11778,9,590,1,590,1,590,1,590,1,590,1,590,5,
+        590,11785,8,590,10,590,12,590,11788,9,590,1,590,3,590,11791,8,590,
+        1,590,1,590,1,591,3,591,11796,8,591,1,591,3,591,11799,8,591,1,591,
+        3,591,11802,8,591,1,591,3,591,11805,8,591,1,591,3,591,11808,8,591,
+        1,591,1,591,3,591,11812,8,591,1,591,3,591,11815,8,591,1,591,3,591,
+        11818,8,591,1,591,1,591,3,591,11822,8,591,3,591,11824,8,591,1,591,
+        1,591,1,591,5,591,11829,8,591,10,591,12,591,11832,9,591,1,592,1,
+        592,1,592,1,592,1,592,3,592,11839,8,592,1,592,1,592,1,592,1,592,
+        1,592,1,592,1,592,1,592,1,592,3,592,11850,8,592,1,592,1,592,1,592,
+        4,592,11855,8,592,11,592,12,592,11856,1,593,1,593,1,593,1,593,1,
+        593,1,593,1,593,3,593,11866,8,593,1,593,1,593,1,593,1,593,1,593,
+        1,593,3,593,11874,8,593,1,593,1,593,1,593,1,593,1,593,3,593,11881,
+        8,593,1,594,1,594,3,594,11885,8,594,1,595,1,595,1,595,1,595,1,595,
+        1,595,3,595,11893,8,595,1,595,1,595,1,595,1,595,3,595,11899,8,595,
+        3,595,11901,8,595,1,595,1,595,1,595,1,595,3,595,11907,8,595,1,595,
+        1,595,1,595,1,595,1,595,1,595,3,595,11915,8,595,3,595,11917,8,595,
+        1,595,3,595,11920,8,595,1,595,1,595,1,595,3,595,11925,8,595,1,595,
+        3,595,11928,8,595,1,596,4,596,11931,8,596,11,596,12,596,11932,1,
+        596,1,596,3,596,11937,8,596,1,596,1,596,3,596,11941,8,596,1,596,
+        5,596,11944,8,596,10,596,12,596,11947,9,596,3,596,11949,8,596,1,
+        597,1,597,1,597,1,597,4,597,11955,8,597,11,597,12,597,11956,1,598,
+        1,598,1,598,1,598,1,598,3,598,11964,8,598,3,598,11966,8,598,1,598,
+        1,598,3,598,11970,8,598,1,599,1,599,1,599,1,600,1,600,1,600,1,600,
+        1,600,1,600,1,600,3,600,11982,8,600,3,600,11984,8,600,1,600,1,600,
+        1,600,1,600,1,600,1,600,3,600,11992,8,600,3,600,11994,8,600,1,601,
+        1,601,3,601,11998,8,601,1,601,1,601,3,601,12002,8,601,1,602,1,602,
+        3,602,12006,8,602,1,602,1,602,3,602,12010,8,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,603,
+        4,603,12026,8,603,11,603,12,603,12027,1,604,1,604,1,604,1,604,1,
+        604,1,604,1,604,1,604,1,604,1,604,1,604,1,604,1,604,1,604,1,604,
+        1,604,1,604,1,604,1,604,1,604,3,604,12050,8,604,1,604,1,604,1,604,
+        1,604,1,604,1,604,1,604,4,604,12059,8,604,11,604,12,604,12060,1,
+        604,1,604,1,605,1,605,1,605,1,605,1,606,1,606,1,606,1,606,3,606,
+        12073,8,606,1,606,3,606,12076,8,606,1,606,1,606,4,606,12080,8,606,
+        11,606,12,606,12081,1,607,1,607,1,607,1,607,1,607,1,607,1,607,1,
+        607,3,607,12092,8,607,1,607,1,607,1,607,3,607,12097,8,607,1,607,
+        3,607,12100,8,607,1,607,1,607,3,607,12104,8,607,1,607,1,607,1,607,
+        1,607,1,607,1,607,3,607,12112,8,607,1,607,1,607,1,607,1,607,1,607,
+        1,607,5,607,12120,8,607,10,607,12,607,12123,9,607,1,607,1,607,3,
+        607,12127,8,607,1,608,1,608,1,608,1,608,1,608,1,608,1,608,1,608,
+        1,608,1,608,3,608,12139,8,608,1,609,1,609,1,609,3,609,12144,8,609,
+        1,610,1,610,1,610,1,610,1,610,1,610,1,610,1,610,1,610,1,610,3,610,
+        12156,8,610,1,610,1,610,1,610,1,610,1,610,1,610,1,610,3,610,12165,
+        8,610,1,611,1,611,1,611,1,611,3,611,12171,8,611,1,611,1,611,3,611,
+        12175,8,611,1,611,1,611,1,611,3,611,12180,8,611,1,611,3,611,12183,
+        8,611,1,612,1,612,1,612,1,612,1,612,1,612,3,612,12191,8,612,1,612,
+        1,612,3,612,12195,8,612,1,613,1,613,1,614,1,614,1,614,3,614,12202,
+        8,614,1,614,1,614,1,614,1,614,1,614,3,614,12209,8,614,1,614,3,614,
+        12212,8,614,1,614,1,614,1,615,1,615,1,615,1,616,3,616,12220,8,616,
+        1,616,3,616,12223,8,616,1,616,3,616,12226,8,616,1,617,1,617,1,617,
+        3,617,12231,8,617,1,617,1,617,1,617,3,617,12236,8,617,1,617,1,617,
+        1,617,1,617,3,617,12242,8,617,3,617,12244,8,617,1,617,3,617,12247,
+        8,617,1,618,1,618,1,619,1,619,1,619,3,619,12254,8,619,1,619,1,619,
+        1,619,1,619,1,619,1,619,1,619,4,619,12263,8,619,11,619,12,619,12264,
+        1,619,1,619,1,619,1,619,1,619,3,619,12272,8,619,3,619,12274,8,619,
+        1,619,1,619,1,619,1,619,1,619,5,619,12281,8,619,10,619,12,619,12284,
+        9,619,1,619,1,619,3,619,12288,8,619,1,620,1,620,1,620,1,620,1,620,
+        1,620,1,620,1,620,1,620,1,620,5,620,12300,8,620,10,620,12,620,12303,
+        9,620,1,620,1,620,1,620,1,620,1,620,1,620,3,620,12311,8,620,1,621,
+        1,621,1,621,1,621,1,621,1,621,1,621,1,621,1,621,3,621,12322,8,621,
+        1,621,1,621,1,621,1,621,1,621,5,621,12329,8,621,10,621,12,621,12332,
+        9,621,1,621,1,621,1,621,1,621,1,621,1,621,1,621,3,621,12341,8,621,
+        1,621,1,621,1,621,1,621,1,621,1,621,3,621,12349,8,621,1,622,1,622,
+        3,622,12353,8,622,1,622,1,622,3,622,12357,8,622,1,622,3,622,12360,
+        8,622,1,623,1,623,1,623,5,623,12365,8,623,10,623,12,623,12368,9,
+        623,1,624,1,624,1,624,1,624,1,624,5,624,12375,8,624,10,624,12,624,
+        12378,9,624,1,625,3,625,12381,8,625,1,625,1,625,3,625,12385,8,625,
+        1,625,3,625,12388,8,625,1,625,3,625,12391,8,625,1,625,1,625,1,625,
+        3,625,12396,8,625,1,625,3,625,12399,8,625,1,625,1,625,1,626,3,626,
+        12404,8,626,1,626,1,626,3,626,12408,8,626,1,626,3,626,12411,8,626,
+        1,626,3,626,12414,8,626,1,626,1,626,1,626,1,626,1,626,3,626,12421,
+        8,626,1,626,1,626,1,626,1,626,1,626,3,626,12428,8,626,1,626,3,626,
+        12431,8,626,3,626,12433,8,626,1,626,1,626,1,626,3,626,12438,8,626,
+        1,626,1,626,3,626,12442,8,626,1,626,3,626,12445,8,626,1,626,3,626,
+        12448,8,626,1,626,1,626,1,626,3,626,12453,8,626,1,626,3,626,12456,
+        8,626,1,626,3,626,12459,8,626,1,626,1,626,1,626,3,626,12464,8,626,
+        1,626,1,626,3,626,12468,8,626,1,626,1,626,1,626,3,626,12473,8,626,
+        1,626,3,626,12476,8,626,1,626,3,626,12479,8,626,1,626,3,626,12482,
+        8,626,1,626,1,626,1,626,1,626,3,626,12488,8,626,1,626,1,626,3,626,
+        12492,8,626,1,627,1,627,1,627,1,627,1,627,3,627,12499,8,627,1,627,
+        1,627,1,627,1,627,3,627,12505,8,627,1,627,3,627,12508,8,627,1,627,
+        1,627,1,627,1,627,1,627,3,627,12515,8,627,3,627,12517,8,627,3,627,
+        12519,8,627,1,628,1,628,1,629,3,629,12524,8,629,1,629,1,629,1,629,
+        1,629,3,629,12530,8,629,1,629,1,629,3,629,12534,8,629,1,629,1,629,
+        1,629,1,629,3,629,12540,8,629,1,630,1,630,1,630,1,631,1,631,1,631,
+        1,631,1,631,1,631,3,631,12551,8,631,1,631,1,631,1,631,1,631,3,631,
+        12557,8,631,1,631,1,631,1,631,5,631,12562,8,631,10,631,12,631,12565,
+        9,631,1,632,1,632,1,632,1,633,1,633,1,633,1,633,1,633,1,633,1,633,
+        1,633,3,633,12578,8,633,1,633,1,633,3,633,12582,8,633,1,633,1,633,
+        3,633,12586,8,633,1,633,1,633,1,633,5,633,12591,8,633,10,633,12,
+        633,12594,9,633,1,633,3,633,12597,8,633,3,633,12599,8,633,1,633,
+        5,633,12602,8,633,10,633,12,633,12605,9,633,1,633,4,633,12608,8,
+        633,11,633,12,633,12609,3,633,12612,8,633,1,634,1,634,1,634,1,634,
+        1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,
+        1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,3,634,12638,
+        8,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,
+        1,634,3,634,12651,8,634,1,635,1,635,1,635,3,635,12656,8,635,1,635,
+        3,635,12659,8,635,1,636,1,636,3,636,12663,8,636,1,636,1,636,1,636,
+        3,636,12668,8,636,1,636,3,636,12671,8,636,1,636,3,636,12674,8,636,
+        1,636,1,636,1,636,1,636,1,636,3,636,12681,8,636,1,636,1,636,1,636,
+        1,636,1,636,3,636,12688,8,636,1,636,1,636,1,636,1,636,1,636,1,636,
+        3,636,12696,8,636,1,636,1,636,1,636,1,636,3,636,12702,8,636,1,636,
+        1,636,1,636,1,636,1,636,3,636,12709,8,636,1,636,3,636,12712,8,636,
+        1,636,3,636,12715,8,636,1,636,3,636,12718,8,636,1,636,3,636,12721,
+        8,636,1,637,1,637,1,637,1,637,1,637,3,637,12728,8,637,1,637,1,637,
+        1,637,1,637,3,637,12734,8,637,1,637,3,637,12737,8,637,1,637,1,637,
+        1,637,1,637,1,637,1,637,3,637,12745,8,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,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,3,637,12779,8,637,1,638,1,638,
+        1,638,5,638,12784,8,638,10,638,12,638,12787,9,638,1,638,1,638,1,
+        638,1,638,1,638,1,638,1,638,5,638,12796,8,638,10,638,12,638,12799,
+        9,638,1,638,1,638,1,638,1,638,1,638,1,638,3,638,12807,8,638,1,638,
+        1,638,1,638,5,638,12812,8,638,10,638,12,638,12815,9,638,1,638,1,
+        638,1,638,1,638,1,638,1,638,1,638,1,638,1,638,1,638,1,638,1,638,
+        3,638,12829,8,638,1,638,1,638,1,638,1,638,1,638,1,638,1,638,1,638,
+        1,638,1,638,1,638,1,638,3,638,12843,8,638,1,638,1,638,1,638,1,638,
+        1,638,1,638,1,638,3,638,12852,8,638,1,638,1,638,1,638,1,638,1,638,
+        1,638,1,638,1,638,1,638,1,638,1,638,1,638,5,638,12866,8,638,10,638,
+        12,638,12869,9,638,3,638,12871,8,638,3,638,12873,8,638,1,638,3,638,
+        12876,8,638,1,639,1,639,1,639,1,639,5,639,12882,8,639,10,639,12,
+        639,12885,9,639,1,639,1,639,1,640,1,640,1,640,1,640,1,640,1,640,
+        1,640,1,640,1,640,5,640,12898,8,640,10,640,12,640,12901,9,640,1,
+        640,1,640,1,640,1,640,1,640,1,640,5,640,12909,8,640,10,640,12,640,
+        12912,9,640,1,640,1,640,3,640,12916,8,640,1,641,1,641,1,641,1,641,
+        1,641,1,641,3,641,12924,8,641,1,641,1,641,3,641,12928,8,641,1,641,
+        1,641,1,641,3,641,12933,8,641,1,642,3,642,12936,8,642,1,642,1,642,
+        1,642,1,643,1,643,1,643,3,643,12944,8,643,1,643,1,643,1,643,3,643,
+        12949,8,643,1,644,1,644,3,644,12953,8,644,1,645,1,645,1,645,1,645,
+        1,645,3,645,12960,8,645,1,645,1,645,1,645,1,645,1,645,3,645,12967,
+        8,645,5,645,12969,8,645,10,645,12,645,12972,9,645,1,645,1,645,1,
+        645,1,645,1,645,1,645,3,645,12980,8,645,1,645,1,645,1,645,1,645,
+        1,645,1,645,3,645,12988,8,645,5,645,12990,8,645,10,645,12,645,12993,
+        9,645,3,645,12995,8,645,1,646,1,646,1,646,1,646,1,646,1,646,3,646,
+        13003,8,646,1,646,1,646,1,646,1,646,3,646,13009,8,646,5,646,13011,
+        8,646,10,646,12,646,13014,9,646,1,646,1,646,3,646,13018,8,646,1,
+        647,1,647,1,647,3,647,13023,8,647,1,647,1,647,1,647,1,647,1,647,
+        3,647,13030,8,647,1,647,1,647,3,647,13034,8,647,4,647,13036,8,647,
+        11,647,12,647,13037,1,647,1,647,1,647,1,648,1,648,1,648,1,648,1,
+        648,1,648,1,648,1,648,1,648,4,648,13052,8,648,11,648,12,648,13053,
+        1,648,3,648,13057,8,648,1,649,1,649,1,649,1,649,3,649,13063,8,649,
+        1,650,1,650,1,650,3,650,13068,8,650,1,650,3,650,13071,8,650,1,650,
+        3,650,13074,8,650,1,651,3,651,13077,8,651,1,651,1,651,1,652,1,652,
+        3,652,13083,8,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,3,653,13097,8,653,3,653,13099,8,653,1,653,
+        1,653,3,653,13103,8,653,1,653,3,653,13106,8,653,1,653,3,653,13109,
+        8,653,1,653,3,653,13112,8,653,1,654,1,654,1,654,1,654,1,654,3,654,
+        13119,8,654,1,654,1,654,3,654,13123,8,654,1,654,1,654,3,654,13127,
+        8,654,1,654,3,654,13130,8,654,1,654,1,654,3,654,13134,8,654,1,654,
+        3,654,13137,8,654,1,655,1,655,1,655,1,655,1,655,3,655,13144,8,655,
+        1,655,1,655,3,655,13148,8,655,3,655,13150,8,655,1,655,3,655,13153,
+        8,655,1,656,1,656,1,656,1,656,1,656,3,656,13160,8,656,1,657,1,657,
+        1,657,1,657,3,657,13166,8,657,1,657,1,657,3,657,13170,8,657,1,658,
+        1,658,1,658,1,658,1,658,3,658,13177,8,658,1,658,1,658,3,658,13181,
+        8,658,1,659,1,659,1,659,1,659,1,659,1,659,1,659,1,660,1,660,1,661,
+        1,661,1,662,1,662,3,662,13196,8,662,1,662,1,662,1,662,1,662,3,662,
+        13202,8,662,1,662,1,662,1,662,1,663,1,663,1,663,3,663,13210,8,663,
+        1,663,1,663,1,663,1,663,1,663,1,663,1,663,3,663,13219,8,663,1,663,
+        1,663,1,663,3,663,13224,8,663,1,663,1,663,1,663,3,663,13229,8,663,
+        1,663,1,663,1,663,1,663,3,663,13235,8,663,1,663,1,663,1,663,1,663,
+        1,663,3,663,13242,8,663,1,663,1,663,1,663,1,663,1,663,3,663,13249,
+        8,663,1,663,3,663,13252,8,663,3,663,13254,8,663,1,664,1,664,3,664,
+        13258,8,664,1,664,1,664,1,664,1,664,3,664,13264,8,664,1,664,1,664,
+        3,664,13268,8,664,1,665,1,665,1,665,1,665,3,665,13274,8,665,1,665,
+        1,665,1,665,1,665,3,665,13280,8,665,1,665,1,665,3,665,13284,8,665,
+        1,665,3,665,13287,8,665,1,666,1,666,1,667,1,667,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,670,1,670,1,670,1,670,1,670,1,670,3,670,13314,8,670,1,670,
+        1,670,1,670,1,670,1,670,1,670,1,670,3,670,13323,8,670,1,671,1,671,
+        1,671,1,671,1,671,1,671,1,671,3,671,13332,8,671,1,671,1,671,1,671,
+        1,671,1,671,1,671,5,671,13340,8,671,10,671,12,671,13343,9,671,1,
+        671,1,671,1,672,1,672,1,672,3,672,13350,8,672,1,672,1,672,1,672,
+        3,672,13355,8,672,1,672,1,672,1,673,1,673,1,673,5,673,13362,8,673,
+        10,673,12,673,13365,9,673,1,674,1,674,1,674,1,674,1,674,1,674,1,
+        674,3,674,13374,8,674,1,674,1,674,1,674,1,674,1,674,1,674,5,674,
+        13382,8,674,10,674,12,674,13385,9,674,1,674,1,674,1,675,1,675,1,
+        675,1,675,1,675,1,675,3,675,13395,8,675,1,675,1,675,1,675,1,675,
+        1,675,3,675,13402,8,675,1,676,1,676,1,676,1,676,1,676,3,676,13409,
+        8,676,1,676,3,676,13412,8,676,1,676,3,676,13415,8,676,1,676,3,676,
+        13418,8,676,1,676,1,676,3,676,13422,8,676,3,676,13424,8,676,1,676,
+        3,676,13427,8,676,1,676,3,676,13430,8,676,1,676,3,676,13433,8,676,
+        1,676,3,676,13436,8,676,1,676,1,676,3,676,13440,8,676,3,676,13442,
+        8,676,1,676,1,676,1,676,1,676,1,676,1,676,3,676,13450,8,676,3,676,
+        13452,8,676,1,677,1,677,1,677,1,677,1,677,1,677,1,677,1,677,1,677,
+        4,677,13463,8,677,11,677,12,677,13464,1,677,3,677,13468,8,677,1,
+        678,1,678,1,678,1,678,1,678,1,678,3,678,13476,8,678,1,678,1,678,
+        1,679,1,679,1,679,1,679,1,679,1,679,3,679,13486,8,679,1,679,1,679,
+        1,680,1,680,1,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,682,1,682,3,682,13507,8,682,3,682,13509,
+        8,682,1,683,1,683,1,683,1,683,1,684,1,684,1,684,1,684,1,685,1,685,
+        1,685,1,685,3,685,13523,8,685,1,685,1,685,3,685,13527,8,685,1,685,
+        3,685,13530,8,685,1,686,1,686,1,686,1,686,3,686,13536,8,686,1,687,
+        1,687,1,687,1,687,1,687,3,687,13543,8,687,1,688,1,688,1,689,1,689,
+        1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,1,690,
+        1,690,1,690,1,690,1,690,1,690,1,690,3,690,13566,8,690,1,691,3,691,
+        13569,8,691,1,691,1,691,3,691,13573,8,691,1,692,1,692,1,692,3,692,
+        13578,8,692,1,692,1,692,1,692,3,692,13583,8,692,1,692,3,692,13586,
+        8,692,1,692,3,692,13589,8,692,1,692,1,692,1,692,3,692,13594,8,692,
+        1,693,1,693,1,694,1,694,1,695,1,695,1,695,1,695,1,695,3,695,13605,
+        8,695,1,696,1,696,1,697,1,697,3,697,13611,8,697,1,697,1,697,3,697,
+        13615,8,697,1,697,1,697,1,697,1,697,3,697,13621,8,697,1,697,1,697,
+        1,697,1,697,1,697,4,697,13628,8,697,11,697,12,697,13629,3,697,13632,
+        8,697,1,697,1,697,3,697,13636,8,697,1,697,3,697,13639,8,697,1,698,
+        3,698,13642,8,698,1,698,1,698,1,698,1,698,1,698,1,698,1,698,1,698,
+        3,698,13652,8,698,1,698,1,698,1,698,1,698,1,698,1,698,4,698,13660,
+        8,698,11,698,12,698,13661,3,698,13664,8,698,1,699,1,699,1,699,1,
+        699,5,699,13670,8,699,10,699,12,699,13673,9,699,1,699,1,699,1,699,
+        1,699,1,699,1,699,5,699,13681,8,699,10,699,12,699,13684,9,699,1,
+        699,3,699,13687,8,699,1,700,1,700,1,700,1,700,1,700,1,700,5,700,
+        13695,8,700,10,700,12,700,13698,9,700,1,700,1,700,1,700,1,700,1,
+        700,1,700,5,700,13706,8,700,10,700,12,700,13709,9,700,3,700,13711,
+        8,700,1,700,1,700,1,700,3,700,13716,8,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,3,701,13730,8,701,
+        1,701,1,701,1,701,1,701,1,701,1,701,1,701,4,701,13739,8,701,11,701,
+        12,701,13740,1,701,1,701,3,701,13745,8,701,1,701,1,701,1,701,1,701,
+        1,701,1,701,3,701,13753,8,701,3,701,13755,8,701,1,702,1,702,1,703,
+        1,703,1,703,1,703,1,703,5,703,13764,8,703,10,703,12,703,13767,9,
+        703,1,703,1,703,1,703,1,703,1,703,1,703,1,703,3,703,13776,8,703,
+        1,704,1,704,1,704,1,704,3,704,13782,8,704,1,704,1,704,1,704,3,704,
+        13787,8,704,5,704,13789,8,704,10,704,12,704,13792,9,704,1,704,1,
+        704,3,704,13796,8,704,1,705,1,705,1,705,3,705,13801,8,705,1,705,
+        1,705,1,705,3,705,13806,8,705,5,705,13808,8,705,10,705,12,705,13811,
+        9,705,1,705,1,705,1,705,1,705,3,705,13817,8,705,1,705,1,705,1,705,
+        1,705,1,705,3,705,13824,8,705,1,706,1,706,1,706,3,706,13829,8,706,
+        1,706,1,706,1,706,3,706,13834,8,706,5,706,13836,8,706,10,706,12,
+        706,13839,9,706,1,706,1,706,1,706,1,706,1,706,1,706,1,706,1,706,
+        3,706,13849,8,706,1,707,1,707,1,707,1,707,3,707,13855,8,707,1,707,
+        1,707,1,707,3,707,13860,8,707,5,707,13862,8,707,10,707,12,707,13865,
+        9,707,1,707,1,707,3,707,13869,8,707,1,707,3,707,13872,8,707,1,707,
+        3,707,13875,8,707,1,708,1,708,3,708,13879,8,708,1,708,3,708,13882,
+        8,708,1,708,3,708,13885,8,708,1,708,1,708,1,708,1,708,1,708,1,708,
+        1,708,1,708,1,708,1,708,3,708,13897,8,708,1,708,1,708,1,708,1,708,
+        1,708,5,708,13904,8,708,10,708,12,708,13907,9,708,1,708,1,708,1,
+        708,1,708,1,708,3,708,13914,8,708,1,708,1,708,1,708,1,708,5,708,
+        13920,8,708,10,708,12,708,13923,9,708,1,708,1,708,3,708,13927,8,
+        708,1,708,1,708,1,708,1,708,3,708,13933,8,708,1,709,1,709,3,709,
+        13937,8,709,1,709,1,709,1,709,1,709,1,709,3,709,13944,8,709,1,709,
+        4,709,13947,8,709,11,709,12,709,13948,1,709,1,709,1,709,3,709,13954,
+        8,709,1,709,1,709,1,709,3,709,13959,8,709,5,709,13961,8,709,10,709,
+        12,709,13964,9,709,1,709,1,709,1,709,1,709,5,709,13970,8,709,10,
+        709,12,709,13973,9,709,3,709,13975,8,709,1,710,1,710,3,710,13979,
+        8,710,1,710,1,710,1,711,1,711,3,711,13985,8,711,1,711,1,711,1,711,
+        1,711,5,711,13991,8,711,10,711,12,711,13994,9,711,1,711,1,711,1,
+        711,1,711,5,711,14000,8,711,10,711,12,711,14003,9,711,3,711,14005,
+        8,711,1,712,1,712,1,712,1,712,1,712,1,712,1,712,1,713,1,713,1,713,
+        1,713,1,713,1,713,3,713,14020,8,713,1,714,1,714,1,715,1,715,1,715,
+        1,715,1,715,1,716,1,716,1,716,1,716,1,716,1,716,5,716,14035,8,716,
+        10,716,12,716,14038,9,716,1,716,1,716,1,716,3,716,14043,8,716,1,
+        717,1,717,3,717,14047,8,717,1,717,1,717,1,717,1,717,1,717,3,717,
+        14054,8,717,1,717,1,717,1,717,1,717,1,717,3,717,14061,8,717,1,717,
+        3,717,14064,8,717,3,717,14066,8,717,1,718,1,718,1,718,1,718,3,718,
+        14072,8,718,3,718,14074,8,718,1,718,3,718,14077,8,718,1,719,1,719,
+        1,719,1,719,1,719,1,719,1,719,3,719,14086,8,719,1,719,3,719,14089,
+        8,719,1,720,1,720,3,720,14093,8,720,1,720,1,720,1,720,1,720,3,720,
+        14099,8,720,1,721,1,721,1,721,1,721,1,721,1,721,1,721,1,722,1,722,
+        1,722,3,722,14111,8,722,1,722,1,722,1,722,1,723,1,723,1,723,1,723,
+        1,723,3,723,14121,8,723,1,723,1,723,3,723,14125,8,723,1,723,3,723,
+        14128,8,723,1,723,3,723,14131,8,723,1,723,1,723,1,723,3,723,14136,
+        8,723,1,723,1,723,3,723,14140,8,723,1,723,1,723,3,723,14144,8,723,
+        1,723,3,723,14147,8,723,1,724,1,724,1,724,1,724,1,724,3,724,14154,
+        8,724,1,724,3,724,14157,8,724,1,724,1,724,1,724,1,724,1,724,3,724,
+        14164,8,724,1,724,1,724,1,724,1,724,3,724,14170,8,724,1,725,1,725,
+        1,725,1,725,1,725,1,726,1,726,1,726,1,726,1,726,1,727,1,727,1,727,
+        1,727,1,727,1,727,1,727,1,727,1,727,1,727,1,727,1,727,1,727,1,727,
+        1,727,1,727,3,727,14198,8,727,1,727,1,727,1,727,1,727,1,727,1,727,
+        4,727,14206,8,727,11,727,12,727,14207,1,727,1,727,1,727,1,727,1,
+        727,1,727,1,727,1,727,3,727,14218,8,727,3,727,14220,8,727,1,727,
+        1,727,1,727,1,727,1,727,1,727,3,727,14228,8,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,731,1,731,
+        1,732,1,732,1,733,1,733,1,734,1,734,1,735,1,735,1,736,1,736,1,736,
+        1,736,1,736,1,736,1,736,3,736,14259,8,736,1,736,1,736,1,736,3,736,
+        14264,8,736,1,737,1,737,1,737,1,737,1,737,1,738,1,738,1,738,1,738,
+        1,738,1,739,1,739,3,739,14278,8,739,1,740,1,740,1,740,1,740,1,740,
+        1,741,1,741,1,741,1,741,1,741,1,742,1,742,1,742,1,742,1,742,1,742,
+        1,743,1,743,1,743,1,743,1,744,1,744,3,744,14302,8,744,1,744,3,744,
+        14305,8,744,1,744,1,744,1,744,1,744,1,744,1,744,1,744,1,744,1,744,
+        1,744,3,744,14317,8,744,1,744,3,744,14320,8,744,1,745,1,745,1,745,
+        1,745,3,745,14326,8,745,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,5,747,14342,8,747,10,747,
+        12,747,14345,9,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,14360,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,14373,8,748,
+        1,748,1,748,1,748,1,748,1,748,1,748,1,748,5,748,14382,8,748,10,748,
+        12,748,14385,9,748,1,748,4,748,14388,8,748,11,748,12,748,14389,1,
+        749,1,749,1,749,1,749,5,749,14396,8,749,10,749,12,749,14399,9,749,
+        1,749,1,749,1,749,1,749,1,749,1,749,3,749,14407,8,749,1,750,1,750,
+        3,750,14411,8,750,1,750,1,750,1,751,1,751,1,751,1,751,3,751,14419,
+        8,751,1,751,1,751,1,751,1,751,5,751,14425,8,751,10,751,12,751,14428,
+        9,751,1,751,1,751,1,751,3,751,14433,8,751,1,752,1,752,1,752,1,752,
+        1,752,3,752,14440,8,752,1,752,1,752,3,752,14444,8,752,1,752,1,752,
+        3,752,14448,8,752,3,752,14450,8,752,1,752,3,752,14453,8,752,1,753,
+        1,753,1,753,1,753,1,753,1,753,5,753,14461,8,753,10,753,12,753,14464,
+        9,753,1,753,1,753,1,753,3,753,14469,8,753,1,754,1,754,1,754,3,754,
+        14474,8,754,1,755,1,755,1,755,1,755,4,755,14480,8,755,11,755,12,
+        755,14481,1,756,1,756,1,756,1,756,1,757,1,757,1,757,1,757,1,757,
+        3,757,14493,8,757,1,757,3,757,14496,8,757,1,758,3,758,14499,8,758,
+        1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,3,758,14509,8,758,
+        1,758,1,758,1,758,1,758,1,758,5,758,14516,8,758,10,758,12,758,14519,
+        9,758,3,758,14521,8,758,1,758,3,758,14524,8,758,1,759,3,759,14527,
+        8,759,1,759,1,759,1,759,1,759,1,759,1,759,1,759,5,759,14536,8,759,
+        10,759,12,759,14539,9,759,3,759,14541,8,759,1,760,1,760,1,760,1,
+        760,3,760,14547,8,760,1,760,3,760,14550,8,760,1,761,1,761,3,761,
+        14554,8,761,1,761,3,761,14557,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,14570,8,761,3,761,14572,
+        8,761,1,761,5,761,14575,8,761,10,761,12,761,14578,9,761,1,761,1,
+        761,3,761,14582,8,761,1,762,1,762,3,762,14586,8,762,1,762,1,762,
+        1,762,1,762,1,763,1,763,1,763,1,763,1,763,1,763,1,764,1,764,1,764,
+        1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,3,764,14609,8,764,
+        1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,
+        1,764,1,764,1,764,3,764,14625,8,764,1,765,1,765,1,765,3,765,14630,
+        8,765,1,765,1,765,3,765,14634,8,765,1,765,1,765,3,765,14638,8,765,
+        1,765,1,765,3,765,14642,8,765,1,765,3,765,14645,8,765,1,765,1,765,
+        1,765,3,765,14650,8,765,3,765,14652,8,765,1,766,1,766,1,766,1,766,
+        1,766,1,766,1,766,1,766,1,766,1,766,5,766,14664,8,766,10,766,12,
+        766,14667,9,766,1,766,1,766,3,766,14671,8,766,1,767,1,767,1,767,
+        1,767,1,767,3,767,14678,8,767,1,768,1,768,1,768,1,768,1,768,1,768,
+        1,768,1,768,1,768,3,768,14689,8,768,1,768,1,768,1,768,1,768,3,768,
+        14695,8,768,3,768,14697,8,768,3,768,14699,8,768,1,769,1,769,1,769,
+        1,769,4,769,14705,8,769,11,769,12,769,14706,1,769,3,769,14710,8,
+        769,1,769,3,769,14713,8,769,1,770,1,770,3,770,14717,8,770,1,770,
+        3,770,14720,8,770,1,771,1,771,1,771,1,771,1,771,1,771,3,771,14728,
+        8,771,1,772,1,772,1,772,1,772,1,772,1,772,3,772,14736,8,772,4,772,
+        14738,8,772,11,772,12,772,14739,1,773,3,773,14743,8,773,1,773,1,
+        773,1,773,1,773,1,774,1,774,1,774,1,774,1,774,1,774,1,774,1,774,
+        1,774,1,774,1,774,1,774,3,774,14761,8,774,1,774,1,774,1,774,3,774,
+        14766,8,774,1,775,1,775,1,775,1,775,1,775,1,775,1,775,1,775,1,775,
+        1,775,1,775,3,775,14779,8,775,1,776,1,776,1,776,1,776,1,776,3,776,
+        14786,8,776,1,776,1,776,3,776,14790,8,776,1,776,3,776,14793,8,776,
+        1,776,3,776,14796,8,776,3,776,14798,8,776,1,777,1,777,1,777,3,777,
+        14803,8,777,1,777,1,777,3,777,14807,8,777,3,777,14809,8,777,1,778,
+        1,778,1,778,1,778,1,778,1,778,1,778,1,778,1,778,1,779,1,779,1,779,
+        1,779,1,779,3,779,14825,8,779,1,779,1,779,3,779,14829,8,779,1,779,
+        3,779,14832,8,779,1,779,1,779,1,779,3,779,14837,8,779,1,779,3,779,
+        14840,8,779,1,780,1,780,1,780,1,780,1,780,1,780,1,780,5,780,14849,
+        8,780,10,780,12,780,14852,9,780,1,780,1,780,1,780,1,780,1,780,1,
+        780,5,780,14860,8,780,10,780,12,780,14863,9,780,1,780,1,780,1,780,
+        1,780,1,780,1,780,1,780,5,780,14872,8,780,10,780,12,780,14875,9,
+        780,1,780,1,780,1,780,5,780,14880,8,780,10,780,12,780,14883,9,780,
+        3,780,14885,8,780,1,780,1,780,3,780,14889,8,780,1,780,1,780,1,780,
+        3,780,14894,8,780,1,781,1,781,1,781,3,781,14899,8,781,1,781,1,781,
+        3,781,14903,8,781,1,781,3,781,14906,8,781,1,781,3,781,14909,8,781,
+        1,781,3,781,14912,8,781,1,781,1,781,3,781,14916,8,781,3,781,14918,
+        8,781,1,782,1,782,1,782,1,782,1,782,1,782,1,782,1,782,3,782,14928,
+        8,782,1,782,1,782,3,782,14932,8,782,1,783,1,783,1,783,3,783,14937,
+        8,783,1,783,1,783,1,783,3,783,14942,8,783,1,784,1,784,1,784,1,784,
+        1,784,3,784,14949,8,784,1,784,1,784,1,785,1,785,1,785,1,785,3,785,
+        14957,8,785,1,785,1,785,1,785,1,785,3,785,14963,8,785,1,785,3,785,
+        14966,8,785,3,785,14968,8,785,1,785,1,785,1,785,1,785,1,785,1,785,
+        1,785,5,785,14977,8,785,10,785,12,785,14980,9,785,1,786,1,786,1,
+        786,1,786,1,787,1,787,1,787,3,787,14989,8,787,1,787,1,787,1,787,
+        1,788,1,788,1,788,1,788,5,788,14998,8,788,10,788,12,788,15001,9,
+        788,1,788,1,788,1,788,1,788,5,788,15007,8,788,10,788,12,788,15010,
+        9,788,1,788,1,788,1,788,1,788,3,788,15016,8,788,1,788,1,788,1,788,
+        5,788,15021,8,788,10,788,12,788,15024,9,788,1,788,3,788,15027,8,
+        788,3,788,15029,8,788,1,789,1,789,1,789,1,789,3,789,15035,8,789,
+        1,789,1,789,1,789,1,789,5,789,15041,8,789,10,789,12,789,15044,9,
+        789,1,789,1,789,1,789,1,789,3,789,15050,8,789,1,789,1,789,1,789,
+        5,789,15055,8,789,10,789,12,789,15058,9,789,1,789,3,789,15061,8,
+        789,3,789,15063,8,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,790,1,790,1,790,1,790,1,790,1,790,
+        1,790,4,790,15084,8,790,11,790,12,790,15085,1,790,3,790,15089,8,
+        790,1,791,1,791,1,791,1,791,3,791,15095,8,791,1,792,1,792,1,792,
+        1,792,3,792,15101,8,792,1,793,1,793,1,793,1,793,1,793,1,793,4,793,
+        15109,8,793,11,793,12,793,15110,3,793,15113,8,793,1,794,1,794,1,
+        794,3,794,15118,8,794,1,794,1,794,1,794,3,794,15123,8,794,1,794,
+        1,794,1,794,3,794,15128,8,794,5,794,15130,8,794,10,794,12,794,15133,
+        9,794,1,794,3,794,15136,8,794,1,795,1,795,3,795,15140,8,795,1,796,
+        1,796,1,796,1,796,1,797,1,797,1,797,1,797,1,797,1,797,3,797,15152,
+        8,797,1,798,1,798,1,798,1,798,3,798,15158,8,798,1,798,1,798,1,798,
+        5,798,15163,8,798,10,798,12,798,15166,9,798,1,799,1,799,3,799,15170,
+        8,799,1,799,1,799,5,799,15174,8,799,10,799,12,799,15177,9,799,1,
+        800,1,800,3,800,15181,8,800,1,800,1,800,3,800,15185,8,800,1,800,
+        1,800,5,800,15189,8,800,10,800,12,800,15192,9,800,1,801,1,801,3,
+        801,15196,8,801,1,801,1,801,1,801,1,801,1,801,5,801,15203,8,801,
+        10,801,12,801,15206,9,801,1,801,1,801,1,801,1,801,1,801,1,801,3,
+        801,15214,8,801,1,801,3,801,15217,8,801,1,801,3,801,15220,8,801,
+        1,801,3,801,15223,8,801,1,801,1,801,3,801,15227,8,801,1,802,1,802,
+        1,802,1,802,1,802,1,802,1,802,1,802,3,802,15237,8,802,1,803,1,803,
+        1,803,1,803,1,803,1,803,3,803,15245,8,803,1,803,1,803,1,803,1,803,
+        1,803,4,803,15252,8,803,11,803,12,803,15253,1,804,1,804,1,805,1,
+        805,1,805,1,805,1,806,1,806,3,806,15264,8,806,1,806,3,806,15267,
+        8,806,1,806,3,806,15270,8,806,1,806,3,806,15273,8,806,1,806,1,806,
+        5,806,15277,8,806,10,806,12,806,15280,9,806,1,806,3,806,15283,8,
+        806,1,807,1,807,1,807,3,807,15288,8,807,1,807,3,807,15291,8,807,
+        1,807,3,807,15294,8,807,1,807,3,807,15297,8,807,1,808,1,808,1,808,
+        1,808,4,808,15303,8,808,11,808,12,808,15304,1,808,3,808,15308,8,
+        808,1,808,3,808,15311,8,808,1,809,1,809,1,809,3,809,15316,8,809,
+        1,810,1,810,1,810,3,810,15321,8,810,1,811,1,811,3,811,15325,8,811,
+        1,811,1,811,3,811,15329,8,811,1,812,1,812,1,812,1,812,3,812,15335,
+        8,812,1,813,1,813,1,813,1,813,1,813,1,813,1,813,1,813,1,814,1,814,
+        1,815,1,815,1,815,1,815,1,815,1,815,1,816,1,816,1,817,1,817,1,818,
+        1,818,1,818,1,818,4,818,15361,8,818,11,818,12,818,15362,1,819,1,
+        819,1,819,1,819,1,819,1,819,1,819,1,819,5,819,15373,8,819,10,819,
+        12,819,15376,9,819,1,819,1,819,3,819,15380,8,819,1,819,1,819,1,819,
+        5,819,15385,8,819,10,819,12,819,15388,9,819,1,819,1,819,1,819,1,
+        819,1,819,1,819,1,819,5,819,15397,8,819,10,819,12,819,15400,9,819,
+        1,819,1,819,3,819,15404,8,819,1,819,1,819,1,819,5,819,15409,8,819,
+        10,819,12,819,15412,9,819,1,819,1,819,3,819,15416,8,819,1,819,1,
+        819,1,819,1,819,1,819,3,819,15423,8,819,1,819,1,819,3,819,15427,
+        8,819,1,820,1,820,1,820,1,820,1,820,5,820,15434,8,820,10,820,12,
+        820,15437,9,820,1,820,1,820,1,820,1,820,1,820,1,820,5,820,15445,
+        8,820,10,820,12,820,15448,9,820,1,820,1,820,1,820,1,820,1,820,3,
+        820,15455,8,820,1,821,1,821,3,821,15459,8,821,1,821,1,821,1,821,
+        3,821,15464,8,821,1,821,1,821,1,821,1,821,3,821,15470,8,821,1,821,
+        1,821,1,821,3,821,15475,8,821,1,821,5,821,15478,8,821,10,821,12,
+        821,15481,9,821,1,821,3,821,15484,8,821,1,821,3,821,15487,8,821,
+        1,822,1,822,1,822,1,823,1,823,1,823,3,823,15495,8,823,1,823,1,823,
+        1,823,1,823,1,823,3,823,15502,8,823,1,824,1,824,1,824,1,824,3,824,
+        15508,8,824,1,824,1,824,1,824,3,824,15513,8,824,5,824,15515,8,824,
+        10,824,12,824,15518,9,824,1,824,1,824,1,824,1,824,3,824,15524,8,
+        824,3,824,15526,8,824,1,824,3,824,15529,8,824,1,825,1,825,1,825,
+        3,825,15534,8,825,1,825,1,825,3,825,15538,8,825,1,826,1,826,1,826,
+        3,826,15543,8,826,1,826,1,826,3,826,15547,8,826,1,826,1,826,1,826,
+        1,826,1,826,3,826,15554,8,826,1,827,1,827,3,827,15558,8,827,1,828,
+        1,828,1,828,3,828,15563,8,828,1,829,1,829,1,829,1,829,3,829,15569,
+        8,829,1,829,3,829,15572,8,829,1,830,1,830,1,830,1,830,1,830,5,830,
+        15579,8,830,10,830,12,830,15582,9,830,1,830,1,830,1,830,1,830,1,
+        830,1,830,5,830,15590,8,830,10,830,12,830,15593,9,830,1,830,4,830,
+        15596,8,830,11,830,12,830,15597,1,830,1,830,1,830,1,830,1,830,1,
+        830,1,830,1,830,1,830,5,830,15609,8,830,10,830,12,830,15612,9,830,
+        1,830,4,830,15615,8,830,11,830,12,830,15616,3,830,15619,8,830,1,
+        831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,831,1,832,1,832,
+        1,832,1,832,1,832,1,832,1,832,1,832,1,832,1,832,1,832,1,832,1,832,
+        1,832,1,832,1,832,3,832,15646,8,832,1,832,3,832,15649,8,832,1,832,
+        1,832,1,832,4,832,15654,8,832,11,832,12,832,15655,1,833,1,833,1,
+        833,1,833,1,833,3,833,15663,8,833,1,833,1,833,1,833,1,833,1,833,
+        1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,1,833,
+        3,833,15681,8,833,1,833,3,833,15684,8,833,4,833,15686,8,833,11,833,
+        12,833,15687,1,834,1,834,1,835,1,835,1,835,3,835,15695,8,835,3,835,
+        15697,8,835,1,836,1,836,1,836,1,836,1,836,1,836,3,836,15705,8,836,
+        1,837,1,837,3,837,15709,8,837,1,837,1,837,1,837,3,837,15714,8,837,
+        1,837,3,837,15717,8,837,1,837,3,837,15720,8,837,1,837,3,837,15723,
+        8,837,1,838,1,838,1,839,1,839,1,839,3,839,15730,8,839,1,839,1,839,
+        1,839,3,839,15735,8,839,1,839,1,839,1,840,1,840,1,840,1,840,3,840,
+        15743,8,840,1,840,1,840,1,840,1,840,5,840,15749,8,840,10,840,12,
+        840,15752,9,840,1,840,1,840,3,840,15756,8,840,1,840,4,840,15759,
+        8,840,11,840,12,840,15760,1,841,1,841,1,841,1,841,1,841,1,841,1,
+        841,1,841,1,841,1,841,1,841,1,841,1,841,1,841,4,841,15777,8,841,
+        11,841,12,841,15778,1,841,1,841,1,841,1,841,1,841,1,841,1,841,1,
+        841,1,841,1,841,1,841,4,841,15792,8,841,11,841,12,841,15793,3,841,
+        15796,8,841,1,842,1,842,1,842,1,842,1,842,1,842,1,842,1,842,1,842,
+        1,842,3,842,15808,8,842,1,843,1,843,1,844,1,844,1,845,1,845,1,845,
+        3,845,15817,8,845,1,845,1,845,3,845,15821,8,845,3,845,15823,8,845,
+        1,845,3,845,15826,8,845,1,845,3,845,15829,8,845,1,845,1,845,1,845,
+        3,845,15834,8,845,1,845,1,845,3,845,15838,8,845,1,845,1,845,3,845,
+        15842,8,845,1,845,4,845,15845,8,845,11,845,12,845,15846,1,845,3,
+        845,15850,8,845,1,845,3,845,15853,8,845,1,846,1,846,1,847,1,847,
+        1,847,1,847,1,847,1,847,3,847,15863,8,847,3,847,15865,8,847,1,847,
+        1,847,1,847,3,847,15870,8,847,1,848,4,848,15873,8,848,11,848,12,
+        848,15874,1,848,1,848,4,848,15879,8,848,11,848,12,848,15880,1,848,
+        1,848,3,848,15885,8,848,1,849,1,849,1,849,1,849,1,849,3,849,15892,
+        8,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,
+        1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,1,849,
+        3,849,15915,8,849,1,850,1,850,1,850,1,850,3,850,15921,8,850,3,850,
+        15923,8,850,1,850,3,850,15926,8,850,1,850,3,850,15929,8,850,1,850,
+        3,850,15932,8,850,1,850,3,850,15935,8,850,1,850,1,850,1,850,1,850,
+        1,850,1,850,3,850,15943,8,850,3,850,15945,8,850,1,850,1,850,1,850,
+        1,850,1,850,1,850,1,850,3,850,15954,8,850,3,850,15956,8,850,1,850,
+        5,850,15959,8,850,10,850,12,850,15962,9,850,1,850,3,850,15965,8,
+        850,1,851,1,851,1,851,3,851,15970,8,851,3,851,15972,8,851,1,851,
+        1,851,1,851,1,851,1,851,3,851,15979,8,851,1,852,1,852,1,852,1,852,
+        1,852,1,852,3,852,15987,8,852,3,852,15989,8,852,1,852,1,852,1,852,
+        1,852,1,852,5,852,15996,8,852,10,852,12,852,15999,9,852,1,852,3,
+        852,16002,8,852,1,853,1,853,1,853,1,853,1,853,1,854,1,854,1,854,
+        1,854,1,854,1,854,3,854,16015,8,854,1,855,1,855,1,855,1,855,3,855,
+        16021,8,855,1,855,3,855,16024,8,855,1,855,3,855,16027,8,855,1,855,
+        1,855,1,855,1,855,1,855,1,855,1,855,1,855,1,855,1,855,4,855,16039,
+        8,855,11,855,12,855,16040,1,855,1,855,3,855,16045,8,855,1,855,1,
+        855,3,855,16049,8,855,1,855,3,855,16052,8,855,1,856,1,856,1,857,
+        3,857,16057,8,857,1,857,1,857,1,857,3,857,16062,8,857,1,857,1,857,
+        1,857,1,857,1,857,3,857,16069,8,857,1,857,1,857,1,857,1,857,3,857,
+        16075,8,857,1,858,1,858,3,858,16079,8,858,1,859,1,859,1,859,1,859,
+        3,859,16085,8,859,1,860,1,860,1,860,1,860,1,861,1,861,1,861,1,861,
+        1,861,5,861,16096,8,861,10,861,12,861,16099,9,861,1,861,3,861,16102,
+        8,861,1,861,1,861,1,861,1,861,1,861,3,861,16109,8,861,1,861,1,861,
+        1,861,1,861,1,861,1,861,1,861,1,861,1,861,1,861,5,861,16121,8,861,
+        10,861,12,861,16124,9,861,1,861,1,861,3,861,16128,8,861,1,861,1,
+        861,3,861,16132,8,861,1,861,1,861,1,861,1,861,1,861,1,861,1,861,
+        4,861,16141,8,861,11,861,12,861,16142,3,861,16145,8,861,1,862,1,
+        862,1,863,1,863,1,864,1,864,1,864,1,864,1,864,1,864,1,864,1,864,
+        5,864,16159,8,864,10,864,12,864,16162,9,864,1,864,1,864,1,864,1,
+        864,3,864,16168,8,864,1,864,3,864,16171,8,864,1,864,1,864,3,864,
+        16175,8,864,1,864,3,864,16178,8,864,1,865,1,865,1,865,1,865,1,865,
+        3,865,16185,8,865,1,866,1,866,1,866,1,866,1,866,3,866,16192,8,866,
+        1,867,1,867,1,867,3,867,16197,8,867,1,867,1,867,1,867,1,867,1,867,
+        3,867,16204,8,867,3,867,16206,8,867,1,868,1,868,1,868,1,868,1,868,
+        3,868,16213,8,868,1,869,1,869,3,869,16217,8,869,3,869,16219,8,869,
+        1,869,1,869,1,869,1,869,4,869,16225,8,869,11,869,12,869,16226,3,
+        869,16229,8,869,1,869,1,869,1,870,1,870,1,870,1,871,1,871,3,871,
+        16238,8,871,1,872,1,872,1,872,1,872,1,872,1,873,1,873,1,873,3,873,
+        16248,8,873,1,873,1,873,1,873,1,873,1,873,1,873,1,873,1,873,1,873,
+        3,873,16259,8,873,3,873,16261,8,873,1,873,3,873,16264,8,873,1,873,
+        1,873,3,873,16268,8,873,1,873,3,873,16271,8,873,1,874,1,874,1,874,
+        1,874,1,874,1,874,1,875,1,875,1,875,1,875,1,875,5,875,16284,8,875,
+        10,875,12,875,16287,9,875,1,875,1,875,1,876,1,876,1,876,1,876,3,
+        876,16295,8,876,1,876,1,876,3,876,16299,8,876,1,876,3,876,16302,
+        8,876,1,876,1,876,3,876,16306,8,876,1,876,3,876,16309,8,876,3,876,
+        16311,8,876,1,877,1,877,3,877,16315,8,877,1,877,1,877,1,877,1,877,
+        1,877,3,877,16322,8,877,1,878,1,878,5,878,16326,8,878,10,878,12,
+        878,16329,9,878,1,878,3,878,16332,8,878,1,878,3,878,16335,8,878,
+        1,879,1,879,1,879,1,880,4,880,16341,8,880,11,880,12,880,16342,1,
+        881,1,881,1,881,1,881,1,881,1,881,1,881,1,881,1,881,1,881,1,881,
+        3,881,16356,8,881,1,882,1,882,3,882,16360,8,882,1,882,1,882,3,882,
+        16364,8,882,1,882,3,882,16367,8,882,1,882,3,882,16370,8,882,1,882,
+        1,882,1,883,1,883,1,883,1,883,1,883,1,883,1,883,1,883,1,883,3,883,
+        16383,8,883,1,883,1,883,3,883,16387,8,883,1,883,1,883,1,884,1,884,
+        1,884,1,884,1,884,1,884,5,884,16397,8,884,10,884,12,884,16400,9,
+        884,1,884,1,884,3,884,16404,8,884,1,884,1,884,3,884,16408,8,884,
+        1,884,1,884,3,884,16412,8,884,1,884,1,884,1,885,1,885,3,885,16418,
+        8,885,1,885,3,885,16421,8,885,1,885,3,885,16424,8,885,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,887,
+        1,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,1,887,
+        1,887,3,887,16451,8,887,1,887,1,887,4,887,16455,8,887,11,887,12,
+        887,16456,1,887,1,887,1,887,1,887,1,887,1,887,1,887,3,887,16466,
+        8,887,1,887,1,887,1,887,3,887,16471,8,887,1,887,1,887,1,888,1,888,
+        1,888,1,888,1,888,5,888,16480,8,888,10,888,12,888,16483,9,888,1,
+        888,1,888,1,889,1,889,3,889,16489,8,889,1,889,1,889,3,889,16493,
+        8,889,1,889,3,889,16496,8,889,1,890,1,890,1,890,1,890,3,890,16502,
+        8,890,1,891,1,891,1,891,1,891,1,891,1,891,1,891,3,891,16511,8,891,
+        1,891,1,891,1,892,1,892,1,892,1,892,1,892,3,892,16520,8,892,1,892,
+        3,892,16523,8,892,1,893,1,893,3,893,16527,8,893,1,893,1,893,1,893,
+        1,894,1,894,3,894,16534,8,894,1,894,3,894,16537,8,894,1,894,1,894,
+        1,894,1,894,1,894,1,894,1,894,3,894,16546,8,894,1,895,5,895,16549,
+        8,895,10,895,12,895,16552,9,895,1,895,1,895,1,895,1,895,1,895,4,
+        895,16559,8,895,11,895,12,895,16560,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,3,897,16586,8,897,1,898,
+        1,898,3,898,16590,8,898,1,898,1,898,1,898,1,899,1,899,3,899,16597,
+        8,899,1,899,1,899,3,899,16601,8,899,1,900,1,900,3,900,16605,8,900,
+        1,900,1,900,3,900,16609,8,900,1,901,1,901,1,901,1,902,1,902,1,902,
+        1,902,1,902,5,902,16619,8,902,10,902,12,902,16622,9,902,1,902,3,
+        902,16625,8,902,1,902,1,902,1,902,1,903,1,903,1,903,1,903,1,903,
+        1,904,1,904,1,904,1,905,3,905,16639,8,905,1,905,1,905,1,905,1,905,
+        3,905,16645,8,905,1,905,1,905,1,905,1,905,1,905,3,905,16652,8,905,
+        1,906,1,906,1,906,3,906,16657,8,906,1,906,1,906,1,906,1,906,1,906,
+        1,906,1,906,1,906,1,906,3,906,16668,8,906,1,906,3,906,16671,8,906,
+        1,906,1,906,1,906,1,906,3,906,16677,8,906,3,906,16679,8,906,1,907,
+        1,907,1,907,1,907,1,907,1,907,3,907,16687,8,907,1,907,1,907,3,907,
+        16691,8,907,1,908,1,908,1,908,1,908,1,908,1,908,1,908,1,908,3,908,
+        16701,8,908,1,908,1,908,1,908,3,908,16706,8,908,1,909,1,909,1,909,
+        1,909,1,909,1,910,1,910,1,911,1,911,1,912,1,912,1,913,1,913,3,913,
+        16721,8,913,1,914,1,914,3,914,16725,8,914,1,915,3,915,16728,8,915,
+        1,915,1,915,3,915,16732,8,915,1,915,1,915,1,915,3,915,16737,8,915,
+        5,915,16739,8,915,10,915,12,915,16742,9,915,1,915,1,915,3,915,16746,
+        8,915,1,916,1,916,1,916,1,916,1,916,1,916,1,917,1,917,1,917,1,917,
+        3,917,16758,8,917,1,917,1,917,1,917,1,917,3,917,16764,8,917,5,917,
+        16766,8,917,10,917,12,917,16769,9,917,1,917,1,917,3,917,16773,8,
+        917,3,917,16775,8,917,1,917,1,917,1,918,1,918,1,918,1,918,1,919,
+        3,919,16784,8,919,1,919,1,919,1,919,1,919,1,919,1,919,1,919,4,919,
+        16793,8,919,11,919,12,919,16794,1,920,1,920,1,920,1,920,4,920,16801,
+        8,920,11,920,12,920,16802,3,920,16805,8,920,1,920,1,920,3,920,16809,
+        8,920,1,921,1,921,1,921,1,921,5,921,16815,8,921,10,921,12,921,16818,
+        9,921,1,921,1,921,1,921,1,922,1,922,5,922,16825,8,922,10,922,12,
+        922,16828,9,922,3,922,16830,8,922,1,922,1,922,1,923,5,923,16835,
+        8,923,10,923,12,923,16838,9,923,1,923,1,923,1,924,1,924,5,924,16844,
+        8,924,10,924,12,924,16847,9,924,3,924,16849,8,924,1,924,1,924,1,
+        925,1,925,1,925,1,925,1,925,3,925,16858,8,925,1,926,1,926,1,926,
+        1,926,1,926,3,926,16865,8,926,1,926,1,926,3,926,16869,8,926,1,926,
+        3,926,16872,8,926,1,927,1,927,1,927,1,928,1,928,1,928,1,928,1,928,
+        1,928,1,928,3,928,16884,8,928,1,929,1,929,1,929,1,929,3,929,16890,
+        8,929,1,930,1,930,1,930,1,931,1,931,1,931,1,931,3,931,16899,8,931,
+        1,931,3,931,16902,8,931,1,932,1,932,1,932,1,932,1,932,1,932,5,932,
+        16910,8,932,10,932,12,932,16913,9,932,1,932,1,932,1,932,1,932,1,
+        932,1,932,5,932,16921,8,932,10,932,12,932,16924,9,932,1,932,1,932,
+        1,932,3,932,16929,8,932,3,932,16931,8,932,3,932,16933,8,932,1,933,
+        1,933,3,933,16937,8,933,1,934,1,934,1,934,1,934,1,934,3,934,16944,
+        8,934,1,934,3,934,16947,8,934,1,935,1,935,1,935,1,935,1,935,3,935,
+        16954,8,935,1,936,1,936,1,936,1,936,1,936,1,936,1,936,1,936,1,936,
+        3,936,16965,8,936,1,936,1,936,1,936,1,936,3,936,16971,8,936,1,936,
+        1,936,3,936,16975,8,936,1,937,1,937,1,937,1,937,1,937,1,937,5,937,
+        16983,8,937,10,937,12,937,16986,9,937,3,937,16988,8,937,1,937,1,
+        937,1,938,1,938,3,938,16994,8,938,1,938,3,938,16997,8,938,1,938,
+        1,938,1,938,3,938,17002,8,938,1,938,1,938,1,938,1,938,3,938,17008,
+        8,938,1,938,1,938,1,938,3,938,17013,8,938,3,938,17015,8,938,1,939,
+        1,939,1,939,5,939,17020,8,939,10,939,12,939,17023,9,939,1,940,1,
+        940,3,940,17027,8,940,1,940,1,940,3,940,17031,8,940,1,940,1,940,
+        1,940,3,940,17036,8,940,1,941,1,941,1,941,1,942,1,942,1,942,1,942,
+        1,942,1,942,1,942,5,942,17048,8,942,10,942,12,942,17051,9,942,1,
+        942,1,942,3,942,17055,8,942,1,942,1,942,1,942,1,942,1,942,3,942,
+        17062,8,942,3,942,17064,8,942,1,943,1,943,1,943,1,943,1,943,1,943,
+        3,943,17072,8,943,1,943,1,943,3,943,17076,8,943,1,943,1,943,1,943,
+        1,943,1,943,1,943,3,943,17084,8,943,1,944,1,944,1,945,1,945,1,945,
+        1,945,1,945,5,945,17093,8,945,10,945,12,945,17096,9,945,1,946,1,
+        946,1,946,5,946,17101,8,946,10,946,12,946,17104,9,946,1,946,1,946,
+        1,946,5,946,17109,8,946,10,946,12,946,17112,9,946,1,946,1,946,1,
+        946,4,946,17117,8,946,11,946,12,946,17118,1,946,1,946,1,946,5,946,
+        17124,8,946,10,946,12,946,17127,9,946,3,946,17129,8,946,3,946,17131,
+        8,946,1,947,1,947,3,947,17135,8,947,1,948,1,948,3,948,17139,8,948,
+        1,948,1,948,1,948,1,948,3,948,17145,8,948,1,948,1,948,3,948,17149,
+        8,948,1,948,3,948,17152,8,948,1,949,1,949,1,949,1,949,1,949,1,949,
+        3,949,17160,8,949,1,949,3,949,17163,8,949,1,949,1,949,3,949,17167,
+        8,949,1,949,1,949,3,949,17171,8,949,1,949,1,949,1,949,3,949,17176,
+        8,949,1,949,3,949,17179,8,949,1,949,1,949,3,949,17183,8,949,1,949,
+        1,949,3,949,17187,8,949,5,949,17189,8,949,10,949,12,949,17192,9,
+        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,952,
+        1,952,1,952,3,952,17217,8,952,1,952,3,952,17220,8,952,1,952,3,952,
+        17223,8,952,1,953,1,953,1,953,1,953,1,953,5,953,17230,8,953,10,953,
+        12,953,17233,9,953,1,953,1,953,1,954,1,954,1,954,1,954,1,954,1,954,
+        5,954,17243,8,954,10,954,12,954,17246,9,954,1,954,1,954,1,955,1,
+        955,3,955,17252,8,955,1,955,1,955,1,955,1,956,1,956,1,956,1,956,
+        1,956,1,956,5,956,17263,8,956,10,956,12,956,17266,9,956,1,956,1,
+        956,1,957,1,957,1,957,1,957,1,957,1,957,1,958,3,958,17277,8,958,
+        1,958,1,958,5,958,17281,8,958,10,958,12,958,17284,9,958,1,959,1,
+        959,5,959,17288,8,959,10,959,12,959,17291,9,959,1,960,1,960,1,960,
+        1,960,1,960,3,960,17298,8,960,1,961,1,961,3,961,17302,8,961,1,961,
+        1,961,3,961,17306,8,961,1,961,1,961,1,962,1,962,3,962,17312,8,962,
+        1,962,1,962,3,962,17316,8,962,1,962,3,962,17319,8,962,1,962,3,962,
+        17322,8,962,1,962,1,962,5,962,17326,8,962,10,962,12,962,17329,9,
+        962,1,962,3,962,17332,8,962,1,962,3,962,17335,8,962,1,962,3,962,
+        17338,8,962,1,962,3,962,17341,8,962,1,963,1,963,1,963,1,963,5,963,
+        17347,8,963,10,963,12,963,17350,9,963,3,963,17352,8,963,1,964,1,
+        964,1,964,1,965,1,965,1,965,1,965,1,965,1,965,3,965,17363,8,965,
+        3,965,17365,8,965,1,966,1,966,1,966,5,966,17370,8,966,10,966,12,
+        966,17373,9,966,1,967,1,967,5,967,17377,8,967,10,967,12,967,17380,
+        9,967,1,967,1,967,3,967,17384,8,967,1,968,1,968,5,968,17388,8,968,
+        10,968,12,968,17391,9,968,1,968,1,968,3,968,17395,8,968,1,969,1,
+        969,1,969,3,969,17400,8,969,1,969,1,969,1,969,5,969,17405,8,969,
+        10,969,12,969,17408,9,969,1,969,1,969,1,969,3,969,17413,8,969,1,
+        969,1,969,1,969,1,969,1,969,3,969,17420,8,969,1,970,3,970,17423,
+        8,970,1,970,3,970,17426,8,970,1,970,1,970,3,970,17430,8,970,1,970,
+        1,970,1,970,3,970,17435,8,970,1,970,1,970,5,970,17439,8,970,10,970,
+        12,970,17442,9,970,1,970,1,970,1,970,3,970,17447,8,970,1,971,1,971,
+        1,971,1,972,1,972,1,972,1,973,1,973,3,973,17457,8,973,1,974,1,974,
+        1,974,1,974,1,974,3,974,17464,8,974,1,974,1,974,3,974,17468,8,974,
+        1,975,1,975,1,975,1,975,1,975,1,975,1,975,1,975,3,975,17478,8,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,3,975,17493,8,975,3,975,17495,8,975,1,976,1,976,3,976,
+        17499,8,976,1,976,1,976,1,976,1,976,5,976,17505,8,976,10,976,12,
+        976,17508,9,976,1,976,1,976,1,976,1,976,3,976,17514,8,976,1,977,
+        1,977,1,977,1,977,1,977,1,977,3,977,17522,8,977,1,977,3,977,17525,
+        8,977,1,978,1,978,1,978,3,978,17530,8,978,1,979,1,979,1,979,1,979,
+        1,979,1,979,5,979,17538,8,979,10,979,12,979,17541,9,979,1,979,1,
+        979,1,979,5,979,17546,8,979,10,979,12,979,17549,9,979,3,979,17551,
+        8,979,1,979,1,979,1,980,1,980,3,980,17557,8,980,1,981,1,981,1,981,
+        3,981,17562,8,981,1,981,3,981,17565,8,981,1,982,1,982,1,982,3,982,
+        17570,8,982,1,982,1,982,1,982,3,982,17575,8,982,1,982,1,982,1,982,
+        1,982,3,982,17581,8,982,1,983,1,983,1,983,1,983,1,983,5,983,17588,
+        8,983,10,983,12,983,17591,9,983,1,983,1,983,1,984,1,984,3,984,17597,
+        8,984,1,984,1,984,1,984,1,984,1,984,1,984,5,984,17605,8,984,10,984,
+        12,984,17608,9,984,1,984,1,984,3,984,17612,8,984,3,984,17614,8,984,
+        1,985,1,985,1,985,3,985,17619,8,985,1,985,1,985,3,985,17623,8,985,
+        1,985,1,985,1,985,1,985,3,985,17629,8,985,1,985,1,985,3,985,17633,
+        8,985,1,986,1,986,1,986,1,986,1,987,1,987,1,987,1,987,1,987,5,987,
+        17644,8,987,10,987,12,987,17647,9,987,1,987,3,987,17650,8,987,1,
+        987,1,987,1,987,1,987,1,987,1,987,5,987,17658,8,987,10,987,12,987,
+        17661,9,987,3,987,17663,8,987,3,987,17665,8,987,1,988,1,988,1,988,
+        3,988,17670,8,988,1,989,1,989,1,989,1,989,1,989,5,989,17677,8,989,
+        10,989,12,989,17680,9,989,1,989,1,989,1,990,1,990,1,990,1,990,1,
+        990,1,990,5,990,17690,8,990,10,990,12,990,17693,9,990,1,990,1,990,
+        1,991,1,991,1,991,3,991,17700,8,991,1,991,1,991,3,991,17704,8,991,
+        1,992,1,992,1,992,1,993,1,993,5,993,17711,8,993,10,993,12,993,17714,
+        9,993,1,993,3,993,17717,8,993,1,993,5,993,17720,8,993,10,993,12,
+        993,17723,9,993,1,993,1,993,1,994,1,994,1,994,1,994,1,994,1,994,
+        3,994,17733,8,994,3,994,17735,8,994,1,995,1,995,1,995,1,995,1,996,
+        1,996,1,996,1,996,1,996,1,996,1,996,1,996,5,996,17749,8,996,10,996,
+        12,996,17752,9,996,1,997,1,997,3,997,17756,8,997,1,997,1,997,5,997,
+        17760,8,997,10,997,12,997,17763,9,997,1,997,1,997,1,998,3,998,17768,
+        8,998,1,998,1,998,1,998,1,998,1,998,1,998,1,999,1,999,1,999,1,999,
+        1,1000,1,1000,1,1000,1,1000,5,1000,17784,8,1000,10,1000,12,1000,
+        17787,9,1000,1,1000,1,1000,1,1001,1,1001,3,1001,17793,8,1001,1,1001,
+        3,1001,17796,8,1001,1,1002,3,1002,17799,8,1002,1,1002,1,1002,1,1002,
+        1,1002,5,1002,17805,8,1002,10,1002,12,1002,17808,9,1002,3,1002,17810,
+        8,1002,1,1002,1,1002,1,1003,1,1003,1,1003,1,1003,3,1003,17818,8,
+        1003,3,1003,17820,8,1003,1,1003,1,1003,3,1003,17824,8,1003,1,1003,
+        3,1003,17827,8,1003,1,1004,1,1004,1,1004,3,1004,17832,8,1004,3,1004,
+        17834,8,1004,1,1004,1,1004,3,1004,17838,8,1004,1,1004,1,1004,1,1004,
+        1,1005,1,1005,1,1006,1,1006,1,1006,1,1006,1,1006,3,1006,17850,8,
+        1006,1,1007,1,1007,1,1007,1,1007,1,1007,1,1008,1,1008,3,1008,17859,
+        8,1008,1,1008,1,1008,1,1008,1,1008,5,1008,17865,8,1008,10,1008,12,
+        1008,17868,9,1008,1,1009,1,1009,3,1009,17872,8,1009,1,1009,1,1009,
+        3,1009,17876,8,1009,1,1010,1,1010,1,1010,1,1010,1,1011,1,1011,1,
+        1011,1,1011,3,1011,17886,8,1011,3,1011,17888,8,1011,1,1011,1,1011,
+        1,1011,1,1011,3,1011,17894,8,1011,1,1012,1,1012,1,1012,3,1012,17899,
+        8,1012,1,1012,3,1012,17902,8,1012,1,1013,1,1013,1,1013,1,1014,1,
+        1014,1,1014,1,1014,1,1014,3,1014,17912,8,1014,1,1015,1,1015,1,1015,
+        1,1015,3,1015,17918,8,1015,1,1015,3,1015,17921,8,1015,1,1015,3,1015,
+        17924,8,1015,1,1016,1,1016,1,1016,1,1016,5,1016,17930,8,1016,10,
+        1016,12,1016,17933,9,1016,1,1016,1,1016,1,1016,1,1016,1,1016,1,1016,
+        1,1016,3,1016,17942,8,1016,1,1017,1,1017,1,1017,1,1017,1,1017,1,
+        1017,1,1017,1,1017,3,1017,17952,8,1017,1,1018,1,1018,3,1018,17956,
+        8,1018,1,1018,1,1018,3,1018,17960,8,1018,1,1018,3,1018,17963,8,1018,
+        1,1018,3,1018,17966,8,1018,1,1019,1,1019,1,1019,3,1019,17971,8,1019,
+        1,1020,1,1020,1,1020,3,1020,17976,8,1020,1,1020,3,1020,17979,8,1020,
+        1,1020,3,1020,17982,8,1020,1,1021,1,1021,4,1021,17986,8,1021,11,
+        1021,12,1021,17987,1,1021,3,1021,17991,8,1021,1,1021,1,1021,1,1022,
+        1,1022,3,1022,17997,8,1022,1,1022,3,1022,18000,8,1022,1,1023,3,1023,
+        18003,8,1023,1,1023,4,1023,18006,8,1023,11,1023,12,1023,18007,1,
+        1023,3,1023,18011,8,1023,1,1024,1,1024,1,1024,1,1024,4,1024,18017,
+        8,1024,11,1024,12,1024,18018,1,1025,1,1025,4,1025,18023,8,1025,11,
+        1025,12,1025,18024,1,1026,1,1026,1,1026,3,1026,18030,8,1026,1,1026,
+        3,1026,18033,8,1026,1,1027,1,1027,1,1027,1,1027,1,1027,1,1027,1,
+        1027,1,1027,1,1027,1,1027,5,1027,18045,8,1027,10,1027,12,1027,18048,
+        9,1027,1,1027,3,1027,18051,8,1027,1,1028,1,1028,1,1028,1,1028,1,
+        1028,1,1028,1,1028,1,1028,1,1028,1,1028,1,1028,3,1028,18064,8,1028,
+        1,1028,1,1028,3,1028,18068,8,1028,3,1028,18070,8,1028,1,1028,3,1028,
+        18073,8,1028,1,1028,3,1028,18076,8,1028,1,1029,1,1029,1,1029,1,1029,
+        1,1029,1,1029,1,1029,1,1029,5,1029,18086,8,1029,10,1029,12,1029,
+        18089,9,1029,1,1029,3,1029,18092,8,1029,1,1029,3,1029,18095,8,1029,
+        1,1030,1,1030,1,1030,1,1030,1,1031,1,1031,1,1031,1,1032,1,1032,1,
+        1032,1,1032,1,1032,1,1032,3,1032,18110,8,1032,1,1032,1,1032,3,1032,
+        18114,8,1032,1,1033,1,1033,1,1033,1,1033,1,1033,1,1033,1,1033,1,
+        1033,1,1033,1,1033,3,1033,18126,8,1033,1,1033,3,1033,18129,8,1033,
+        1,1034,1,1034,1,1034,1,1034,1,1034,5,1034,18136,8,1034,10,1034,12,
+        1034,18139,9,1034,1,1034,1,1034,1,1034,1,1034,3,1034,18145,8,1034,
+        1,1035,1,1035,1,1035,3,1035,18150,8,1035,1,1036,1,1036,3,1036,18154,
+        8,1036,1,1037,1,1037,1,1037,1,1037,1,1037,1,1037,3,1037,18162,8,
+        1037,1,1037,1,1037,1,1037,1,1037,3,1037,18168,8,1037,1,1038,1,1038,
+        1,1038,1,1038,1,1038,1,1038,3,1038,18176,8,1038,1,1038,3,1038,18179,
+        8,1038,1,1039,1,1039,1,1039,1,1039,1,1040,1,1040,1,1040,3,1040,18188,
+        8,1040,1,1040,3,1040,18191,8,1040,1,1040,3,1040,18194,8,1040,1,1041,
+        1,1041,1,1041,1,1042,1,1042,1,1042,1,1042,3,1042,18203,8,1042,1,
+        1043,1,1043,1,1043,1,1043,3,1043,18209,8,1043,1,1043,1,1043,1,1043,
+        1,1043,3,1043,18215,8,1043,1,1043,3,1043,18218,8,1043,1,1043,1,1043,
+        1,1043,3,1043,18223,8,1043,1,1043,1,1043,1,1043,1,1043,3,1043,18229,
+        8,1043,1,1043,1,1043,1,1043,1,1043,1,1043,1,1043,1,1043,1,1043,1,
+        1043,1,1043,3,1043,18241,8,1043,1,1044,1,1044,1,1044,1,1044,1,1044,
+        1,1044,1,1044,1,1044,1,1044,3,1044,18252,8,1044,3,1044,18254,8,1044,
+        1,1045,1,1045,1,1045,1,1045,1,1045,1,1045,1,1045,3,1045,18263,8,
+        1045,3,1045,18265,8,1045,1,1046,1,1046,3,1046,18269,8,1046,1,1046,
+        1,1046,1,1046,1,1046,3,1046,18275,8,1046,1,1046,1,1046,3,1046,18279,
+        8,1046,1,1047,1,1047,1,1047,1,1047,1,1047,1,1048,1,1048,1,1048,1,
+        1048,1,1048,1,1048,3,1048,18292,8,1048,1,1049,1,1049,1,1049,5,1049,
+        18297,8,1049,10,1049,12,1049,18300,9,1049,1,1050,1,1050,3,1050,18304,
+        8,1050,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,5,1052,18320,8,1052,10,1052,
+        12,1052,18323,9,1052,1,1053,3,1053,18326,8,1053,1,1053,1,1053,3,
+        1053,18330,8,1053,1,1054,1,1054,3,1054,18334,8,1054,1,1054,1,1054,
+        1,1055,1,1055,1,1055,1,1055,1,1055,1,1055,1,1055,1,1055,1,1055,3,
+        1055,18347,8,1055,1,1055,1,1055,3,1055,18351,8,1055,1,1055,1,1055,
+        1,1055,5,1055,18356,8,1055,10,1055,12,1055,18359,9,1055,1,1055,1,
+        1055,1,1055,1,1055,1,1055,3,1055,18366,8,1055,1,1055,3,1055,18369,
+        8,1055,1,1055,1,1055,1,1055,3,1055,18374,8,1055,3,1055,18376,8,1055,
+        1,1056,1,1056,1,1056,3,1056,18381,8,1056,1,1056,1,1056,3,1056,18385,
+        8,1056,1,1056,3,1056,18388,8,1056,1,1056,1,1056,1,1056,1,1056,3,
+        1056,18394,8,1056,1,1056,5,1056,18397,8,1056,10,1056,12,1056,18400,
+        9,1056,1,1057,1,1057,1,1057,1,1057,1,1057,1,1057,1,1057,1,1057,1,
+        1057,3,1057,18411,8,1057,1,1057,1,1057,5,1057,18415,8,1057,10,1057,
+        12,1057,18418,9,1057,1,1058,1,1058,3,1058,18422,8,1058,1,1058,1,
+        1058,1,1058,1,1058,1,1058,1,1058,1,1058,1,1058,3,1058,18432,8,1058,
+        3,1058,18434,8,1058,3,1058,18436,8,1058,1,1059,1,1059,1,1059,1,1059,
+        1,1059,1,1059,1,1059,1,1059,3,1059,18446,8,1059,1,1059,1,1059,3,
+        1059,18450,8,1059,3,1059,18452,8,1059,1,1060,1,1060,1,1060,1,1060,
+        1,1060,1,1060,1,1060,1,1060,5,1060,18462,8,1060,10,1060,12,1060,
+        18465,9,1060,1,1060,1,1060,1,1060,1,1060,1,1060,3,1060,18472,8,1060,
+        1,1061,1,1061,1,1061,1,1061,1,1062,1,1062,1,1062,1,1062,1,1062,1,
+        1062,1,1062,3,1062,18485,8,1062,1,1062,3,1062,18488,8,1062,1,1062,
+        1,1062,1,1062,3,1062,18493,8,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,5,1062,18511,8,1062,10,1062,12,1062,18514,9,1062,1,
+        1063,1,1063,1,1063,1,1063,1,1063,3,1063,18521,8,1063,1,1063,1,1063,
+        1,1063,1,1063,1,1063,1,1063,3,1063,18529,8,1063,1,1063,1,1063,1,
+        1063,1,1063,1,1063,3,1063,18536,8,1063,1,1063,1,1063,3,1063,18540,
+        8,1063,1,1064,3,1064,18543,8,1064,1,1064,1,1064,1,1064,1,1064,1,
+        1064,3,1064,18550,8,1064,1,1065,1,1065,3,1065,18554,8,1065,1,1065,
+        1,1065,1,1065,3,1065,18559,8,1065,5,1065,18561,8,1065,10,1065,12,
+        1065,18564,9,1065,1,1065,1,1065,1,1065,5,1065,18569,8,1065,10,1065,
+        12,1065,18572,9,1065,1,1065,3,1065,18575,8,1065,1,1066,1,1066,1,
+        1066,1,1066,1,1066,3,1066,18582,8,1066,1,1066,1,1066,1,1066,3,1066,
+        18587,8,1066,1,1066,1,1066,1,1066,1,1066,1,1066,1,1066,1,1066,3,
+        1066,18596,8,1066,1,1067,1,1067,1,1067,1,1067,1,1067,1,1067,1,1067,
+        3,1067,18605,8,1067,1,1067,3,1067,18608,8,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,3,1068,18628,8,1068,3,1068,
+        18630,8,1068,3,1068,18632,8,1068,1,1069,1,1069,1,1069,1,1069,1,1069,
+        1,1069,1,1069,3,1069,18641,8,1069,1,1070,1,1070,1,1070,1,1070,1,
+        1070,1,1070,1,1070,1,1070,1,1070,5,1070,18652,8,1070,10,1070,12,
+        1070,18655,9,1070,1,1070,1,1070,3,1070,18659,8,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,1071,1,1071,1,1071,3,1071,18678,8,1071,3,1071,
+        18680,8,1071,1,1072,1,1072,1,1072,1,1072,1,1072,1,1072,5,1072,18688,
+        8,1072,10,1072,12,1072,18691,9,1072,1,1073,1,1073,3,1073,18695,8,
+        1073,1,1074,3,1074,18698,8,1074,1,1074,1,1074,1,1074,4,1074,18703,
+        8,1074,11,1074,12,1074,18704,1,1074,3,1074,18708,8,1074,1,1074,1,
+        1074,3,1074,18712,8,1074,1,1074,3,1074,18715,8,1074,1,1075,3,1075,
+        18718,8,1075,1,1075,1,1075,4,1075,18722,8,1075,11,1075,12,1075,18723,
+        1,1075,3,1075,18727,8,1075,1,1075,1,1075,3,1075,18731,8,1075,1,1075,
+        3,1075,18734,8,1075,1,1076,1,1076,1,1076,1,1076,1,1076,1,1077,1,
+        1077,1,1077,1,1078,1,1078,3,1078,18746,8,1078,1,1079,1,1079,1,1079,
+        4,1079,18751,8,1079,11,1079,12,1079,18752,1,1079,3,1079,18756,8,
+        1079,1,1079,1,1079,3,1079,18760,8,1079,1,1080,1,1080,4,1080,18764,
+        8,1080,11,1080,12,1080,18765,1,1080,3,1080,18769,8,1080,1,1080,1,
+        1080,3,1080,18773,8,1080,1,1081,1,1081,1,1081,1,1081,1,1081,1,1082,
+        1,1082,1,1082,1,1083,1,1083,1,1083,1,1083,1,1083,3,1083,18788,8,
+        1083,1,1083,1,1083,1,1083,1,1083,5,1083,18794,8,1083,10,1083,12,
+        1083,18797,9,1083,1,1083,1,1083,1,1083,1,1083,1,1083,5,1083,18804,
+        8,1083,10,1083,12,1083,18807,9,1083,1,1083,1,1083,1,1083,1,1083,
+        3,1083,18813,8,1083,1,1084,1,1084,1,1084,1,1084,1,1084,1,1084,1,
+        1084,1,1084,1,1084,5,1084,18824,8,1084,10,1084,12,1084,18827,9,1084,
+        1,1084,1,1084,3,1084,18831,8,1084,1,1085,1,1085,1,1085,1,1085,1,
+        1085,1,1085,1,1085,3,1085,18840,8,1085,1,1085,1,1085,1,1085,1,1085,
+        1,1085,1,1085,1,1085,3,1085,18849,8,1085,1,1085,1,1085,3,1085,18853,
+        8,1085,1,1085,1,1085,3,1085,18857,8,1085,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,1085,
+        1,1085,1,1085,1,1085,1,1085,1,1085,1,1085,1,1085,1,1085,1,1085,1,
+        1085,1,1085,3,1085,18883,8,1085,1,1085,3,1085,18886,8,1085,1,1085,
+        3,1085,18889,8,1085,1,1085,1,1085,1,1085,1,1085,1,1085,1,1085,1,
+        1085,1,1085,3,1085,18899,8,1085,1,1085,1,1085,1,1085,1,1085,1,1085,
+        1,1085,3,1085,18907,8,1085,1,1085,1,1085,1,1085,1,1085,3,1085,18913,
+        8,1085,3,1085,18915,8,1085,1,1085,1,1085,3,1085,18919,8,1085,1,1086,
+        1,1086,1,1086,1,1086,1,1086,3,1086,18926,8,1086,1,1087,1,1087,1,
+        1087,1,1087,1,1087,5,1087,18933,8,1087,10,1087,12,1087,18936,9,1087,
+        1,1087,3,1087,18939,8,1087,1,1087,3,1087,18942,8,1087,1,1087,3,1087,
+        18945,8,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,3,
+        1087,18954,8,1087,1,1087,3,1087,18957,8,1087,1,1087,3,1087,18960,
+        8,1087,1,1087,3,1087,18963,8,1087,1,1087,3,1087,18966,8,1087,1,1087,
+        1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,3,
+        1087,18978,8,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,3,1087,
+        18986,8,1087,1,1087,1,1087,1,1087,1,1087,1,1087,3,1087,18993,8,1087,
+        1,1087,3,1087,18996,8,1087,1,1087,1,1087,3,1087,19000,8,1087,3,1087,
+        19002,8,1087,1,1087,3,1087,19005,8,1087,1,1087,1,1087,1,1087,3,1087,
+        19010,8,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,3,
+        1087,19019,8,1087,1,1087,1,1087,1,1087,1,1087,3,1087,19025,8,1087,
+        1,1087,3,1087,19028,8,1087,1,1087,3,1087,19031,8,1087,1,1087,1,1087,
+        1,1087,1,1087,1,1087,1,1087,1,1087,3,1087,19040,8,1087,1,1087,3,
+        1087,19043,8,1087,1,1087,3,1087,19046,8,1087,1,1087,3,1087,19049,
+        8,1087,1,1087,1,1087,1,1087,1,1087,3,1087,19055,8,1087,1,1087,1,
+        1087,3,1087,19059,8,1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,
+        1,1087,1,1087,5,1087,19069,8,1087,10,1087,12,1087,19072,9,1087,1,
+        1087,1,1087,1,1087,1,1087,1,1087,1,1087,1,1087,3,1087,19081,8,1087,
+        1,1087,1,1087,3,1087,19085,8,1087,1,1087,3,1087,19088,8,1087,1,1087,
+        1,1087,1,1087,1,1087,3,1087,19094,8,1087,1,1087,1,1087,3,1087,19098,
+        8,1087,1,1087,1,1087,1,1087,1,1087,3,1087,19104,8,1087,1,1087,1,
+        1087,3,1087,19108,8,1087,1,1087,3,1087,19111,8,1087,1,1087,3,1087,
+        19114,8,1087,3,1087,19116,8,1087,1,1088,1,1088,1,1088,5,1088,19121,
+        8,1088,10,1088,12,1088,19124,9,1088,1,1088,3,1088,19127,8,1088,1,
+        1088,3,1088,19130,8,1088,1,1088,3,1088,19133,8,1088,1,1088,3,1088,
+        19136,8,1088,1,1088,1,1088,1,1088,3,1088,19141,8,1088,1,1089,3,1089,
+        19144,8,1089,1,1089,1,1089,3,1089,19148,8,1089,1,1089,1,1089,1,1089,
+        1,1089,1,1089,1,1089,1,1089,3,1089,19157,8,1089,1,1089,1,1089,3,
+        1089,19161,8,1089,1,1090,1,1090,1,1090,1,1090,1,1090,3,1090,19168,
+        8,1090,1,1090,1,1090,3,1090,19172,8,1090,1,1090,1,1090,1,1090,3,
+        1090,19177,8,1090,1,1090,1,1090,1,1090,3,1090,19182,8,1090,1,1090,
+        3,1090,19185,8,1090,1,1090,1,1090,1,1091,1,1091,1,1091,1,1091,1,
+        1091,3,1091,19194,8,1091,1,1091,1,1091,3,1091,19198,8,1091,1,1092,
+        1,1092,1,1092,1,1092,1,1093,1,1093,1,1093,1,1093,1,1093,3,1093,19209,
+        8,1093,1,1093,3,1093,19212,8,1093,1,1093,1,1093,3,1093,19216,8,1093,
+        1,1094,1,1094,1,1094,3,1094,19221,8,1094,1,1094,1,1094,3,1094,19225,
+        8,1094,1,1094,1,1094,1,1094,1,1094,1,1094,1,1094,1,1094,3,1094,19234,
+        8,1094,1,1094,3,1094,19237,8,1094,1,1094,1,1094,3,1094,19241,8,1094,
+        1,1094,1,1094,1,1094,1,1094,1,1094,1,1094,1,1094,3,1094,19250,8,
+        1094,1,1094,3,1094,19253,8,1094,1,1094,1,1094,3,1094,19257,8,1094,
+        1,1094,1,1094,1,1094,3,1094,19262,8,1094,1,1094,1,1094,1,1094,1,
+        1094,1,1094,1,1094,1,1094,3,1094,19271,8,1094,1,1094,3,1094,19274,
+        8,1094,1,1094,1,1094,3,1094,19278,8,1094,1,1094,1,1094,1,1094,1,
+        1094,1,1094,1,1094,3,1094,19286,8,1094,1,1094,1,1094,1,1094,3,1094,
+        19291,8,1094,1,1094,1,1094,1,1094,3,1094,19296,8,1094,1,1094,3,1094,
+        19299,8,1094,1,1094,1,1094,3,1094,19303,8,1094,3,1094,19305,8,1094,
+        1,1095,1,1095,1,1095,1,1095,1,1095,5,1095,19312,8,1095,10,1095,12,
+        1095,19315,9,1095,1,1095,1,1095,1,1096,1,1096,3,1096,19321,8,1096,
+        1,1096,3,1096,19324,8,1096,1,1096,1,1096,1,1096,1,1096,1,1096,3,
+        1096,19331,8,1096,3,1096,19333,8,1096,1,1096,3,1096,19336,8,1096,
+        1,1096,3,1096,19339,8,1096,1,1096,1,1096,3,1096,19343,8,1096,1,1096,
+        3,1096,19346,8,1096,1,1096,1,1096,1,1096,3,1096,19351,8,1096,1,1096,
+        1,1096,1,1096,1,1096,1,1096,3,1096,19358,8,1096,1,1096,1,1096,1,
+        1096,1,1096,3,1096,19364,8,1096,1,1096,1,1096,1,1096,1,1096,1,1096,
+        1,1096,3,1096,19372,8,1096,1,1097,1,1097,3,1097,19376,8,1097,1,1097,
+        3,1097,19379,8,1097,1,1097,3,1097,19382,8,1097,1,1098,1,1098,1,1098,
+        1,1098,3,1098,19388,8,1098,1,1098,3,1098,19391,8,1098,1,1098,1,1098,
+        3,1098,19395,8,1098,1,1099,1,1099,3,1099,19399,8,1099,1,1099,1,1099,
+        1,1099,3,1099,19404,8,1099,1,1099,3,1099,19407,8,1099,1,1099,3,1099,
+        19410,8,1099,1,1100,1,1100,1,1100,1,1100,1,1100,1,1100,1,1100,3,
+        1100,19419,8,1100,1,1100,1,1100,1,1100,1,1101,1,1101,1,1101,1,1101,
+        1,1101,1,1101,1,1101,3,1101,19431,8,1101,1,1101,1,1101,1,1101,1,
+        1102,1,1102,3,1102,19438,8,1102,1,1102,3,1102,19441,8,1102,1,1103,
+        1,1103,1,1103,1,1103,3,1103,19447,8,1103,1,1103,3,1103,19450,8,1103,
+        1,1103,3,1103,19453,8,1103,1,1103,1,1103,1,1103,1,1103,1,1103,1,
+        1103,1,1103,3,1103,19462,8,1103,1,1103,3,1103,19465,8,1103,1,1103,
+        1,1103,1,1103,1,1103,3,1103,19471,8,1103,1,1103,1,1103,1,1103,1,
+        1103,1,1103,3,1103,19478,8,1103,3,1103,19480,8,1103,1,1104,1,1104,
+        1,1104,1,1104,1,1104,1,1104,1,1104,1,1104,1,1104,1,1104,1,1104,3,
+        1104,19493,8,1104,1,1105,1,1105,1,1105,1,1105,1,1105,3,1105,19500,
+        8,1105,1,1106,1,1106,1,1106,3,1106,19505,8,1106,1,1107,1,1107,1,
+        1107,3,1107,19510,8,1107,1,1107,1,1107,1,1107,1,1107,3,1107,19516,
+        8,1107,1,1107,1,1107,1,1107,1,1107,3,1107,19522,8,1107,1,1107,3,
+        1107,19525,8,1107,3,1107,19527,8,1107,1,1107,1,1107,1,1107,3,1107,
+        19532,8,1107,1,1107,1,1107,1,1107,1,1107,1,1107,1,1107,3,1107,19540,
+        8,1107,3,1107,19542,8,1107,1,1107,1,1107,1,1107,1,1107,1,1107,3,
+        1107,19549,8,1107,1,1107,1,1107,1,1107,1,1107,3,1107,19555,8,1107,
+        1,1107,1,1107,1,1107,3,1107,19560,8,1107,1,1107,1,1107,1,1107,1,
+        1107,3,1107,19566,8,1107,1,1107,1,1107,1,1107,3,1107,19571,8,1107,
+        1,1107,1,1107,1,1107,1,1107,3,1107,19577,8,1107,1,1107,1,1107,1,
+        1107,1,1107,1,1107,1,1107,1,1107,1,1107,1,1107,1,1107,3,1107,19589,
+        8,1107,1,1108,1,1108,1,1108,1,1108,3,1108,19595,8,1108,1,1108,1,
+        1108,3,1108,19599,8,1108,1,1109,1,1109,1,1109,3,1109,19604,8,1109,
+        1,1109,1,1109,1,1109,3,1109,19609,8,1109,1,1109,1,1109,1,1109,1,
+        1109,3,1109,19615,8,1109,1,1109,3,1109,19618,8,1109,1,1109,1,1109,
+        3,1109,19622,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,
+        1109,1,1109,3,1109,19632,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,
+        1,1109,1,1109,1,1109,3,1109,19642,8,1109,1,1109,1,1109,1,1109,1,
+        1109,3,1109,19648,8,1109,3,1109,19650,8,1109,1,1109,1,1109,1,1109,
+        1,1109,1,1109,1,1109,1,1109,1,1109,3,1109,19660,8,1109,3,1109,19662,
+        8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,3,1109,19669,8,1109,1,
+        1109,1,1109,3,1109,19673,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,
+        4,1109,19680,8,1109,11,1109,12,1109,19681,1,1109,1,1109,1,1109,3,
+        1109,19687,8,1109,1,1109,1,1109,1,1109,3,1109,19692,8,1109,1,1109,
+        3,1109,19695,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,
+        1109,3,1109,19704,8,1109,1,1109,3,1109,19707,8,1109,1,1109,1,1109,
+        1,1109,1,1109,1,1109,1,1109,1,1109,3,1109,19716,8,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,3,1109,19730,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,3,
+        1109,19737,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,3,1109,
+        19745,8,1109,1,1109,3,1109,19748,8,1109,1,1109,1,1109,1,1109,1,1109,
+        1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,3,1109,19761,8,
+        1109,1,1109,1,1109,1,1109,1,1109,3,1109,19767,8,1109,3,1109,19769,
+        8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,
+        1109,1,1109,1,1109,3,1109,19782,8,1109,1,1109,1,1109,1,1109,1,1109,
+        1,1109,1,1109,1,1109,3,1109,19791,8,1109,1,1109,1,1109,5,1109,19795,
+        8,1109,10,1109,12,1109,19798,9,1109,1,1109,1,1109,1,1109,1,1109,
+        1,1109,1,1109,1,1109,3,1109,19807,8,1109,1,1109,1,1109,1,1109,1,
+        1109,5,1109,19813,8,1109,10,1109,12,1109,19816,9,1109,1,1109,1,1109,
+        1,1109,3,1109,19821,8,1109,1,1109,3,1109,19824,8,1109,1,1109,3,1109,
+        19827,8,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,3,1109,19841,8,1109,3,1109,19843,
+        8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,3,1109,19851,8,
+        1109,1,1109,1,1109,1,1109,5,1109,19856,8,1109,10,1109,12,1109,19859,
+        9,1109,1,1109,1,1109,1,1109,1,1109,1,1109,5,1109,19866,8,1109,10,
+        1109,12,1109,19869,9,1109,1,1109,1,1109,1,1109,5,1109,19874,8,1109,
+        10,1109,12,1109,19877,9,1109,1,1109,1,1109,1,1109,3,1109,19882,8,
+        1109,1,1109,3,1109,19885,8,1109,1,1109,1,1109,1,1109,3,1109,19890,
+        8,1109,1,1109,1,1109,1,1109,3,1109,19895,8,1109,5,1109,19897,8,1109,
+        10,1109,12,1109,19900,9,1109,1,1109,1,1109,1,1109,5,1109,19905,8,
+        1109,10,1109,12,1109,19908,9,1109,1,1109,1,1109,1,1109,1,1109,3,
+        1109,19914,8,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,
+        3,1109,19923,8,1109,1,1109,1,1109,1,1109,5,1109,19928,8,1109,10,
+        1109,12,1109,19931,9,1109,1,1109,1,1109,1,1109,1,1109,1,1109,1,1109,
+        3,1109,19939,8,1109,1,1109,1,1109,3,1109,19943,8,1109,1,1109,1,1109,
+        1,1109,5,1109,19948,8,1109,10,1109,12,1109,19951,9,1109,1,1109,1,
+        1109,1,1109,1,1109,3,1109,19957,8,1109,1,1109,1,1109,1,1109,1,1109,
+        1,1109,3,1109,19964,8,1109,1,1109,1,1109,1,1109,5,1109,19969,8,1109,
+        10,1109,12,1109,19972,9,1109,1,1109,1,1109,1,1109,1,1109,1,1109,
+        3,1109,19979,8,1109,1,1109,1,1109,3,1109,19983,8,1109,1,1109,1,1109,
+        1,1109,5,1109,19988,8,1109,10,1109,12,1109,19991,9,1109,1,1109,1,
+        1109,1,1109,1,1109,1,1109,1,1109,3,1109,19999,8,1109,1,1109,3,1109,
+        20002,8,1109,1,1109,3,1109,20005,8,1109,1,1109,3,1109,20008,8,1109,
+        1,1109,1,1109,3,1109,20012,8,1109,1,1109,1,1109,1,1109,3,1109,20017,
+        8,1109,1,1109,1,1109,1,1109,3,1109,20022,8,1109,1,1110,1,1110,1,
+        1111,1,1111,1,1112,1,1112,1,1113,1,1113,1,1113,3,1113,20033,8,1113,
+        1,1113,1,1113,3,1113,20037,8,1113,3,1113,20039,8,1113,1,1113,1,1113,
+        1,1113,1,1113,1,1113,1,1113,1,1113,1,1113,1,1113,3,1113,20050,8,
+        1113,3,1113,20052,8,1113,1,1113,1,1113,1,1114,1,1114,1,1114,1,1114,
+        1,1114,1,1114,1,1114,3,1114,20063,8,1114,1,1115,1,1115,1,1116,1,
+        1116,1,1116,1,1116,1,1116,1,1116,1,1116,3,1116,20074,8,1116,1,1117,
+        1,1117,1,1117,1,1117,1,1117,5,1117,20081,8,1117,10,1117,12,1117,
+        20084,9,1117,3,1117,20086,8,1117,1,1118,1,1118,1,1118,1,1118,1,1118,
+        1,1118,1,1118,1,1118,3,1118,20096,8,1118,1,1119,1,1119,3,1119,20100,
+        8,1119,1,1120,1,1120,1,1120,1,1120,1,1120,5,1120,20107,8,1120,10,
+        1120,12,1120,20110,9,1120,1,1121,1,1121,1,1121,1,1121,1,1121,1,1121,
+        1,1121,3,1121,20119,8,1121,1,1122,1,1122,1,1122,1,1122,1,1122,1,
+        1122,1,1122,1,1122,3,1122,20129,8,1122,1,1122,1,1122,1,1122,1,1122,
+        5,1122,20135,8,1122,10,1122,12,1122,20138,9,1122,1,1123,1,1123,1,
+        1123,3,1123,20143,8,1123,1,1123,1,1123,1,1123,1,1123,5,1123,20149,
+        8,1123,10,1123,12,1123,20152,9,1123,1,1123,1,1123,1,1123,1,1123,
+        3,1123,20158,8,1123,1,1123,1,1123,3,1123,20162,8,1123,1,1124,1,1124,
+        1,1124,3,1124,20167,8,1124,1,1124,1,1124,3,1124,20171,8,1124,1,1124,
+        1,1124,1,1124,3,1124,20176,8,1124,5,1124,20178,8,1124,10,1124,12,
+        1124,20181,9,1124,1,1125,1,1125,1,1125,3,1125,20186,8,1125,1,1125,
+        3,1125,20189,8,1125,1,1125,1,1125,1,1125,5,1125,20194,8,1125,10,
+        1125,12,1125,20197,9,1125,1,1125,1,1125,1,1126,1,1126,1,1126,1,1126,
+        1,1126,3,1126,20206,8,1126,1,1126,1,1126,1,1126,1,1126,5,1126,20212,
+        8,1126,10,1126,12,1126,20215,9,1126,1,1126,3,1126,20218,8,1126,1,
+        1126,1,1126,1,1127,1,1127,1,1127,1,1127,1,1127,1,1127,3,1127,20228,
+        8,1127,1,1127,3,1127,20231,8,1127,3,1127,20233,8,1127,1,1128,1,1128,
+        1,1128,1,1129,1,1129,3,1129,20240,8,1129,1,1129,1,1129,1,1129,1,
+        1129,3,1129,20246,8,1129,1,1130,1,1130,1,1130,1,1130,3,1130,20252,
+        8,1130,1,1131,1,1131,1,1131,1,1131,3,1131,20258,8,1131,3,1131,20260,
+        8,1131,1,1132,1,1132,1,1132,1,1133,1,1133,1,1133,1,1134,1,1134,1,
+        1134,1,1134,1,1134,1,1134,3,1134,20274,8,1134,3,1134,20276,8,1134,
+        1,1135,1,1135,1,1135,1,1135,1,1135,1,1136,1,1136,1,1136,1,1136,1,
+        1136,1,1136,3,1136,20289,8,1136,1,1136,1,1136,1,1136,3,1136,20294,
+        8,1136,1,1136,3,1136,20297,8,1136,1,1136,1,1136,1,1136,5,1136,20302,
+        8,1136,10,1136,12,1136,20305,9,1136,1,1137,1,1137,3,1137,20309,8,
+        1137,1,1138,1,1138,1,1138,1,1138,1,1138,1,1138,1,1138,1,1138,1,1138,
+        1,1138,3,1138,20321,8,1138,1,1139,1,1139,1,1139,1,1139,1,1140,1,
+        1140,1,1140,3,1140,20330,8,1140,3,1140,20332,8,1140,1,1140,1,1140,
+        1,1141,1,1141,1,1141,3,1141,20339,8,1141,1,1141,3,1141,20342,8,1141,
+        1,1141,1,1141,1,1141,5,1141,20347,8,1141,10,1141,12,1141,20350,9,
+        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,3,1142,20364,8,1142,1,1142,3,1142,20367,8,1142,
+        1,1142,1,1142,3,1142,20371,8,1142,3,1142,20373,8,1142,1,1143,1,1143,
+        1,1143,1,1143,4,1143,20379,8,1143,11,1143,12,1143,20380,1,1143,1,
+        1143,1,1143,1,1143,1,1143,1,1143,3,1143,20389,8,1143,3,1143,20391,
+        8,1143,1,1144,1,1144,1,1144,5,1144,20396,8,1144,10,1144,12,1144,
+        20399,9,1144,1,1144,1,1144,3,1144,20403,8,1144,1,1145,1,1145,3,1145,
+        20407,8,1145,1,1145,1,1145,3,1145,20411,8,1145,1,1146,1,1146,3,1146,
+        20415,8,1146,1,1146,1,1146,3,1146,20419,8,1146,1,1146,1,1146,1,1147,
+        3,1147,20424,8,1147,1,1147,1,1147,3,1147,20428,8,1147,1,1147,3,1147,
+        20431,8,1147,1,1148,1,1148,3,1148,20435,8,1148,1,1149,1,1149,1,1149,
+        1,1149,1,1149,3,1149,20442,8,1149,1,1150,1,1150,3,1150,20446,8,1150,
+        1,1150,1,1150,1,1150,3,1150,20451,8,1150,1,1150,1,1150,1,1150,3,
+        1150,20456,8,1150,5,1150,20458,8,1150,10,1150,12,1150,20461,9,1150,
+        1,1151,1,1151,3,1151,20465,8,1151,1,1152,1,1152,1,1153,1,1153,1,
+        1154,1,1154,1,1155,1,1155,1,1156,1,1156,1,1157,1,1157,1,1157,5,1157,
+        20480,8,1157,10,1157,12,1157,20483,9,1157,1,1157,1,1157,3,1157,20487,
+        8,1157,1,1158,1,1158,1,1159,1,1159,1,1159,3,1159,20494,8,1159,1,
+        1160,1,1160,1,1161,1,1161,1,1162,1,1162,1,1163,1,1163,1,1163,3,1163,
+        20505,8,1163,1,1164,1,1164,1,1164,5,1164,20510,8,1164,10,1164,12,
+        1164,20513,9,1164,1,1165,1,1165,1,1166,1,1166,3,1166,20519,8,1166,
+        1,1167,1,1167,3,1167,20523,8,1167,1,1168,1,1168,1,1168,5,1168,20528,
+        8,1168,10,1168,12,1168,20531,9,1168,1,1168,1,1168,3,1168,20535,8,
+        1168,1,1169,1,1169,1,1170,1,1170,1,1170,5,1170,20542,8,1170,10,1170,
+        12,1170,20545,9,1170,1,1171,1,1171,1,1171,5,1171,20550,8,1171,10,
+        1171,12,1171,20553,9,1171,1,1172,1,1172,1,1172,5,1172,20558,8,1172,
+        10,1172,12,1172,20561,9,1172,1,1173,1,1173,1,1173,3,1173,20566,8,
+        1173,1,1174,1,1174,1,1174,3,1174,20571,8,1174,1,1175,1,1175,1,1175,
+        3,1175,20576,8,1175,1,1176,1,1176,3,1176,20580,8,1176,1,1176,1,1176,
+        1,1176,3,1176,20585,8,1176,1,1176,3,1176,20588,8,1176,1,1177,1,1177,
+        1,1177,3,1177,20593,8,1177,1,1178,1,1178,3,1178,20597,8,1178,1,1179,
+        1,1179,3,1179,20601,8,1179,1,1180,1,1180,1,1180,5,1180,20606,8,1180,
+        10,1180,12,1180,20609,9,1180,1,1180,1,1180,3,1180,20613,8,1180,1,
+        1181,1,1181,1,1182,1,1182,1,1183,1,1183,1,1183,5,1183,20622,8,1183,
+        10,1183,12,1183,20625,9,1183,1,1184,1,1184,1,1184,3,1184,20630,8,
+        1184,1,1184,1,1184,1,1184,3,1184,20635,8,1184,1,1184,1,1184,3,1184,
+        20639,8,1184,3,1184,20641,8,1184,1,1185,1,1185,1,1185,1,1185,1,1185,
+        3,1185,20648,8,1185,1,1185,1,1185,3,1185,20652,8,1185,1,1185,1,1185,
+        1,1185,1,1185,3,1185,20658,8,1185,1,1185,1,1185,1,1185,1,1185,5,
+        1185,20664,8,1185,10,1185,12,1185,20667,9,1185,3,1185,20669,8,1185,
+        1,1185,1,1185,1,1185,3,1185,20674,8,1185,1,1186,1,1186,1,1186,5,
+        1186,20679,8,1186,10,1186,12,1186,20682,9,1186,1,1187,1,1187,1,1188,
+        1,1188,1,1189,1,1189,1,1190,1,1190,1,1191,1,1191,1,1191,1,1191,1,
+        1191,5,1191,20697,8,1191,10,1191,12,1191,20700,9,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,20716,8,1191,1,1192,1,1192,1,1192,5,1192,
+        20721,8,1192,10,1192,12,1192,20724,9,1192,1,1193,1,1193,1,1193,1,
+        1193,1,1194,1,1194,1,1194,1,1194,1,1194,1,1194,3,1194,20736,8,1194,
+        1,1194,1,1194,3,1194,20740,8,1194,1,1195,1,1195,1,1195,1,1195,5,
+        1195,20746,8,1195,10,1195,12,1195,20749,9,1195,3,1195,20751,8,1195,
+        1,1195,1,1195,3,1195,20755,8,1195,1,1196,1,1196,1,1196,3,1196,20760,
+        8,1196,1,1196,1,1196,1,1196,3,1196,20765,8,1196,5,1196,20767,8,1196,
+        10,1196,12,1196,20770,9,1196,3,1196,20772,8,1196,1,1196,1,1196,3,
+        1196,20776,8,1196,1,1197,1,1197,1,1197,1,1197,1,1197,3,1197,20783,
+        8,1197,1,1197,1,1197,1,1197,3,1197,20788,8,1197,3,1197,20790,8,1197,
+        3,1197,20792,8,1197,1,1197,1,1197,1,1197,1,1197,1,1197,1,1197,1,
+        1197,1,1197,3,1197,20802,8,1197,1,1197,1,1197,1,1197,3,1197,20807,
+        8,1197,5,1197,20809,8,1197,10,1197,12,1197,20812,9,1197,3,1197,20814,
+        8,1197,1,1197,1,1197,3,1197,20818,8,1197,1,1198,1,1198,1,1198,1,
+        1199,1,1199,1,1199,1,1199,3,1199,20827,8,1199,1,1199,1,1199,1,1200,
+        1,1200,3,1200,20833,8,1200,1,1200,1,1200,3,1200,20837,8,1200,3,1200,
+        20839,8,1200,1,1201,1,1201,3,1201,20843,8,1201,1,1201,1,1201,3,1201,
+        20847,8,1201,1,1201,1,1201,1,1201,1,1201,1,1201,3,1201,20854,8,1201,
+        1,1201,1,1201,1,1201,1,1201,1,1201,1,1201,3,1201,20862,8,1201,1,
+        1201,1,1201,1,1201,1,1201,1,1201,1,1201,3,1201,20870,8,1201,3,1201,
+        20872,8,1201,1,1202,1,1202,1,1202,3,1202,20877,8,1202,1,1202,1,1202,
+        1,1202,3,1202,20882,8,1202,3,1202,20884,8,1202,1,1202,3,1202,20887,
+        8,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,3,1203,20911,8,1203,1,1203,1,1203,1,
+        1203,1,1203,1,1203,3,1203,20918,8,1203,1,1203,1,1203,1,1203,3,1203,
+        20923,8,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,1203,1,
+        1203,1,1203,1,1203,1,1203,1,1203,3,1203,20956,8,1203,1,1204,1,1204,
+        1,1204,3,1204,20961,8,1204,1,1204,3,1204,20964,8,1204,1,1204,1,1204,
+        1,1204,3,1204,20969,8,1204,3,1204,20971,8,1204,1,1204,1,1204,5,1204,
+        20975,8,1204,10,1204,12,1204,20978,9,1204,1,1205,1,1205,1,1205,1,
+        1205,1,1205,1,1205,3,1205,20986,8,1205,1,1205,1,1205,1,1205,4,1205,
+        20991,8,1205,11,1205,12,1205,20992,5,1205,20995,8,1205,10,1205,12,
+        1205,20998,9,1205,1,1206,1,1206,3,1206,21002,8,1206,1,1206,1,1206,
+        1,1206,3,1206,21007,8,1206,1,1206,5,1206,21010,8,1206,10,1206,12,
+        1206,21013,9,1206,1,1207,1,1207,3,1207,21017,8,1207,1,1207,1,1207,
+        1,1207,5,1207,21022,8,1207,10,1207,12,1207,21025,9,1207,1,1208,1,
+        1208,3,1208,21029,8,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,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,1208,1,1208,1,1208,3,1208,21063,8,
+        1208,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21070,8,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,3,1209,21085,8,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,3,1209,21101,8,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,1209,1,
+        1209,1,1209,3,1209,21120,8,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,
+        1209,3,1209,21137,8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,
+        21144,8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21152,
+        8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,
+        1209,1,1209,1,1209,3,1209,21165,8,1209,1,1209,1,1209,1,1209,1,1209,
+        1,1209,1,1209,1,1209,3,1209,21174,8,1209,1,1209,1,1209,1,1209,1,
+        1209,1,1209,1,1209,1,1209,3,1209,21183,8,1209,1,1209,1,1209,1,1209,
+        1,1209,1,1209,1,1209,1,1209,3,1209,21192,8,1209,1,1209,1,1209,1,
+        1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21202,8,1209,1,1209,
+        1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21210,8,1209,1,1209,1,
+        1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21220,8,1209,
+        1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21230,
+        8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,
+        1209,1,1209,3,1209,21242,8,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,3,
+        1209,21258,8,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,1209,1,1209,3,
+        1209,21276,8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,
+        1,1209,1,1209,1,1209,1,1209,3,1209,21289,8,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,3,1209,21304,8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,
+        1209,1,1209,1,1209,1,1209,3,1209,21315,8,1209,1,1209,1,1209,1,1209,
+        1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21325,8,1209,1,1209,1,
+        1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21336,
+        8,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,
+        1209,21346,8,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,1209,3,1209,21363,
+        8,1209,1,1209,1,1209,1,1209,1,1209,3,1209,21369,8,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,1209,1,1209,1,1209,1,1209,1,1209,1,1209,3,
+        1209,21391,8,1209,1,1210,1,1210,1,1210,3,1210,21396,8,1210,1,1210,
+        1,1210,1,1210,1,1210,3,1210,21402,8,1210,1,1210,1,1210,1,1210,1,
+        1210,3,1210,21408,8,1210,1,1210,1,1210,1,1210,1,1210,3,1210,21414,
+        8,1210,1,1210,1,1210,1,1210,3,1210,21419,8,1210,3,1210,21421,8,1210,
+        1,1210,3,1210,21424,8,1210,1,1210,1,1210,1,1210,1,1210,1,1210,1,
+        1210,1,1210,1,1210,1,1210,3,1210,21435,8,1210,1,1210,3,1210,21438,
+        8,1210,3,1210,21440,8,1210,3,1210,21442,8,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,3,
+        1210,21456,8,1210,1,1211,1,1211,3,1211,21460,8,1211,1,1211,3,1211,
+        21463,8,1211,1,1212,1,1212,1,1212,1,1213,1,1213,1,1214,1,1214,3,
+        1214,21472,8,1214,1,1214,1,1214,1,1215,1,1215,3,1215,21478,8,1215,
+        1,1216,1,1216,1,1217,1,1217,1,1217,1,1217,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,
+        1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,1,1218,
+        1,1218,1,1218,1,1218,1,1218,3,1218,21617,8,1218,1,1219,1,1219,1,
+        1220,1,1220,1,1221,1,1221,1,1221,1,3873,7,1262,2104,2112,2114,2124,
+        2244,2410,1222,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,2392,2394,2396,2398,2400,2402,2404,2406,2408,2410,2412,2414,
+        2416,2418,2420,2422,2424,2426,2428,2430,2432,2434,2436,2438,2440,
+        2442,0,307,2,0,1221,1221,2295,2295,2,0,685,685,902,902,2,0,2308,
+        2308,2310,2310,2,0,1173,1173,1562,1562,2,0,21,21,981,981,5,0,465,
+        465,676,676,964,964,1342,1342,2198,2198,2,0,230,230,597,597,2,0,
+        617,617,1105,1105,2,0,813,813,902,902,2,0,21,21,469,469,3,0,650,
+        650,1312,1312,1327,1327,2,0,1260,1260,2315,2315,2,0,650,650,1327,
+        1327,4,0,91,91,676,676,898,898,2408,2408,3,0,220,220,350,350,2293,
+        2293,2,0,1491,1491,1550,1550,2,0,1180,1180,1578,1578,2,0,429,429,
+        499,499,2,0,206,206,1715,1715,2,0,2446,2446,2452,2452,2,0,482,482,
+        1133,1133,2,0,949,949,1134,1134,2,0,69,69,786,786,3,0,661,661,863,
+        863,1497,1497,2,0,389,389,617,617,2,0,1608,1608,2085,2085,5,0,633,
+        633,1331,1331,1463,1463,2159,2159,2168,2168,2,0,220,220,1305,1305,
+        2,0,1457,1457,1475,1475,3,0,38,38,244,244,874,874,2,0,933,933,961,
+        961,3,0,147,147,1331,1331,1717,1717,2,0,35,35,1396,1396,2,0,420,
+        420,1333,1333,4,0,281,281,319,319,888,888,1458,1458,2,0,146,146,
+        1701,1701,2,0,33,33,112,112,3,0,403,403,757,757,2209,2209,3,0,1022,
+        1022,1252,1252,1339,1339,2,0,617,617,2255,2255,2,0,147,147,1717,
+        1717,3,0,346,346,1281,1281,1721,1721,2,0,911,911,1305,1305,2,0,937,
+        937,1747,1747,3,0,596,596,762,762,1326,1326,3,0,242,242,1203,1203,
+        1598,1598,3,0,376,376,449,449,1486,1486,2,0,14,14,38,38,3,0,351,
+        351,949,949,1134,1134,2,0,1101,1101,2431,2431,1,0,2443,2444,2,0,
+        1172,1172,1556,1556,2,0,1732,1732,2114,2114,10,0,366,366,659,659,
+        681,681,960,960,988,988,1484,1484,1639,1639,1732,1732,2298,2298,
+        2359,2359,2,0,2408,2408,2411,2411,2,0,70,70,414,414,2,0,599,599,
+        826,826,3,0,760,760,1669,1669,1745,1745,14,0,42,42,85,85,241,241,
+        403,403,543,543,606,606,648,648,718,718,757,757,882,882,1507,1507,
+        1561,1561,1649,1649,2209,2209,3,0,42,42,321,321,469,469,3,0,543,
+        543,1507,1507,2315,2315,4,0,359,359,425,425,1254,1254,2357,2357,
+        3,0,87,87,635,635,682,682,2,0,1175,1175,1567,1567,5,0,480,480,636,
+        636,902,902,1330,1330,2079,2079,3,0,365,365,986,986,2360,2360,6,
+        0,410,410,672,672,787,787,848,848,938,941,1340,1341,2,0,137,137,
+        2185,2185,2,0,2205,2205,2217,2217,2,0,395,395,699,699,2,0,783,783,
+        2292,2292,2,0,984,984,1128,1128,2,0,21,21,1560,1560,2,0,562,562,
+        644,644,2,0,389,389,2094,2094,2,0,882,882,2189,2189,2,0,21,21,2209,
+        2209,2,0,1380,1380,1609,1609,2,0,1245,1245,1258,1258,2,0,1951,1951,
+        2239,2239,2,0,160,160,534,534,2,0,4,4,1669,1669,2,0,38,38,336,336,
+        2,0,1629,1629,2110,2110,2,0,718,718,2085,2085,2,0,26,26,401,401,
+        2,0,1572,1572,1715,1715,3,0,633,633,1331,1331,1463,1463,3,0,206,
+        206,1572,1572,1715,1715,2,0,249,249,1570,1570,3,0,119,119,142,142,
+        215,215,2,0,179,179,1580,1580,2,0,341,341,398,398,2,0,291,291,293,
+        293,2,0,687,687,690,690,1,0,286,287,2,0,1217,1217,2255,2255,2,0,
+        872,872,2083,2083,2,0,352,352,2091,2091,3,0,699,699,1180,1180,2094,
+        2094,2,0,1246,1246,1261,1261,2,0,122,122,1707,1707,3,0,594,594,885,
+        885,1120,1120,2,0,91,91,910,910,2,0,656,656,1109,1109,2,0,676,676,
+        898,898,2,0,389,389,2443,2443,2,0,242,242,406,406,2,0,511,511,2163,
+        2163,2,0,166,166,1067,1067,2,0,540,540,706,706,2,0,79,79,1796,1796,
+        3,0,249,249,579,579,617,617,3,0,250,250,579,579,617,617,3,0,242,
+        242,406,406,1745,1745,2,0,874,874,914,914,2,0,1182,1182,1601,1601,
+        6,0,256,256,281,281,318,319,691,691,887,888,1670,1670,3,0,389,389,
+        2187,2187,2443,2443,4,0,572,572,703,703,1355,1357,1359,1360,2,0,
+        643,643,1457,1457,2,0,403,403,1449,1449,2,0,107,107,1642,1642,2,
+        0,56,56,1140,1140,2,0,469,469,1449,1449,2,0,771,771,860,860,2,0,
+        1139,1139,2362,2362,2,0,561,561,779,779,6,0,480,480,636,636,813,
+        813,902,902,1330,1330,2079,2079,2,0,64,64,1486,1486,2,0,29,29,106,
+        106,2,0,176,176,1486,1486,5,0,326,326,676,676,898,898,936,936,1134,
+        1134,2,0,2187,2187,2443,2443,3,0,389,389,815,815,1521,1521,3,0,389,
+        389,815,815,1134,1134,3,0,403,403,429,429,499,499,2,0,237,237,1608,
+        1608,2,0,4,4,979,979,2,0,650,650,1647,1647,4,0,365,366,986,986,988,
+        988,2359,2360,1,0,2382,2385,2,0,262,262,870,870,1,0,2453,2454,2,
+        0,381,381,2366,2366,2,0,2262,2263,2265,2266,4,0,835,835,900,901,
+        1205,1205,1611,1611,2,0,367,367,2361,2361,2,0,390,390,1229,1229,
+        2,0,49,49,1309,1309,2,0,121,121,864,864,2,0,200,200,1068,1068,2,
+        0,164,164,194,194,2,0,424,424,1089,1089,1,0,451,452,3,0,1061,1061,
+        1090,1090,1119,1119,3,0,105,105,438,438,883,883,2,0,361,361,2110,
+        2110,2,0,2465,2465,2474,2474,2,0,430,430,499,499,4,0,106,106,676,
+        676,898,898,936,936,2,0,430,430,500,500,2,0,2471,2471,2474,2474,
+        2,0,954,954,1124,1124,2,0,1449,1449,1477,1477,2,0,469,469,815,815,
+        2,0,49,49,815,815,2,0,40,40,435,435,3,0,249,249,482,482,1133,1133,
+        2,0,469,469,1589,1589,2,0,216,216,1736,1736,2,0,466,466,2213,2213,
+        2,0,113,113,508,508,2,0,886,886,1394,1394,3,0,98,98,1387,1387,1471,
+        1471,2,0,242,242,1443,1443,2,0,1,1,1763,1763,2,0,1394,1394,1709,
+        1709,3,0,38,38,1134,1134,1736,1736,3,0,676,676,964,964,2198,2198,
+        4,0,429,429,499,499,1560,1560,1792,1792,2,0,576,576,2160,2160,2,
+        0,1560,1560,1673,1673,2,0,1799,1799,1951,1951,2,0,923,923,926,926,
+        1,0,927,929,2,0,38,38,836,836,2,0,505,505,1552,1552,3,0,387,387,
+        505,505,1552,1552,2,0,1507,1507,2315,2315,2,0,1350,1350,1777,1777,
+        2,0,1350,1350,1352,1352,1,0,1776,1777,2,0,781,781,2209,2209,2,0,
+        1190,1190,1711,1711,2,0,878,878,2260,2260,2,0,627,627,1375,1375,
+        2,0,388,388,814,814,3,0,676,676,898,898,936,936,2,0,336,336,1230,
+        1230,2,0,643,643,874,874,2,0,469,469,817,817,1,0,2435,2436,4,0,739,
+        739,751,751,1081,1081,1320,1320,2,0,389,389,2459,2459,1,1,2472,2472,
+        1,0,1587,1588,2,0,108,108,699,699,2,0,403,403,2431,2431,2,0,152,
+        152,410,410,3,0,38,38,445,445,2185,2185,2,0,327,327,1005,1005,2,
+        0,327,327,1315,1315,3,0,631,631,840,840,1594,1594,3,0,1629,1629,
+        1709,1709,2110,2110,2,0,539,539,704,704,2,0,332,332,1600,1600,2,
+        0,693,693,815,815,2,0,38,38,2208,2208,2,0,95,95,1657,1657,1,0,1608,
+        1609,2,0,599,599,1026,1026,2,0,38,38,599,599,2,0,2085,2085,2102,
+        2102,2,0,830,830,1768,1768,2,0,937,937,1774,1774,3,0,534,534,776,
+        776,2183,2183,2,0,38,38,445,445,2,0,854,856,858,858,1,0,2469,2470,
+        2,0,520,520,2161,2161,3,0,982,982,2452,2452,2456,2456,2,0,386,386,
+        708,708,4,0,313,313,599,599,826,826,859,859,3,0,546,546,1026,1026,
+        1456,1456,1,0,523,524,4,0,38,38,55,55,546,546,1710,1710,3,0,149,
+        149,839,839,2148,2148,2,0,3,3,1230,1230,2,0,163,163,196,196,2,0,
+        68,68,1240,1240,2,0,786,786,2260,2260,2,0,520,520,1230,1230,2,0,
+        497,497,1230,1230,2,0,520,520,693,693,3,0,520,520,693,693,1564,1564,
+        4,0,520,520,693,693,1230,1230,1560,1560,3,0,321,321,520,520,693,
+        693,3,0,520,520,693,693,1230,1230,2,0,265,265,2178,2178,2,0,181,
+        181,2323,2323,2,0,445,445,2185,2185,2,0,1377,1379,1382,1382,2,0,
+        175,175,248,248,2,0,602,602,827,827,2,0,2404,2404,2407,2407,3,0,
+        2127,2128,2136,2136,2139,2140,2,0,2131,2131,2144,2144,2,0,197,197,
+        1008,1008,2,0,2325,2325,2333,2333,2,0,515,515,1097,1097,2,0,529,
+        529,998,998,2,0,294,294,455,455,2,0,671,671,1685,1685,10,0,1228,
+        1228,2267,2267,2400,2402,2405,2406,2408,2409,2411,2412,2414,2415,
+        2417,2417,2421,2424,2437,2437,2,0,2393,2394,2396,2399,1,0,2367,2372,
+        2,0,1497,1497,1609,1609,2,0,614,614,1438,1438,2,0,1184,1184,1626,
+        1626,2,0,518,518,522,522,1,0,542,543,1,0,2456,2457,1,0,1724,1725,
+        2,0,1311,1311,1722,1722,2,0,242,242,1598,1598,3,0,242,242,1134,1134,
+        1598,1598,2,0,693,693,1573,1573,1,0,1383,1384,2,0,365,365,2360,2360,
+        2,0,986,986,1638,1638,2,0,42,42,469,469,2,0,321,321,469,469,2,0,
+        42,42,321,321,3,0,42,42,469,469,543,543,2,0,55,55,561,561,2,0,206,
+        206,1466,1466,4,0,42,42,241,241,469,469,1649,1649,4,0,42,42,469,
+        469,1649,1649,2209,2209,3,0,403,403,469,469,757,757,6,0,42,42,403,
+        403,469,469,757,757,1649,1649,2209,2209,2,0,469,469,2209,2209,3,
+        0,42,42,469,469,648,648,3,0,42,42,469,469,1649,1649,3,0,42,42,321,
+        321,1578,1578,3,0,42,42,469,469,2243,2243,10,0,42,42,102,102,241,
+        241,403,403,469,469,757,757,882,882,1507,1507,1649,1649,2209,2209,
+        5,0,42,42,321,321,469,469,906,906,2187,2187,4,0,42,42,469,469,543,
+        543,2179,2179,3,0,469,469,947,947,2179,2179,2,0,46,46,85,85,2,0,
+        421,421,2149,2149,6,0,365,365,680,680,959,959,986,986,1638,1638,
+        2360,2360,2,0,2438,2438,2445,2445,1,0,2433,2434,257,0,6,6,8,8,10,
+        12,14,14,16,16,19,20,29,29,32,32,43,43,45,45,47,47,52,53,60,60,62,
+        63,65,65,74,74,76,76,94,94,97,97,99,100,103,103,109,110,114,114,
+        117,117,136,136,154,154,170,172,176,177,184,184,207,211,214,214,
+        221,222,224,224,244,245,252,253,264,266,269,271,290,293,299,299,
+        301,303,322,322,325,326,331,331,334,334,355,355,357,357,359,360,
+        366,366,374,374,384,384,392,393,397,397,401,402,415,416,423,423,
+        428,428,432,432,437,437,448,448,475,476,482,482,487,487,493,493,
+        498,498,501,501,517,517,528,528,530,530,545,545,557,557,563,563,
+        569,569,574,575,577,578,580,580,582,583,587,587,591,592,604,604,
+        610,610,622,622,635,635,637,637,642,642,659,659,672,673,681,682,
+        685,685,698,698,702,703,719,719,738,738,747,747,749,749,752,752,
+        771,771,782,782,787,787,796,810,812,812,821,821,823,823,830,830,
+        837,838,848,848,851,851,860,860,879,879,881,881,890,890,896,896,
+        909,909,911,911,916,919,930,930,938,942,949,949,960,960,973,973,
+        977,977,979,979,983,983,988,988,994,994,1013,1013,1056,1057,1062,
+        1062,1064,1064,1072,1072,1074,1074,1081,1081,1086,1087,1093,1093,
+        1107,1107,1113,1115,1133,1133,1135,1135,1141,1141,1152,1154,1157,
+        1157,1159,1161,1166,1166,1171,1171,1174,1174,1181,1181,1191,1191,
+        1209,1209,1216,1216,1218,1220,1227,1227,1241,1241,1247,1247,1254,
+        1254,1256,1257,1278,1280,1292,1297,1302,1302,1340,1341,1344,1344,
+        1346,1347,1361,1361,1363,1364,1366,1366,1368,1368,1388,1388,1391,
+        1392,1411,1411,1415,1419,1427,1427,1429,1430,1433,1434,1442,1442,
+        1450,1450,1452,1452,1454,1455,1459,1459,1469,1469,1472,1474,1480,
+        1480,1484,1484,1493,1493,1510,1510,1523,1523,1555,1555,1558,1558,
+        1574,1574,1596,1596,1602,1602,1614,1614,1619,1619,1631,1631,1634,
+        1634,1639,1640,1663,1663,1665,1665,1667,1667,1683,1684,1690,1690,
+        1713,1714,1728,1728,1732,1733,1735,1735,1745,1746,1767,1767,1780,
+        1781,1789,1789,1799,1799,1803,1803,1805,1805,1811,1811,1829,1829,
+        1834,1835,1839,1840,1862,1862,1874,1874,1877,1881,1906,1906,1934,
+        1934,1945,1945,2076,2078,2087,2087,2098,2098,2106,2107,2126,2126,
+        2150,2150,2156,2156,2164,2164,2172,2172,2178,2178,2190,2190,2197,
+        2197,2203,2203,2217,2217,2221,2221,2225,2225,2232,2232,2238,2238,
+        2244,2244,2246,2247,2249,2254,2256,2256,2258,2258,2274,2277,2289,
+        2289,2291,2291,2298,2299,2309,2309,2314,2314,2357,2357,2359,2359,
+        2364,2364,2373,2385,2387,2387,2389,2389,2391,2392,2410,2410,2442,
+        2442,393,0,1,2,4,5,7,7,9,9,13,13,15,15,17,18,21,28,30,31,33,33,37,
+        37,39,41,44,44,46,46,48,48,50,50,54,54,56,59,61,61,64,64,66,66,68,
+        68,71,73,75,75,77,84,86,91,93,93,95,95,98,98,102,102,106,108,111,
+        113,115,116,119,120,122,122,124,130,132,135,137,140,142,147,149,
+        153,155,159,161,163,166,169,173,174,178,181,183,183,185,190,192,
+        193,197,199,201,206,212,212,215,219,223,223,225,233,235,243,246,
+        246,248,251,254,257,260,260,262,262,267,268,272,279,281,287,289,
+        289,294,298,300,300,304,313,315,320,323,324,327,329,332,333,335,
+        345,347,353,356,356,358,358,364,365,368,373,375,380,382,383,385,
+        388,391,391,394,396,398,400,404,404,406,408,410,413,417,417,419,
+        419,421,422,425,427,429,429,433,436,439,441,443,444,446,447,449,
+        450,454,455,462,468,470,470,472,473,477,479,481,481,483,486,488,
+        490,495,497,499,499,502,502,504,506,509,509,511,516,519,522,525,
+        525,527,527,529,529,531,534,537,540,543,544,547,547,549,556,558,
+        562,564,568,570,573,576,576,579,579,581,581,584,586,590,590,594,
+        602,605,607,609,609,611,615,617,620,623,628,630,634,638,641,643,
+        646,649,649,651,657,660,663,665,671,675,680,683,684,687,693,695,
+        697,699,701,704,717,720,734,736,737,740,746,748,748,750,750,754,
+        756,758,769,772,775,777,778,781,781,783,784,788,789,791,795,814,
+        820,822,822,825,828,831,834,836,836,839,847,849,850,852,857,859,
+        859,862,863,866,869,871,878,880,880,883,889,891,893,897,899,901,
+        901,903,908,910,910,912,912,914,915,920,929,931,937,943,948,950,
+        956,958,959,961,964,967,972,974,976,980,982,984,987,989,990,992,
+        993,995,1005,1007,1012,1014,1022,1024,1055,1058,1060,1063,1063,1065,
+        1067,1069,1071,1073,1073,1076,1080,1082,1085,1088,1088,1091,1092,
+        1094,1100,1102,1106,1108,1112,1116,1117,1120,1132,1134,1134,1137,
+        1140,1142,1151,1155,1156,1158,1158,1162,1165,1167,1170,1172,1173,
+        1175,1180,1182,1182,1184,1188,1190,1190,1192,1204,1207,1208,1210,
+        1215,1217,1217,1222,1226,1228,1229,1231,1231,1233,1240,1242,1246,
+        1249,1253,1255,1255,1258,1258,1260,1260,1262,1273,1276,1277,1285,
+        1291,1298,1301,1303,1304,1306,1308,1310,1310,1312,1317,1319,1319,
+        1321,1325,1327,1329,1331,1332,1334,1335,1337,1339,1342,1342,1345,
+        1345,1348,1360,1362,1362,1365,1365,1367,1367,1369,1370,1372,1376,
+        1380,1381,1387,1387,1389,1390,1393,1395,1398,1404,1406,1410,1413,
+        1414,1420,1420,1423,1426,1428,1428,1431,1432,1436,1441,1443,1443,
+        1445,1449,1451,1451,1453,1453,1457,1458,1460,1468,1470,1471,1476,
+        1479,1481,1483,1485,1492,1495,1499,1501,1504,1506,1508,1511,1513,
+        1516,1522,1524,1553,1556,1557,1559,1560,1562,1571,1573,1573,1575,
+        1578,1580,1581,1583,1590,1592,1595,1597,1601,1603,1613,1615,1618,
+        1620,1630,1632,1633,1636,1638,1641,1648,1651,1655,1657,1657,1661,
+        1661,1664,1664,1666,1666,1668,1672,1674,1677,1680,1681,1685,1689,
+        1691,1693,1696,1700,1703,1707,1709,1712,1715,1720,1723,1724,1726,
+        1727,1729,1731,1734,1734,1736,1738,1741,1744,1747,1766,1768,1779,
+        1782,1786,1788,1788,1790,1797,1799,1802,1804,1804,1806,1810,1812,
+        1828,1830,1833,1836,1838,1841,1861,1863,1873,1875,1876,1882,1905,
+        1907,1933,1935,1944,1946,2075,2080,2086,2088,2095,2097,2097,2100,
+        2102,2104,2105,2108,2108,2110,2110,2113,2122,2124,2125,2127,2142,
+        2144,2149,2152,2155,2157,2158,2160,2163,2165,2171,2174,2177,2179,
+        2182,2186,2189,2191,2196,2198,2201,2204,2208,2210,2216,2218,2220,
+        2222,2224,2226,2231,2233,2237,2239,2243,2245,2245,2248,2248,2255,
+        2255,2257,2257,2260,2260,2267,2273,2278,2287,2290,2290,2292,2296,
+        2300,2302,2305,2308,2311,2311,2313,2313,2315,2316,2318,2320,2322,
+        2333,2335,2349,2351,2356,2360,2360,2362,2362,2365,2365,2367,2372,
+        2390,2390,2393,2401,2404,2404,2407,2414,2416,2422,2424,2427,24986,
+        0,2450,1,0,0,0,2,2478,1,0,0,0,4,2486,1,0,0,0,6,2495,1,0,0,0,8,2632,
+        1,0,0,0,10,2634,1,0,0,0,12,2691,1,0,0,0,14,2716,1,0,0,0,16,2757,
+        1,0,0,0,18,2763,1,0,0,0,20,2790,1,0,0,0,22,2792,1,0,0,0,24,2811,
+        1,0,0,0,26,2852,1,0,0,0,28,2884,1,0,0,0,30,2889,1,0,0,0,32,2911,
+        1,0,0,0,34,2913,1,0,0,0,36,2943,1,0,0,0,38,2945,1,0,0,0,40,2955,
+        1,0,0,0,42,2957,1,0,0,0,44,2959,1,0,0,0,46,3002,1,0,0,0,48,3004,
+        1,0,0,0,50,3044,1,0,0,0,52,3057,1,0,0,0,54,3059,1,0,0,0,56,3077,
+        1,0,0,0,58,3088,1,0,0,0,60,3094,1,0,0,0,62,3104,1,0,0,0,64,3138,
+        1,0,0,0,66,3177,1,0,0,0,68,3179,1,0,0,0,70,3211,1,0,0,0,72,3235,
+        1,0,0,0,74,3285,1,0,0,0,76,3287,1,0,0,0,78,3289,1,0,0,0,80,3295,
+        1,0,0,0,82,3297,1,0,0,0,84,3316,1,0,0,0,86,3324,1,0,0,0,88,3331,
+        1,0,0,0,90,3337,1,0,0,0,92,3339,1,0,0,0,94,3353,1,0,0,0,96,3355,
+        1,0,0,0,98,3368,1,0,0,0,100,3372,1,0,0,0,102,3407,1,0,0,0,104,3421,
+        1,0,0,0,106,3442,1,0,0,0,108,3477,1,0,0,0,110,3479,1,0,0,0,112,3537,
+        1,0,0,0,114,3545,1,0,0,0,116,3549,1,0,0,0,118,3563,1,0,0,0,120,3573,
+        1,0,0,0,122,3586,1,0,0,0,124,3590,1,0,0,0,126,3594,1,0,0,0,128,3602,
+        1,0,0,0,130,3605,1,0,0,0,132,3617,1,0,0,0,134,3622,1,0,0,0,136,3643,
+        1,0,0,0,138,3645,1,0,0,0,140,3659,1,0,0,0,142,3677,1,0,0,0,144,3695,
+        1,0,0,0,146,3718,1,0,0,0,148,3740,1,0,0,0,150,3775,1,0,0,0,152,3777,
+        1,0,0,0,154,3785,1,0,0,0,156,3787,1,0,0,0,158,3792,1,0,0,0,160,3804,
+        1,0,0,0,162,3824,1,0,0,0,164,3853,1,0,0,0,166,3900,1,0,0,0,168,3902,
+        1,0,0,0,170,3931,1,0,0,0,172,3975,1,0,0,0,174,3977,1,0,0,0,176,3999,
+        1,0,0,0,178,4013,1,0,0,0,180,4017,1,0,0,0,182,4034,1,0,0,0,184,4080,
+        1,0,0,0,186,4117,1,0,0,0,188,4161,1,0,0,0,190,4170,1,0,0,0,192,4174,
+        1,0,0,0,194,4188,1,0,0,0,196,4198,1,0,0,0,198,4203,1,0,0,0,200,4207,
+        1,0,0,0,202,4226,1,0,0,0,204,4228,1,0,0,0,206,4230,1,0,0,0,208,4245,
+        1,0,0,0,210,4249,1,0,0,0,212,4272,1,0,0,0,214,4298,1,0,0,0,216,4307,
+        1,0,0,0,218,4316,1,0,0,0,220,4325,1,0,0,0,222,4329,1,0,0,0,224,4334,
+        1,0,0,0,226,4357,1,0,0,0,228,4359,1,0,0,0,230,4409,1,0,0,0,232,4437,
+        1,0,0,0,234,4439,1,0,0,0,236,4453,1,0,0,0,238,4458,1,0,0,0,240,4466,
+        1,0,0,0,242,4474,1,0,0,0,244,4477,1,0,0,0,246,4486,1,0,0,0,248,4501,
+        1,0,0,0,250,4518,1,0,0,0,252,4535,1,0,0,0,254,4543,1,0,0,0,256,4586,
+        1,0,0,0,258,4588,1,0,0,0,260,4612,1,0,0,0,262,4615,1,0,0,0,264,4623,
+        1,0,0,0,266,4625,1,0,0,0,268,4636,1,0,0,0,270,4647,1,0,0,0,272,4659,
+        1,0,0,0,274,4687,1,0,0,0,276,4693,1,0,0,0,278,4696,1,0,0,0,280,4703,
+        1,0,0,0,282,4711,1,0,0,0,284,4724,1,0,0,0,286,4726,1,0,0,0,288,4731,
+        1,0,0,0,290,4738,1,0,0,0,292,4766,1,0,0,0,294,4797,1,0,0,0,296,4845,
+        1,0,0,0,298,4855,1,0,0,0,300,4857,1,0,0,0,302,4862,1,0,0,0,304,4876,
+        1,0,0,0,306,4878,1,0,0,0,308,4889,1,0,0,0,310,4891,1,0,0,0,312,4929,
+        1,0,0,0,314,4957,1,0,0,0,316,4976,1,0,0,0,318,5009,1,0,0,0,320,5047,
+        1,0,0,0,322,5051,1,0,0,0,324,5066,1,0,0,0,326,5068,1,0,0,0,328,5085,
+        1,0,0,0,330,5089,1,0,0,0,332,5097,1,0,0,0,334,5160,1,0,0,0,336,5162,
+        1,0,0,0,338,5212,1,0,0,0,340,5214,1,0,0,0,342,5218,1,0,0,0,344,5291,
+        1,0,0,0,346,5293,1,0,0,0,348,5296,1,0,0,0,350,5299,1,0,0,0,352,5311,
+        1,0,0,0,354,5313,1,0,0,0,356,5329,1,0,0,0,358,5342,1,0,0,0,360,5412,
+        1,0,0,0,362,5424,1,0,0,0,364,5436,1,0,0,0,366,5448,1,0,0,0,368,5453,
+        1,0,0,0,370,5458,1,0,0,0,372,5462,1,0,0,0,374,5467,1,0,0,0,376,5471,
+        1,0,0,0,378,5476,1,0,0,0,380,5485,1,0,0,0,382,5508,1,0,0,0,384,5521,
+        1,0,0,0,386,5546,1,0,0,0,388,5548,1,0,0,0,390,5567,1,0,0,0,392,5573,
+        1,0,0,0,394,5615,1,0,0,0,396,5633,1,0,0,0,398,5645,1,0,0,0,400,5651,
+        1,0,0,0,402,5662,1,0,0,0,404,5673,1,0,0,0,406,5688,1,0,0,0,408,5703,
+        1,0,0,0,410,5774,1,0,0,0,412,5789,1,0,0,0,414,5792,1,0,0,0,416,5800,
+        1,0,0,0,418,5820,1,0,0,0,420,5848,1,0,0,0,422,5860,1,0,0,0,424,5864,
+        1,0,0,0,426,5873,1,0,0,0,428,5905,1,0,0,0,430,5907,1,0,0,0,432,5916,
+        1,0,0,0,434,5918,1,0,0,0,436,5948,1,0,0,0,438,5950,1,0,0,0,440,5959,
+        1,0,0,0,442,6017,1,0,0,0,444,6019,1,0,0,0,446,6040,1,0,0,0,448,6046,
+        1,0,0,0,450,6048,1,0,0,0,452,6100,1,0,0,0,454,6112,1,0,0,0,456,6121,
+        1,0,0,0,458,6142,1,0,0,0,460,6146,1,0,0,0,462,6150,1,0,0,0,464,6184,
+        1,0,0,0,466,6192,1,0,0,0,468,6204,1,0,0,0,470,6210,1,0,0,0,472,6217,
+        1,0,0,0,474,6219,1,0,0,0,476,6243,1,0,0,0,478,6251,1,0,0,0,480,6255,
+        1,0,0,0,482,6278,1,0,0,0,484,6324,1,0,0,0,486,6339,1,0,0,0,488,6341,
+        1,0,0,0,490,6355,1,0,0,0,492,6387,1,0,0,0,494,6396,1,0,0,0,496,6412,
+        1,0,0,0,498,6454,1,0,0,0,500,6485,1,0,0,0,502,6487,1,0,0,0,504,6494,
+        1,0,0,0,506,6505,1,0,0,0,508,6516,1,0,0,0,510,6554,1,0,0,0,512,6556,
+        1,0,0,0,514,6583,1,0,0,0,516,6596,1,0,0,0,518,6637,1,0,0,0,520,6639,
+        1,0,0,0,522,6653,1,0,0,0,524,6658,1,0,0,0,526,6662,1,0,0,0,528,6675,
+        1,0,0,0,530,6700,1,0,0,0,532,6702,1,0,0,0,534,6704,1,0,0,0,536,6706,
+        1,0,0,0,538,6740,1,0,0,0,540,6742,1,0,0,0,542,6759,1,0,0,0,544,6774,
+        1,0,0,0,546,6779,1,0,0,0,548,6805,1,0,0,0,550,6807,1,0,0,0,552,6817,
+        1,0,0,0,554,6821,1,0,0,0,556,6847,1,0,0,0,558,6867,1,0,0,0,560,6874,
+        1,0,0,0,562,6876,1,0,0,0,564,6878,1,0,0,0,566,6880,1,0,0,0,568,6903,
+        1,0,0,0,570,6952,1,0,0,0,572,6954,1,0,0,0,574,6964,1,0,0,0,576,6969,
+        1,0,0,0,578,6973,1,0,0,0,580,6979,1,0,0,0,582,6983,1,0,0,0,584,6991,
+        1,0,0,0,586,7017,1,0,0,0,588,7019,1,0,0,0,590,7025,1,0,0,0,592,7028,
+        1,0,0,0,594,7031,1,0,0,0,596,7034,1,0,0,0,598,7088,1,0,0,0,600,7090,
+        1,0,0,0,602,7101,1,0,0,0,604,7109,1,0,0,0,606,7120,1,0,0,0,608,7122,
+        1,0,0,0,610,7140,1,0,0,0,612,7142,1,0,0,0,614,7159,1,0,0,0,616,7169,
+        1,0,0,0,618,7172,1,0,0,0,620,7181,1,0,0,0,622,7195,1,0,0,0,624,7209,
+        1,0,0,0,626,7227,1,0,0,0,628,7242,1,0,0,0,630,7259,1,0,0,0,632,7283,
+        1,0,0,0,634,7285,1,0,0,0,636,7314,1,0,0,0,638,7343,1,0,0,0,640,7345,
+        1,0,0,0,642,7347,1,0,0,0,644,7363,1,0,0,0,646,7375,1,0,0,0,648,7408,
+        1,0,0,0,650,7425,1,0,0,0,652,7442,1,0,0,0,654,7458,1,0,0,0,656,7497,
+        1,0,0,0,658,7504,1,0,0,0,660,7508,1,0,0,0,662,7516,1,0,0,0,664,7518,
+        1,0,0,0,666,7536,1,0,0,0,668,7548,1,0,0,0,670,7565,1,0,0,0,672,7580,
+        1,0,0,0,674,7590,1,0,0,0,676,7596,1,0,0,0,678,7600,1,0,0,0,680,7602,
+        1,0,0,0,682,7604,1,0,0,0,684,7619,1,0,0,0,686,7687,1,0,0,0,688,7718,
+        1,0,0,0,690,7720,1,0,0,0,692,7728,1,0,0,0,694,7778,1,0,0,0,696,7780,
+        1,0,0,0,698,7787,1,0,0,0,700,7792,1,0,0,0,702,7794,1,0,0,0,704,7804,
+        1,0,0,0,706,7865,1,0,0,0,708,7880,1,0,0,0,710,7882,1,0,0,0,712,7887,
+        1,0,0,0,714,7889,1,0,0,0,716,7899,1,0,0,0,718,7901,1,0,0,0,720,7903,
+        1,0,0,0,722,7905,1,0,0,0,724,7909,1,0,0,0,726,7911,1,0,0,0,728,7917,
+        1,0,0,0,730,7964,1,0,0,0,732,7966,1,0,0,0,734,7993,1,0,0,0,736,7997,
+        1,0,0,0,738,8038,1,0,0,0,740,8040,1,0,0,0,742,8049,1,0,0,0,744,8060,
+        1,0,0,0,746,8064,1,0,0,0,748,8066,1,0,0,0,750,8084,1,0,0,0,752,8091,
+        1,0,0,0,754,8098,1,0,0,0,756,8172,1,0,0,0,758,8174,1,0,0,0,760,8181,
+        1,0,0,0,762,8308,1,0,0,0,764,8319,1,0,0,0,766,8330,1,0,0,0,768,8361,
+        1,0,0,0,770,8369,1,0,0,0,772,8385,1,0,0,0,774,8409,1,0,0,0,776,8414,
+        1,0,0,0,778,8467,1,0,0,0,780,8471,1,0,0,0,782,8486,1,0,0,0,784,8493,
+        1,0,0,0,786,8510,1,0,0,0,788,8533,1,0,0,0,790,8589,1,0,0,0,792,8600,
+        1,0,0,0,794,8608,1,0,0,0,796,8623,1,0,0,0,798,8638,1,0,0,0,800,8640,
+        1,0,0,0,802,8642,1,0,0,0,804,8679,1,0,0,0,806,8688,1,0,0,0,808,8708,
+        1,0,0,0,810,8718,1,0,0,0,812,8722,1,0,0,0,814,8794,1,0,0,0,816,8805,
+        1,0,0,0,818,8823,1,0,0,0,820,8827,1,0,0,0,822,8830,1,0,0,0,824,8833,
+        1,0,0,0,826,8839,1,0,0,0,828,8844,1,0,0,0,830,8848,1,0,0,0,832,8897,
+        1,0,0,0,834,8927,1,0,0,0,836,8949,1,0,0,0,838,8958,1,0,0,0,840,8962,
+        1,0,0,0,842,8985,1,0,0,0,844,8987,1,0,0,0,846,9024,1,0,0,0,848,9027,
+        1,0,0,0,850,9091,1,0,0,0,852,9096,1,0,0,0,854,9098,1,0,0,0,856,9118,
+        1,0,0,0,858,9172,1,0,0,0,860,9201,1,0,0,0,862,9238,1,0,0,0,864,9242,
+        1,0,0,0,866,9293,1,0,0,0,868,9297,1,0,0,0,870,9321,1,0,0,0,872,9348,
+        1,0,0,0,874,9350,1,0,0,0,876,9352,1,0,0,0,878,9435,1,0,0,0,880,9443,
+        1,0,0,0,882,9445,1,0,0,0,884,9451,1,0,0,0,886,9462,1,0,0,0,888,9464,
+        1,0,0,0,890,9467,1,0,0,0,892,9469,1,0,0,0,894,9478,1,0,0,0,896,9508,
+        1,0,0,0,898,9511,1,0,0,0,900,9513,1,0,0,0,902,9524,1,0,0,0,904,9529,
+        1,0,0,0,906,9546,1,0,0,0,908,9563,1,0,0,0,910,9566,1,0,0,0,912,9617,
+        1,0,0,0,914,9619,1,0,0,0,916,9627,1,0,0,0,918,9643,1,0,0,0,920,9656,
+        1,0,0,0,922,9658,1,0,0,0,924,9697,1,0,0,0,926,9699,1,0,0,0,928,9705,
+        1,0,0,0,930,9712,1,0,0,0,932,9736,1,0,0,0,934,9749,1,0,0,0,936,9761,
+        1,0,0,0,938,9766,1,0,0,0,940,9784,1,0,0,0,942,9786,1,0,0,0,944,9789,
+        1,0,0,0,946,9840,1,0,0,0,948,9842,1,0,0,0,950,9873,1,0,0,0,952,9875,
+        1,0,0,0,954,9885,1,0,0,0,956,9910,1,0,0,0,958,9915,1,0,0,0,960,9920,
+        1,0,0,0,962,9958,1,0,0,0,964,10021,1,0,0,0,966,10025,1,0,0,0,968,
+        10030,1,0,0,0,970,10054,1,0,0,0,972,10067,1,0,0,0,974,10072,1,0,
+        0,0,976,10098,1,0,0,0,978,10102,1,0,0,0,980,10107,1,0,0,0,982,10112,
+        1,0,0,0,984,10120,1,0,0,0,986,10126,1,0,0,0,988,10129,1,0,0,0,990,
+        10137,1,0,0,0,992,10143,1,0,0,0,994,10164,1,0,0,0,996,10187,1,0,
+        0,0,998,10195,1,0,0,0,1000,10197,1,0,0,0,1002,10205,1,0,0,0,1004,
+        10217,1,0,0,0,1006,10234,1,0,0,0,1008,10237,1,0,0,0,1010,10252,1,
+        0,0,0,1012,10351,1,0,0,0,1014,10366,1,0,0,0,1016,10416,1,0,0,0,1018,
+        10418,1,0,0,0,1020,10424,1,0,0,0,1022,10445,1,0,0,0,1024,10453,1,
+        0,0,0,1026,10464,1,0,0,0,1028,10484,1,0,0,0,1030,10486,1,0,0,0,1032,
+        10538,1,0,0,0,1034,10562,1,0,0,0,1036,10581,1,0,0,0,1038,10583,1,
+        0,0,0,1040,10591,1,0,0,0,1042,10594,1,0,0,0,1044,10597,1,0,0,0,1046,
+        10625,1,0,0,0,1048,10650,1,0,0,0,1050,10659,1,0,0,0,1052,10711,1,
+        0,0,0,1054,10747,1,0,0,0,1056,10769,1,0,0,0,1058,10811,1,0,0,0,1060,
+        10819,1,0,0,0,1062,10829,1,0,0,0,1064,10870,1,0,0,0,1066,10872,1,
+        0,0,0,1068,10886,1,0,0,0,1070,10917,1,0,0,0,1072,10920,1,0,0,0,1074,
+        10938,1,0,0,0,1076,10944,1,0,0,0,1078,10963,1,0,0,0,1080,10967,1,
+        0,0,0,1082,10969,1,0,0,0,1084,10978,1,0,0,0,1086,10993,1,0,0,0,1088,
+        10997,1,0,0,0,1090,11006,1,0,0,0,1092,11021,1,0,0,0,1094,11027,1,
+        0,0,0,1096,11059,1,0,0,0,1098,11061,1,0,0,0,1100,11064,1,0,0,0,1102,
+        11067,1,0,0,0,1104,11093,1,0,0,0,1106,11104,1,0,0,0,1108,11116,1,
+        0,0,0,1110,11118,1,0,0,0,1112,11137,1,0,0,0,1114,11139,1,0,0,0,1116,
+        11150,1,0,0,0,1118,11164,1,0,0,0,1120,11185,1,0,0,0,1122,11187,1,
+        0,0,0,1124,11195,1,0,0,0,1126,11205,1,0,0,0,1128,11207,1,0,0,0,1130,
+        11263,1,0,0,0,1132,11311,1,0,0,0,1134,11328,1,0,0,0,1136,11351,1,
+        0,0,0,1138,11388,1,0,0,0,1140,11390,1,0,0,0,1142,11440,1,0,0,0,1144,
+        11462,1,0,0,0,1146,11482,1,0,0,0,1148,11501,1,0,0,0,1150,11507,1,
+        0,0,0,1152,11522,1,0,0,0,1154,11564,1,0,0,0,1156,11606,1,0,0,0,1158,
+        11640,1,0,0,0,1160,11642,1,0,0,0,1162,11658,1,0,0,0,1164,11667,1,
+        0,0,0,1166,11700,1,0,0,0,1168,11702,1,0,0,0,1170,11710,1,0,0,0,1172,
+        11718,1,0,0,0,1174,11725,1,0,0,0,1176,11742,1,0,0,0,1178,11767,1,
+        0,0,0,1180,11769,1,0,0,0,1182,11795,1,0,0,0,1184,11854,1,0,0,0,1186,
+        11858,1,0,0,0,1188,11882,1,0,0,0,1190,11927,1,0,0,0,1192,11948,1,
+        0,0,0,1194,11954,1,0,0,0,1196,11969,1,0,0,0,1198,11971,1,0,0,0,1200,
+        11974,1,0,0,0,1202,12001,1,0,0,0,1204,12009,1,0,0,0,1206,12025,1,
+        0,0,0,1208,12029,1,0,0,0,1210,12064,1,0,0,0,1212,12079,1,0,0,0,1214,
+        12126,1,0,0,0,1216,12128,1,0,0,0,1218,12143,1,0,0,0,1220,12164,1,
+        0,0,0,1222,12166,1,0,0,0,1224,12194,1,0,0,0,1226,12196,1,0,0,0,1228,
+        12208,1,0,0,0,1230,12215,1,0,0,0,1232,12219,1,0,0,0,1234,12227,1,
+        0,0,0,1236,12248,1,0,0,0,1238,12253,1,0,0,0,1240,12310,1,0,0,0,1242,
+        12312,1,0,0,0,1244,12350,1,0,0,0,1246,12361,1,0,0,0,1248,12369,1,
+        0,0,0,1250,12380,1,0,0,0,1252,12491,1,0,0,0,1254,12518,1,0,0,0,1256,
+        12520,1,0,0,0,1258,12523,1,0,0,0,1260,12541,1,0,0,0,1262,12544,1,
+        0,0,0,1264,12566,1,0,0,0,1266,12611,1,0,0,0,1268,12650,1,0,0,0,1270,
+        12658,1,0,0,0,1272,12660,1,0,0,0,1274,12778,1,0,0,0,1276,12780,1,
+        0,0,0,1278,12877,1,0,0,0,1280,12915,1,0,0,0,1282,12932,1,0,0,0,1284,
+        12935,1,0,0,0,1286,12948,1,0,0,0,1288,12952,1,0,0,0,1290,12994,1,
+        0,0,0,1292,12996,1,0,0,0,1294,13019,1,0,0,0,1296,13042,1,0,0,0,1298,
+        13058,1,0,0,0,1300,13064,1,0,0,0,1302,13076,1,0,0,0,1304,13080,1,
+        0,0,0,1306,13089,1,0,0,0,1308,13113,1,0,0,0,1310,13138,1,0,0,0,1312,
+        13154,1,0,0,0,1314,13161,1,0,0,0,1316,13171,1,0,0,0,1318,13182,1,
+        0,0,0,1320,13189,1,0,0,0,1322,13191,1,0,0,0,1324,13193,1,0,0,0,1326,
+        13253,1,0,0,0,1328,13255,1,0,0,0,1330,13269,1,0,0,0,1332,13288,1,
+        0,0,0,1334,13290,1,0,0,0,1336,13292,1,0,0,0,1338,13299,1,0,0,0,1340,
+        13307,1,0,0,0,1342,13324,1,0,0,0,1344,13354,1,0,0,0,1346,13358,1,
+        0,0,0,1348,13366,1,0,0,0,1350,13388,1,0,0,0,1352,13403,1,0,0,0,1354,
+        13453,1,0,0,0,1356,13469,1,0,0,0,1358,13479,1,0,0,0,1360,13489,1,
+        0,0,0,1362,13494,1,0,0,0,1364,13499,1,0,0,0,1366,13510,1,0,0,0,1368,
+        13514,1,0,0,0,1370,13518,1,0,0,0,1372,13531,1,0,0,0,1374,13537,1,
+        0,0,0,1376,13544,1,0,0,0,1378,13546,1,0,0,0,1380,13548,1,0,0,0,1382,
+        13568,1,0,0,0,1384,13593,1,0,0,0,1386,13595,1,0,0,0,1388,13597,1,
+        0,0,0,1390,13604,1,0,0,0,1392,13606,1,0,0,0,1394,13608,1,0,0,0,1396,
+        13641,1,0,0,0,1398,13686,1,0,0,0,1400,13688,1,0,0,0,1402,13719,1,
+        0,0,0,1404,13756,1,0,0,0,1406,13775,1,0,0,0,1408,13777,1,0,0,0,1410,
+        13797,1,0,0,0,1412,13825,1,0,0,0,1414,13850,1,0,0,0,1416,13932,1,
+        0,0,0,1418,13934,1,0,0,0,1420,13978,1,0,0,0,1422,13982,1,0,0,0,1424,
+        14006,1,0,0,0,1426,14013,1,0,0,0,1428,14021,1,0,0,0,1430,14023,1,
+        0,0,0,1432,14042,1,0,0,0,1434,14065,1,0,0,0,1436,14067,1,0,0,0,1438,
+        14085,1,0,0,0,1440,14090,1,0,0,0,1442,14100,1,0,0,0,1444,14107,1,
+        0,0,0,1446,14115,1,0,0,0,1448,14148,1,0,0,0,1450,14171,1,0,0,0,1452,
+        14176,1,0,0,0,1454,14227,1,0,0,0,1456,14229,1,0,0,0,1458,14234,1,
+        0,0,0,1460,14238,1,0,0,0,1462,14241,1,0,0,0,1464,14243,1,0,0,0,1466,
+        14245,1,0,0,0,1468,14247,1,0,0,0,1470,14249,1,0,0,0,1472,14251,1,
+        0,0,0,1474,14265,1,0,0,0,1476,14270,1,0,0,0,1478,14277,1,0,0,0,1480,
+        14279,1,0,0,0,1482,14284,1,0,0,0,1484,14289,1,0,0,0,1486,14295,1,
+        0,0,0,1488,14299,1,0,0,0,1490,14325,1,0,0,0,1492,14327,1,0,0,0,1494,
+        14334,1,0,0,0,1496,14346,1,0,0,0,1498,14406,1,0,0,0,1500,14410,1,
+        0,0,0,1502,14432,1,0,0,0,1504,14434,1,0,0,0,1506,14454,1,0,0,0,1508,
+        14470,1,0,0,0,1510,14475,1,0,0,0,1512,14483,1,0,0,0,1514,14487,1,
+        0,0,0,1516,14498,1,0,0,0,1518,14526,1,0,0,0,1520,14542,1,0,0,0,1522,
+        14551,1,0,0,0,1524,14583,1,0,0,0,1526,14591,1,0,0,0,1528,14624,1,
+        0,0,0,1530,14626,1,0,0,0,1532,14653,1,0,0,0,1534,14672,1,0,0,0,1536,
+        14698,1,0,0,0,1538,14700,1,0,0,0,1540,14719,1,0,0,0,1542,14727,1,
+        0,0,0,1544,14737,1,0,0,0,1546,14742,1,0,0,0,1548,14765,1,0,0,0,1550,
+        14778,1,0,0,0,1552,14780,1,0,0,0,1554,14799,1,0,0,0,1556,14810,1,
+        0,0,0,1558,14819,1,0,0,0,1560,14841,1,0,0,0,1562,14895,1,0,0,0,1564,
+        14919,1,0,0,0,1566,14933,1,0,0,0,1568,14943,1,0,0,0,1570,14952,1,
+        0,0,0,1572,14981,1,0,0,0,1574,14985,1,0,0,0,1576,14993,1,0,0,0,1578,
+        15030,1,0,0,0,1580,15083,1,0,0,0,1582,15094,1,0,0,0,1584,15096,1,
+        0,0,0,1586,15112,1,0,0,0,1588,15114,1,0,0,0,1590,15139,1,0,0,0,1592,
+        15141,1,0,0,0,1594,15145,1,0,0,0,1596,15153,1,0,0,0,1598,15167,1,
+        0,0,0,1600,15178,1,0,0,0,1602,15193,1,0,0,0,1604,15228,1,0,0,0,1606,
+        15251,1,0,0,0,1608,15255,1,0,0,0,1610,15257,1,0,0,0,1612,15261,1,
+        0,0,0,1614,15284,1,0,0,0,1616,15310,1,0,0,0,1618,15315,1,0,0,0,1620,
+        15320,1,0,0,0,1622,15324,1,0,0,0,1624,15334,1,0,0,0,1626,15336,1,
+        0,0,0,1628,15344,1,0,0,0,1630,15346,1,0,0,0,1632,15352,1,0,0,0,1634,
+        15354,1,0,0,0,1636,15360,1,0,0,0,1638,15426,1,0,0,0,1640,15428,1,
+        0,0,0,1642,15456,1,0,0,0,1644,15488,1,0,0,0,1646,15491,1,0,0,0,1648,
+        15503,1,0,0,0,1650,15530,1,0,0,0,1652,15539,1,0,0,0,1654,15557,1,
+        0,0,0,1656,15562,1,0,0,0,1658,15571,1,0,0,0,1660,15573,1,0,0,0,1662,
+        15620,1,0,0,0,1664,15653,1,0,0,0,1666,15685,1,0,0,0,1668,15689,1,
+        0,0,0,1670,15696,1,0,0,0,1672,15698,1,0,0,0,1674,15708,1,0,0,0,1676,
+        15724,1,0,0,0,1678,15729,1,0,0,0,1680,15758,1,0,0,0,1682,15762,1,
+        0,0,0,1684,15797,1,0,0,0,1686,15809,1,0,0,0,1688,15811,1,0,0,0,1690,
+        15813,1,0,0,0,1692,15854,1,0,0,0,1694,15856,1,0,0,0,1696,15884,1,
+        0,0,0,1698,15914,1,0,0,0,1700,15916,1,0,0,0,1702,15978,1,0,0,0,1704,
+        15980,1,0,0,0,1706,16003,1,0,0,0,1708,16008,1,0,0,0,1710,16016,1,
+        0,0,0,1712,16053,1,0,0,0,1714,16074,1,0,0,0,1716,16078,1,0,0,0,1718,
+        16080,1,0,0,0,1720,16086,1,0,0,0,1722,16144,1,0,0,0,1724,16146,1,
+        0,0,0,1726,16148,1,0,0,0,1728,16150,1,0,0,0,1730,16179,1,0,0,0,1732,
+        16186,1,0,0,0,1734,16193,1,0,0,0,1736,16207,1,0,0,0,1738,16218,1,
+        0,0,0,1740,16232,1,0,0,0,1742,16237,1,0,0,0,1744,16239,1,0,0,0,1746,
+        16247,1,0,0,0,1748,16272,1,0,0,0,1750,16278,1,0,0,0,1752,16310,1,
+        0,0,0,1754,16321,1,0,0,0,1756,16323,1,0,0,0,1758,16336,1,0,0,0,1760,
+        16340,1,0,0,0,1762,16355,1,0,0,0,1764,16357,1,0,0,0,1766,16373,1,
+        0,0,0,1768,16390,1,0,0,0,1770,16415,1,0,0,0,1772,16425,1,0,0,0,1774,
+        16429,1,0,0,0,1776,16474,1,0,0,0,1778,16486,1,0,0,0,1780,16497,1,
+        0,0,0,1782,16503,1,0,0,0,1784,16514,1,0,0,0,1786,16526,1,0,0,0,1788,
+        16536,1,0,0,0,1790,16558,1,0,0,0,1792,16562,1,0,0,0,1794,16585,1,
+        0,0,0,1796,16589,1,0,0,0,1798,16594,1,0,0,0,1800,16602,1,0,0,0,1802,
+        16610,1,0,0,0,1804,16613,1,0,0,0,1806,16629,1,0,0,0,1808,16634,1,
+        0,0,0,1810,16638,1,0,0,0,1812,16678,1,0,0,0,1814,16680,1,0,0,0,1816,
+        16705,1,0,0,0,1818,16707,1,0,0,0,1820,16712,1,0,0,0,1822,16714,1,
+        0,0,0,1824,16716,1,0,0,0,1826,16718,1,0,0,0,1828,16722,1,0,0,0,1830,
+        16727,1,0,0,0,1832,16747,1,0,0,0,1834,16753,1,0,0,0,1836,16778,1,
+        0,0,0,1838,16792,1,0,0,0,1840,16796,1,0,0,0,1842,16810,1,0,0,0,1844,
+        16829,1,0,0,0,1846,16836,1,0,0,0,1848,16848,1,0,0,0,1850,16857,1,
+        0,0,0,1852,16859,1,0,0,0,1854,16873,1,0,0,0,1856,16883,1,0,0,0,1858,
+        16889,1,0,0,0,1860,16891,1,0,0,0,1862,16894,1,0,0,0,1864,16903,1,
+        0,0,0,1866,16936,1,0,0,0,1868,16938,1,0,0,0,1870,16953,1,0,0,0,1872,
+        16955,1,0,0,0,1874,16976,1,0,0,0,1876,16991,1,0,0,0,1878,17016,1,
+        0,0,0,1880,17024,1,0,0,0,1882,17037,1,0,0,0,1884,17040,1,0,0,0,1886,
+        17065,1,0,0,0,1888,17085,1,0,0,0,1890,17087,1,0,0,0,1892,17130,1,
+        0,0,0,1894,17134,1,0,0,0,1896,17136,1,0,0,0,1898,17153,1,0,0,0,1900,
+        17196,1,0,0,0,1902,17205,1,0,0,0,1904,17213,1,0,0,0,1906,17224,1,
+        0,0,0,1908,17236,1,0,0,0,1910,17251,1,0,0,0,1912,17256,1,0,0,0,1914,
+        17269,1,0,0,0,1916,17276,1,0,0,0,1918,17285,1,0,0,0,1920,17297,1,
+        0,0,0,1922,17305,1,0,0,0,1924,17309,1,0,0,0,1926,17351,1,0,0,0,1928,
+        17353,1,0,0,0,1930,17364,1,0,0,0,1932,17366,1,0,0,0,1934,17374,1,
+        0,0,0,1936,17385,1,0,0,0,1938,17419,1,0,0,0,1940,17446,1,0,0,0,1942,
+        17448,1,0,0,0,1944,17451,1,0,0,0,1946,17454,1,0,0,0,1948,17458,1,
+        0,0,0,1950,17494,1,0,0,0,1952,17496,1,0,0,0,1954,17521,1,0,0,0,1956,
+        17526,1,0,0,0,1958,17531,1,0,0,0,1960,17554,1,0,0,0,1962,17564,1,
+        0,0,0,1964,17566,1,0,0,0,1966,17582,1,0,0,0,1968,17596,1,0,0,0,1970,
+        17632,1,0,0,0,1972,17634,1,0,0,0,1974,17664,1,0,0,0,1976,17669,1,
+        0,0,0,1978,17671,1,0,0,0,1980,17683,1,0,0,0,1982,17703,1,0,0,0,1984,
+        17705,1,0,0,0,1986,17708,1,0,0,0,1988,17734,1,0,0,0,1990,17736,1,
+        0,0,0,1992,17740,1,0,0,0,1994,17755,1,0,0,0,1996,17767,1,0,0,0,1998,
+        17775,1,0,0,0,2000,17779,1,0,0,0,2002,17792,1,0,0,0,2004,17798,1,
+        0,0,0,2006,17813,1,0,0,0,2008,17833,1,0,0,0,2010,17842,1,0,0,0,2012,
+        17844,1,0,0,0,2014,17851,1,0,0,0,2016,17856,1,0,0,0,2018,17869,1,
+        0,0,0,2020,17877,1,0,0,0,2022,17881,1,0,0,0,2024,17895,1,0,0,0,2026,
+        17903,1,0,0,0,2028,17911,1,0,0,0,2030,17913,1,0,0,0,2032,17925,1,
+        0,0,0,2034,17951,1,0,0,0,2036,17953,1,0,0,0,2038,17967,1,0,0,0,2040,
+        17972,1,0,0,0,2042,17990,1,0,0,0,2044,17994,1,0,0,0,2046,18002,1,
+        0,0,0,2048,18012,1,0,0,0,2050,18020,1,0,0,0,2052,18026,1,0,0,0,2054,
+        18034,1,0,0,0,2056,18052,1,0,0,0,2058,18077,1,0,0,0,2060,18096,1,
+        0,0,0,2062,18100,1,0,0,0,2064,18103,1,0,0,0,2066,18125,1,0,0,0,2068,
+        18130,1,0,0,0,2070,18149,1,0,0,0,2072,18151,1,0,0,0,2074,18167,1,
+        0,0,0,2076,18175,1,0,0,0,2078,18180,1,0,0,0,2080,18184,1,0,0,0,2082,
+        18195,1,0,0,0,2084,18198,1,0,0,0,2086,18240,1,0,0,0,2088,18242,1,
+        0,0,0,2090,18255,1,0,0,0,2092,18266,1,0,0,0,2094,18280,1,0,0,0,2096,
+        18291,1,0,0,0,2098,18293,1,0,0,0,2100,18303,1,0,0,0,2102,18305,1,
+        0,0,0,2104,18310,1,0,0,0,2106,18325,1,0,0,0,2108,18331,1,0,0,0,2110,
+        18375,1,0,0,0,2112,18377,1,0,0,0,2114,18401,1,0,0,0,2116,18419,1,
+        0,0,0,2118,18451,1,0,0,0,2120,18471,1,0,0,0,2122,18473,1,0,0,0,2124,
+        18477,1,0,0,0,2126,18539,1,0,0,0,2128,18542,1,0,0,0,2130,18574,1,
+        0,0,0,2132,18576,1,0,0,0,2134,18597,1,0,0,0,2136,18631,1,0,0,0,2138,
+        18640,1,0,0,0,2140,18642,1,0,0,0,2142,18662,1,0,0,0,2144,18681,1,
+        0,0,0,2146,18694,1,0,0,0,2148,18697,1,0,0,0,2150,18717,1,0,0,0,2152,
+        18735,1,0,0,0,2154,18740,1,0,0,0,2156,18745,1,0,0,0,2158,18747,1,
+        0,0,0,2160,18761,1,0,0,0,2162,18774,1,0,0,0,2164,18779,1,0,0,0,2166,
+        18812,1,0,0,0,2168,18814,1,0,0,0,2170,18918,1,0,0,0,2172,18925,1,
+        0,0,0,2174,19115,1,0,0,0,2176,19126,1,0,0,0,2178,19156,1,0,0,0,2180,
+        19162,1,0,0,0,2182,19193,1,0,0,0,2184,19199,1,0,0,0,2186,19203,1,
+        0,0,0,2188,19304,1,0,0,0,2190,19306,1,0,0,0,2192,19371,1,0,0,0,2194,
+        19375,1,0,0,0,2196,19394,1,0,0,0,2198,19409,1,0,0,0,2200,19418,1,
+        0,0,0,2202,19430,1,0,0,0,2204,19435,1,0,0,0,2206,19479,1,0,0,0,2208,
+        19481,1,0,0,0,2210,19499,1,0,0,0,2212,19501,1,0,0,0,2214,19588,1,
+        0,0,0,2216,19590,1,0,0,0,2218,20021,1,0,0,0,2220,20023,1,0,0,0,2222,
+        20025,1,0,0,0,2224,20027,1,0,0,0,2226,20029,1,0,0,0,2228,20055,1,
+        0,0,0,2230,20064,1,0,0,0,2232,20073,1,0,0,0,2234,20075,1,0,0,0,2236,
+        20095,1,0,0,0,2238,20099,1,0,0,0,2240,20101,1,0,0,0,2242,20118,1,
+        0,0,0,2244,20128,1,0,0,0,2246,20139,1,0,0,0,2248,20163,1,0,0,0,2250,
+        20182,1,0,0,0,2252,20200,1,0,0,0,2254,20221,1,0,0,0,2256,20234,1,
+        0,0,0,2258,20237,1,0,0,0,2260,20247,1,0,0,0,2262,20253,1,0,0,0,2264,
+        20261,1,0,0,0,2266,20264,1,0,0,0,2268,20275,1,0,0,0,2270,20277,1,
+        0,0,0,2272,20296,1,0,0,0,2274,20306,1,0,0,0,2276,20320,1,0,0,0,2278,
+        20322,1,0,0,0,2280,20331,1,0,0,0,2282,20338,1,0,0,0,2284,20355,1,
+        0,0,0,2286,20374,1,0,0,0,2288,20392,1,0,0,0,2290,20410,1,0,0,0,2292,
+        20412,1,0,0,0,2294,20430,1,0,0,0,2296,20434,1,0,0,0,2298,20436,1,
+        0,0,0,2300,20445,1,0,0,0,2302,20464,1,0,0,0,2304,20466,1,0,0,0,2306,
+        20468,1,0,0,0,2308,20470,1,0,0,0,2310,20472,1,0,0,0,2312,20474,1,
+        0,0,0,2314,20476,1,0,0,0,2316,20488,1,0,0,0,2318,20490,1,0,0,0,2320,
+        20495,1,0,0,0,2322,20497,1,0,0,0,2324,20499,1,0,0,0,2326,20501,1,
+        0,0,0,2328,20506,1,0,0,0,2330,20514,1,0,0,0,2332,20516,1,0,0,0,2334,
+        20522,1,0,0,0,2336,20524,1,0,0,0,2338,20536,1,0,0,0,2340,20538,1,
+        0,0,0,2342,20546,1,0,0,0,2344,20554,1,0,0,0,2346,20562,1,0,0,0,2348,
+        20567,1,0,0,0,2350,20572,1,0,0,0,2352,20587,1,0,0,0,2354,20589,1,
+        0,0,0,2356,20596,1,0,0,0,2358,20600,1,0,0,0,2360,20602,1,0,0,0,2362,
+        20614,1,0,0,0,2364,20616,1,0,0,0,2366,20618,1,0,0,0,2368,20640,1,
+        0,0,0,2370,20642,1,0,0,0,2372,20675,1,0,0,0,2374,20683,1,0,0,0,2376,
+        20685,1,0,0,0,2378,20687,1,0,0,0,2380,20689,1,0,0,0,2382,20715,1,
+        0,0,0,2384,20717,1,0,0,0,2386,20725,1,0,0,0,2388,20729,1,0,0,0,2390,
+        20741,1,0,0,0,2392,20756,1,0,0,0,2394,20777,1,0,0,0,2396,20819,1,
+        0,0,0,2398,20826,1,0,0,0,2400,20838,1,0,0,0,2402,20871,1,0,0,0,2404,
+        20873,1,0,0,0,2406,20955,1,0,0,0,2408,20960,1,0,0,0,2410,20985,1,
+        0,0,0,2412,21001,1,0,0,0,2414,21016,1,0,0,0,2416,21062,1,0,0,0,2418,
+        21390,1,0,0,0,2420,21455,1,0,0,0,2422,21462,1,0,0,0,2424,21464,1,
+        0,0,0,2426,21467,1,0,0,0,2428,21471,1,0,0,0,2430,21477,1,0,0,0,2432,
+        21479,1,0,0,0,2434,21481,1,0,0,0,2436,21616,1,0,0,0,2438,21618,1,
+        0,0,0,2440,21620,1,0,0,0,2442,21622,1,0,0,0,2444,2446,3,2276,1138,
+        0,2445,2447,5,2472,0,0,2446,2445,1,0,0,0,2446,2447,1,0,0,0,2447,
+        2449,1,0,0,0,2448,2444,1,0,0,0,2449,2452,1,0,0,0,2450,2448,1,0,0,
+        0,2450,2451,1,0,0,0,2451,2465,1,0,0,0,2452,2450,1,0,0,0,2453,2459,
+        3,2,1,0,2454,2455,3,4,2,0,2455,2456,3,2,1,0,2456,2458,1,0,0,0,2457,
+        2454,1,0,0,0,2458,2461,1,0,0,0,2459,2457,1,0,0,0,2459,2460,1,0,0,
+        0,2460,2463,1,0,0,0,2461,2459,1,0,0,0,2462,2464,3,4,2,0,2463,2462,
+        1,0,0,0,2463,2464,1,0,0,0,2464,2466,1,0,0,0,2465,2453,1,0,0,0,2465,
+        2466,1,0,0,0,2466,2467,1,0,0,0,2467,2468,5,0,0,1,2468,1,1,0,0,0,
+        2469,2470,3,6,3,0,2470,2471,6,1,-1,0,2471,2479,1,0,0,0,2472,2473,
+        3,8,4,0,2473,2474,6,1,-1,0,2474,2479,1,0,0,0,2475,2476,3,2276,1138,
+        0,2476,2477,6,1,-1,0,2477,2479,1,0,0,0,2478,2469,1,0,0,0,2478,2472,
+        1,0,0,0,2478,2475,1,0,0,0,2479,3,1,0,0,0,2480,2487,5,2472,0,0,2481,
+        2482,5,2472,0,0,2482,2483,4,2,0,0,2483,2487,5,2456,0,0,2484,2485,
+        4,2,1,0,2485,2487,5,2456,0,0,2486,2480,1,0,0,0,2486,2481,1,0,0,0,
+        2486,2484,1,0,0,0,2487,5,1,0,0,0,2488,2496,3,1738,869,0,2489,2496,
+        3,110,55,0,2490,2496,3,186,93,0,2491,2496,3,162,81,0,2492,2496,3,
+        164,82,0,2493,2496,3,212,106,0,2494,2496,3,268,134,0,2495,2488,1,
+        0,0,0,2495,2489,1,0,0,0,2495,2490,1,0,0,0,2495,2491,1,0,0,0,2495,
+        2492,1,0,0,0,2495,2493,1,0,0,0,2495,2494,1,0,0,0,2496,7,1,0,0,0,
+        2497,2633,3,1340,670,0,2498,2633,3,1350,675,0,2499,2633,3,1352,676,
+        0,2500,2633,3,1354,677,0,2501,2633,3,1380,690,0,2502,2633,3,1488,
+        744,0,2503,2633,3,830,415,0,2504,2633,3,10,5,0,2505,2633,3,100,50,
+        0,2506,2633,3,104,52,0,2507,2633,3,102,51,0,2508,2633,3,526,263,
+        0,2509,2633,3,566,283,0,2510,2633,3,106,53,0,2511,2633,3,806,403,
+        0,2512,2633,3,138,69,0,2513,2633,3,944,472,0,2514,2633,3,954,477,
+        0,2515,2633,3,970,485,0,2516,2633,3,988,494,0,2517,2633,3,134,67,
+        0,2518,2633,3,160,80,0,2519,2633,3,174,87,0,2520,2633,3,180,90,0,
+        2521,2633,3,188,94,0,2522,2633,3,1534,767,0,2523,2633,3,192,96,0,
+        2524,2633,3,330,165,0,2525,2633,3,332,166,0,2526,2633,3,1324,662,
+        0,2527,2633,3,1538,769,0,2528,2633,3,876,438,0,2529,2633,3,1526,
+        763,0,2530,2633,3,210,105,0,2531,2633,3,246,123,0,2532,2633,3,570,
+        285,0,2533,2633,3,844,422,0,2534,2633,3,1830,915,0,2535,2633,3,342,
+        171,0,2536,2633,3,392,196,0,2537,2633,3,418,209,0,2538,2633,3,1030,
+        515,0,2539,2633,3,1026,513,0,2540,2633,3,440,220,0,2541,2633,3,1494,
+        747,0,2542,2633,3,1496,748,0,2543,2633,3,1522,761,0,2544,2633,3,
+        794,397,0,2545,2633,3,796,398,0,2546,2633,3,450,225,0,2547,2633,
+        3,454,227,0,2548,2633,3,456,228,0,2549,2633,3,462,231,0,2550,2633,
+        3,474,237,0,2551,2633,3,802,401,0,2552,2633,3,812,406,0,2553,2633,
+        3,814,407,0,2554,2633,3,1038,519,0,2555,2633,3,1010,505,0,2556,2633,
+        3,962,481,0,2557,2633,3,968,484,0,2558,2633,3,992,496,0,2559,2633,
+        3,1044,522,0,2560,2633,3,200,100,0,2561,2633,3,1032,516,0,2562,2633,
+        3,1046,523,0,2563,2633,3,1048,524,0,2564,2633,3,206,103,0,2565,2633,
+        3,336,168,0,2566,2633,3,1330,665,0,2567,2633,3,1326,663,0,2568,2633,
+        3,1050,525,0,2569,2633,3,892,446,0,2570,2633,3,910,455,0,2571,2633,
+        3,266,133,0,2572,2633,3,568,284,0,2573,2633,3,848,424,0,2574,2633,
+        3,1356,678,0,2575,2633,3,1358,679,0,2576,2633,3,1360,680,0,2577,
+        2633,3,1364,682,0,2578,2633,3,1366,683,0,2579,2633,3,1520,760,0,
+        2580,2633,3,1524,762,0,2581,2633,3,1368,684,0,2582,2633,3,1370,685,
+        0,2583,2633,3,1372,686,0,2584,2633,3,1362,681,0,2585,2633,3,98,49,
+        0,2586,2633,3,804,402,0,2587,2633,3,758,379,0,2588,2633,3,762,381,
+        0,2589,2633,3,764,382,0,2590,2633,3,808,404,0,2591,2633,3,810,405,
+        0,2592,2633,3,156,78,0,2593,2633,3,1022,511,0,2594,2633,3,1024,512,
+        0,2595,2633,3,972,486,0,2596,2633,3,990,495,0,2597,2633,3,190,95,
+        0,2598,2633,3,158,79,0,2599,2633,3,176,88,0,2600,2633,3,178,89,0,
+        2601,2633,3,194,97,0,2602,2633,3,198,99,0,2603,2633,3,196,98,0,2604,
+        2633,3,328,164,0,2605,2633,3,1328,664,0,2606,2633,3,1308,654,0,2607,
+        2633,3,1310,655,0,2608,2633,3,1312,656,0,2609,2633,3,208,104,0,2610,
+        2633,3,244,122,0,2611,2633,3,572,286,0,2612,2633,3,1316,658,0,2613,
+        2633,3,608,304,0,2614,2633,3,684,342,0,2615,2633,3,702,351,0,2616,
+        2633,3,732,366,0,2617,2633,3,1318,659,0,2618,2633,3,1338,669,0,2619,
+        2633,3,1336,668,0,2620,2633,3,1856,928,0,2621,2633,3,760,380,0,2622,
+        2633,3,766,383,0,2623,2633,3,776,388,0,2624,2633,3,772,386,0,2625,
+        2633,3,770,385,0,2626,2633,3,774,387,0,2627,2633,3,780,390,0,2628,
+        2633,3,1870,935,0,2629,2633,3,1374,687,0,2630,2633,3,1306,653,0,
+        2631,2633,3,728,364,0,2632,2497,1,0,0,0,2632,2498,1,0,0,0,2632,2499,
+        1,0,0,0,2632,2500,1,0,0,0,2632,2501,1,0,0,0,2632,2502,1,0,0,0,2632,
+        2503,1,0,0,0,2632,2504,1,0,0,0,2632,2505,1,0,0,0,2632,2506,1,0,0,
+        0,2632,2507,1,0,0,0,2632,2508,1,0,0,0,2632,2509,1,0,0,0,2632,2510,
+        1,0,0,0,2632,2511,1,0,0,0,2632,2512,1,0,0,0,2632,2513,1,0,0,0,2632,
+        2514,1,0,0,0,2632,2515,1,0,0,0,2632,2516,1,0,0,0,2632,2517,1,0,0,
+        0,2632,2518,1,0,0,0,2632,2519,1,0,0,0,2632,2520,1,0,0,0,2632,2521,
+        1,0,0,0,2632,2522,1,0,0,0,2632,2523,1,0,0,0,2632,2524,1,0,0,0,2632,
+        2525,1,0,0,0,2632,2526,1,0,0,0,2632,2527,1,0,0,0,2632,2528,1,0,0,
+        0,2632,2529,1,0,0,0,2632,2530,1,0,0,0,2632,2531,1,0,0,0,2632,2532,
+        1,0,0,0,2632,2533,1,0,0,0,2632,2534,1,0,0,0,2632,2535,1,0,0,0,2632,
+        2536,1,0,0,0,2632,2537,1,0,0,0,2632,2538,1,0,0,0,2632,2539,1,0,0,
+        0,2632,2540,1,0,0,0,2632,2541,1,0,0,0,2632,2542,1,0,0,0,2632,2543,
+        1,0,0,0,2632,2544,1,0,0,0,2632,2545,1,0,0,0,2632,2546,1,0,0,0,2632,
+        2547,1,0,0,0,2632,2548,1,0,0,0,2632,2549,1,0,0,0,2632,2550,1,0,0,
+        0,2632,2551,1,0,0,0,2632,2552,1,0,0,0,2632,2553,1,0,0,0,2632,2554,
+        1,0,0,0,2632,2555,1,0,0,0,2632,2556,1,0,0,0,2632,2557,1,0,0,0,2632,
+        2558,1,0,0,0,2632,2559,1,0,0,0,2632,2560,1,0,0,0,2632,2561,1,0,0,
+        0,2632,2562,1,0,0,0,2632,2563,1,0,0,0,2632,2564,1,0,0,0,2632,2565,
+        1,0,0,0,2632,2566,1,0,0,0,2632,2567,1,0,0,0,2632,2568,1,0,0,0,2632,
+        2569,1,0,0,0,2632,2570,1,0,0,0,2632,2571,1,0,0,0,2632,2572,1,0,0,
+        0,2632,2573,1,0,0,0,2632,2574,1,0,0,0,2632,2575,1,0,0,0,2632,2576,
+        1,0,0,0,2632,2577,1,0,0,0,2632,2578,1,0,0,0,2632,2579,1,0,0,0,2632,
+        2580,1,0,0,0,2632,2581,1,0,0,0,2632,2582,1,0,0,0,2632,2583,1,0,0,
+        0,2632,2584,1,0,0,0,2632,2585,1,0,0,0,2632,2586,1,0,0,0,2632,2587,
+        1,0,0,0,2632,2588,1,0,0,0,2632,2589,1,0,0,0,2632,2590,1,0,0,0,2632,
+        2591,1,0,0,0,2632,2592,1,0,0,0,2632,2593,1,0,0,0,2632,2594,1,0,0,
+        0,2632,2595,1,0,0,0,2632,2596,1,0,0,0,2632,2597,1,0,0,0,2632,2598,
+        1,0,0,0,2632,2599,1,0,0,0,2632,2600,1,0,0,0,2632,2601,1,0,0,0,2632,
+        2602,1,0,0,0,2632,2603,1,0,0,0,2632,2604,1,0,0,0,2632,2605,1,0,0,
+        0,2632,2606,1,0,0,0,2632,2607,1,0,0,0,2632,2608,1,0,0,0,2632,2609,
+        1,0,0,0,2632,2610,1,0,0,0,2632,2611,1,0,0,0,2632,2612,1,0,0,0,2632,
+        2613,1,0,0,0,2632,2614,1,0,0,0,2632,2615,1,0,0,0,2632,2616,1,0,0,
+        0,2632,2617,1,0,0,0,2632,2618,1,0,0,0,2632,2619,1,0,0,0,2632,2620,
+        1,0,0,0,2632,2621,1,0,0,0,2632,2622,1,0,0,0,2632,2623,1,0,0,0,2632,
+        2624,1,0,0,0,2632,2625,1,0,0,0,2632,2626,1,0,0,0,2632,2627,1,0,0,
+        0,2632,2628,1,0,0,0,2632,2629,1,0,0,0,2632,2630,1,0,0,0,2632,2631,
+        1,0,0,0,2633,9,1,0,0,0,2634,2635,5,42,0,0,2635,2689,5,441,0,0,2636,
+        2671,3,2430,1215,0,2637,2640,3,12,6,0,2638,2640,3,14,7,0,2639,2637,
+        1,0,0,0,2639,2638,1,0,0,0,2640,2641,1,0,0,0,2641,2639,1,0,0,0,2641,
+        2642,1,0,0,0,2642,2645,1,0,0,0,2643,2645,3,16,8,0,2644,2639,1,0,
+        0,0,2644,2643,1,0,0,0,2645,2647,1,0,0,0,2646,2648,3,30,15,0,2647,
+        2646,1,0,0,0,2647,2648,1,0,0,0,2648,2672,1,0,0,0,2649,2670,3,18,
+        9,0,2650,2670,3,22,11,0,2651,2670,3,24,12,0,2652,2670,3,26,13,0,
+        2653,2670,3,30,15,0,2654,2670,3,34,17,0,2655,2670,3,36,18,0,2656,
+        2670,3,46,23,0,2657,2670,3,50,25,0,2658,2670,3,52,26,0,2659,2670,
+        3,58,29,0,2660,2670,3,60,30,0,2661,2670,3,62,31,0,2662,2670,3,64,
+        32,0,2663,2670,3,66,33,0,2664,2670,3,68,34,0,2665,2670,3,70,35,0,
+        2666,2670,3,72,36,0,2667,2670,3,74,37,0,2668,2670,3,80,40,0,2669,
+        2649,1,0,0,0,2669,2650,1,0,0,0,2669,2651,1,0,0,0,2669,2652,1,0,0,
+        0,2669,2653,1,0,0,0,2669,2654,1,0,0,0,2669,2655,1,0,0,0,2669,2656,
+        1,0,0,0,2669,2657,1,0,0,0,2669,2658,1,0,0,0,2669,2659,1,0,0,0,2669,
+        2660,1,0,0,0,2669,2661,1,0,0,0,2669,2662,1,0,0,0,2669,2663,1,0,0,
+        0,2669,2664,1,0,0,0,2669,2665,1,0,0,0,2669,2666,1,0,0,0,2669,2667,
+        1,0,0,0,2669,2668,1,0,0,0,2670,2672,1,0,0,0,2671,2644,1,0,0,0,2671,
+        2669,1,0,0,0,2672,2690,1,0,0,0,2673,2678,3,2430,1215,0,2674,2675,
+        5,2455,0,0,2675,2677,3,2430,1215,0,2676,2674,1,0,0,0,2677,2680,1,
+        0,0,0,2678,2676,1,0,0,0,2678,2679,1,0,0,0,2679,2683,1,0,0,0,2680,
+        2678,1,0,0,0,2681,2683,5,38,0,0,2682,2673,1,0,0,0,2682,2681,1,0,
+        0,0,2683,2687,1,0,0,0,2684,2688,3,92,46,0,2685,2688,3,94,47,0,2686,
+        2688,3,96,48,0,2687,2684,1,0,0,0,2687,2685,1,0,0,0,2687,2686,1,0,
+        0,0,2688,2690,1,0,0,0,2689,2636,1,0,0,0,2689,2682,1,0,0,0,2690,11,
+        1,0,0,0,2691,2712,5,21,0,0,2692,2693,5,1690,0,0,2693,2695,3,2430,
+        1215,0,2694,2692,1,0,0,0,2694,2695,1,0,0,0,2695,2697,1,0,0,0,2696,
+        2698,3,90,45,0,2697,2696,1,0,0,0,2697,2698,1,0,0,0,2698,2701,1,0,
+        0,0,2699,2700,5,573,0,0,2700,2702,3,2430,1215,0,2701,2699,1,0,0,
+        0,2701,2702,1,0,0,0,2702,2703,1,0,0,0,2703,2704,5,440,0,0,2704,2709,
+        3,452,226,0,2705,2706,5,2455,0,0,2706,2708,3,452,226,0,2707,2705,
+        1,0,0,0,2708,2711,1,0,0,0,2709,2707,1,0,0,0,2709,2710,1,0,0,0,2710,
+        2713,1,0,0,0,2711,2709,1,0,0,0,2712,2694,1,0,0,0,2713,2714,1,0,0,
+        0,2714,2712,1,0,0,0,2714,2715,1,0,0,0,2715,13,1,0,0,0,2716,2755,
+        5,469,0,0,2717,2719,3,90,45,0,2718,2717,1,0,0,0,2718,2719,1,0,0,
+        0,2719,2720,1,0,0,0,2720,2721,5,440,0,0,2721,2723,3,2430,1215,0,
+        2722,2724,3,44,22,0,2723,2722,1,0,0,0,2723,2724,1,0,0,0,2724,2732,
+        1,0,0,0,2725,2726,5,2455,0,0,2726,2728,3,2430,1215,0,2727,2729,3,
+        44,22,0,2728,2727,1,0,0,0,2728,2729,1,0,0,0,2729,2731,1,0,0,0,2730,
+        2725,1,0,0,0,2731,2734,1,0,0,0,2732,2730,1,0,0,0,2732,2733,1,0,0,
+        0,2733,2756,1,0,0,0,2734,2732,1,0,0,0,2735,2736,5,443,0,0,2736,2738,
+        5,739,0,0,2737,2739,3,90,45,0,2738,2737,1,0,0,0,2738,2739,1,0,0,
+        0,2739,2740,1,0,0,0,2740,2741,5,573,0,0,2741,2743,3,2430,1215,0,
+        2742,2744,3,44,22,0,2743,2742,1,0,0,0,2743,2744,1,0,0,0,2744,2752,
+        1,0,0,0,2745,2746,5,2455,0,0,2746,2748,3,2430,1215,0,2747,2749,3,
+        44,22,0,2748,2747,1,0,0,0,2748,2749,1,0,0,0,2749,2751,1,0,0,0,2750,
+        2745,1,0,0,0,2751,2754,1,0,0,0,2752,2750,1,0,0,0,2752,2753,1,0,0,
+        0,2753,2756,1,0,0,0,2754,2752,1,0,0,0,2755,2718,1,0,0,0,2755,2735,
+        1,0,0,0,2756,15,1,0,0,0,2757,2758,5,1569,0,0,2758,2761,5,38,0,0,
+        2759,2760,5,1701,0,0,2760,2762,3,1188,594,0,2761,2759,1,0,0,0,2761,
+        2762,1,0,0,0,2762,17,1,0,0,0,2763,2764,5,1564,0,0,2764,2765,5,440,
+        0,0,2765,2766,3,2430,1215,0,2766,2767,5,2310,0,0,2767,2769,5,2445,
+        0,0,2768,2770,3,44,22,0,2769,2768,1,0,0,0,2769,2770,1,0,0,0,2770,
+        2780,1,0,0,0,2771,2772,5,2455,0,0,2772,2773,3,2430,1215,0,2773,2774,
+        5,2310,0,0,2774,2776,5,2445,0,0,2775,2777,3,44,22,0,2776,2775,1,
+        0,0,0,2776,2777,1,0,0,0,2777,2779,1,0,0,0,2778,2771,1,0,0,0,2779,
+        2782,1,0,0,0,2780,2778,1,0,0,0,2780,2781,1,0,0,0,2781,2785,1,0,0,
+        0,2782,2780,1,0,0,0,2783,2784,5,1426,0,0,2784,2786,3,2422,1211,0,
+        2785,2783,1,0,0,0,2785,2786,1,0,0,0,2786,2788,1,0,0,0,2787,2789,
+        3,20,10,0,2788,2787,1,0,0,0,2788,2789,1,0,0,0,2789,19,1,0,0,0,2790,
+        2791,7,0,0,0,2791,21,1,0,0,0,2792,2809,5,1561,0,0,2793,2794,5,440,
+        0,0,2794,2795,3,2430,1215,0,2795,2796,5,2143,0,0,2796,2804,3,2430,
+        1215,0,2797,2798,5,2455,0,0,2798,2799,3,2430,1215,0,2799,2800,5,
+        2143,0,0,2800,2801,3,2430,1215,0,2801,2803,1,0,0,0,2802,2797,1,0,
+        0,0,2803,2806,1,0,0,0,2804,2802,1,0,0,0,2804,2805,1,0,0,0,2805,2810,
+        1,0,0,0,2806,2804,1,0,0,0,2807,2808,5,443,0,0,2808,2810,5,38,0,0,
+        2809,2793,1,0,0,0,2809,2807,1,0,0,0,2810,23,1,0,0,0,2811,2843,5,
+        1258,0,0,2812,2814,3,90,45,0,2813,2812,1,0,0,0,2813,2814,1,0,0,0,
+        2814,2815,1,0,0,0,2815,2816,5,440,0,0,2816,2821,3,2430,1215,0,2817,
+        2818,5,2455,0,0,2818,2820,3,2430,1215,0,2819,2817,1,0,0,0,2820,2823,
+        1,0,0,0,2821,2819,1,0,0,0,2821,2822,1,0,0,0,2822,2839,1,0,0,0,2823,
+        2821,1,0,0,0,2824,2825,5,443,0,0,2825,2827,5,739,0,0,2826,2828,3,
+        90,45,0,2827,2826,1,0,0,0,2827,2828,1,0,0,0,2828,2829,1,0,0,0,2829,
+        2830,5,573,0,0,2830,2835,3,2430,1215,0,2831,2832,5,2455,0,0,2832,
+        2834,3,2430,1215,0,2833,2831,1,0,0,0,2834,2837,1,0,0,0,2835,2833,
+        1,0,0,0,2835,2836,1,0,0,0,2836,2839,1,0,0,0,2837,2835,1,0,0,0,2838,
+        2813,1,0,0,0,2838,2824,1,0,0,0,2839,2840,1,0,0,0,2840,2838,1,0,0,
+        0,2840,2841,1,0,0,0,2841,2844,1,0,0,0,2842,2844,5,38,0,0,2843,2838,
+        1,0,0,0,2843,2842,1,0,0,0,2844,2847,1,0,0,0,2845,2846,5,1426,0,0,
+        2846,2848,3,2422,1211,0,2847,2845,1,0,0,0,2847,2848,1,0,0,0,2848,
+        2850,1,0,0,0,2849,2851,3,20,10,0,2850,2849,1,0,0,0,2850,2851,1,0,
+        0,0,2851,25,1,0,0,0,2852,2879,5,1245,0,0,2853,2855,3,90,45,0,2854,
+        2853,1,0,0,0,2854,2855,1,0,0,0,2855,2856,1,0,0,0,2856,2857,5,440,
+        0,0,2857,2862,3,2430,1215,0,2858,2859,5,2455,0,0,2859,2861,3,2430,
+        1215,0,2860,2858,1,0,0,0,2861,2864,1,0,0,0,2862,2860,1,0,0,0,2862,
+        2863,1,0,0,0,2863,2880,1,0,0,0,2864,2862,1,0,0,0,2865,2866,5,443,
+        0,0,2866,2868,5,739,0,0,2867,2869,3,90,45,0,2868,2867,1,0,0,0,2868,
+        2869,1,0,0,0,2869,2870,1,0,0,0,2870,2871,5,573,0,0,2871,2876,3,2430,
+        1215,0,2872,2873,5,2455,0,0,2873,2875,3,2430,1215,0,2874,2872,1,
+        0,0,0,2875,2878,1,0,0,0,2876,2874,1,0,0,0,2876,2877,1,0,0,0,2877,
+        2880,1,0,0,0,2878,2876,1,0,0,0,2879,2854,1,0,0,0,2879,2865,1,0,0,
+        0,2880,2882,1,0,0,0,2881,2883,3,28,14,0,2882,2881,1,0,0,0,2882,2883,
+        1,0,0,0,2883,27,1,0,0,0,2884,2885,5,469,0,0,2885,2886,5,33,0,0,2886,
+        2887,3,2422,1211,0,2887,2888,7,1,0,0,2888,29,1,0,0,0,2889,2909,5,
+        1512,0,0,2890,2892,7,2,0,0,2891,2893,3,32,16,0,2892,2891,1,0,0,0,
+        2893,2894,1,0,0,0,2894,2892,1,0,0,0,2894,2895,1,0,0,0,2895,2897,
+        1,0,0,0,2896,2890,1,0,0,0,2896,2897,1,0,0,0,2897,2898,1,0,0,0,2898,
+        2899,5,1426,0,0,2899,2900,3,2422,1211,0,2900,2902,1,0,0,0,2901,2903,
+        7,0,0,0,2902,2901,1,0,0,0,2902,2903,1,0,0,0,2903,2910,1,0,0,0,2904,
+        2905,5,981,0,0,2905,2907,5,1426,0,0,2906,2908,3,2422,1211,0,2907,
+        2906,1,0,0,0,2907,2908,1,0,0,0,2908,2910,1,0,0,0,2909,2896,1,0,0,
+        0,2909,2904,1,0,0,0,2910,31,1,0,0,0,2911,2912,3,2430,1215,0,2912,
+        33,1,0,0,0,2913,2915,5,200,0,0,2914,2916,5,38,0,0,2915,2914,1,0,
+        0,0,2915,2916,1,0,0,0,2916,2918,1,0,0,0,2917,2919,7,3,0,0,2918,2917,
+        1,0,0,0,2918,2919,1,0,0,0,2919,35,1,0,0,0,2920,2921,7,4,0,0,2921,
+        2922,5,2092,0,0,2922,2923,3,2430,1215,0,2923,2930,3,38,19,0,2924,
+        2925,5,2455,0,0,2925,2926,3,2430,1215,0,2926,2927,3,38,19,0,2927,
+        2929,1,0,0,0,2928,2924,1,0,0,0,2929,2932,1,0,0,0,2930,2928,1,0,0,
+        0,2930,2931,1,0,0,0,2931,2944,1,0,0,0,2932,2930,1,0,0,0,2933,2934,
+        5,469,0,0,2934,2935,5,2092,0,0,2935,2940,3,2430,1215,0,2936,2937,
+        5,2455,0,0,2937,2939,3,2430,1215,0,2938,2936,1,0,0,0,2939,2942,1,
+        0,0,0,2940,2938,1,0,0,0,2940,2941,1,0,0,0,2941,2944,1,0,0,0,2942,
+        2940,1,0,0,0,2943,2920,1,0,0,0,2943,2933,1,0,0,0,2944,37,1,0,0,0,
+        2945,2946,5,84,0,0,2946,2948,5,2449,0,0,2947,2949,3,40,20,0,2948,
+        2947,1,0,0,0,2948,2949,1,0,0,0,2949,2951,1,0,0,0,2950,2952,3,42,
+        21,0,2951,2950,1,0,0,0,2951,2952,1,0,0,0,2952,2953,1,0,0,0,2953,
+        2954,5,2450,0,0,2954,39,1,0,0,0,2955,2956,7,5,0,0,2956,41,1,0,0,
+        0,2957,2958,7,6,0,0,2958,43,1,0,0,0,2959,2960,7,7,0,0,2960,45,1,
+        0,0,0,2961,2962,5,21,0,0,2962,2963,5,426,0,0,2963,2968,3,1470,735,
+        0,2964,2965,5,2455,0,0,2965,2967,3,1470,735,0,2966,2964,1,0,0,0,
+        2967,2970,1,0,0,0,2968,2966,1,0,0,0,2968,2969,1,0,0,0,2969,3003,
+        1,0,0,0,2970,2968,1,0,0,0,2971,2972,5,469,0,0,2972,2973,5,426,0,
+        0,2973,2975,3,1470,735,0,2974,2976,3,44,22,0,2975,2974,1,0,0,0,2975,
+        2976,1,0,0,0,2976,2984,1,0,0,0,2977,2978,5,2455,0,0,2978,2980,3,
+        1470,735,0,2979,2981,3,44,22,0,2980,2979,1,0,0,0,2980,2981,1,0,0,
+        0,2981,2983,1,0,0,0,2982,2977,1,0,0,0,2983,2986,1,0,0,0,2984,2982,
+        1,0,0,0,2984,2985,1,0,0,0,2985,3003,1,0,0,0,2986,2984,1,0,0,0,2987,
+        2988,5,1561,0,0,2988,2989,5,426,0,0,2989,2990,3,48,24,0,2990,2991,
+        5,2143,0,0,2991,2999,3,48,24,0,2992,2993,5,2455,0,0,2993,2994,3,
+        48,24,0,2994,2995,5,2143,0,0,2995,2996,3,48,24,0,2996,2998,1,0,0,
+        0,2997,2992,1,0,0,0,2998,3001,1,0,0,0,2999,2997,1,0,0,0,2999,3000,
+        1,0,0,0,3000,3003,1,0,0,0,3001,2999,1,0,0,0,3002,2961,1,0,0,0,3002,
+        2971,1,0,0,0,3002,2987,1,0,0,0,3003,47,1,0,0,0,3004,3005,5,2445,
+        0,0,3005,49,1,0,0,0,3006,3007,5,21,0,0,3007,3008,5,37,0,0,3008,3009,
+        5,2445,0,0,3009,3010,5,621,0,0,3010,3017,5,2445,0,0,3011,3012,5,
+        2455,0,0,3012,3013,5,2445,0,0,3013,3014,5,621,0,0,3014,3016,5,2445,
+        0,0,3015,3011,1,0,0,0,3016,3019,1,0,0,0,3017,3015,1,0,0,0,3017,3018,
+        1,0,0,0,3018,3045,1,0,0,0,3019,3017,1,0,0,0,3020,3021,5,469,0,0,
+        3021,3022,5,37,0,0,3022,3027,5,2445,0,0,3023,3024,5,2455,0,0,3024,
+        3026,5,2445,0,0,3025,3023,1,0,0,0,3026,3029,1,0,0,0,3027,3025,1,
+        0,0,0,3027,3028,1,0,0,0,3028,3045,1,0,0,0,3029,3027,1,0,0,0,3030,
+        3031,5,1561,0,0,3031,3032,5,37,0,0,3032,3033,5,2445,0,0,3033,3034,
+        5,2143,0,0,3034,3041,5,2445,0,0,3035,3036,5,2455,0,0,3036,3037,5,
+        2445,0,0,3037,3038,5,2143,0,0,3038,3040,5,2445,0,0,3039,3035,1,0,
+        0,0,3040,3043,1,0,0,0,3041,3039,1,0,0,0,3041,3042,1,0,0,0,3042,3045,
+        1,0,0,0,3043,3041,1,0,0,0,3044,3006,1,0,0,0,3044,3020,1,0,0,0,3044,
+        3030,1,0,0,0,3045,51,1,0,0,0,3046,3058,3,54,27,0,3047,3058,3,56,
+        28,0,3048,3049,5,1569,0,0,3049,3050,5,2293,0,0,3050,3051,3,2430,
+        1215,0,3051,3052,5,1701,0,0,3052,3053,3,1188,594,0,3053,3058,1,0,
+        0,0,3054,3055,5,469,0,0,3055,3056,5,2293,0,0,3056,3058,3,2430,1215,
+        0,3057,3046,1,0,0,0,3057,3047,1,0,0,0,3057,3048,1,0,0,0,3057,3054,
+        1,0,0,0,3058,53,1,0,0,0,3059,3060,5,21,0,0,3060,3061,5,2293,0,0,
+        3061,3062,3,2430,1215,0,3062,3063,5,1701,0,0,3063,3065,3,1188,594,
+        0,3064,3066,3,40,20,0,3065,3064,1,0,0,0,3065,3066,1,0,0,0,3066,3071,
+        1,0,0,0,3067,3068,5,1771,0,0,3068,3069,3,2422,1211,0,3069,3070,7,
+        8,0,0,3070,3072,1,0,0,0,3071,3067,1,0,0,0,3071,3072,1,0,0,0,3072,
+        3075,1,0,0,0,3073,3074,5,1770,0,0,3074,3076,3,2422,1211,0,3075,3073,
+        1,0,0,0,3075,3076,1,0,0,0,3076,55,1,0,0,0,3077,3078,5,981,0,0,3078,
+        3079,5,2293,0,0,3079,3082,3,2430,1215,0,3080,3081,5,990,0,0,3081,
+        3083,5,2445,0,0,3082,3080,1,0,0,0,3082,3083,1,0,0,0,3083,3086,1,
+        0,0,0,3084,3085,5,2218,0,0,3085,3087,5,2445,0,0,3086,3084,1,0,0,
+        0,3086,3087,1,0,0,0,3087,57,1,0,0,0,3088,3089,5,1673,0,0,3089,3090,
+        5,83,0,0,3090,3091,5,2445,0,0,3091,3092,5,2474,0,0,3092,3093,5,2445,
+        0,0,3093,59,1,0,0,0,3094,3095,5,469,0,0,3095,3096,5,590,0,0,3096,
+        3101,3,1470,735,0,3097,3098,5,2455,0,0,3098,3100,3,1470,735,0,3099,
+        3097,1,0,0,0,3100,3103,1,0,0,0,3101,3099,1,0,0,0,3101,3102,1,0,0,
+        0,3102,61,1,0,0,0,3103,3101,1,0,0,0,3104,3105,5,300,0,0,3105,3106,
+        5,1526,0,0,3106,3107,5,2143,0,0,3107,3108,5,610,0,0,3108,63,1,0,
+        0,0,3109,3110,5,21,0,0,3110,3111,5,2235,0,0,3111,3112,5,2445,0,0,
+        3112,3113,5,2310,0,0,3113,3114,5,937,0,0,3114,3119,5,2445,0,0,3115,
+        3116,5,2455,0,0,3116,3118,5,2445,0,0,3117,3115,1,0,0,0,3118,3121,
+        1,0,0,0,3119,3117,1,0,0,0,3119,3120,1,0,0,0,3120,3139,1,0,0,0,3121,
+        3119,1,0,0,0,3122,3123,5,981,0,0,3123,3124,5,2235,0,0,3124,3125,
+        5,2445,0,0,3125,3126,7,9,0,0,3126,3127,5,937,0,0,3127,3132,5,2445,
+        0,0,3128,3129,5,2455,0,0,3129,3131,5,2445,0,0,3130,3128,1,0,0,0,
+        3131,3134,1,0,0,0,3132,3130,1,0,0,0,3132,3133,1,0,0,0,3133,3139,
+        1,0,0,0,3134,3132,1,0,0,0,3135,3136,5,469,0,0,3136,3137,5,2235,0,
+        0,3137,3139,5,2445,0,0,3138,3109,1,0,0,0,3138,3122,1,0,0,0,3138,
+        3135,1,0,0,0,3139,65,1,0,0,0,3140,3141,5,21,0,0,3141,3142,5,2239,
+        0,0,3142,3147,5,2445,0,0,3143,3144,5,2455,0,0,3144,3146,5,2445,0,
+        0,3145,3143,1,0,0,0,3146,3149,1,0,0,0,3147,3145,1,0,0,0,3147,3148,
+        1,0,0,0,3148,3178,1,0,0,0,3149,3147,1,0,0,0,3150,3151,5,469,0,0,
+        3151,3152,5,2239,0,0,3152,3157,5,2445,0,0,3153,3154,5,2455,0,0,3154,
+        3156,5,2445,0,0,3155,3153,1,0,0,0,3156,3159,1,0,0,0,3157,3155,1,
+        0,0,0,3157,3158,1,0,0,0,3158,3161,1,0,0,0,3159,3157,1,0,0,0,3160,
+        3162,5,179,0,0,3161,3160,1,0,0,0,3161,3162,1,0,0,0,3162,3178,1,0,
+        0,0,3163,3164,5,1564,0,0,3164,3165,5,2239,0,0,3165,3166,5,2445,0,
+        0,3166,3167,5,2310,0,0,3167,3174,5,2445,0,0,3168,3169,5,2455,0,0,
+        3169,3170,5,2445,0,0,3170,3171,5,2310,0,0,3171,3173,5,2445,0,0,3172,
+        3168,1,0,0,0,3173,3176,1,0,0,0,3174,3172,1,0,0,0,3174,3175,1,0,0,
+        0,3175,3178,1,0,0,0,3176,3174,1,0,0,0,3177,3140,1,0,0,0,3177,3150,
+        1,0,0,0,3177,3163,1,0,0,0,3178,67,1,0,0,0,3179,3180,5,1673,0,0,3180,
+        3181,5,1390,0,0,3181,3182,7,10,0,0,3182,3186,5,2474,0,0,3183,3187,
+        5,1134,0,0,3184,3185,5,1507,0,0,3185,3187,7,11,0,0,3186,3183,1,0,
+        0,0,3186,3184,1,0,0,0,3187,3198,1,0,0,0,3188,3189,5,2455,0,0,3189,
+        3190,7,10,0,0,3190,3194,5,2474,0,0,3191,3195,5,1134,0,0,3192,3193,
+        5,1507,0,0,3193,3195,7,11,0,0,3194,3191,1,0,0,0,3194,3192,1,0,0,
+        0,3195,3197,1,0,0,0,3196,3188,1,0,0,0,3197,3200,1,0,0,0,3198,3196,
+        1,0,0,0,3198,3199,1,0,0,0,3199,3201,1,0,0,0,3200,3198,1,0,0,0,3201,
+        3202,5,621,0,0,3202,3203,5,590,0,0,3203,3208,5,2445,0,0,3204,3205,
+        5,2455,0,0,3205,3207,5,2445,0,0,3206,3204,1,0,0,0,3207,3210,1,0,
+        0,0,3208,3206,1,0,0,0,3208,3209,1,0,0,0,3209,69,1,0,0,0,3210,3208,
+        1,0,0,0,3211,3212,5,1673,0,0,3212,3213,5,1328,0,0,3213,3214,7,12,
+        0,0,3214,3215,5,2474,0,0,3215,3222,5,2445,0,0,3216,3217,5,2455,0,
+        0,3217,3218,7,12,0,0,3218,3219,5,2474,0,0,3219,3221,5,2445,0,0,3220,
+        3216,1,0,0,0,3221,3224,1,0,0,0,3222,3220,1,0,0,0,3222,3223,1,0,0,
+        0,3223,3225,1,0,0,0,3224,3222,1,0,0,0,3225,3226,5,621,0,0,3226,3227,
+        5,590,0,0,3227,3232,5,2445,0,0,3228,3229,5,2455,0,0,3229,3231,5,
+        2445,0,0,3230,3228,1,0,0,0,3231,3234,1,0,0,0,3232,3230,1,0,0,0,3232,
+        3233,1,0,0,0,3233,71,1,0,0,0,3234,3232,1,0,0,0,3235,3240,5,1631,
+        0,0,3236,3237,5,590,0,0,3237,3241,5,2445,0,0,3238,3239,5,440,0,0,
+        3239,3241,3,2430,1215,0,3240,3236,1,0,0,0,3240,3238,1,0,0,0,3240,
+        3241,1,0,0,0,3241,3243,1,0,0,0,3242,3244,7,3,0,0,3243,3242,1,0,0,
+        0,3243,3244,1,0,0,0,3244,3247,1,0,0,0,3245,3246,5,1426,0,0,3246,
+        3248,7,13,0,0,3247,3245,1,0,0,0,3247,3248,1,0,0,0,3248,3250,1,0,
+        0,0,3249,3251,3,20,10,0,3250,3249,1,0,0,0,3250,3251,1,0,0,0,3251,
+        3253,1,0,0,0,3252,3254,3,44,22,0,3253,3252,1,0,0,0,3253,3254,1,0,
+        0,0,3254,3256,1,0,0,0,3255,3257,5,1763,0,0,3256,3255,1,0,0,0,3256,
+        3257,1,0,0,0,3257,73,1,0,0,0,3258,3259,5,21,0,0,3259,3260,5,1493,
+        0,0,3260,3266,3,2430,1215,0,3261,3262,5,1673,0,0,3262,3263,3,76,
+        38,0,3263,3264,5,2474,0,0,3264,3265,3,78,39,0,3265,3267,1,0,0,0,
+        3266,3261,1,0,0,0,3266,3267,1,0,0,0,3267,3286,1,0,0,0,3268,3269,
+        5,981,0,0,3269,3270,5,1493,0,0,3270,3271,3,2430,1215,0,3271,3272,
+        5,1673,0,0,3272,3273,3,76,38,0,3273,3274,5,2474,0,0,3274,3275,3,
+        78,39,0,3275,3286,1,0,0,0,3276,3277,5,993,0,0,3277,3278,5,1493,0,
+        0,3278,3279,3,2430,1215,0,3279,3280,5,2143,0,0,3280,3281,3,2430,
+        1215,0,3281,3286,1,0,0,0,3282,3283,5,469,0,0,3283,3284,5,1493,0,
+        0,3284,3286,3,2430,1215,0,3285,3258,1,0,0,0,3285,3268,1,0,0,0,3285,
+        3276,1,0,0,0,3285,3282,1,0,0,0,3286,75,1,0,0,0,3287,3288,3,2430,
+        1215,0,3288,77,1,0,0,0,3289,3290,3,2430,1215,0,3290,79,1,0,0,0,3291,
+        3296,3,82,41,0,3292,3296,3,84,42,0,3293,3296,3,86,43,0,3294,3296,
+        3,88,44,0,3295,3291,1,0,0,0,3295,3292,1,0,0,0,3295,3293,1,0,0,0,
+        3295,3294,1,0,0,0,3296,81,1,0,0,0,3297,3298,5,21,0,0,3298,3299,5,
+        592,0,0,3299,3303,3,2430,1215,0,3300,3301,7,14,0,0,3301,3304,3,2430,
+        1215,0,3302,3304,5,2092,0,0,3303,3300,1,0,0,0,3303,3302,1,0,0,0,
+        3304,3308,1,0,0,0,3305,3306,5,629,0,0,3306,3307,5,2092,0,0,3307,
+        3309,3,2430,1215,0,3308,3305,1,0,0,0,3308,3309,1,0,0,0,3309,3314,
+        1,0,0,0,3310,3311,5,1673,0,0,3311,3312,5,2445,0,0,3312,3313,5,2474,
+        0,0,3313,3315,5,2445,0,0,3314,3310,1,0,0,0,3314,3315,1,0,0,0,3315,
+        83,1,0,0,0,3316,3317,5,981,0,0,3317,3318,5,592,0,0,3318,3319,3,2430,
+        1215,0,3319,3320,5,1673,0,0,3320,3321,5,2445,0,0,3321,3322,5,2474,
+        0,0,3322,3323,5,2445,0,0,3323,85,1,0,0,0,3324,3325,5,993,0,0,3325,
+        3326,5,590,0,0,3326,3327,5,2445,0,0,3327,3328,5,2143,0,0,3328,3329,
+        5,592,0,0,3329,3330,3,2430,1215,0,3330,87,1,0,0,0,3331,3332,5,469,
+        0,0,3332,3333,5,592,0,0,3333,3335,3,2430,1215,0,3334,3336,5,179,
+        0,0,3335,3334,1,0,0,0,3335,3336,1,0,0,0,3336,89,1,0,0,0,3337,3338,
+        7,15,0,0,3338,91,1,0,0,0,3339,3340,5,2181,0,0,3340,3341,5,443,0,
+        0,3341,93,1,0,0,0,3342,3344,5,989,0,0,3343,3345,7,16,0,0,3344,3343,
+        1,0,0,0,3344,3345,1,0,0,0,3345,3347,1,0,0,0,3346,3348,7,7,0,0,3347,
+        3346,1,0,0,0,3347,3348,1,0,0,0,3348,3354,1,0,0,0,3349,3351,5,444,
+        0,0,3350,3352,7,7,0,0,3351,3350,1,0,0,0,3351,3352,1,0,0,0,3352,3354,
+        1,0,0,0,3353,3342,1,0,0,0,3353,3349,1,0,0,0,3354,95,1,0,0,0,3355,
+        3356,7,17,0,0,3356,3366,5,2293,0,0,3357,3362,3,2430,1215,0,3358,
+        3359,5,2455,0,0,3359,3361,3,2430,1215,0,3360,3358,1,0,0,0,3361,3364,
+        1,0,0,0,3362,3360,1,0,0,0,3362,3363,1,0,0,0,3363,3367,1,0,0,0,3364,
+        3362,1,0,0,0,3365,3367,5,38,0,0,3366,3357,1,0,0,0,3366,3365,1,0,
+        0,0,3367,97,1,0,0,0,3368,3369,5,469,0,0,3369,3370,5,633,0,0,3370,
+        3371,3,2346,1173,0,3371,99,1,0,0,0,3372,3373,5,42,0,0,3373,3374,
+        5,606,0,0,3374,3375,5,64,0,0,3375,3405,3,2430,1215,0,3376,3377,5,
+        1673,0,0,3377,3406,5,389,0,0,3378,3379,7,4,0,0,3379,3380,5,2082,
+        0,0,3380,3382,3,2430,1215,0,3381,3383,3,458,229,0,3382,3381,1,0,
+        0,0,3382,3383,1,0,0,0,3383,3406,1,0,0,0,3384,3385,5,1560,0,0,3385,
+        3386,5,2082,0,0,3386,3406,3,2430,1215,0,3387,3388,5,981,0,0,3388,
+        3406,3,460,230,0,3389,3398,5,1477,0,0,3390,3399,5,38,0,0,3391,3396,
+        5,112,0,0,3392,3393,5,1629,0,0,3393,3397,3,2100,1050,0,3394,3395,
+        5,2110,0,0,3395,3397,3,2100,1050,0,3396,3392,1,0,0,0,3396,3394,1,
+        0,0,0,3397,3399,1,0,0,0,3398,3390,1,0,0,0,3398,3391,1,0,0,0,3399,
+        3406,1,0,0,0,3400,3402,5,1139,0,0,3401,3400,1,0,0,0,3401,3402,1,
+        0,0,0,3402,3403,1,0,0,0,3403,3404,5,1271,0,0,3404,3406,5,351,0,0,
+        3405,3376,1,0,0,0,3405,3378,1,0,0,0,3405,3384,1,0,0,0,3405,3387,
+        1,0,0,0,3405,3389,1,0,0,0,3405,3401,1,0,0,0,3406,101,1,0,0,0,3407,
+        3408,5,42,0,0,3408,3412,5,675,0,0,3409,3410,3,2312,1156,0,3410,3411,
+        5,2442,0,0,3411,3413,1,0,0,0,3412,3409,1,0,0,0,3412,3413,1,0,0,0,
+        3413,3414,1,0,0,0,3414,3419,3,2430,1215,0,3415,3416,5,1561,0,0,3416,
+        3417,5,2143,0,0,3417,3420,3,2430,1215,0,3418,3420,5,249,0,0,3419,
+        3415,1,0,0,0,3419,3418,1,0,0,0,3420,103,1,0,0,0,3421,3422,5,42,0,
+        0,3422,3423,5,633,0,0,3423,3440,3,2346,1173,0,3424,3441,5,482,0,
+        0,3425,3441,5,1133,0,0,3426,3428,5,249,0,0,3427,3429,5,378,0,0,3428,
+        3427,1,0,0,0,3428,3429,1,0,0,0,3429,3433,1,0,0,0,3430,3432,3,824,
+        412,0,3431,3430,1,0,0,0,3432,3435,1,0,0,0,3433,3431,1,0,0,0,3433,
+        3434,1,0,0,0,3434,3438,1,0,0,0,3435,3433,1,0,0,0,3436,3437,5,1589,
+        0,0,3437,3439,5,1675,0,0,3438,3436,1,0,0,0,3438,3439,1,0,0,0,3439,
+        3441,1,0,0,0,3440,3424,1,0,0,0,3440,3425,1,0,0,0,3440,3426,1,0,0,
+        0,3441,105,1,0,0,0,3442,3443,5,42,0,0,3443,3444,5,793,0,0,3444,3448,
+        7,18,0,0,3445,3446,3,2312,1156,0,3446,3447,5,2442,0,0,3447,3449,
+        1,0,0,0,3448,3445,1,0,0,0,3448,3449,1,0,0,0,3449,3450,1,0,0,0,3450,
+        3470,3,2430,1215,0,3451,3452,5,1571,0,0,3452,3464,5,2449,0,0,3453,
+        3454,5,2449,0,0,3454,3456,3,108,54,0,3455,3457,5,2455,0,0,3456,3455,
+        1,0,0,0,3456,3457,1,0,0,0,3457,3460,1,0,0,0,3458,3461,3,2312,1156,
+        0,3459,3461,5,2454,0,0,3460,3458,1,0,0,0,3460,3459,1,0,0,0,3461,
+        3462,1,0,0,0,3462,3463,5,2450,0,0,3463,3465,1,0,0,0,3464,3453,1,
+        0,0,0,3465,3466,1,0,0,0,3466,3464,1,0,0,0,3466,3467,1,0,0,0,3467,
+        3468,1,0,0,0,3468,3469,5,2450,0,0,3469,3471,1,0,0,0,3470,3451,1,
+        0,0,0,3470,3471,1,0,0,0,3471,3475,1,0,0,0,3472,3476,5,249,0,0,3473,
+        3476,5,1570,0,0,3474,3476,3,1740,870,0,3475,3472,1,0,0,0,3475,3473,
+        1,0,0,0,3475,3474,1,0,0,0,3476,107,1,0,0,0,3477,3478,7,19,0,0,3478,
+        109,1,0,0,0,3479,3482,5,321,0,0,3480,3481,5,1309,0,0,3481,3483,5,
+        1564,0,0,3482,3480,1,0,0,0,3482,3483,1,0,0,0,3483,3485,1,0,0,0,3484,
+        3486,7,20,0,0,3485,3484,1,0,0,0,3485,3486,1,0,0,0,3486,3487,1,0,
+        0,0,3487,3488,5,633,0,0,3488,3500,3,2346,1173,0,3489,3490,5,2449,
+        0,0,3490,3495,3,1756,878,0,3491,3492,5,2455,0,0,3492,3494,3,1756,
+        878,0,3493,3491,1,0,0,0,3494,3497,1,0,0,0,3495,3493,1,0,0,0,3495,
+        3496,1,0,0,0,3496,3498,1,0,0,0,3497,3495,1,0,0,0,3498,3499,5,2450,
+        0,0,3499,3501,1,0,0,0,3500,3489,1,0,0,0,3500,3501,1,0,0,0,3501,3502,
+        1,0,0,0,3502,3503,5,1588,0,0,3503,3507,3,2400,1200,0,3504,3505,5,
+        1683,0,0,3505,3506,5,2474,0,0,3506,3508,7,21,0,0,3507,3504,1,0,0,
+        0,3507,3508,1,0,0,0,3508,3518,1,0,0,0,3509,3517,3,1740,870,0,3510,
+        3517,3,120,60,0,3511,3517,3,122,61,0,3512,3517,3,114,57,0,3513,3517,
+        3,118,59,0,3514,3517,5,1396,0,0,3515,3517,5,420,0,0,3516,3509,1,
+        0,0,0,3516,3510,1,0,0,0,3516,3511,1,0,0,0,3516,3512,1,0,0,0,3516,
+        3513,1,0,0,0,3516,3514,1,0,0,0,3516,3515,1,0,0,0,3517,3520,1,0,0,
+        0,3518,3516,1,0,0,0,3518,3519,1,0,0,0,3519,3535,1,0,0,0,3520,3518,
+        1,0,0,0,3521,3530,7,22,0,0,3522,3524,5,382,0,0,3523,3522,1,0,0,0,
+        3523,3524,1,0,0,0,3524,3526,1,0,0,0,3525,3527,3,1760,880,0,3526,
+        3525,1,0,0,0,3526,3527,1,0,0,0,3527,3528,1,0,0,0,3528,3531,3,1840,
+        920,0,3529,3531,3,1742,871,0,3530,3523,1,0,0,0,3530,3529,1,0,0,0,
+        3531,3536,1,0,0,0,3532,3536,3,124,62,0,3533,3536,3,126,63,0,3534,
+        3536,3,112,56,0,3535,3521,1,0,0,0,3535,3532,1,0,0,0,3535,3533,1,
+        0,0,0,3535,3534,1,0,0,0,3536,111,1,0,0,0,3537,3538,5,1726,0,0,3538,
+        3539,5,786,0,0,3539,3540,5,113,0,0,3540,3541,5,1588,0,0,3541,3542,
+        3,2426,1213,0,3542,3543,5,2472,0,0,3543,3544,5,508,0,0,3544,113,
+        1,0,0,0,3545,3547,5,1333,0,0,3546,3548,3,116,58,0,3547,3546,1,0,
+        0,0,3547,3548,1,0,0,0,3548,115,1,0,0,0,3549,3550,5,2449,0,0,3550,
+        3551,5,1350,0,0,3551,3552,3,2100,1050,0,3552,3556,5,160,0,0,3553,
+        3557,5,55,0,0,3554,3555,7,23,0,0,3555,3557,3,2386,1193,0,3556,3553,
+        1,0,0,0,3556,3554,1,0,0,0,3557,3559,1,0,0,0,3558,3560,3,132,66,0,
+        3559,3558,1,0,0,0,3559,3560,1,0,0,0,3560,3561,1,0,0,0,3561,3562,
+        5,2450,0,0,3562,117,1,0,0,0,3563,3565,5,1581,0,0,3564,3566,3,130,
+        65,0,3565,3564,1,0,0,0,3565,3566,1,0,0,0,3566,3571,1,0,0,0,3567,
+        3568,5,2449,0,0,3568,3569,5,978,0,0,3569,3570,7,24,0,0,3570,3572,
+        5,2450,0,0,3571,3567,1,0,0,0,3571,3572,1,0,0,0,3572,119,1,0,0,0,
+        3573,3574,5,6,0,0,3574,3575,5,160,0,0,3575,3576,5,2449,0,0,3576,
+        3581,3,128,64,0,3577,3578,5,2455,0,0,3578,3580,3,128,64,0,3579,3577,
+        1,0,0,0,3580,3583,1,0,0,0,3581,3579,1,0,0,0,3581,3582,1,0,0,0,3582,
+        3584,1,0,0,0,3583,3581,1,0,0,0,3584,3585,5,2450,0,0,3585,121,1,0,
+        0,0,3586,3587,5,389,0,0,3587,3588,5,2375,0,0,3588,3589,5,2247,0,
+        0,3589,123,1,0,0,0,3590,3591,5,35,0,0,3591,3592,5,2248,0,0,3592,
+        3593,3,2318,1159,0,3593,125,1,0,0,0,3594,3597,5,1396,0,0,3595,3596,
+        7,25,0,0,3596,3598,5,2434,0,0,3597,3595,1,0,0,0,3597,3598,1,0,0,
+        0,3598,3599,1,0,0,0,3599,3600,5,2248,0,0,3600,3601,3,2318,1159,0,
+        3601,127,1,0,0,0,3602,3603,7,26,0,0,3603,3604,3,2346,1173,0,3604,
+        129,1,0,0,0,3605,3606,5,1554,0,0,3606,3607,5,2449,0,0,3607,3612,
+        3,2368,1184,0,3608,3609,5,2455,0,0,3609,3611,3,2368,1184,0,3610,
+        3608,1,0,0,0,3611,3614,1,0,0,0,3612,3610,1,0,0,0,3612,3613,1,0,0,
+        0,3613,3615,1,0,0,0,3614,3612,1,0,0,0,3615,3616,5,2450,0,0,3616,
+        131,1,0,0,0,3617,3618,7,27,0,0,3618,3619,3,2100,1050,0,3619,3620,
+        5,160,0,0,3620,3621,3,2386,1193,0,3621,133,1,0,0,0,3622,3623,5,42,
+        0,0,3623,3625,5,1317,0,0,3624,3626,7,28,0,0,3625,3624,1,0,0,0,3625,
+        3626,1,0,0,0,3626,3627,1,0,0,0,3627,3629,3,2430,1215,0,3628,3630,
+        3,136,68,0,3629,3628,1,0,0,0,3630,3631,1,0,0,0,3631,3629,1,0,0,0,
+        3631,3632,1,0,0,0,3632,135,1,0,0,0,3633,3644,5,1513,0,0,3634,3635,
+        5,1561,0,0,3635,3636,5,2143,0,0,3636,3644,3,2430,1215,0,3637,3638,
+        5,190,0,0,3638,3639,5,183,0,0,3639,3640,5,2143,0,0,3640,3644,3,2430,
+        1215,0,3641,3644,5,499,0,0,3642,3644,5,429,0,0,3643,3633,1,0,0,0,
+        3643,3634,1,0,0,0,3643,3637,1,0,0,0,3643,3641,1,0,0,0,3643,3642,
+        1,0,0,0,3644,137,1,0,0,0,3645,3646,5,42,0,0,3646,3647,5,879,0,0,
+        3647,3648,5,1465,0,0,3648,3652,3,2430,1215,0,3649,3653,3,140,70,
+        0,3650,3653,3,142,71,0,3651,3653,3,144,72,0,3652,3649,1,0,0,0,3652,
+        3650,1,0,0,0,3652,3651,1,0,0,0,3653,3657,1,0,0,0,3654,3655,5,2237,
+        0,0,3655,3656,5,2474,0,0,3656,3658,7,29,0,0,3657,3654,1,0,0,0,3657,
+        3658,1,0,0,0,3658,139,1,0,0,0,3659,3660,3,154,77,0,3660,3675,5,582,
+        0,0,3661,3662,5,2474,0,0,3662,3663,5,2449,0,0,3663,3664,3,152,76,
+        0,3664,3665,5,2450,0,0,3665,3676,1,0,0,0,3666,3673,5,38,0,0,3667,
+        3668,5,534,0,0,3668,3669,5,2474,0,0,3669,3670,5,2449,0,0,3670,3671,
+        3,152,76,0,3671,3672,5,2450,0,0,3672,3674,1,0,0,0,3673,3667,1,0,
+        0,0,3673,3674,1,0,0,0,3674,3676,1,0,0,0,3675,3661,1,0,0,0,3675,3666,
+        1,0,0,0,3676,141,1,0,0,0,3677,3678,3,154,77,0,3678,3693,5,1274,0,
+        0,3679,3680,5,2474,0,0,3680,3681,5,2449,0,0,3681,3682,3,152,76,0,
+        3682,3683,5,2450,0,0,3683,3694,1,0,0,0,3684,3691,5,38,0,0,3685,3686,
+        5,534,0,0,3686,3687,5,2474,0,0,3687,3688,5,2449,0,0,3688,3689,3,
+        152,76,0,3689,3690,5,2450,0,0,3690,3692,1,0,0,0,3691,3685,1,0,0,
+        0,3691,3692,1,0,0,0,3692,3694,1,0,0,0,3693,3679,1,0,0,0,3693,3684,
+        1,0,0,0,3694,143,1,0,0,0,3695,3696,3,154,77,0,3696,3716,5,1745,0,
+        0,3697,3698,5,2474,0,0,3698,3699,5,2449,0,0,3699,3700,3,152,76,0,
+        3700,3701,5,2450,0,0,3701,3717,1,0,0,0,3702,3703,5,2474,0,0,3703,
+        3704,5,2449,0,0,3704,3705,5,2445,0,0,3705,3706,5,2450,0,0,3706,3717,
+        3,146,73,0,3707,3714,5,38,0,0,3708,3709,5,534,0,0,3709,3710,5,2474,
+        0,0,3710,3711,5,2449,0,0,3711,3712,3,152,76,0,3712,3713,5,2450,0,
+        0,3713,3715,1,0,0,0,3714,3708,1,0,0,0,3714,3715,1,0,0,0,3715,3717,
+        1,0,0,0,3716,3697,1,0,0,0,3716,3702,1,0,0,0,3716,3707,1,0,0,0,3717,
+        145,1,0,0,0,3718,3738,5,209,0,0,3719,3720,5,2474,0,0,3720,3721,5,
+        2449,0,0,3721,3722,3,152,76,0,3722,3723,5,2450,0,0,3723,3739,1,0,
+        0,0,3724,3725,5,2474,0,0,3725,3726,5,2449,0,0,3726,3727,5,2445,0,
+        0,3727,3728,5,2450,0,0,3728,3739,3,148,74,0,3729,3736,5,38,0,0,3730,
+        3731,5,534,0,0,3731,3732,5,2474,0,0,3732,3733,5,2449,0,0,3733,3734,
+        3,152,76,0,3734,3735,5,2450,0,0,3735,3737,1,0,0,0,3736,3730,1,0,
+        0,0,3736,3737,1,0,0,0,3737,3739,1,0,0,0,3738,3719,1,0,0,0,3738,3724,
+        1,0,0,0,3738,3729,1,0,0,0,3739,147,1,0,0,0,3740,3764,5,1274,0,0,
+        3741,3742,5,2474,0,0,3742,3743,5,2449,0,0,3743,3744,3,152,76,0,3744,
+        3745,5,2450,0,0,3745,3765,1,0,0,0,3746,3747,5,2474,0,0,3747,3748,
+        5,2449,0,0,3748,3749,5,2445,0,0,3749,3751,5,2450,0,0,3750,3752,3,
+        150,75,0,3751,3750,1,0,0,0,3752,3753,1,0,0,0,3753,3751,1,0,0,0,3753,
+        3754,1,0,0,0,3754,3765,1,0,0,0,3755,3762,5,38,0,0,3756,3757,5,534,
+        0,0,3757,3758,5,2474,0,0,3758,3759,5,2449,0,0,3759,3760,3,152,76,
+        0,3760,3761,5,2450,0,0,3761,3763,1,0,0,0,3762,3756,1,0,0,0,3762,
+        3763,1,0,0,0,3763,3765,1,0,0,0,3764,3741,1,0,0,0,3764,3746,1,0,0,
+        0,3764,3755,1,0,0,0,3765,149,1,0,0,0,3766,3767,5,2260,0,0,3767,3768,
+        5,2474,0,0,3768,3769,5,2449,0,0,3769,3770,3,152,76,0,3770,3771,5,
+        2450,0,0,3771,3776,1,0,0,0,3772,3773,7,30,0,0,3773,3774,5,2474,0,
+        0,3774,3776,5,2445,0,0,3775,3766,1,0,0,0,3775,3772,1,0,0,0,3776,
+        151,1,0,0,0,3777,3782,5,2445,0,0,3778,3779,5,2455,0,0,3779,3781,
+        5,2445,0,0,3780,3778,1,0,0,0,3781,3784,1,0,0,0,3782,3780,1,0,0,0,
+        3782,3783,1,0,0,0,3783,153,1,0,0,0,3784,3782,1,0,0,0,3785,3786,7,
+        17,0,0,3786,155,1,0,0,0,3787,3788,5,469,0,0,3788,3789,5,879,0,0,
+        3789,3790,5,1465,0,0,3790,3791,3,2430,1215,0,3791,157,1,0,0,0,3792,
+        3793,5,469,0,0,3793,3795,5,1331,0,0,3794,3796,5,147,0,0,3795,3794,
+        1,0,0,0,3795,3796,1,0,0,0,3796,3800,1,0,0,0,3797,3798,3,2376,1188,
+        0,3798,3799,5,2442,0,0,3799,3801,1,0,0,0,3800,3797,1,0,0,0,3800,
+        3801,1,0,0,0,3801,3802,1,0,0,0,3802,3803,3,2316,1158,0,3803,159,
+        1,0,0,0,3804,3805,5,42,0,0,3805,3806,5,1331,0,0,3806,3807,3,2316,
+        1158,0,3807,3809,5,249,0,0,3808,3810,5,378,0,0,3809,3808,1,0,0,0,
+        3809,3810,1,0,0,0,3810,3812,1,0,0,0,3811,3813,7,31,0,0,3812,3811,
+        1,0,0,0,3812,3813,1,0,0,0,3813,3817,1,0,0,0,3814,3816,3,824,412,
+        0,3815,3814,1,0,0,0,3816,3819,1,0,0,0,3817,3815,1,0,0,0,3817,3818,
+        1,0,0,0,3818,3822,1,0,0,0,3819,3817,1,0,0,0,3820,3821,5,1589,0,0,
+        3821,3823,5,1675,0,0,3822,3820,1,0,0,0,3822,3823,1,0,0,0,3823,161,
+        1,0,0,0,3824,3827,5,321,0,0,3825,3826,5,1309,0,0,3826,3828,5,1564,
+        0,0,3827,3825,1,0,0,0,3827,3828,1,0,0,0,3828,3830,1,0,0,0,3829,3831,
+        7,20,0,0,3830,3829,1,0,0,0,3830,3831,1,0,0,0,3831,3832,1,0,0,0,3832,
+        3836,5,1331,0,0,3833,3834,3,2376,1188,0,3834,3835,5,2442,0,0,3835,
+        3837,1,0,0,0,3836,3833,1,0,0,0,3836,3837,1,0,0,0,3837,3838,1,0,0,
+        0,3838,3840,3,2316,1158,0,3839,3841,3,1740,870,0,3840,3839,1,0,0,
+        0,3840,3841,1,0,0,0,3841,3842,1,0,0,0,3842,3846,7,22,0,0,3843,3845,
+        3,166,83,0,3844,3843,1,0,0,0,3845,3848,1,0,0,0,3846,3844,1,0,0,0,
+        3846,3847,1,0,0,0,3847,3849,1,0,0,0,3848,3846,1,0,0,0,3849,3851,
+        5,508,0,0,3850,3852,3,2316,1158,0,3851,3850,1,0,0,0,3851,3852,1,
+        0,0,0,3852,163,1,0,0,0,3853,3856,5,321,0,0,3854,3855,5,1309,0,0,
+        3855,3857,5,1564,0,0,3856,3854,1,0,0,0,3856,3857,1,0,0,0,3857,3859,
+        1,0,0,0,3858,3860,7,20,0,0,3859,3858,1,0,0,0,3859,3860,1,0,0,0,3860,
+        3861,1,0,0,0,3861,3862,5,1331,0,0,3862,3866,5,147,0,0,3863,3864,
+        3,2376,1188,0,3864,3865,5,2442,0,0,3865,3867,1,0,0,0,3866,3863,1,
+        0,0,0,3866,3867,1,0,0,0,3867,3868,1,0,0,0,3868,3869,3,2316,1158,
+        0,3869,3873,7,22,0,0,3870,3872,3,172,86,0,3871,3870,1,0,0,0,3872,
+        3875,1,0,0,0,3873,3874,1,0,0,0,3873,3871,1,0,0,0,3874,3886,1,0,0,
+        0,3875,3873,1,0,0,0,3876,3877,5,113,0,0,3877,3884,3,1790,895,0,3878,
+        3880,5,535,0,0,3879,3881,3,1842,921,0,3880,3879,1,0,0,0,3881,3882,
+        1,0,0,0,3882,3880,1,0,0,0,3882,3883,1,0,0,0,3883,3885,1,0,0,0,3884,
+        3878,1,0,0,0,3884,3885,1,0,0,0,3885,3887,1,0,0,0,3886,3876,1,0,0,
+        0,3886,3887,1,0,0,0,3887,3888,1,0,0,0,3888,3890,5,508,0,0,3889,3891,
+        3,2316,1158,0,3890,3889,1,0,0,0,3890,3891,1,0,0,0,3891,165,1,0,0,
+        0,3892,3901,3,1774,887,0,3893,3901,3,1772,886,0,3894,3901,3,168,
+        84,0,3895,3901,3,170,85,0,3896,3901,3,1764,882,0,3897,3901,3,1766,
+        883,0,3898,3901,3,1768,884,0,3899,3901,3,1782,891,0,3900,3892,1,
+        0,0,0,3900,3893,1,0,0,0,3900,3894,1,0,0,0,3900,3895,1,0,0,0,3900,
+        3896,1,0,0,0,3900,3897,1,0,0,0,3900,3898,1,0,0,0,3900,3899,1,0,0,
+        0,3901,167,1,0,0,0,3902,3903,5,1463,0,0,3903,3915,3,2428,1214,0,
+        3904,3905,5,2449,0,0,3905,3910,3,1756,878,0,3906,3907,5,2455,0,0,
+        3907,3909,3,1756,878,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,2450,0,0,3914,3916,1,0,0,0,3915,3904,1,0,0,0,3915,
+        3916,1,0,0,0,3916,3922,1,0,0,0,3917,3921,3,120,60,0,3918,3921,5,
+        1333,0,0,3919,3921,5,420,0,0,3920,3917,1,0,0,0,3920,3918,1,0,0,0,
+        3920,3919,1,0,0,0,3921,3924,1,0,0,0,3922,3920,1,0,0,0,3922,3923,
+        1,0,0,0,3923,3927,1,0,0,0,3924,3922,1,0,0,0,3925,3926,5,69,0,0,3926,
+        3928,3,1742,871,0,3927,3925,1,0,0,0,3927,3928,1,0,0,0,3928,3929,
+        1,0,0,0,3929,3930,5,2472,0,0,3930,169,1,0,0,0,3931,3932,5,633,0,
+        0,3932,3944,3,2428,1214,0,3933,3934,5,2449,0,0,3934,3939,3,1756,
+        878,0,3935,3936,5,2455,0,0,3936,3938,3,1756,878,0,3937,3935,1,0,
+        0,0,3938,3941,1,0,0,0,3939,3937,1,0,0,0,3939,3940,1,0,0,0,3940,3942,
+        1,0,0,0,3941,3939,1,0,0,0,3942,3943,5,2450,0,0,3943,3945,1,0,0,0,
+        3944,3933,1,0,0,0,3944,3945,1,0,0,0,3945,3946,1,0,0,0,3946,3947,
+        5,1588,0,0,3947,3955,3,2400,1200,0,3948,3954,5,420,0,0,3949,3954,
+        5,1396,0,0,3950,3954,3,114,57,0,3951,3954,5,1581,0,0,3952,3954,3,
+        132,66,0,3953,3948,1,0,0,0,3953,3949,1,0,0,0,3953,3950,1,0,0,0,3953,
+        3951,1,0,0,0,3953,3952,1,0,0,0,3954,3957,1,0,0,0,3955,3953,1,0,0,
+        0,3955,3956,1,0,0,0,3956,3960,1,0,0,0,3957,3955,1,0,0,0,3958,3959,
+        5,69,0,0,3959,3961,3,1742,871,0,3960,3958,1,0,0,0,3960,3961,1,0,
+        0,0,3961,3962,1,0,0,0,3962,3963,5,2472,0,0,3963,171,1,0,0,0,3964,
+        3976,3,1774,887,0,3965,3976,3,1772,886,0,3966,3976,3,168,84,0,3967,
+        3976,3,170,85,0,3968,3976,3,1766,883,0,3969,3976,3,1768,884,0,3970,
+        3976,3,1764,882,0,3971,3976,3,1782,891,0,3972,3976,3,184,92,0,3973,
+        3976,3,182,91,0,3974,3976,3,1834,917,0,3975,3964,1,0,0,0,3975,3965,
+        1,0,0,0,3975,3966,1,0,0,0,3975,3967,1,0,0,0,3975,3968,1,0,0,0,3975,
+        3969,1,0,0,0,3975,3970,1,0,0,0,3975,3971,1,0,0,0,3975,3972,1,0,0,
+        0,3975,3973,1,0,0,0,3975,3974,1,0,0,0,3976,173,1,0,0,0,3977,3978,
+        5,42,0,0,3978,3979,5,1412,0,0,3979,3980,5,593,0,0,3980,3997,3,2430,
+        1215,0,3981,3982,5,1569,0,0,3982,3998,3,1188,594,0,3983,3998,3,934,
+        467,0,3984,3987,5,989,0,0,3985,3986,5,991,0,0,3986,3988,3,204,102,
+        0,3987,3985,1,0,0,0,3987,3988,1,0,0,0,3988,3991,1,0,0,0,3989,3990,
+        5,101,0,0,3990,3992,3,1470,735,0,3991,3989,1,0,0,0,3991,3992,1,0,
+        0,0,3992,3994,1,0,0,0,3993,3995,5,617,0,0,3994,3993,1,0,0,0,3994,
+        3995,1,0,0,0,3995,3998,1,0,0,0,3996,3998,5,444,0,0,3997,3981,1,0,
+        0,0,3997,3983,1,0,0,0,3997,3984,1,0,0,0,3997,3996,1,0,0,0,3998,175,
+        1,0,0,0,3999,4000,5,469,0,0,4000,4001,5,1412,0,0,4001,4002,5,593,
+        0,0,4002,4011,3,2430,1215,0,4003,4005,5,617,0,0,4004,4003,1,0,0,
+        0,4004,4005,1,0,0,0,4005,4006,1,0,0,0,4006,4009,5,706,0,0,4007,4009,
+        5,540,0,0,4008,4004,1,0,0,0,4008,4007,1,0,0,0,4009,4010,1,0,0,0,
+        4010,4012,5,295,0,0,4011,4008,1,0,0,0,4011,4012,1,0,0,0,4012,177,
+        1,0,0,0,4013,4014,5,469,0,0,4014,4015,5,1463,0,0,4015,4016,3,2348,
+        1174,0,4016,179,1,0,0,0,4017,4018,5,42,0,0,4018,4019,5,1463,0,0,
+        4019,4020,3,2348,1174,0,4020,4022,5,249,0,0,4021,4023,5,378,0,0,
+        4022,4021,1,0,0,0,4022,4023,1,0,0,0,4023,4027,1,0,0,0,4024,4026,
+        3,824,412,0,4025,4024,1,0,0,0,4026,4029,1,0,0,0,4027,4025,1,0,0,
+        0,4027,4028,1,0,0,0,4028,4032,1,0,0,0,4029,4027,1,0,0,0,4030,4031,
+        5,1589,0,0,4031,4033,5,1675,0,0,4032,4030,1,0,0,0,4032,4033,1,0,
+        0,0,4033,181,1,0,0,0,4034,4035,5,633,0,0,4035,4047,3,2428,1214,0,
+        4036,4037,5,2449,0,0,4037,4042,3,1756,878,0,4038,4039,5,2455,0,0,
+        4039,4041,3,1756,878,0,4040,4038,1,0,0,0,4041,4044,1,0,0,0,4042,
+        4040,1,0,0,0,4042,4043,1,0,0,0,4043,4045,1,0,0,0,4044,4042,1,0,0,
+        0,4045,4046,5,2450,0,0,4046,4048,1,0,0,0,4047,4036,1,0,0,0,4047,
+        4048,1,0,0,0,4048,4049,1,0,0,0,4049,4050,5,1588,0,0,4050,4059,3,
+        2400,1200,0,4051,4058,5,1396,0,0,4052,4058,5,420,0,0,4053,4058,3,
+        1740,870,0,4054,4058,3,114,57,0,4055,4058,3,118,59,0,4056,4058,3,
+        132,66,0,4057,4051,1,0,0,0,4057,4052,1,0,0,0,4057,4053,1,0,0,0,4057,
+        4054,1,0,0,0,4057,4055,1,0,0,0,4057,4056,1,0,0,0,4058,4061,1,0,0,
+        0,4059,4057,1,0,0,0,4059,4060,1,0,0,0,4060,4076,1,0,0,0,4061,4059,
+        1,0,0,0,4062,4071,7,22,0,0,4063,4065,5,382,0,0,4064,4063,1,0,0,0,
+        4064,4065,1,0,0,0,4065,4067,1,0,0,0,4066,4068,3,1760,880,0,4067,
+        4066,1,0,0,0,4067,4068,1,0,0,0,4068,4069,1,0,0,0,4069,4072,3,1840,
+        920,0,4070,4072,3,1742,871,0,4071,4064,1,0,0,0,4071,4070,1,0,0,0,
+        4072,4077,1,0,0,0,4073,4074,7,32,0,0,4074,4075,5,2248,0,0,4075,4077,
+        3,2318,1159,0,4076,4062,1,0,0,0,4076,4073,1,0,0,0,4077,4078,1,0,
+        0,0,4078,4079,5,2472,0,0,4079,183,1,0,0,0,4080,4081,5,1463,0,0,4081,
+        4093,3,2428,1214,0,4082,4083,5,2449,0,0,4083,4088,3,1756,878,0,4084,
+        4085,5,2455,0,0,4085,4087,3,1756,878,0,4086,4084,1,0,0,0,4087,4090,
+        1,0,0,0,4088,4086,1,0,0,0,4088,4089,1,0,0,0,4089,4091,1,0,0,0,4090,
+        4088,1,0,0,0,4091,4092,5,2450,0,0,4092,4094,1,0,0,0,4093,4082,1,
+        0,0,0,4093,4094,1,0,0,0,4094,4100,1,0,0,0,4095,4099,3,120,60,0,4096,
+        4099,5,1333,0,0,4097,4099,5,420,0,0,4098,4095,1,0,0,0,4098,4096,
+        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,4103,1,0,0,0,4102,4100,1,0,0,0,4103,4113,7,22,
+        0,0,4104,4106,5,382,0,0,4105,4104,1,0,0,0,4105,4106,1,0,0,0,4106,
+        4108,1,0,0,0,4107,4109,3,1760,880,0,4108,4107,1,0,0,0,4108,4109,
+        1,0,0,0,4109,4110,1,0,0,0,4110,4114,3,1840,920,0,4111,4114,3,1742,
+        871,0,4112,4114,5,561,0,0,4113,4105,1,0,0,0,4113,4111,1,0,0,0,4113,
+        4112,1,0,0,0,4114,4115,1,0,0,0,4115,4116,5,2472,0,0,4116,185,1,0,
+        0,0,4117,4120,5,321,0,0,4118,4119,5,1309,0,0,4119,4121,5,1564,0,
+        0,4120,4118,1,0,0,0,4120,4121,1,0,0,0,4121,4123,1,0,0,0,4122,4124,
+        7,20,0,0,4123,4122,1,0,0,0,4123,4124,1,0,0,0,4124,4125,1,0,0,0,4125,
+        4126,5,1463,0,0,4126,4138,3,2348,1174,0,4127,4128,5,2449,0,0,4128,
+        4133,3,1756,878,0,4129,4130,5,2455,0,0,4130,4132,3,1756,878,0,4131,
+        4129,1,0,0,0,4132,4135,1,0,0,0,4133,4131,1,0,0,0,4133,4134,1,0,0,
+        0,4134,4136,1,0,0,0,4135,4133,1,0,0,0,4136,4137,5,2450,0,0,4137,
+        4139,1,0,0,0,4138,4127,1,0,0,0,4138,4139,1,0,0,0,4139,4141,1,0,0,
+        0,4140,4142,3,1740,870,0,4141,4140,1,0,0,0,4141,4142,1,0,0,0,4142,
+        4146,1,0,0,0,4143,4145,7,33,0,0,4144,4143,1,0,0,0,4145,4148,1,0,
+        0,0,4146,4144,1,0,0,0,4146,4147,1,0,0,0,4147,4149,1,0,0,0,4148,4146,
+        1,0,0,0,4149,4159,7,22,0,0,4150,4152,5,382,0,0,4151,4150,1,0,0,0,
+        4151,4152,1,0,0,0,4152,4154,1,0,0,0,4153,4155,3,1760,880,0,4154,
+        4153,1,0,0,0,4154,4155,1,0,0,0,4155,4156,1,0,0,0,4156,4160,3,1840,
+        920,0,4157,4160,3,1742,871,0,4158,4160,5,561,0,0,4159,4151,1,0,0,
+        0,4159,4157,1,0,0,0,4159,4158,1,0,0,0,4160,187,1,0,0,0,4161,4162,
+        5,42,0,0,4162,4163,5,1572,0,0,4163,4166,5,311,0,0,4164,4165,7,34,
+        0,0,4165,4167,5,2443,0,0,4166,4164,1,0,0,0,4167,4168,1,0,0,0,4168,
+        4166,1,0,0,0,4168,4169,1,0,0,0,4169,189,1,0,0,0,4170,4171,5,469,
+        0,0,4171,4172,5,1317,0,0,4172,4173,3,2430,1215,0,4173,191,1,0,0,
+        0,4174,4175,5,42,0,0,4175,4176,5,1598,0,0,4176,4177,5,1647,0,0,4177,
+        4186,3,2310,1155,0,4178,4187,5,1258,0,0,4179,4187,5,1245,0,0,4180,
+        4187,3,1208,604,0,4181,4184,5,1686,0,0,4182,4183,5,2143,0,0,4183,
+        4185,3,1188,594,0,4184,4182,1,0,0,0,4184,4185,1,0,0,0,4185,4187,
+        1,0,0,0,4186,4178,1,0,0,0,4186,4179,1,0,0,0,4186,4180,1,0,0,0,4186,
+        4181,1,0,0,0,4187,193,1,0,0,0,4188,4189,5,469,0,0,4189,4190,5,1576,
+        0,0,4190,4191,5,1413,0,0,4191,4196,3,2430,1215,0,4192,4193,5,621,
+        0,0,4193,4194,5,1411,0,0,4194,4195,5,350,0,0,4195,4197,3,2430,1215,
+        0,4196,4192,1,0,0,0,4196,4197,1,0,0,0,4197,195,1,0,0,0,4198,4199,
+        5,469,0,0,4199,4200,5,1598,0,0,4200,4201,5,1647,0,0,4201,4202,3,
+        2310,1155,0,4202,197,1,0,0,0,4203,4204,5,469,0,0,4204,4205,5,1595,
+        0,0,4205,4206,3,2334,1167,0,4206,199,1,0,0,0,4207,4208,5,321,0,0,
+        4208,4209,5,1412,0,0,4209,4210,5,593,0,0,4210,4212,3,2430,1215,0,
+        4211,4213,3,202,101,0,4212,4211,1,0,0,0,4213,4214,1,0,0,0,4214,4212,
+        1,0,0,0,4214,4215,1,0,0,0,4215,201,1,0,0,0,4216,4217,5,991,0,0,4217,
+        4227,3,204,102,0,4218,4219,5,101,0,0,4219,4221,3,1470,735,0,4220,
+        4222,5,1589,0,0,4221,4220,1,0,0,0,4221,4222,1,0,0,0,4222,4227,1,
+        0,0,0,4223,4224,7,35,0,0,4224,4227,3,1188,594,0,4225,4227,3,934,
+        467,0,4226,4216,1,0,0,0,4226,4218,1,0,0,0,4226,4223,1,0,0,0,4226,
+        4225,1,0,0,0,4227,203,1,0,0,0,4228,4229,5,2445,0,0,4229,205,1,0,
+        0,0,4230,4232,5,321,0,0,4231,4233,5,1475,0,0,4232,4231,1,0,0,0,4232,
+        4233,1,0,0,0,4233,4234,1,0,0,0,4234,4235,5,1598,0,0,4235,4236,5,
+        1647,0,0,4236,4242,3,2310,1155,0,4237,4238,5,2082,0,0,4238,4241,
+        3,1676,838,0,4239,4241,3,1208,604,0,4240,4237,1,0,0,0,4240,4239,
+        1,0,0,0,4241,4244,1,0,0,0,4242,4240,1,0,0,0,4242,4243,1,0,0,0,4243,
+        207,1,0,0,0,4244,4242,1,0,0,0,4245,4246,5,469,0,0,4246,4247,5,2159,
+        0,0,4247,4248,3,2350,1175,0,4248,209,1,0,0,0,4249,4250,5,42,0,0,
+        4250,4251,5,2159,0,0,4251,4270,3,2350,1175,0,4252,4271,7,17,0,0,
+        4253,4254,5,1561,0,0,4254,4255,5,2143,0,0,4255,4271,3,2350,1175,
+        0,4256,4258,5,249,0,0,4257,4259,5,378,0,0,4258,4257,1,0,0,0,4258,
+        4259,1,0,0,0,4259,4263,1,0,0,0,4260,4262,3,824,412,0,4261,4260,1,
+        0,0,0,4262,4265,1,0,0,0,4263,4261,1,0,0,0,4263,4264,1,0,0,0,4264,
+        4268,1,0,0,0,4265,4263,1,0,0,0,4266,4267,5,1589,0,0,4267,4269,5,
+        1675,0,0,4268,4266,1,0,0,0,4268,4269,1,0,0,0,4269,4271,1,0,0,0,4270,
+        4252,1,0,0,0,4270,4253,1,0,0,0,4270,4256,1,0,0,0,4271,211,1,0,0,
+        0,4272,4275,5,321,0,0,4273,4274,5,1309,0,0,4274,4276,5,1564,0,0,
+        4275,4273,1,0,0,0,4275,4276,1,0,0,0,4276,4278,1,0,0,0,4277,4279,
+        7,20,0,0,4278,4277,1,0,0,0,4278,4279,1,0,0,0,4279,4280,1,0,0,0,4280,
+        4281,5,2159,0,0,4281,4285,3,2350,1175,0,4282,4286,3,218,109,0,4283,
+        4286,3,222,111,0,4284,4286,3,224,112,0,4285,4282,1,0,0,0,4285,4283,
+        1,0,0,0,4285,4284,1,0,0,0,4286,4288,1,0,0,0,4287,4289,3,214,107,
+        0,4288,4287,1,0,0,0,4288,4289,1,0,0,0,4289,4291,1,0,0,0,4290,4292,
+        7,17,0,0,4291,4290,1,0,0,0,4291,4292,1,0,0,0,4292,4294,1,0,0,0,4293,
+        4295,3,216,108,0,4294,4293,1,0,0,0,4294,4295,1,0,0,0,4295,4296,1,
+        0,0,0,4296,4297,3,226,113,0,4297,213,1,0,0,0,4298,4299,5,615,0,0,
+        4299,4304,3,2350,1175,0,4300,4301,5,2455,0,0,4301,4303,3,2350,1175,
+        0,4302,4300,1,0,0,0,4303,4306,1,0,0,0,4304,4302,1,0,0,0,4304,4305,
+        1,0,0,0,4305,215,1,0,0,0,4306,4304,1,0,0,0,4307,4308,5,2302,0,0,
+        4308,4309,5,2449,0,0,4309,4310,3,2096,1048,0,4310,4311,5,2450,0,
+        0,4311,217,1,0,0,0,4312,4317,5,112,0,0,4313,4317,5,33,0,0,4314,4315,
+        5,764,0,0,4315,4317,5,1248,0,0,4316,4312,1,0,0,0,4316,4313,1,0,0,
+        0,4316,4314,1,0,0,0,4317,4318,1,0,0,0,4318,4320,3,234,117,0,4319,
+        4321,3,240,120,0,4320,4319,1,0,0,0,4320,4321,1,0,0,0,4321,4323,1,
+        0,0,0,4322,4324,3,220,110,0,4323,4322,1,0,0,0,4323,4324,1,0,0,0,
+        4324,219,1,0,0,0,4325,4326,5,621,0,0,4326,4327,5,481,0,0,4327,4328,
+        5,1608,0,0,4328,221,1,0,0,0,4329,4330,5,621,0,0,4330,4332,3,234,
+        117,0,4331,4333,3,240,120,0,4332,4331,1,0,0,0,4332,4333,1,0,0,0,
+        4333,223,1,0,0,0,4334,4335,7,36,0,0,4335,4340,3,232,116,0,4336,4337,
+        5,1309,0,0,4337,4339,3,232,116,0,4338,4336,1,0,0,0,4339,4342,1,0,
+        0,0,4340,4338,1,0,0,0,4340,4341,1,0,0,0,4341,4343,1,0,0,0,4342,4340,
+        1,0,0,0,4343,4351,5,1261,0,0,4344,4352,5,350,0,0,4345,4346,3,2312,
+        1156,0,4346,4347,5,2442,0,0,4347,4349,1,0,0,0,4348,4345,1,0,0,0,
+        4348,4349,1,0,0,0,4349,4350,1,0,0,0,4350,4352,5,1627,0,0,4351,4344,
+        1,0,0,0,4351,4348,1,0,0,0,4352,225,1,0,0,0,4353,4358,3,228,114,0,
+        4354,4355,5,173,0,0,4355,4358,3,2428,1214,0,4356,4358,3,1844,922,
+        0,4357,4353,1,0,0,0,4357,4354,1,0,0,0,4357,4356,1,0,0,0,4358,227,
+        1,0,0,0,4359,4360,5,257,0,0,4360,4362,5,2159,0,0,4361,4363,3,1760,
+        880,0,4362,4361,1,0,0,0,4362,4363,1,0,0,0,4363,4365,1,0,0,0,4364,
+        4366,3,230,115,0,4365,4364,1,0,0,0,4366,4367,1,0,0,0,4367,4365,1,
+        0,0,0,4367,4368,1,0,0,0,4368,4369,1,0,0,0,4369,4371,5,508,0,0,4370,
+        4372,3,2350,1175,0,4371,4370,1,0,0,0,4371,4372,1,0,0,0,4372,229,
+        1,0,0,0,4373,4374,5,112,0,0,4374,4375,5,1745,0,0,4375,4376,5,786,
+        0,0,4376,4377,3,1846,923,0,4377,4378,5,112,0,0,4378,4379,5,1745,
+        0,0,4379,4380,5,2472,0,0,4380,4410,1,0,0,0,4381,4382,5,112,0,0,4382,
+        4383,5,481,0,0,4383,4384,5,1608,0,0,4384,4385,5,786,0,0,4385,4386,
+        3,1846,923,0,4386,4387,5,112,0,0,4387,4388,5,481,0,0,4388,4389,5,
+        1608,0,0,4389,4390,5,2472,0,0,4390,4410,1,0,0,0,4391,4392,5,33,0,
+        0,4392,4393,5,1745,0,0,4393,4394,5,786,0,0,4394,4395,3,1846,923,
+        0,4395,4396,5,33,0,0,4396,4397,5,1745,0,0,4397,4398,5,2472,0,0,4398,
+        4410,1,0,0,0,4399,4400,5,33,0,0,4400,4401,5,481,0,0,4401,4402,5,
+        1608,0,0,4402,4403,5,786,0,0,4403,4404,3,1846,923,0,4404,4405,5,
+        33,0,0,4405,4406,5,481,0,0,4406,4407,5,1608,0,0,4407,4408,5,2472,
+        0,0,4408,4410,1,0,0,0,4409,4373,1,0,0,0,4409,4381,1,0,0,0,4409,4391,
+        1,0,0,0,4409,4399,1,0,0,0,4410,231,1,0,0,0,4411,4438,5,42,0,0,4412,
+        4438,5,46,0,0,4413,4414,5,77,0,0,4414,4438,5,1748,0,0,4415,4438,
+        5,85,0,0,4416,4438,5,241,0,0,4417,4438,5,321,0,0,4418,4419,5,436,
+        0,0,4419,4438,5,1748,0,0,4420,4438,5,469,0,0,4421,4438,5,648,0,0,
+        4422,4438,5,1060,0,0,4423,4438,5,1561,0,0,4424,4438,5,1591,0,0,4425,
+        4438,5,2161,0,0,4426,4438,5,376,0,0,4427,4438,5,1741,0,0,4428,4438,
+        5,1687,0,0,4429,4438,5,372,0,0,4430,4438,5,892,0,0,4431,4438,5,891,
+        0,0,4432,4438,5,1664,0,0,4433,4438,5,1792,0,0,4434,4438,5,350,0,
+        0,4435,4438,5,1627,0,0,4436,4438,5,615,0,0,4437,4411,1,0,0,0,4437,
+        4412,1,0,0,0,4437,4413,1,0,0,0,4437,4415,1,0,0,0,4437,4416,1,0,0,
+        0,4437,4417,1,0,0,0,4437,4418,1,0,0,0,4437,4420,1,0,0,0,4437,4421,
+        1,0,0,0,4437,4422,1,0,0,0,4437,4423,1,0,0,0,4437,4424,1,0,0,0,4437,
+        4425,1,0,0,0,4437,4426,1,0,0,0,4437,4427,1,0,0,0,4437,4428,1,0,0,
+        0,4437,4429,1,0,0,0,4437,4430,1,0,0,0,4437,4431,1,0,0,0,4437,4432,
+        1,0,0,0,4437,4433,1,0,0,0,4437,4434,1,0,0,0,4437,4435,1,0,0,0,4437,
+        4436,1,0,0,0,4438,233,1,0,0,0,4439,4444,3,236,118,0,4440,4441,5,
+        1309,0,0,4441,4443,3,236,118,0,4442,4440,1,0,0,0,4443,4446,1,0,0,
+        0,4444,4442,1,0,0,0,4444,4445,1,0,0,0,4445,4447,1,0,0,0,4446,4444,
+        1,0,0,0,4447,4449,5,1261,0,0,4448,4450,3,238,119,0,4449,4448,1,0,
+        0,0,4449,4450,1,0,0,0,4450,4451,1,0,0,0,4451,4452,3,2368,1184,0,
+        4452,235,1,0,0,0,4453,4456,7,37,0,0,4454,4455,5,1248,0,0,4455,4457,
+        3,2384,1192,0,4456,4454,1,0,0,0,4456,4457,1,0,0,0,4457,237,1,0,0,
+        0,4458,4459,5,1014,0,0,4459,4460,5,2085,0,0,4460,4461,3,2368,1184,
+        0,4461,4462,5,1248,0,0,4462,239,1,0,0,0,4463,4464,5,1531,0,0,4464,
+        4467,3,242,121,0,4465,4467,5,1530,0,0,4466,4463,1,0,0,0,4466,4465,
+        1,0,0,0,4467,4471,1,0,0,0,4468,4470,3,242,121,0,4469,4468,1,0,0,
+        0,4470,4473,1,0,0,0,4471,4469,1,0,0,0,4471,4472,1,0,0,0,4472,241,
+        1,0,0,0,4473,4471,1,0,0,0,4474,4475,7,38,0,0,4475,4476,3,2294,1147,
+        0,4476,243,1,0,0,0,4477,4478,5,469,0,0,4478,4480,5,2168,0,0,4479,
+        4481,5,147,0,0,4480,4479,1,0,0,0,4480,4481,1,0,0,0,4481,4482,1,0,
+        0,0,4482,4484,3,2340,1170,0,4483,4485,7,39,0,0,4484,4483,1,0,0,0,
+        4484,4485,1,0,0,0,4485,245,1,0,0,0,4486,4487,5,42,0,0,4487,4488,
+        5,2168,0,0,4488,4496,3,2340,1170,0,4489,4497,3,248,124,0,4490,4497,
+        3,250,125,0,4491,4497,3,252,126,0,4492,4497,3,256,128,0,4493,4497,
+        3,258,129,0,4494,4497,3,296,148,0,4495,4497,3,308,154,0,4496,4489,
+        1,0,0,0,4496,4490,1,0,0,0,4496,4491,1,0,0,0,4496,4492,1,0,0,0,4496,
+        4493,1,0,0,0,4496,4494,1,0,0,0,4496,4495,1,0,0,0,4497,4499,1,0,0,
+        0,4498,4500,3,260,130,0,4499,4498,1,0,0,0,4499,4500,1,0,0,0,4500,
+        247,1,0,0,0,4501,4503,5,249,0,0,4502,4504,5,378,0,0,4503,4502,1,
+        0,0,0,4503,4504,1,0,0,0,4504,4506,1,0,0,0,4505,4507,7,40,0,0,4506,
+        4505,1,0,0,0,4506,4507,1,0,0,0,4507,4511,1,0,0,0,4508,4510,3,824,
+        412,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,4516,1,0,0,0,4513,4511,1,0,0,0,4514,4515,5,1589,
+        0,0,4515,4517,5,1675,0,0,4516,4514,1,0,0,0,4516,4517,1,0,0,0,4517,
+        249,1,0,0,0,4518,4520,5,1564,0,0,4519,4521,3,1740,870,0,4520,4519,
+        1,0,0,0,4520,4521,1,0,0,0,4521,4522,1,0,0,0,4522,4523,5,69,0,0,4523,
+        4524,5,1240,0,0,4524,4525,5,2449,0,0,4525,4530,3,298,149,0,4526,
+        4527,5,2455,0,0,4527,4529,3,298,149,0,4528,4526,1,0,0,0,4529,4532,
+        1,0,0,0,4530,4528,1,0,0,0,4530,4531,1,0,0,0,4531,4533,1,0,0,0,4532,
+        4530,1,0,0,0,4533,4534,5,2450,0,0,4534,251,1,0,0,0,4535,4540,3,254,
+        127,0,4536,4537,5,2455,0,0,4537,4539,3,254,127,0,4538,4536,1,0,0,
+        0,4539,4542,1,0,0,0,4540,4538,1,0,0,0,4540,4541,1,0,0,0,4541,253,
+        1,0,0,0,4542,4540,1,0,0,0,4543,4546,7,9,0,0,4544,4547,3,320,160,
+        0,4545,4547,3,306,153,0,4546,4544,1,0,0,0,4546,4545,1,0,0,0,4547,
+        255,1,0,0,0,4548,4549,7,4,0,0,4549,4568,5,83,0,0,4550,4552,3,2428,
+        1214,0,4551,4553,3,2400,1200,0,4552,4551,1,0,0,0,4552,4553,1,0,0,
+        0,4553,4569,1,0,0,0,4554,4555,5,2449,0,0,4555,4556,3,2428,1214,0,
+        4556,4563,3,2400,1200,0,4557,4558,5,2455,0,0,4558,4559,3,2428,1214,
+        0,4559,4560,3,2400,1200,0,4560,4562,1,0,0,0,4561,4557,1,0,0,0,4562,
+        4565,1,0,0,0,4563,4561,1,0,0,0,4563,4564,1,0,0,0,4564,4566,1,0,0,
+        0,4565,4563,1,0,0,0,4566,4567,5,2450,0,0,4567,4569,1,0,0,0,4568,
+        4550,1,0,0,0,4568,4554,1,0,0,0,4569,4587,1,0,0,0,4570,4571,5,469,
+        0,0,4571,4584,5,83,0,0,4572,4585,3,2428,1214,0,4573,4574,5,2449,
+        0,0,4574,4579,3,2428,1214,0,4575,4576,5,2455,0,0,4576,4578,3,2428,
+        1214,0,4577,4575,1,0,0,0,4578,4581,1,0,0,0,4579,4577,1,0,0,0,4579,
+        4580,1,0,0,0,4580,4582,1,0,0,0,4581,4579,1,0,0,0,4582,4583,5,2450,
+        0,0,4583,4585,1,0,0,0,4584,4572,1,0,0,0,4584,4573,1,0,0,0,4585,4587,
+        1,0,0,0,4586,4548,1,0,0,0,4586,4570,1,0,0,0,4587,257,1,0,0,0,4588,
+        4594,5,981,0,0,4589,4590,5,859,0,0,4590,4595,3,2100,1050,0,4591,
+        4592,5,486,0,0,4592,4593,5,2168,0,0,4593,4595,3,2400,1200,0,4594,
+        4589,1,0,0,0,4594,4591,1,0,0,0,4595,259,1,0,0,0,4596,4613,5,781,
+        0,0,4597,4607,5,179,0,0,4598,4599,5,300,0,0,4599,4600,5,2143,0,0,
+        4600,4608,5,1782,0,0,4601,4603,5,1206,0,0,4602,4601,1,0,0,0,4602,
+        4603,1,0,0,0,4603,4604,1,0,0,0,4604,4605,5,706,0,0,4605,4606,5,2085,
+        0,0,4606,4608,5,351,0,0,4607,4598,1,0,0,0,4607,4602,1,0,0,0,4607,
+        4608,1,0,0,0,4608,4610,1,0,0,0,4609,4611,3,262,131,0,4610,4609,1,
+        0,0,0,4610,4611,1,0,0,0,4611,4613,1,0,0,0,4612,4596,1,0,0,0,4612,
+        4597,1,0,0,0,4613,261,1,0,0,0,4614,4616,5,617,0,0,4615,4614,1,0,
+        0,0,4615,4616,1,0,0,0,4616,4617,1,0,0,0,4617,4618,5,537,0,0,4618,
+        4619,5,780,0,0,4619,4620,3,2368,1184,0,4620,263,1,0,0,0,4621,4624,
+        3,266,133,0,4622,4624,3,268,134,0,4623,4621,1,0,0,0,4623,4622,1,
+        0,0,0,4624,265,1,0,0,0,4625,4628,5,321,0,0,4626,4627,5,1309,0,0,
+        4627,4629,5,1564,0,0,4628,4626,1,0,0,0,4628,4629,1,0,0,0,4629,4631,
+        1,0,0,0,4630,4632,7,20,0,0,4631,4630,1,0,0,0,4631,4632,1,0,0,0,4632,
+        4633,1,0,0,0,4633,4634,5,2168,0,0,4634,4635,3,270,135,0,4635,267,
+        1,0,0,0,4636,4639,5,321,0,0,4637,4638,5,1309,0,0,4638,4640,5,1564,
+        0,0,4639,4637,1,0,0,0,4639,4640,1,0,0,0,4640,4642,1,0,0,0,4641,4643,
+        7,20,0,0,4642,4641,1,0,0,0,4642,4643,1,0,0,0,4643,4644,1,0,0,0,4644,
+        4645,5,2168,0,0,4645,4646,3,282,141,0,4646,269,1,0,0,0,4647,4650,
+        3,2340,1170,0,4648,4649,5,1250,0,0,4649,4651,5,2445,0,0,4650,4648,
+        1,0,0,0,4650,4651,1,0,0,0,4651,4653,1,0,0,0,4652,4654,5,617,0,0,
+        4653,4652,1,0,0,0,4653,4654,1,0,0,0,4654,4656,1,0,0,0,4655,4657,
+        3,272,136,0,4656,4655,1,0,0,0,4656,4657,1,0,0,0,4657,271,1,0,0,0,
+        4658,4660,3,1740,870,0,4659,4658,1,0,0,0,4659,4660,1,0,0,0,4660,
+        4663,1,0,0,0,4661,4664,3,274,137,0,4662,4664,3,276,138,0,4663,4661,
+        1,0,0,0,4663,4662,1,0,0,0,4664,4666,1,0,0,0,4665,4667,3,280,140,
+        0,4666,4665,1,0,0,0,4666,4667,1,0,0,0,4667,4679,1,0,0,0,4668,4669,
+        5,2449,0,0,4669,4674,3,298,149,0,4670,4671,5,2455,0,0,4671,4673,
+        3,298,149,0,4672,4670,1,0,0,0,4673,4676,1,0,0,0,4674,4672,1,0,0,
+        0,4674,4675,1,0,0,0,4675,4677,1,0,0,0,4676,4674,1,0,0,0,4677,4678,
+        5,2450,0,0,4678,4680,1,0,0,0,4679,4668,1,0,0,0,4679,4680,1,0,0,0,
+        4680,4684,1,0,0,0,4681,4683,3,296,148,0,4682,4681,1,0,0,0,4683,4686,
+        1,0,0,0,4684,4682,1,0,0,0,4684,4685,1,0,0,0,4685,273,1,0,0,0,4686,
+        4684,1,0,0,0,4687,4691,7,22,0,0,4688,4692,5,1240,0,0,4689,4692,3,
+        1788,894,0,4690,4692,3,278,139,0,4691,4688,1,0,0,0,4691,4689,1,0,
+        0,0,4691,4690,1,0,0,0,4692,275,1,0,0,0,4693,4694,5,2179,0,0,4694,
+        4695,3,2400,1200,0,4695,277,1,0,0,0,4696,4697,5,2085,0,0,4697,4698,
+        5,1248,0,0,4698,4701,3,2400,1200,0,4699,4700,5,1206,0,0,4700,4702,
+        5,1230,0,0,4701,4699,1,0,0,0,4701,4702,1,0,0,0,4702,279,1,0,0,0,
+        4703,4704,5,561,0,0,4704,4705,5,998,0,0,4705,4706,3,2100,1050,0,
+        4706,4707,5,824,0,0,4707,4708,5,793,0,0,4708,4709,5,2248,0,0,4709,
+        4710,7,41,0,0,4710,281,1,0,0,0,4711,4712,5,147,0,0,4712,4713,3,2340,
+        1170,0,4713,4715,7,22,0,0,4714,4716,3,284,142,0,4715,4714,1,0,0,
+        0,4716,4717,1,0,0,0,4717,4715,1,0,0,0,4717,4718,1,0,0,0,4718,4719,
+        1,0,0,0,4719,4720,5,508,0,0,4720,283,1,0,0,0,4721,4725,3,286,143,
+        0,4722,4725,3,288,144,0,4723,4725,3,308,154,0,4724,4721,1,0,0,0,
+        4724,4722,1,0,0,0,4724,4723,1,0,0,0,4725,285,1,0,0,0,4726,4727,7,
+        42,0,0,4727,4728,5,937,0,0,4728,4729,3,292,146,0,4729,287,1,0,0,
+        0,4730,4732,7,43,0,0,4731,4730,1,0,0,0,4731,4732,1,0,0,0,4732,4736,
+        1,0,0,0,4733,4737,3,290,145,0,4734,4737,3,292,146,0,4735,4737,3,
+        294,147,0,4736,4733,1,0,0,0,4736,4734,1,0,0,0,4736,4735,1,0,0,0,
+        4737,289,1,0,0,0,4738,4739,5,1463,0,0,4739,4751,3,2348,1174,0,4740,
+        4741,5,2449,0,0,4741,4746,3,326,163,0,4742,4743,5,2455,0,0,4743,
+        4745,3,326,163,0,4744,4742,1,0,0,0,4745,4748,1,0,0,0,4746,4744,1,
+        0,0,0,4746,4747,1,0,0,0,4747,4749,1,0,0,0,4748,4746,1,0,0,0,4749,
+        4750,5,2450,0,0,4750,4752,1,0,0,0,4751,4740,1,0,0,0,4751,4752,1,
+        0,0,0,4752,4753,1,0,0,0,4753,4764,7,22,0,0,4754,4765,3,1742,871,
+        0,4755,4757,5,382,0,0,4756,4755,1,0,0,0,4756,4757,1,0,0,0,4757,4759,
+        1,0,0,0,4758,4760,3,1760,880,0,4759,4758,1,0,0,0,4759,4760,1,0,0,
+        0,4760,4761,1,0,0,0,4761,4762,3,1840,920,0,4762,4763,5,2472,0,0,
+        4763,4765,1,0,0,0,4764,4754,1,0,0,0,4764,4756,1,0,0,0,4765,291,1,
+        0,0,0,4766,4767,5,633,0,0,4767,4779,3,2346,1173,0,4768,4769,5,2449,
+        0,0,4769,4774,3,326,163,0,4770,4771,5,2455,0,0,4771,4773,3,326,163,
+        0,4772,4770,1,0,0,0,4773,4776,1,0,0,0,4774,4772,1,0,0,0,4774,4775,
+        1,0,0,0,4775,4777,1,0,0,0,4776,4774,1,0,0,0,4777,4778,5,2450,0,0,
+        4778,4780,1,0,0,0,4779,4768,1,0,0,0,4779,4780,1,0,0,0,4780,4781,
+        1,0,0,0,4781,4782,5,1588,0,0,4782,4783,3,2400,1200,0,4783,4794,7,
+        22,0,0,4784,4795,3,1742,871,0,4785,4787,5,382,0,0,4786,4785,1,0,
+        0,0,4786,4787,1,0,0,0,4787,4789,1,0,0,0,4788,4790,3,1760,880,0,4789,
+        4788,1,0,0,0,4789,4790,1,0,0,0,4790,4791,1,0,0,0,4791,4792,3,1840,
+        920,0,4792,4793,5,2472,0,0,4793,4795,1,0,0,0,4794,4784,1,0,0,0,4794,
+        4786,1,0,0,0,4795,293,1,0,0,0,4796,4798,5,596,0,0,4797,4796,1,0,
+        0,0,4797,4798,1,0,0,0,4798,4800,1,0,0,0,4799,4801,5,762,0,0,4800,
+        4799,1,0,0,0,4800,4801,1,0,0,0,4801,4802,1,0,0,0,4802,4803,5,288,
+        0,0,4803,4804,5,633,0,0,4804,4825,3,2346,1173,0,4805,4812,5,2449,
+        0,0,4806,4807,5,1650,0,0,4807,4808,5,739,0,0,4808,4809,5,1320,0,
+        0,4809,4810,3,2400,1200,0,4810,4811,5,2455,0,0,4811,4813,1,0,0,0,
+        4812,4806,1,0,0,0,4812,4813,1,0,0,0,4813,4822,1,0,0,0,4814,4819,
+        3,326,163,0,4815,4816,5,2455,0,0,4816,4818,3,326,163,0,4817,4815,
+        1,0,0,0,4818,4821,1,0,0,0,4819,4817,1,0,0,0,4819,4820,1,0,0,0,4820,
+        4823,1,0,0,0,4821,4819,1,0,0,0,4822,4814,1,0,0,0,4822,4823,1,0,0,
+        0,4823,4824,1,0,0,0,4824,4826,5,2450,0,0,4825,4805,1,0,0,0,4825,
+        4826,1,0,0,0,4826,4827,1,0,0,0,4827,4828,5,1588,0,0,4828,4829,5,
+        1650,0,0,4829,4830,5,69,0,0,4830,4831,5,1582,0,0,4831,4842,7,22,
+        0,0,4832,4843,3,1742,871,0,4833,4835,5,382,0,0,4834,4833,1,0,0,0,
+        4834,4835,1,0,0,0,4835,4837,1,0,0,0,4836,4838,3,1760,880,0,4837,
+        4836,1,0,0,0,4837,4838,1,0,0,0,4838,4839,1,0,0,0,4839,4840,3,1840,
+        920,0,4840,4841,5,2472,0,0,4841,4843,1,0,0,0,4842,4832,1,0,0,0,4842,
+        4834,1,0,0,0,4843,295,1,0,0,0,4844,4846,5,1206,0,0,4845,4844,1,0,
+        0,0,4845,4846,1,0,0,0,4846,4847,1,0,0,0,4847,4848,7,44,0,0,4848,
+        297,1,0,0,0,4849,4850,3,2428,1214,0,4850,4852,3,2400,1200,0,4851,
+        4853,3,300,150,0,4852,4851,1,0,0,0,4852,4853,1,0,0,0,4853,4856,1,
+        0,0,0,4854,4856,3,302,151,0,4855,4849,1,0,0,0,4855,4854,1,0,0,0,
+        4856,299,1,0,0,0,4857,4858,5,561,0,0,4858,4859,5,998,0,0,4859,4860,
+        3,2100,1050,0,4860,301,1,0,0,0,4861,4863,3,296,148,0,4862,4861,1,
+        0,0,0,4862,4863,1,0,0,0,4863,4865,1,0,0,0,4864,4866,3,304,152,0,
+        4865,4864,1,0,0,0,4866,4867,1,0,0,0,4867,4865,1,0,0,0,4867,4868,
+        1,0,0,0,4868,4871,1,0,0,0,4869,4870,5,2455,0,0,4870,4872,3,322,161,
+        0,4871,4869,1,0,0,0,4871,4872,1,0,0,0,4872,303,1,0,0,0,4873,4877,
+        3,306,153,0,4874,4877,3,318,159,0,4875,4877,3,320,160,0,4876,4873,
+        1,0,0,0,4876,4874,1,0,0,0,4876,4875,1,0,0,0,4877,305,1,0,0,0,4878,
+        4881,7,43,0,0,4879,4882,3,314,157,0,4880,4882,3,316,158,0,4881,4879,
+        1,0,0,0,4881,4880,1,0,0,0,4882,307,1,0,0,0,4883,4884,5,1326,0,0,
+        4884,4885,5,937,0,0,4885,4890,3,310,155,0,4886,4887,5,1326,0,0,4887,
+        4888,5,937,0,0,4888,4890,3,312,156,0,4889,4883,1,0,0,0,4889,4886,
+        1,0,0,0,4890,309,1,0,0,0,4891,4892,5,633,0,0,4892,4904,3,2346,1173,
+        0,4893,4894,5,2449,0,0,4894,4899,3,326,163,0,4895,4896,5,2455,0,
+        0,4896,4898,3,326,163,0,4897,4895,1,0,0,0,4898,4901,1,0,0,0,4899,
+        4897,1,0,0,0,4899,4900,1,0,0,0,4900,4902,1,0,0,0,4901,4899,1,0,0,
+        0,4902,4903,5,2450,0,0,4903,4905,1,0,0,0,4904,4893,1,0,0,0,4904,
+        4905,1,0,0,0,4905,4906,1,0,0,0,4906,4911,5,1588,0,0,4907,4912,3,
+        2400,1200,0,4908,4909,5,1650,0,0,4909,4910,5,69,0,0,4910,4912,5,
+        1582,0,0,4911,4907,1,0,0,0,4911,4908,1,0,0,0,4912,4924,1,0,0,0,4913,
+        4915,5,1396,0,0,4914,4913,1,0,0,0,4914,4915,1,0,0,0,4915,4916,1,
+        0,0,0,4916,4918,7,22,0,0,4917,4919,5,382,0,0,4918,4917,1,0,0,0,4918,
+        4919,1,0,0,0,4919,4921,1,0,0,0,4920,4922,3,1760,880,0,4921,4920,
+        1,0,0,0,4921,4922,1,0,0,0,4922,4923,1,0,0,0,4923,4925,3,1840,920,
+        0,4924,4914,1,0,0,0,4924,4925,1,0,0,0,4925,4927,1,0,0,0,4926,4928,
+        5,2472,0,0,4927,4926,1,0,0,0,4927,4928,1,0,0,0,4928,311,1,0,0,0,
+        4929,4930,5,1463,0,0,4930,4942,3,2348,1174,0,4931,4932,5,2449,0,
+        0,4932,4937,3,326,163,0,4933,4934,5,2455,0,0,4934,4936,3,326,163,
+        0,4935,4933,1,0,0,0,4936,4939,1,0,0,0,4937,4935,1,0,0,0,4937,4938,
+        1,0,0,0,4938,4940,1,0,0,0,4939,4937,1,0,0,0,4940,4941,5,2450,0,0,
+        4941,4943,1,0,0,0,4942,4931,1,0,0,0,4942,4943,1,0,0,0,4943,4944,
+        1,0,0,0,4944,4955,7,22,0,0,4945,4956,3,1742,871,0,4946,4948,5,382,
+        0,0,4947,4946,1,0,0,0,4947,4948,1,0,0,0,4948,4950,1,0,0,0,4949,4951,
+        3,1760,880,0,4950,4949,1,0,0,0,4950,4951,1,0,0,0,4951,4952,1,0,0,
+        0,4952,4953,3,1840,920,0,4953,4954,5,2472,0,0,4954,4956,1,0,0,0,
+        4955,4945,1,0,0,0,4955,4947,1,0,0,0,4956,313,1,0,0,0,4957,4958,5,
+        1463,0,0,4958,4970,3,2348,1174,0,4959,4960,5,2449,0,0,4960,4965,
+        3,326,163,0,4961,4962,5,2455,0,0,4962,4964,3,326,163,0,4963,4961,
+        1,0,0,0,4964,4967,1,0,0,0,4965,4963,1,0,0,0,4965,4966,1,0,0,0,4966,
+        4968,1,0,0,0,4967,4965,1,0,0,0,4968,4969,5,2450,0,0,4969,4971,1,
+        0,0,0,4970,4959,1,0,0,0,4970,4971,1,0,0,0,4971,4974,1,0,0,0,4972,
+        4973,7,22,0,0,4973,4975,3,1742,871,0,4974,4972,1,0,0,0,4974,4975,
+        1,0,0,0,4975,315,1,0,0,0,4976,4977,5,633,0,0,4977,4989,3,2346,1173,
+        0,4978,4979,5,2449,0,0,4979,4984,3,326,163,0,4980,4981,5,2455,0,
+        0,4981,4983,3,326,163,0,4982,4980,1,0,0,0,4983,4986,1,0,0,0,4984,
+        4982,1,0,0,0,4984,4985,1,0,0,0,4985,4987,1,0,0,0,4986,4984,1,0,0,
+        0,4987,4988,5,2450,0,0,4988,4990,1,0,0,0,4989,4978,1,0,0,0,4989,
+        4990,1,0,0,0,4990,4991,1,0,0,0,4991,4996,5,1588,0,0,4992,4997,3,
+        2400,1200,0,4993,4994,5,1650,0,0,4994,4995,5,69,0,0,4995,4997,5,
+        1582,0,0,4996,4992,1,0,0,0,4996,4993,1,0,0,0,4997,5006,1,0,0,0,4998,
+        4999,7,22,0,0,4999,5007,3,1742,871,0,5000,5002,5,561,0,0,5001,5003,
+        5,2264,0,0,5002,5001,1,0,0,0,5002,5003,1,0,0,0,5003,5004,1,0,0,0,
+        5004,5005,5,998,0,0,5005,5007,3,2100,1050,0,5006,4998,1,0,0,0,5006,
+        5000,1,0,0,0,5006,5007,1,0,0,0,5007,317,1,0,0,0,5008,5010,5,596,
+        0,0,5009,5008,1,0,0,0,5009,5010,1,0,0,0,5010,5012,1,0,0,0,5011,5013,
+        5,762,0,0,5012,5011,1,0,0,0,5012,5013,1,0,0,0,5013,5014,1,0,0,0,
+        5014,5015,5,288,0,0,5015,5016,5,633,0,0,5016,5037,3,2400,1200,0,
+        5017,5024,5,2449,0,0,5018,5019,5,1650,0,0,5019,5020,5,739,0,0,5020,
+        5021,5,1320,0,0,5021,5022,3,2400,1200,0,5022,5023,5,2455,0,0,5023,
+        5025,1,0,0,0,5024,5018,1,0,0,0,5024,5025,1,0,0,0,5025,5034,1,0,0,
+        0,5026,5031,3,326,163,0,5027,5028,5,2455,0,0,5028,5030,3,326,163,
+        0,5029,5027,1,0,0,0,5030,5033,1,0,0,0,5031,5029,1,0,0,0,5031,5032,
+        1,0,0,0,5032,5035,1,0,0,0,5033,5031,1,0,0,0,5034,5026,1,0,0,0,5034,
+        5035,1,0,0,0,5035,5036,1,0,0,0,5036,5038,5,2450,0,0,5037,5017,1,
+        0,0,0,5037,5038,1,0,0,0,5038,5039,1,0,0,0,5039,5040,5,1588,0,0,5040,
+        5041,5,1650,0,0,5041,5042,5,69,0,0,5042,5045,5,1582,0,0,5043,5044,
+        7,22,0,0,5044,5046,3,1742,871,0,5045,5043,1,0,0,0,5045,5046,1,0,
+        0,0,5046,319,1,0,0,0,5047,5048,7,42,0,0,5048,5049,5,937,0,0,5049,
+        5050,3,316,158,0,5050,321,1,0,0,0,5051,5052,5,1435,0,0,5052,5053,
+        5,1579,0,0,5053,5054,5,2449,0,0,5054,5059,3,324,162,0,5055,5056,
+        5,2455,0,0,5056,5058,3,324,162,0,5057,5055,1,0,0,0,5058,5061,1,0,
+        0,0,5059,5057,1,0,0,0,5059,5060,1,0,0,0,5060,5062,1,0,0,0,5061,5059,
+        1,0,0,0,5062,5063,5,2450,0,0,5063,323,1,0,0,0,5064,5067,3,2428,1214,
+        0,5065,5067,5,389,0,0,5066,5064,1,0,0,0,5066,5065,1,0,0,0,5067,325,
+        1,0,0,0,5068,5078,3,2320,1160,0,5069,5070,5,739,0,0,5070,5071,5,
+        1320,0,0,5071,5079,5,1081,0,0,5072,5073,5,739,0,0,5073,5079,5,1320,
+        0,0,5074,5075,5,1320,0,0,5075,5079,5,1081,0,0,5076,5079,5,1320,0,
+        0,5077,5079,5,739,0,0,5078,5069,1,0,0,0,5078,5072,1,0,0,0,5078,5074,
+        1,0,0,0,5078,5076,1,0,0,0,5078,5077,1,0,0,0,5078,5079,1,0,0,0,5079,
+        5080,1,0,0,0,5080,5083,3,2400,1200,0,5081,5082,5,2459,0,0,5082,5084,
+        3,2420,1210,0,5083,5081,1,0,0,0,5083,5084,1,0,0,0,5084,327,1,0,0,
+        0,5085,5086,5,469,0,0,5086,5087,5,1655,0,0,5087,5088,3,2342,1171,
+        0,5088,329,1,0,0,0,5089,5090,5,42,0,0,5090,5091,5,1655,0,0,5091,
+        5093,3,2342,1171,0,5092,5094,3,338,169,0,5093,5092,1,0,0,0,5094,
+        5095,1,0,0,0,5095,5093,1,0,0,0,5095,5096,1,0,0,0,5096,331,1,0,0,
+        0,5097,5098,5,42,0,0,5098,5128,5,1669,0,0,5099,5100,5,30,0,0,5100,
+        5129,7,45,0,0,5101,5102,5,218,0,0,5102,5103,5,350,0,0,5103,5104,
+        5,862,0,0,5104,5129,3,2320,1160,0,5105,5106,3,1320,660,0,5106,5107,
+        5,242,0,0,5107,5108,5,739,0,0,5108,5109,5,1463,0,0,5109,5129,1,0,
+        0,0,5110,5111,3,1320,660,0,5111,5112,5,657,0,0,5112,5129,1,0,0,0,
+        5113,5116,3,1320,660,0,5114,5116,5,617,0,0,5115,5113,1,0,0,0,5115,
+        5114,1,0,0,0,5116,5117,1,0,0,0,5117,5118,5,1335,0,0,5118,5124,7,
+        46,0,0,5119,5122,5,1335,0,0,5120,5123,3,2210,1105,0,5121,5123,3,
+        2320,1160,0,5122,5120,1,0,0,0,5122,5121,1,0,0,0,5123,5125,1,0,0,
+        0,5124,5119,1,0,0,0,5124,5125,1,0,0,0,5125,5129,1,0,0,0,5126,5127,
+        5,1673,0,0,5127,5129,3,334,167,0,5128,5099,1,0,0,0,5128,5101,1,0,
+        0,0,5128,5105,1,0,0,0,5128,5110,1,0,0,0,5128,5115,1,0,0,0,5128,5126,
+        1,0,0,0,5129,333,1,0,0,0,5130,5131,3,2320,1160,0,5131,5132,5,2474,
+        0,0,5132,5133,3,826,413,0,5133,5135,1,0,0,0,5134,5130,1,0,0,0,5135,
+        5136,1,0,0,0,5136,5134,1,0,0,0,5136,5137,1,0,0,0,5137,5161,1,0,0,
+        0,5138,5139,5,483,0,0,5139,5140,5,2474,0,0,5140,5161,3,2430,1215,
+        0,5141,5142,5,289,0,0,5142,5143,5,2474,0,0,5143,5147,3,2430,1215,
+        0,5144,5145,5,1666,0,0,5145,5146,5,2474,0,0,5146,5148,3,2430,1215,
+        0,5147,5144,1,0,0,0,5147,5148,1,0,0,0,5148,5161,1,0,0,0,5149,5150,
+        5,1608,0,0,5150,5151,5,63,0,0,5151,5152,5,2291,0,0,5152,5153,5,2474,
+        0,0,5153,5161,7,47,0,0,5154,5155,5,392,0,0,5155,5158,5,2474,0,0,
+        5156,5159,3,2430,1215,0,5157,5159,5,1134,0,0,5158,5156,1,0,0,0,5158,
+        5157,1,0,0,0,5159,5161,1,0,0,0,5160,5134,1,0,0,0,5160,5138,1,0,0,
+        0,5160,5141,1,0,0,0,5160,5149,1,0,0,0,5160,5154,1,0,0,0,5161,335,
+        1,0,0,0,5162,5163,5,321,0,0,5163,5167,5,1655,0,0,5164,5165,5,692,
+        0,0,5165,5166,5,1206,0,0,5166,5168,5,546,0,0,5167,5164,1,0,0,0,5167,
+        5168,1,0,0,0,5168,5169,1,0,0,0,5169,5173,3,2342,1171,0,5170,5172,
+        3,338,169,0,5171,5170,1,0,0,0,5172,5175,1,0,0,0,5173,5171,1,0,0,
+        0,5173,5174,1,0,0,0,5174,5179,1,0,0,0,5175,5173,1,0,0,0,5176,5177,
+        5,1683,0,0,5177,5178,5,2474,0,0,5178,5180,7,48,0,0,5179,5176,1,0,
+        0,0,5179,5180,1,0,0,0,5180,337,1,0,0,0,5181,5182,5,708,0,0,5182,
+        5183,5,160,0,0,5183,5213,5,2443,0,0,5184,5213,3,340,170,0,5185,5186,
+        5,933,0,0,5186,5213,5,2443,0,0,5187,5213,5,1122,0,0,5188,5189,5,
+        961,0,0,5189,5213,5,2443,0,0,5190,5213,5,1125,0,0,5191,5213,5,348,
+        0,0,5192,5213,5,1085,0,0,5193,5194,5,166,0,0,5194,5213,5,2443,0,
+        0,5195,5213,5,1067,0,0,5196,5213,5,1305,0,0,5197,5213,5,1142,0,0,
+        5198,5213,5,815,0,0,5199,5213,5,1115,0,0,5200,5202,5,1622,0,0,5201,
+        5203,7,49,0,0,5202,5201,1,0,0,0,5202,5203,1,0,0,0,5203,5213,1,0,
+        0,0,5204,5213,5,1183,0,0,5205,5207,5,1678,0,0,5206,5208,7,49,0,0,
+        5207,5206,1,0,0,0,5207,5208,1,0,0,0,5208,5213,1,0,0,0,5209,5213,
+        5,1189,0,0,5210,5213,5,1669,0,0,5211,5213,5,643,0,0,5212,5181,1,
+        0,0,0,5212,5184,1,0,0,0,5212,5185,1,0,0,0,5212,5187,1,0,0,0,5212,
+        5188,1,0,0,0,5212,5190,1,0,0,0,5212,5191,1,0,0,0,5212,5192,1,0,0,
+        0,5212,5193,1,0,0,0,5212,5195,1,0,0,0,5212,5196,1,0,0,0,5212,5197,
+        1,0,0,0,5212,5198,1,0,0,0,5212,5199,1,0,0,0,5212,5200,1,0,0,0,5212,
+        5204,1,0,0,0,5212,5205,1,0,0,0,5212,5209,1,0,0,0,5212,5210,1,0,0,
+        0,5212,5211,1,0,0,0,5213,339,1,0,0,0,5214,5215,5,1739,0,0,5215,5216,
+        5,2310,0,0,5216,5217,7,50,0,0,5217,341,1,0,0,0,5218,5221,5,321,0,
+        0,5219,5220,5,1309,0,0,5220,5222,5,1564,0,0,5221,5219,1,0,0,0,5221,
+        5222,1,0,0,0,5222,5224,1,0,0,0,5223,5225,7,7,0,0,5224,5223,1,0,0,
+        0,5224,5225,1,0,0,0,5225,5226,1,0,0,0,5226,5227,5,45,0,0,5227,5228,
+        5,2288,0,0,5228,5232,3,2430,1215,0,5229,5230,5,1683,0,0,5230,5231,
+        5,2474,0,0,5231,5233,7,21,0,0,5232,5229,1,0,0,0,5232,5233,1,0,0,
+        0,5233,5237,1,0,0,0,5234,5236,3,344,172,0,5235,5234,1,0,0,0,5236,
+        5239,1,0,0,0,5237,5235,1,0,0,0,5237,5238,1,0,0,0,5238,5241,1,0,0,
+        0,5239,5237,1,0,0,0,5240,5242,3,354,177,0,5241,5240,1,0,0,0,5241,
+        5242,1,0,0,0,5242,5244,1,0,0,0,5243,5245,3,356,178,0,5244,5243,1,
+        0,0,0,5244,5245,1,0,0,0,5245,5247,1,0,0,0,5246,5248,3,364,182,0,
+        5247,5246,1,0,0,0,5247,5248,1,0,0,0,5248,5250,1,0,0,0,5249,5251,
+        3,374,187,0,5250,5249,1,0,0,0,5250,5251,1,0,0,0,5251,5253,1,0,0,
+        0,5252,5254,3,376,188,0,5253,5252,1,0,0,0,5253,5254,1,0,0,0,5254,
+        5256,1,0,0,0,5255,5257,3,378,189,0,5256,5255,1,0,0,0,5256,5257,1,
+        0,0,0,5257,5259,1,0,0,0,5258,5260,3,388,194,0,5259,5258,1,0,0,0,
+        5259,5260,1,0,0,0,5260,5262,1,0,0,0,5261,5263,3,390,195,0,5262,5261,
+        1,0,0,0,5262,5263,1,0,0,0,5263,343,1,0,0,0,5264,5266,3,346,173,0,
+        5265,5267,3,348,174,0,5266,5265,1,0,0,0,5266,5267,1,0,0,0,5267,5273,
+        1,0,0,0,5268,5270,3,346,173,0,5269,5268,1,0,0,0,5269,5270,1,0,0,
+        0,5270,5271,1,0,0,0,5271,5273,3,348,174,0,5272,5264,1,0,0,0,5272,
+        5269,1,0,0,0,5273,5277,1,0,0,0,5274,5276,3,350,175,0,5275,5274,1,
+        0,0,0,5276,5279,1,0,0,0,5277,5275,1,0,0,0,5277,5278,1,0,0,0,5278,
+        5292,1,0,0,0,5279,5277,1,0,0,0,5280,5282,3,346,173,0,5281,5280,1,
+        0,0,0,5281,5282,1,0,0,0,5282,5284,1,0,0,0,5283,5285,3,348,174,0,
+        5284,5283,1,0,0,0,5284,5285,1,0,0,0,5285,5287,1,0,0,0,5286,5288,
+        3,350,175,0,5287,5286,1,0,0,0,5288,5289,1,0,0,0,5289,5287,1,0,0,
+        0,5289,5290,1,0,0,0,5290,5292,1,0,0,0,5291,5272,1,0,0,0,5291,5281,
+        1,0,0,0,5292,345,1,0,0,0,5293,5294,5,177,0,0,5294,5295,3,2426,1213,
+        0,5295,347,1,0,0,0,5296,5297,5,415,0,0,5297,5298,3,2426,1213,0,5298,
+        349,1,0,0,0,5299,5300,5,207,0,0,5300,5303,3,2430,1215,0,5301,5302,
+        5,2260,0,0,5302,5304,3,2426,1213,0,5303,5301,1,0,0,0,5303,5304,1,
+        0,0,0,5304,5307,1,0,0,0,5305,5306,5,824,0,0,5306,5308,3,352,176,
+        0,5307,5305,1,0,0,0,5307,5308,1,0,0,0,5308,351,1,0,0,0,5309,5312,
+        5,1230,0,0,5310,5312,3,2430,1215,0,5311,5309,1,0,0,0,5311,5310,1,
+        0,0,0,5312,353,1,0,0,0,5313,5317,5,2248,0,0,5314,5315,3,2312,1156,
+        0,5315,5316,5,2442,0,0,5316,5318,1,0,0,0,5317,5314,1,0,0,0,5317,
+        5318,1,0,0,0,5318,5319,1,0,0,0,5319,5321,3,2430,1215,0,5320,5322,
+        5,1558,0,0,5321,5320,1,0,0,0,5321,5322,1,0,0,0,5322,5327,1,0,0,0,
+        5323,5325,5,69,0,0,5324,5323,1,0,0,0,5324,5325,1,0,0,0,5325,5326,
+        1,0,0,0,5326,5328,3,2430,1215,0,5327,5324,1,0,0,0,5327,5328,1,0,
+        0,0,5328,355,1,0,0,0,5329,5330,5,422,0,0,5330,5331,5,160,0,0,5331,
+        5332,5,2449,0,0,5332,5337,3,358,179,0,5333,5334,5,2455,0,0,5334,
+        5336,3,358,179,0,5335,5333,1,0,0,0,5336,5339,1,0,0,0,5337,5335,1,
+        0,0,0,5337,5338,1,0,0,0,5338,5340,1,0,0,0,5339,5337,1,0,0,0,5340,
+        5341,5,2450,0,0,5341,357,1,0,0,0,5342,5346,3,360,180,0,5343,5345,
+        3,344,172,0,5344,5343,1,0,0,0,5345,5348,1,0,0,0,5346,5344,1,0,0,
+        0,5346,5347,1,0,0,0,5347,5349,1,0,0,0,5348,5346,1,0,0,0,5349,5377,
+        5,817,0,0,5350,5354,5,2449,0,0,5351,5352,3,2430,1215,0,5352,5353,
+        5,2442,0,0,5353,5355,1,0,0,0,5354,5351,1,0,0,0,5354,5355,1,0,0,0,
+        5355,5356,1,0,0,0,5356,5366,3,2366,1183,0,5357,5361,5,2455,0,0,5358,
+        5359,3,2430,1215,0,5359,5360,5,2442,0,0,5360,5362,1,0,0,0,5361,5358,
+        1,0,0,0,5361,5362,1,0,0,0,5362,5363,1,0,0,0,5363,5365,3,2366,1183,
+        0,5364,5357,1,0,0,0,5365,5368,1,0,0,0,5366,5364,1,0,0,0,5366,5367,
+        1,0,0,0,5367,5369,1,0,0,0,5368,5366,1,0,0,0,5369,5370,5,2450,0,0,
+        5370,5378,1,0,0,0,5371,5372,3,2430,1215,0,5372,5373,5,2442,0,0,5373,
+        5375,1,0,0,0,5374,5371,1,0,0,0,5374,5375,1,0,0,0,5375,5376,1,0,0,
+        0,5376,5378,3,2366,1183,0,5377,5350,1,0,0,0,5377,5374,1,0,0,0,5378,
+        5379,1,0,0,0,5379,5381,5,1530,0,0,5380,5382,5,445,0,0,5381,5380,
+        1,0,0,0,5381,5382,1,0,0,0,5382,5395,1,0,0,0,5383,5384,5,2449,0,0,
+        5384,5389,3,2306,1153,0,5385,5386,5,2455,0,0,5386,5388,3,2306,1153,
+        0,5387,5385,1,0,0,0,5388,5391,1,0,0,0,5389,5387,1,0,0,0,5389,5390,
+        1,0,0,0,5390,5392,1,0,0,0,5391,5389,1,0,0,0,5392,5393,5,2450,0,0,
+        5393,5396,1,0,0,0,5394,5396,3,2306,1153,0,5395,5383,1,0,0,0,5395,
+        5394,1,0,0,0,5396,5397,1,0,0,0,5397,5398,5,674,0,0,5398,5399,5,2449,
+        0,0,5399,5404,3,362,181,0,5400,5401,5,2455,0,0,5401,5403,3,362,181,
+        0,5402,5400,1,0,0,0,5403,5406,1,0,0,0,5404,5402,1,0,0,0,5404,5405,
+        1,0,0,0,5405,5407,1,0,0,0,5406,5404,1,0,0,0,5407,5408,5,2450,0,0,
+        5408,359,1,0,0,0,5409,5410,3,2312,1156,0,5410,5411,5,2442,0,0,5411,
+        5413,1,0,0,0,5412,5409,1,0,0,0,5412,5413,1,0,0,0,5413,5414,1,0,0,
+        0,5414,5419,3,2430,1215,0,5415,5417,5,69,0,0,5416,5415,1,0,0,0,5416,
+        5417,1,0,0,0,5417,5418,1,0,0,0,5418,5420,3,2430,1215,0,5419,5416,
+        1,0,0,0,5419,5420,1,0,0,0,5420,361,1,0,0,0,5421,5422,3,2312,1156,
+        0,5422,5423,5,2442,0,0,5423,5425,1,0,0,0,5424,5421,1,0,0,0,5424,
+        5425,1,0,0,0,5425,5426,1,0,0,0,5426,5431,3,2430,1215,0,5427,5429,
+        5,69,0,0,5428,5427,1,0,0,0,5428,5429,1,0,0,0,5429,5430,1,0,0,0,5430,
+        5432,3,2430,1215,0,5431,5428,1,0,0,0,5431,5432,1,0,0,0,5432,5434,
+        1,0,0,0,5433,5435,5,389,0,0,5434,5433,1,0,0,0,5434,5435,1,0,0,0,
+        5435,363,1,0,0,0,5436,5437,5,935,0,0,5437,5438,5,2449,0,0,5438,5443,
+        3,366,183,0,5439,5440,5,2455,0,0,5440,5442,3,366,183,0,5441,5439,
+        1,0,0,0,5442,5445,1,0,0,0,5443,5441,1,0,0,0,5443,5444,1,0,0,0,5444,
+        5446,1,0,0,0,5445,5443,1,0,0,0,5446,5447,5,2450,0,0,5447,365,1,0,
+        0,0,5448,5451,3,2430,1215,0,5449,5452,3,368,184,0,5450,5452,3,372,
+        186,0,5451,5449,1,0,0,0,5451,5450,1,0,0,0,5451,5452,1,0,0,0,5452,
+        367,1,0,0,0,5453,5454,5,568,0,0,5454,5456,3,2430,1215,0,5455,5457,
+        3,370,185,0,5456,5455,1,0,0,0,5456,5457,1,0,0,0,5457,369,1,0,0,0,
+        5458,5459,5,35,0,0,5459,5460,5,160,0,0,5460,5461,3,2328,1164,0,5461,
+        371,1,0,0,0,5462,5463,5,69,0,0,5463,5464,5,2449,0,0,5464,5465,3,
+        2100,1050,0,5465,5466,5,2450,0,0,5466,373,1,0,0,0,5467,5468,5,389,
+        0,0,5468,5469,5,934,0,0,5469,5470,3,2430,1215,0,5470,375,1,0,0,0,
+        5471,5472,5,389,0,0,5472,5473,5,35,0,0,5473,5474,5,160,0,0,5474,
+        5475,3,2328,1164,0,5475,377,1,0,0,0,5476,5477,5,166,0,0,5477,5482,
+        3,380,190,0,5478,5479,5,2455,0,0,5479,5481,3,380,190,0,5480,5478,
+        1,0,0,0,5481,5484,1,0,0,0,5482,5480,1,0,0,0,5482,5483,1,0,0,0,5483,
+        379,1,0,0,0,5484,5482,1,0,0,0,5485,5486,5,934,0,0,5486,5506,5,650,
+        0,0,5487,5507,5,38,0,0,5488,5489,5,2449,0,0,5489,5494,3,2430,1215,
+        0,5490,5491,5,2455,0,0,5491,5493,3,2430,1215,0,5492,5490,1,0,0,0,
+        5493,5496,1,0,0,0,5494,5492,1,0,0,0,5494,5495,1,0,0,0,5495,5497,
+        1,0,0,0,5496,5494,1,0,0,0,5497,5498,5,2450,0,0,5498,5503,3,382,191,
+        0,5499,5500,5,2455,0,0,5500,5502,3,382,191,0,5501,5499,1,0,0,0,5502,
+        5505,1,0,0,0,5503,5501,1,0,0,0,5503,5504,1,0,0,0,5504,5507,1,0,0,
+        0,5505,5503,1,0,0,0,5506,5487,1,0,0,0,5506,5488,1,0,0,0,5507,381,
+        1,0,0,0,5508,5509,5,849,0,0,5509,5510,5,2449,0,0,5510,5515,3,384,
+        192,0,5511,5512,5,2455,0,0,5512,5514,3,384,192,0,5513,5511,1,0,0,
+        0,5514,5517,1,0,0,0,5515,5513,1,0,0,0,5515,5516,1,0,0,0,5516,5518,
+        1,0,0,0,5517,5515,1,0,0,0,5518,5519,5,2450,0,0,5519,5520,3,386,193,
+        0,5520,383,1,0,0,0,5521,5530,5,2449,0,0,5522,5523,3,2430,1215,0,
+        5523,5524,5,2442,0,0,5524,5526,1,0,0,0,5525,5522,1,0,0,0,5525,5526,
+        1,0,0,0,5526,5527,1,0,0,0,5527,5528,3,2430,1215,0,5528,5529,5,2442,
+        0,0,5529,5531,1,0,0,0,5530,5525,1,0,0,0,5530,5531,1,0,0,0,5531,5532,
+        1,0,0,0,5532,5533,3,2430,1215,0,5533,5534,5,2450,0,0,5534,385,1,
+        0,0,0,5535,5547,5,477,0,0,5536,5544,5,920,0,0,5537,5541,5,2248,0,
+        0,5538,5539,3,2312,1156,0,5539,5540,5,2442,0,0,5540,5542,1,0,0,0,
+        5541,5538,1,0,0,0,5541,5542,1,0,0,0,5542,5543,1,0,0,0,5543,5545,
+        3,2430,1215,0,5544,5537,1,0,0,0,5544,5545,1,0,0,0,5545,5547,1,0,
+        0,0,5546,5535,1,0,0,0,5546,5536,1,0,0,0,5547,387,1,0,0,0,5548,5549,
+        5,568,0,0,5549,5550,5,237,0,0,5550,5565,3,2366,1183,0,5551,5553,
+        5,69,0,0,5552,5551,1,0,0,0,5552,5553,1,0,0,0,5553,5554,1,0,0,0,5554,
+        5562,3,2430,1215,0,5555,5557,5,2455,0,0,5556,5558,5,69,0,0,5557,
+        5556,1,0,0,0,5557,5558,1,0,0,0,5558,5559,1,0,0,0,5559,5561,3,2430,
+        1215,0,5560,5555,1,0,0,0,5561,5564,1,0,0,0,5562,5560,1,0,0,0,5562,
+        5563,1,0,0,0,5563,5566,1,0,0,0,5564,5562,1,0,0,0,5565,5552,1,0,0,
+        0,5565,5566,1,0,0,0,5566,389,1,0,0,0,5567,5568,5,499,0,0,5568,5569,
+        5,1486,0,0,5569,5571,5,2150,0,0,5570,5572,7,51,0,0,5571,5570,1,0,
+        0,0,5571,5572,1,0,0,0,5572,391,1,0,0,0,5573,5576,5,321,0,0,5574,
+        5575,5,1309,0,0,5575,5577,5,1564,0,0,5576,5574,1,0,0,0,5576,5577,
+        1,0,0,0,5577,5579,1,0,0,0,5578,5580,7,7,0,0,5579,5578,1,0,0,0,5579,
+        5580,1,0,0,0,5580,5581,1,0,0,0,5581,5582,5,83,0,0,5582,5586,5,422,
+        0,0,5583,5584,3,2312,1156,0,5584,5585,5,2442,0,0,5585,5587,1,0,0,
+        0,5586,5583,1,0,0,0,5586,5587,1,0,0,0,5587,5588,1,0,0,0,5588,5592,
+        3,2430,1215,0,5589,5590,5,1683,0,0,5590,5591,5,2474,0,0,5591,5593,
+        7,21,0,0,5592,5589,1,0,0,0,5592,5593,1,0,0,0,5593,5597,1,0,0,0,5594,
+        5596,3,344,172,0,5595,5594,1,0,0,0,5596,5599,1,0,0,0,5597,5595,1,
+        0,0,0,5597,5598,1,0,0,0,5598,5603,1,0,0,0,5599,5597,1,0,0,0,5600,
+        5601,5,422,0,0,5601,5602,5,2168,0,0,5602,5604,7,52,0,0,5603,5600,
+        1,0,0,0,5603,5604,1,0,0,0,5604,5605,1,0,0,0,5605,5606,3,394,197,
+        0,5606,5608,3,404,202,0,5607,5609,3,408,204,0,5608,5607,1,0,0,0,
+        5609,5610,1,0,0,0,5610,5608,1,0,0,0,5610,5611,1,0,0,0,5611,5613,
+        1,0,0,0,5612,5614,3,416,208,0,5613,5612,1,0,0,0,5613,5614,1,0,0,
+        0,5614,393,1,0,0,0,5615,5616,5,2248,0,0,5616,5621,3,396,198,0,5617,
+        5618,5,2455,0,0,5618,5620,3,396,198,0,5619,5617,1,0,0,0,5620,5623,
+        1,0,0,0,5621,5619,1,0,0,0,5621,5622,1,0,0,0,5622,5627,1,0,0,0,5623,
+        5621,1,0,0,0,5624,5626,3,398,199,0,5625,5624,1,0,0,0,5626,5629,1,
+        0,0,0,5627,5625,1,0,0,0,5627,5628,1,0,0,0,5628,395,1,0,0,0,5629,
+        5627,1,0,0,0,5630,5631,3,2312,1156,0,5631,5632,5,2442,0,0,5632,5634,
+        1,0,0,0,5633,5630,1,0,0,0,5633,5634,1,0,0,0,5634,5635,1,0,0,0,5635,
+        5637,3,2430,1215,0,5636,5638,5,1558,0,0,5637,5636,1,0,0,0,5637,5638,
+        1,0,0,0,5638,5643,1,0,0,0,5639,5641,5,69,0,0,5640,5639,1,0,0,0,5640,
+        5641,1,0,0,0,5641,5642,1,0,0,0,5642,5644,3,2430,1215,0,5643,5640,
+        1,0,0,0,5643,5644,1,0,0,0,5644,397,1,0,0,0,5645,5646,5,795,0,0,5646,
+        5647,5,1365,0,0,5647,5648,3,2430,1215,0,5648,5649,5,1261,0,0,5649,
+        5650,3,400,200,0,5650,399,1,0,0,0,5651,5656,3,402,201,0,5652,5653,
+        5,49,0,0,5653,5655,3,402,201,0,5654,5652,1,0,0,0,5655,5658,1,0,0,
+        0,5656,5654,1,0,0,0,5656,5657,1,0,0,0,5657,401,1,0,0,0,5658,5656,
+        1,0,0,0,5659,5660,3,2430,1215,0,5660,5661,5,2442,0,0,5661,5663,1,
+        0,0,0,5662,5659,1,0,0,0,5662,5663,1,0,0,0,5663,5664,1,0,0,0,5664,
+        5665,3,2366,1183,0,5665,5669,5,2474,0,0,5666,5667,3,2430,1215,0,
+        5667,5668,5,2442,0,0,5668,5670,1,0,0,0,5669,5666,1,0,0,0,5669,5670,
+        1,0,0,0,5670,5671,1,0,0,0,5671,5672,3,2366,1183,0,5672,403,1,0,0,
+        0,5673,5674,5,84,0,0,5674,5675,5,2449,0,0,5675,5680,3,406,203,0,
+        5676,5677,5,2455,0,0,5677,5679,3,406,203,0,5678,5676,1,0,0,0,5679,
+        5682,1,0,0,0,5680,5678,1,0,0,0,5680,5681,1,0,0,0,5681,5683,1,0,0,
+        0,5682,5680,1,0,0,0,5683,5684,5,2450,0,0,5684,405,1,0,0,0,5685,5686,
+        3,2430,1215,0,5686,5687,5,2442,0,0,5687,5689,1,0,0,0,5688,5685,1,
+        0,0,0,5688,5689,1,0,0,0,5689,5690,1,0,0,0,5690,5695,3,2366,1183,
+        0,5691,5693,5,69,0,0,5692,5691,1,0,0,0,5692,5693,1,0,0,0,5693,5694,
+        1,0,0,0,5694,5696,3,2430,1215,0,5695,5692,1,0,0,0,5695,5696,1,0,
+        0,0,5696,5700,1,0,0,0,5697,5699,3,344,172,0,5698,5697,1,0,0,0,5699,
+        5702,1,0,0,0,5700,5698,1,0,0,0,5700,5701,1,0,0,0,5701,407,1,0,0,
+        0,5702,5700,1,0,0,0,5703,5704,5,847,0,0,5704,5710,3,2430,1215,0,
+        5705,5706,5,1206,0,0,5706,5711,5,1230,0,0,5707,5708,5,1704,0,0,5708,
+        5709,5,2302,0,0,5709,5711,5,1230,0,0,5710,5705,1,0,0,0,5710,5707,
+        1,0,0,0,5710,5711,1,0,0,0,5711,5715,1,0,0,0,5712,5713,5,847,0,0,
+        5713,5714,5,2168,0,0,5714,5716,7,53,0,0,5715,5712,1,0,0,0,5715,5716,
+        1,0,0,0,5716,5720,1,0,0,0,5717,5719,3,344,172,0,5718,5717,1,0,0,
+        0,5719,5722,1,0,0,0,5720,5718,1,0,0,0,5720,5721,1,0,0,0,5721,5723,
+        1,0,0,0,5722,5720,1,0,0,0,5723,5725,3,410,205,0,5724,5726,3,412,
+        206,0,5725,5724,1,0,0,0,5725,5726,1,0,0,0,5726,5730,1,0,0,0,5727,
+        5728,5,937,0,0,5728,5729,5,998,0,0,5729,5731,3,2100,1050,0,5730,
+        5727,1,0,0,0,5730,5731,1,0,0,0,5731,5735,1,0,0,0,5732,5733,5,937,
+        0,0,5733,5734,5,177,0,0,5734,5736,3,2100,1050,0,5735,5732,1,0,0,
+        0,5735,5736,1,0,0,0,5736,5740,1,0,0,0,5737,5738,5,937,0,0,5738,5739,
+        5,415,0,0,5739,5741,3,2100,1050,0,5740,5737,1,0,0,0,5740,5741,1,
+        0,0,0,5741,5758,1,0,0,0,5742,5743,5,1305,0,0,5743,5745,5,160,0,0,
+        5744,5746,7,54,0,0,5745,5744,1,0,0,0,5745,5746,1,0,0,0,5746,5747,
+        1,0,0,0,5747,5755,3,414,207,0,5748,5750,5,2455,0,0,5749,5751,7,54,
+        0,0,5750,5749,1,0,0,0,5750,5751,1,0,0,0,5751,5752,1,0,0,0,5752,5754,
+        3,414,207,0,5753,5748,1,0,0,0,5754,5757,1,0,0,0,5755,5753,1,0,0,
+        0,5755,5756,1,0,0,0,5756,5759,1,0,0,0,5757,5755,1,0,0,0,5758,5742,
+        1,0,0,0,5758,5759,1,0,0,0,5759,5772,1,0,0,0,5760,5761,5,419,0,0,
+        5761,5762,5,2449,0,0,5762,5767,3,2430,1215,0,5763,5764,5,2455,0,
+        0,5764,5766,3,2430,1215,0,5765,5763,1,0,0,0,5766,5769,1,0,0,0,5767,
+        5765,1,0,0,0,5767,5768,1,0,0,0,5768,5770,1,0,0,0,5769,5767,1,0,0,
+        0,5770,5771,5,2450,0,0,5771,5773,1,0,0,0,5772,5760,1,0,0,0,5772,
+        5773,1,0,0,0,5773,409,1,0,0,0,5774,5787,5,817,0,0,5775,5788,3,2430,
+        1215,0,5776,5777,5,2449,0,0,5777,5782,3,2430,1215,0,5778,5779,5,
+        2455,0,0,5779,5781,3,2430,1215,0,5780,5778,1,0,0,0,5781,5784,1,0,
+        0,0,5782,5780,1,0,0,0,5782,5783,1,0,0,0,5783,5785,1,0,0,0,5784,5782,
+        1,0,0,0,5785,5786,5,2450,0,0,5786,5788,1,0,0,0,5787,5775,1,0,0,0,
+        5787,5776,1,0,0,0,5788,411,1,0,0,0,5789,5790,5,43,0,0,5790,5791,
+        3,410,205,0,5791,413,1,0,0,0,5792,5794,3,2430,1215,0,5793,5795,7,
+        55,0,0,5794,5793,1,0,0,0,5794,5795,1,0,0,0,5795,5798,1,0,0,0,5796,
+        5797,5,1231,0,0,5797,5799,7,56,0,0,5798,5796,1,0,0,0,5798,5799,1,
+        0,0,0,5799,415,1,0,0,0,5800,5801,5,38,0,0,5801,5818,5,937,0,0,5802,
+        5803,5,998,0,0,5803,5807,3,2100,1050,0,5804,5805,5,937,0,0,5805,
+        5806,5,177,0,0,5806,5808,3,2100,1050,0,5807,5804,1,0,0,0,5807,5808,
+        1,0,0,0,5808,5819,1,0,0,0,5809,5810,5,177,0,0,5810,5814,3,2100,1050,
+        0,5811,5812,5,937,0,0,5812,5813,5,415,0,0,5813,5815,3,2100,1050,
+        0,5814,5811,1,0,0,0,5814,5815,1,0,0,0,5815,5819,1,0,0,0,5816,5817,
+        5,415,0,0,5817,5819,3,2100,1050,0,5818,5802,1,0,0,0,5818,5809,1,
+        0,0,0,5818,5816,1,0,0,0,5819,417,1,0,0,0,5820,5821,5,321,0,0,5821,
+        5822,5,85,0,0,5822,5823,5,1414,0,0,5823,5825,3,2430,1215,0,5824,
+        5826,3,420,210,0,5825,5824,1,0,0,0,5825,5826,1,0,0,0,5826,5828,1,
+        0,0,0,5827,5829,3,422,211,0,5828,5827,1,0,0,0,5828,5829,1,0,0,0,
+        5829,5831,1,0,0,0,5830,5832,3,438,219,0,5831,5830,1,0,0,0,5831,5832,
+        1,0,0,0,5832,5839,1,0,0,0,5833,5834,5,2302,0,0,5834,5835,3,2426,
+        1213,0,5835,5836,5,530,0,0,5836,5837,5,1392,0,0,5837,5838,7,57,0,
+        0,5838,5840,1,0,0,0,5839,5833,1,0,0,0,5839,5840,1,0,0,0,5840,5843,
+        1,0,0,0,5841,5842,5,1260,0,0,5842,5844,5,2137,0,0,5843,5841,1,0,
+        0,0,5843,5844,1,0,0,0,5844,5846,1,0,0,0,5845,5847,3,778,389,0,5846,
+        5845,1,0,0,0,5846,5847,1,0,0,0,5847,419,1,0,0,0,5848,5849,5,1461,
+        0,0,5849,5854,3,2418,1209,0,5850,5851,5,2455,0,0,5851,5853,3,2418,
+        1209,0,5852,5850,1,0,0,0,5853,5856,1,0,0,0,5854,5852,1,0,0,0,5854,
+        5855,1,0,0,0,5855,421,1,0,0,0,5856,5854,1,0,0,0,5857,5861,3,426,
+        213,0,5858,5861,3,434,217,0,5859,5861,3,424,212,0,5860,5857,1,0,
+        0,0,5860,5858,1,0,0,0,5860,5859,1,0,0,0,5861,5862,1,0,0,0,5862,5860,
+        1,0,0,0,5862,5863,1,0,0,0,5863,423,1,0,0,0,5864,5865,5,12,0,0,5865,
+        5870,3,2418,1209,0,5866,5867,5,2455,0,0,5867,5869,3,2418,1209,0,
+        5868,5866,1,0,0,0,5869,5872,1,0,0,0,5870,5868,1,0,0,0,5870,5871,
+        1,0,0,0,5871,425,1,0,0,0,5872,5870,1,0,0,0,5873,5874,5,12,0,0,5874,
+        5879,3,428,214,0,5875,5876,5,2455,0,0,5876,5878,3,428,214,0,5877,
+        5875,1,0,0,0,5878,5881,1,0,0,0,5879,5877,1,0,0,0,5879,5880,1,0,0,
+        0,5880,427,1,0,0,0,5881,5879,1,0,0,0,5882,5885,3,430,215,0,5883,
+        5885,5,38,0,0,5884,5882,1,0,0,0,5884,5883,1,0,0,0,5885,5886,1,0,
+        0,0,5886,5899,5,1261,0,0,5887,5888,5,426,0,0,5888,5900,3,798,399,
+        0,5889,5890,5,956,0,0,5890,5892,5,972,0,0,5891,5889,1,0,0,0,5891,
+        5892,1,0,0,0,5892,5896,1,0,0,0,5893,5894,3,2312,1156,0,5894,5895,
+        5,2442,0,0,5895,5897,1,0,0,0,5896,5893,1,0,0,0,5896,5897,1,0,0,0,
+        5897,5898,1,0,0,0,5898,5900,3,2430,1215,0,5899,5887,1,0,0,0,5899,
+        5891,1,0,0,0,5900,5906,1,0,0,0,5901,5904,3,432,216,0,5902,5904,5,
+        38,0,0,5903,5901,1,0,0,0,5903,5902,1,0,0,0,5904,5906,1,0,0,0,5905,
+        5884,1,0,0,0,5905,5903,1,0,0,0,5906,429,1,0,0,0,5907,5908,7,58,0,
+        0,5908,431,1,0,0,0,5909,5917,3,2430,1215,0,5910,5911,7,59,0,0,5911,
+        5917,5,793,0,0,5912,5913,5,882,0,0,5913,5917,5,2085,0,0,5914,5915,
+        7,60,0,0,5915,5917,5,426,0,0,5916,5909,1,0,0,0,5916,5910,1,0,0,0,
+        5916,5912,1,0,0,0,5916,5914,1,0,0,0,5917,433,1,0,0,0,5918,5919,5,
+        12,0,0,5919,5920,5,252,0,0,5920,5946,5,2474,0,0,5921,5922,7,61,0,
+        0,5922,5927,3,436,218,0,5923,5924,5,2455,0,0,5924,5926,3,436,218,
+        0,5925,5923,1,0,0,0,5926,5929,1,0,0,0,5927,5925,1,0,0,0,5927,5928,
+        1,0,0,0,5928,5947,1,0,0,0,5929,5927,1,0,0,0,5930,5931,5,476,0,0,
+        5931,5932,3,436,218,0,5932,5933,5,1261,0,0,5933,5941,3,2430,1215,
+        0,5934,5935,5,2455,0,0,5935,5936,3,436,218,0,5936,5937,5,1261,0,
+        0,5937,5938,3,2430,1215,0,5938,5940,1,0,0,0,5939,5934,1,0,0,0,5940,
+        5943,1,0,0,0,5941,5939,1,0,0,0,5941,5942,1,0,0,0,5942,5947,1,0,0,
+        0,5943,5941,1,0,0,0,5944,5945,5,1472,0,0,5945,5947,7,62,0,0,5946,
+        5921,1,0,0,0,5946,5930,1,0,0,0,5946,5944,1,0,0,0,5947,435,1,0,0,
+        0,5948,5949,3,2430,1215,0,5949,437,1,0,0,0,5950,5951,5,1597,0,0,
+        5951,5956,3,2334,1167,0,5952,5953,5,2455,0,0,5953,5955,3,2334,1167,
+        0,5954,5952,1,0,0,0,5955,5958,1,0,0,0,5956,5954,1,0,0,0,5956,5957,
+        1,0,0,0,5957,439,1,0,0,0,5958,5956,1,0,0,0,5959,5960,5,321,0,0,5960,
+        5962,5,298,0,0,5961,5963,5,1589,0,0,5962,5961,1,0,0,0,5962,5963,
+        1,0,0,0,5963,5965,1,0,0,0,5964,5966,5,1673,0,0,5965,5964,1,0,0,0,
+        5965,5966,1,0,0,0,5966,5967,1,0,0,0,5967,5968,5,350,0,0,5968,5970,
+        3,2430,1215,0,5969,5971,3,444,222,0,5970,5969,1,0,0,0,5970,5971,
+        1,0,0,0,5971,5972,1,0,0,0,5972,5982,7,63,0,0,5973,5974,5,352,0,0,
+        5974,5979,3,448,224,0,5975,5976,5,2455,0,0,5976,5978,3,448,224,0,
+        5977,5975,1,0,0,0,5978,5981,1,0,0,0,5979,5977,1,0,0,0,5979,5980,
+        1,0,0,0,5980,5983,1,0,0,0,5981,5979,1,0,0,0,5982,5973,1,0,0,0,5982,
+        5983,1,0,0,0,5983,5987,1,0,0,0,5984,5986,3,442,221,0,5985,5984,1,
+        0,0,0,5986,5989,1,0,0,0,5987,5985,1,0,0,0,5987,5988,1,0,0,0,5988,
+        5991,1,0,0,0,5989,5987,1,0,0,0,5990,5992,3,446,223,0,5991,5990,1,
+        0,0,0,5991,5992,1,0,0,0,5992,441,1,0,0,0,5993,5994,5,927,0,0,5994,
+        6018,3,2422,1211,0,5995,5996,5,929,0,0,5996,6018,3,2422,1211,0,5997,
+        5998,5,928,0,0,5998,6018,3,2422,1211,0,5999,6000,5,923,0,0,6000,
+        6018,3,2422,1211,0,6001,6002,5,926,0,0,6002,6018,3,2422,1211,0,6003,
+        6018,5,66,0,0,6004,6018,5,1059,0,0,6005,6006,5,617,0,0,6006,6018,
+        5,885,0,0,6007,6008,5,1673,0,0,6008,6009,5,1736,0,0,6009,6010,5,
+        1120,0,0,6010,6015,5,621,0,0,6011,6012,5,351,0,0,6012,6016,5,98,
+        0,0,6013,6014,5,868,0,0,6014,6016,5,1387,0,0,6015,6011,1,0,0,0,6015,
+        6013,1,0,0,0,6016,6018,1,0,0,0,6017,5993,1,0,0,0,6017,5995,1,0,0,
+        0,6017,5997,1,0,0,0,6017,5999,1,0,0,0,6017,6001,1,0,0,0,6017,6003,
+        1,0,0,0,6017,6004,1,0,0,0,6017,6005,1,0,0,0,6017,6007,1,0,0,0,6018,
+        443,1,0,0,0,6019,6024,5,883,0,0,6020,6022,5,650,0,0,6021,6020,1,
+        0,0,0,6021,6022,1,0,0,0,6022,6023,1,0,0,0,6023,6025,3,2422,1211,
+        0,6024,6021,1,0,0,0,6024,6025,1,0,0,0,6025,6026,1,0,0,0,6026,6037,
+        3,448,224,0,6027,6032,5,2455,0,0,6028,6030,5,650,0,0,6029,6028,1,
+        0,0,0,6029,6030,1,0,0,0,6030,6031,1,0,0,0,6031,6033,3,2422,1211,
+        0,6032,6029,1,0,0,0,6032,6033,1,0,0,0,6033,6034,1,0,0,0,6034,6036,
+        3,448,224,0,6035,6027,1,0,0,0,6036,6039,1,0,0,0,6037,6035,1,0,0,
+        0,6037,6038,1,0,0,0,6038,445,1,0,0,0,6039,6037,1,0,0,0,6040,6041,
+        5,193,0,0,6041,6042,5,1673,0,0,6042,6043,3,2430,1215,0,6043,447,
+        1,0,0,0,6044,6047,3,930,465,0,6045,6047,3,932,466,0,6046,6044,1,
+        0,0,0,6046,6045,1,0,0,0,6047,449,1,0,0,0,6048,6049,5,321,0,0,6049,
+        6050,5,441,0,0,6050,6063,3,2430,1215,0,6051,6061,5,676,0,0,6052,
+        6061,5,1180,0,0,6053,6061,5,610,0,0,6054,6057,5,2378,0,0,6055,6056,
+        5,1690,0,0,6056,6058,3,2430,1215,0,6057,6055,1,0,0,0,6057,6058,1,
+        0,0,0,6058,6061,1,0,0,0,6059,6061,5,561,0,0,6060,6051,1,0,0,0,6060,
+        6052,1,0,0,0,6060,6053,1,0,0,0,6060,6054,1,0,0,0,6060,6059,1,0,0,
+        0,6061,6062,1,0,0,0,6062,6064,5,1526,0,0,6063,6060,1,0,0,0,6063,
+        6064,1,0,0,0,6064,6081,1,0,0,0,6065,6067,3,90,45,0,6066,6065,1,0,
+        0,0,6066,6067,1,0,0,0,6067,6070,1,0,0,0,6068,6069,5,573,0,0,6069,
+        6071,3,2430,1215,0,6070,6068,1,0,0,0,6070,6071,1,0,0,0,6071,6072,
+        1,0,0,0,6072,6073,5,440,0,0,6073,6078,3,452,226,0,6074,6075,5,2455,
+        0,0,6075,6077,3,452,226,0,6076,6074,1,0,0,0,6077,6080,1,0,0,0,6078,
+        6076,1,0,0,0,6078,6079,1,0,0,0,6079,6082,1,0,0,0,6080,6078,1,0,0,
+        0,6081,6066,1,0,0,0,6082,6083,1,0,0,0,6083,6081,1,0,0,0,6083,6084,
+        1,0,0,0,6084,6098,1,0,0,0,6085,6086,5,83,0,0,6086,6087,5,2445,0,
+        0,6087,6088,5,2474,0,0,6088,6095,5,2445,0,0,6089,6090,5,2455,0,0,
+        6090,6091,5,2445,0,0,6091,6092,5,2474,0,0,6092,6094,5,2445,0,0,6093,
+        6089,1,0,0,0,6094,6097,1,0,0,0,6095,6093,1,0,0,0,6095,6096,1,0,0,
+        0,6096,6099,1,0,0,0,6097,6095,1,0,0,0,6098,6085,1,0,0,0,6098,6099,
+        1,0,0,0,6099,451,1,0,0,0,6100,6103,5,2445,0,0,6101,6102,5,998,0,
+        0,6102,6104,3,2430,1215,0,6103,6101,1,0,0,0,6103,6104,1,0,0,0,6104,
+        6107,1,0,0,0,6105,6106,5,1701,0,0,6106,6108,3,1188,594,0,6107,6105,
+        1,0,0,0,6107,6108,1,0,0,0,6108,6110,1,0,0,0,6109,6111,3,44,22,0,
+        6110,6109,1,0,0,0,6110,6111,1,0,0,0,6111,453,1,0,0,0,6112,6113,5,
+        321,0,0,6113,6114,5,483,0,0,6114,6119,3,2430,1215,0,6115,6116,5,
+        69,0,0,6116,6117,5,202,0,0,6117,6118,5,1248,0,0,6118,6120,3,2430,
+        1215,0,6119,6115,1,0,0,0,6119,6120,1,0,0,0,6120,455,1,0,0,0,6121,
+        6122,5,321,0,0,6122,6123,5,606,0,0,6123,6125,5,64,0,0,6124,6126,
+        5,389,0,0,6125,6124,1,0,0,0,6125,6126,1,0,0,0,6126,6127,1,0,0,0,
+        6127,6128,3,2430,1215,0,6128,6129,5,2082,0,0,6129,6131,3,2430,1215,
+        0,6130,6132,3,458,229,0,6131,6130,1,0,0,0,6131,6132,1,0,0,0,6132,
+        6138,1,0,0,0,6133,6135,5,1139,0,0,6134,6133,1,0,0,0,6134,6135,1,
+        0,0,0,6135,6136,1,0,0,0,6136,6137,5,1271,0,0,6137,6139,5,351,0,0,
+        6138,6134,1,0,0,0,6138,6139,1,0,0,0,6139,6140,1,0,0,0,6140,6141,
+        3,460,230,0,6141,457,1,0,0,0,6142,6143,5,1492,0,0,6143,6144,5,2443,
+        0,0,6144,6145,7,64,0,0,6145,459,1,0,0,0,6146,6147,5,1585,0,0,6147,
+        6148,5,2443,0,0,6148,6149,7,65,0,0,6149,461,1,0,0,0,6150,6153,5,
+        321,0,0,6151,6152,5,1309,0,0,6152,6154,5,1564,0,0,6153,6151,1,0,
+        0,0,6153,6154,1,0,0,0,6154,6159,1,0,0,0,6155,6157,5,1139,0,0,6156,
+        6155,1,0,0,0,6156,6157,1,0,0,0,6157,6158,1,0,0,0,6158,6160,5,617,
+        0,0,6159,6156,1,0,0,0,6159,6160,1,0,0,0,6160,6161,1,0,0,0,6161,6165,
+        5,675,0,0,6162,6163,3,2312,1156,0,6163,6164,5,2442,0,0,6164,6166,
+        1,0,0,0,6165,6162,1,0,0,0,6165,6166,1,0,0,0,6166,6167,1,0,0,0,6167,
+        6171,3,2430,1215,0,6168,6169,5,1683,0,0,6169,6170,5,2474,0,0,6170,
+        6172,7,21,0,0,6171,6168,1,0,0,0,6171,6172,1,0,0,0,6172,6176,1,0,
+        0,0,6173,6175,3,344,172,0,6174,6173,1,0,0,0,6175,6178,1,0,0,0,6176,
+        6174,1,0,0,0,6176,6177,1,0,0,0,6177,6179,1,0,0,0,6178,6176,1,0,0,
+        0,6179,6180,3,464,232,0,6180,6182,3,466,233,0,6181,6183,3,468,234,
+        0,6182,6181,1,0,0,0,6182,6183,1,0,0,0,6183,463,1,0,0,0,6184,6188,
+        5,2248,0,0,6185,6186,3,2312,1156,0,6186,6187,5,2442,0,0,6187,6189,
+        1,0,0,0,6188,6185,1,0,0,0,6188,6189,1,0,0,0,6189,6190,1,0,0,0,6190,
+        6191,3,2430,1215,0,6191,465,1,0,0,0,6192,6198,5,2449,0,0,6193,6196,
+        3,2430,1215,0,6194,6195,5,202,0,0,6195,6197,5,1248,0,0,6196,6194,
+        1,0,0,0,6196,6197,1,0,0,0,6197,6199,1,0,0,0,6198,6193,1,0,0,0,6199,
+        6200,1,0,0,0,6200,6198,1,0,0,0,6200,6201,1,0,0,0,6201,6202,1,0,0,
+        0,6202,6203,5,2450,0,0,6203,467,1,0,0,0,6204,6205,5,673,0,0,6205,
+        6206,5,84,0,0,6206,6207,5,2449,0,0,6207,6208,3,470,235,0,6208,6209,
+        5,2450,0,0,6209,469,1,0,0,0,6210,6214,3,472,236,0,6211,6213,3,344,
+        172,0,6212,6211,1,0,0,0,6213,6216,1,0,0,0,6214,6212,1,0,0,0,6214,
+        6215,1,0,0,0,6215,471,1,0,0,0,6216,6214,1,0,0,0,6217,6218,7,66,0,
+        0,6218,473,1,0,0,0,6219,6221,5,321,0,0,6220,6222,7,67,0,0,6221,6220,
+        1,0,0,0,6221,6222,1,0,0,0,6222,6223,1,0,0,0,6223,6224,5,718,0,0,
+        6224,6228,3,2354,1177,0,6225,6226,5,692,0,0,6226,6227,5,1206,0,0,
+        6227,6229,5,546,0,0,6228,6225,1,0,0,0,6228,6229,1,0,0,0,6229,6230,
+        1,0,0,0,6230,6234,5,1261,0,0,6231,6235,3,476,238,0,6232,6235,3,480,
+        240,0,6233,6235,3,482,241,0,6234,6231,1,0,0,0,6234,6232,1,0,0,0,
+        6234,6233,1,0,0,0,6235,6237,1,0,0,0,6236,6238,7,68,0,0,6237,6236,
+        1,0,0,0,6237,6238,1,0,0,0,6238,6241,1,0,0,0,6239,6240,7,69,0,0,6240,
+        6242,5,782,0,0,6241,6239,1,0,0,0,6241,6242,1,0,0,0,6242,475,1,0,
+        0,0,6243,6244,5,220,0,0,6244,6246,3,478,239,0,6245,6247,3,1606,803,
+        0,6246,6245,1,0,0,0,6246,6247,1,0,0,0,6247,477,1,0,0,0,6248,6249,
+        3,2430,1215,0,6249,6250,5,2442,0,0,6250,6252,1,0,0,0,6251,6248,1,
+        0,0,0,6251,6252,1,0,0,0,6252,6253,1,0,0,0,6253,6254,3,2430,1215,
+        0,6254,479,1,0,0,0,6255,6257,3,2368,1184,0,6256,6258,3,2296,1148,
+        0,6257,6256,1,0,0,0,6257,6258,1,0,0,0,6258,6259,1,0,0,0,6259,6260,
+        5,2449,0,0,6260,6262,3,484,242,0,6261,6263,7,55,0,0,6262,6261,1,
+        0,0,0,6262,6263,1,0,0,0,6263,6271,1,0,0,0,6264,6265,5,2455,0,0,6265,
+        6267,3,484,242,0,6266,6268,7,55,0,0,6267,6266,1,0,0,0,6267,6268,
+        1,0,0,0,6268,6270,1,0,0,0,6269,6264,1,0,0,0,6270,6273,1,0,0,0,6271,
+        6269,1,0,0,0,6271,6272,1,0,0,0,6272,6274,1,0,0,0,6273,6271,1,0,0,
+        0,6274,6276,5,2450,0,0,6275,6277,3,486,243,0,6276,6275,1,0,0,0,6276,
+        6277,1,0,0,0,6277,481,1,0,0,0,6278,6279,3,2368,1184,0,6279,6282,
+        5,2449,0,0,6280,6283,3,2368,1184,0,6281,6283,3,2296,1148,0,6282,
+        6280,1,0,0,0,6282,6281,1,0,0,0,6282,6283,1,0,0,0,6283,6284,1,0,0,
+        0,6284,6286,3,2366,1183,0,6285,6287,7,55,0,0,6286,6285,1,0,0,0,6286,
+        6287,1,0,0,0,6287,6299,1,0,0,0,6288,6291,5,2455,0,0,6289,6292,3,
+        2368,1184,0,6290,6292,3,2296,1148,0,6291,6289,1,0,0,0,6291,6290,
+        1,0,0,0,6291,6292,1,0,0,0,6292,6293,1,0,0,0,6293,6295,3,2366,1183,
+        0,6294,6296,7,55,0,0,6295,6294,1,0,0,0,6295,6296,1,0,0,0,6296,6298,
+        1,0,0,0,6297,6288,1,0,0,0,6298,6301,1,0,0,0,6299,6297,1,0,0,0,6299,
+        6300,1,0,0,0,6300,6302,1,0,0,0,6301,6299,1,0,0,0,6302,6303,5,2450,
+        0,0,6303,6304,5,629,0,0,6304,6305,3,2368,1184,0,6305,6312,3,2296,
+        1148,0,6306,6307,5,2455,0,0,6307,6308,3,2368,1184,0,6308,6309,3,
+        2296,1148,0,6309,6311,1,0,0,0,6310,6306,1,0,0,0,6311,6314,1,0,0,
+        0,6312,6310,1,0,0,0,6312,6313,1,0,0,0,6313,6315,1,0,0,0,6314,6312,
+        1,0,0,0,6315,6317,3,2298,1149,0,6316,6318,3,502,251,0,6317,6316,
+        1,0,0,0,6317,6318,1,0,0,0,6318,6320,1,0,0,0,6319,6321,3,1606,803,
+        0,6320,6319,1,0,0,0,6320,6321,1,0,0,0,6321,483,1,0,0,0,6322,6325,
+        3,2366,1183,0,6323,6325,3,2100,1050,0,6324,6322,1,0,0,0,6324,6323,
+        1,0,0,0,6325,485,1,0,0,0,6326,6330,3,496,248,0,6327,6330,3,502,251,
+        0,6328,6330,3,1606,803,0,6329,6326,1,0,0,0,6329,6327,1,0,0,0,6329,
+        6328,1,0,0,0,6330,6331,1,0,0,0,6331,6329,1,0,0,0,6331,6332,1,0,0,
+        0,6332,6340,1,0,0,0,6333,6334,5,732,0,0,6334,6337,5,786,0,0,6335,
+        6338,3,488,244,0,6336,6338,3,492,246,0,6337,6335,1,0,0,0,6337,6336,
+        1,0,0,0,6338,6340,1,0,0,0,6339,6329,1,0,0,0,6339,6333,1,0,0,0,6339,
+        6340,1,0,0,0,6340,487,1,0,0,0,6341,6343,3,524,262,0,6342,6344,3,
+        490,245,0,6343,6342,1,0,0,0,6343,6344,1,0,0,0,6344,6346,1,0,0,0,
+        6345,6347,3,940,470,0,6346,6345,1,0,0,0,6346,6347,1,0,0,0,6347,6353,
+        1,0,0,0,6348,6349,5,1337,0,0,6349,6350,5,2449,0,0,6350,6351,3,522,
+        261,0,6351,6352,5,2450,0,0,6352,6354,1,0,0,0,6353,6348,1,0,0,0,6353,
+        6354,1,0,0,0,6354,489,1,0,0,0,6355,6383,5,874,0,0,6356,6357,5,2449,
+        0,0,6357,6358,5,1350,0,0,6358,6364,3,1716,858,0,6359,6360,5,1337,
+        0,0,6360,6361,5,2449,0,0,6361,6362,3,522,261,0,6362,6363,5,2450,
+        0,0,6363,6365,1,0,0,0,6364,6359,1,0,0,0,6364,6365,1,0,0,0,6365,6378,
+        1,0,0,0,6366,6367,5,2455,0,0,6367,6368,5,1350,0,0,6368,6374,3,1716,
+        858,0,6369,6370,5,1337,0,0,6370,6371,5,2449,0,0,6371,6372,3,522,
+        261,0,6372,6373,5,2450,0,0,6373,6375,1,0,0,0,6374,6369,1,0,0,0,6374,
+        6375,1,0,0,0,6375,6377,1,0,0,0,6376,6366,1,0,0,0,6377,6380,1,0,0,
+        0,6378,6376,1,0,0,0,6378,6379,1,0,0,0,6379,6381,1,0,0,0,6380,6378,
+        1,0,0,0,6381,6382,5,2450,0,0,6382,6384,1,0,0,0,6383,6356,1,0,0,0,
+        6383,6384,1,0,0,0,6384,491,1,0,0,0,6385,6386,5,2317,0,0,6386,6388,
+        5,2442,0,0,6387,6385,1,0,0,0,6387,6388,1,0,0,0,6388,6389,1,0,0,0,
+        6389,6391,5,2334,0,0,6390,6392,3,494,247,0,6391,6390,1,0,0,0,6391,
+        6392,1,0,0,0,6392,6394,1,0,0,0,6393,6395,3,940,470,0,6394,6393,1,
+        0,0,0,6394,6395,1,0,0,0,6395,493,1,0,0,0,6396,6410,5,874,0,0,6397,
+        6398,5,2449,0,0,6398,6399,5,1350,0,0,6399,6405,3,1716,858,0,6400,
+        6401,5,2455,0,0,6401,6402,5,1350,0,0,6402,6404,3,1716,858,0,6403,
+        6400,1,0,0,0,6404,6407,1,0,0,0,6405,6403,1,0,0,0,6405,6406,1,0,0,
+        0,6406,6408,1,0,0,0,6407,6405,1,0,0,0,6408,6409,5,2450,0,0,6409,
+        6411,1,0,0,0,6410,6397,1,0,0,0,6410,6411,1,0,0,0,6411,495,1,0,0,
+        0,6412,6413,5,643,0,0,6413,6414,5,1350,0,0,6414,6452,5,160,0,0,6415,
+        6416,5,1497,0,0,6416,6417,5,2449,0,0,6417,6422,3,2366,1183,0,6418,
+        6419,5,2455,0,0,6419,6421,3,2366,1183,0,6420,6418,1,0,0,0,6421,6424,
+        1,0,0,0,6422,6420,1,0,0,0,6422,6423,1,0,0,0,6423,6425,1,0,0,0,6424,
+        6422,1,0,0,0,6425,6426,5,2450,0,0,6426,6427,5,2449,0,0,6427,6432,
+        3,498,249,0,6428,6429,5,2455,0,0,6429,6431,3,498,249,0,6430,6428,
+        1,0,0,0,6431,6434,1,0,0,0,6432,6430,1,0,0,0,6432,6433,1,0,0,0,6433,
+        6435,1,0,0,0,6434,6432,1,0,0,0,6435,6436,5,2450,0,0,6436,6453,1,
+        0,0,0,6437,6438,5,661,0,0,6438,6439,5,2449,0,0,6439,6444,3,2366,
+        1183,0,6440,6441,5,2455,0,0,6441,6443,3,2366,1183,0,6442,6440,1,
+        0,0,0,6443,6446,1,0,0,0,6444,6442,1,0,0,0,6444,6445,1,0,0,0,6445,
+        6447,1,0,0,0,6446,6444,1,0,0,0,6447,6450,5,2450,0,0,6448,6451,3,
+        1134,567,0,6449,6451,3,1136,568,0,6450,6448,1,0,0,0,6450,6449,1,
+        0,0,0,6451,6453,1,0,0,0,6452,6415,1,0,0,0,6452,6437,1,0,0,0,6453,
+        497,1,0,0,0,6454,6456,5,1350,0,0,6455,6457,3,1716,858,0,6456,6455,
+        1,0,0,0,6456,6457,1,0,0,0,6457,6458,1,0,0,0,6458,6459,5,2259,0,0,
+        6459,6460,5,846,0,0,6460,6461,5,2100,0,0,6461,6462,5,2449,0,0,6462,
+        6463,3,500,250,0,6463,6465,5,2450,0,0,6464,6466,3,1212,606,0,6465,
+        6464,1,0,0,0,6465,6466,1,0,0,0,6466,499,1,0,0,0,6467,6472,3,2210,
+        1105,0,6468,6469,5,2455,0,0,6469,6471,3,2210,1105,0,6470,6468,1,
+        0,0,0,6471,6474,1,0,0,0,6472,6470,1,0,0,0,6472,6473,1,0,0,0,6473,
+        6486,1,0,0,0,6474,6472,1,0,0,0,6475,6476,5,2110,0,0,6476,6482,3,
+        2210,1105,0,6477,6478,5,2455,0,0,6478,6479,5,2110,0,0,6479,6481,
+        3,2210,1105,0,6480,6477,1,0,0,0,6481,6484,1,0,0,0,6482,6480,1,0,
+        0,0,6482,6483,1,0,0,0,6483,6486,1,0,0,0,6484,6482,1,0,0,0,6485,6467,
+        1,0,0,0,6485,6475,1,0,0,0,6486,501,1,0,0,0,6487,6492,5,874,0,0,6488,
+        6493,3,504,252,0,6489,6493,3,506,253,0,6490,6493,3,510,255,0,6491,
+        6493,3,514,257,0,6492,6488,1,0,0,0,6492,6489,1,0,0,0,6492,6490,1,
+        0,0,0,6492,6491,1,0,0,0,6492,6493,1,0,0,0,6493,503,1,0,0,0,6494,
+        6495,5,2449,0,0,6495,6500,3,508,254,0,6496,6497,5,2455,0,0,6497,
+        6499,3,508,254,0,6498,6496,1,0,0,0,6499,6502,1,0,0,0,6500,6498,1,
+        0,0,0,6500,6501,1,0,0,0,6501,6503,1,0,0,0,6502,6500,1,0,0,0,6503,
+        6504,5,2450,0,0,6504,505,1,0,0,0,6505,6506,5,2449,0,0,6506,6511,
+        3,508,254,0,6507,6508,5,2455,0,0,6508,6510,3,508,254,0,6509,6507,
+        1,0,0,0,6510,6513,1,0,0,0,6511,6509,1,0,0,0,6511,6512,1,0,0,0,6512,
+        6514,1,0,0,0,6513,6511,1,0,0,0,6514,6515,5,2450,0,0,6515,507,1,0,
+        0,0,6516,6518,5,1350,0,0,6517,6519,3,1716,858,0,6518,6517,1,0,0,
+        0,6518,6519,1,0,0,0,6519,6524,1,0,0,0,6520,6523,3,1212,606,0,6521,
+        6523,3,1620,810,0,6522,6520,1,0,0,0,6522,6521,1,0,0,0,6523,6526,
+        1,0,0,0,6524,6522,1,0,0,0,6524,6525,1,0,0,0,6525,6528,1,0,0,0,6526,
+        6524,1,0,0,0,6527,6529,5,2205,0,0,6528,6527,1,0,0,0,6528,6529,1,
+        0,0,0,6529,509,1,0,0,0,6530,6531,5,1765,0,0,6531,6532,5,739,0,0,
+        6532,6533,5,2449,0,0,6533,6538,3,1676,838,0,6534,6535,5,2455,0,0,
+        6535,6537,3,1676,838,0,6536,6534,1,0,0,0,6537,6540,1,0,0,0,6538,
+        6536,1,0,0,0,6538,6539,1,0,0,0,6539,6541,1,0,0,0,6540,6538,1,0,0,
+        0,6541,6542,5,2450,0,0,6542,6555,1,0,0,0,6543,6544,5,2449,0,0,6544,
+        6549,3,512,256,0,6545,6546,5,2455,0,0,6546,6548,3,512,256,0,6547,
+        6545,1,0,0,0,6548,6551,1,0,0,0,6549,6547,1,0,0,0,6549,6550,1,0,0,
+        0,6550,6552,1,0,0,0,6551,6549,1,0,0,0,6552,6553,5,2450,0,0,6553,
+        6555,1,0,0,0,6554,6530,1,0,0,0,6554,6543,1,0,0,0,6555,511,1,0,0,
+        0,6556,6558,5,1350,0,0,6557,6559,3,1716,858,0,6558,6557,1,0,0,0,
+        6558,6559,1,0,0,0,6559,6562,1,0,0,0,6560,6561,5,2082,0,0,6561,6563,
+        3,1676,838,0,6562,6560,1,0,0,0,6562,6563,1,0,0,0,6563,6565,1,0,0,
+        0,6564,6566,3,1620,810,0,6565,6564,1,0,0,0,6565,6566,1,0,0,0,6566,
+        6568,1,0,0,0,6567,6569,5,2205,0,0,6568,6567,1,0,0,0,6568,6569,1,
+        0,0,0,6569,513,1,0,0,0,6570,6571,5,1765,0,0,6571,6572,5,739,0,0,
+        6572,6573,5,2449,0,0,6573,6578,3,1676,838,0,6574,6575,5,2455,0,0,
+        6575,6577,3,1676,838,0,6576,6574,1,0,0,0,6577,6580,1,0,0,0,6578,
+        6576,1,0,0,0,6578,6579,1,0,0,0,6579,6581,1,0,0,0,6580,6578,1,0,0,
+        0,6581,6582,5,2450,0,0,6582,6584,1,0,0,0,6583,6570,1,0,0,0,6583,
+        6584,1,0,0,0,6584,6585,1,0,0,0,6585,6586,5,2449,0,0,6586,6591,3,
+        516,258,0,6587,6588,5,2455,0,0,6588,6590,3,516,258,0,6589,6587,1,
+        0,0,0,6590,6593,1,0,0,0,6591,6589,1,0,0,0,6591,6592,1,0,0,0,6592,
+        6594,1,0,0,0,6593,6591,1,0,0,0,6594,6595,5,2450,0,0,6595,515,1,0,
+        0,0,6596,6598,5,1350,0,0,6597,6599,3,1716,858,0,6598,6597,1,0,0,
+        0,6598,6599,1,0,0,0,6599,6604,1,0,0,0,6600,6603,3,1212,606,0,6601,
+        6603,3,1620,810,0,6602,6600,1,0,0,0,6602,6601,1,0,0,0,6603,6606,
+        1,0,0,0,6604,6602,1,0,0,0,6604,6605,1,0,0,0,6605,6608,1,0,0,0,6606,
+        6604,1,0,0,0,6607,6609,5,2205,0,0,6608,6607,1,0,0,0,6608,6609,1,
+        0,0,0,6609,6611,1,0,0,0,6610,6612,3,518,259,0,6611,6610,1,0,0,0,
+        6611,6612,1,0,0,0,6612,517,1,0,0,0,6613,6614,5,1765,0,0,6614,6615,
+        5,739,0,0,6615,6616,5,2449,0,0,6616,6621,3,1676,838,0,6617,6618,
+        5,2455,0,0,6618,6620,3,1676,838,0,6619,6617,1,0,0,0,6620,6623,1,
+        0,0,0,6621,6619,1,0,0,0,6621,6622,1,0,0,0,6622,6624,1,0,0,0,6623,
+        6621,1,0,0,0,6624,6625,5,2450,0,0,6625,6638,1,0,0,0,6626,6627,5,
+        2449,0,0,6627,6632,3,520,260,0,6628,6629,5,2455,0,0,6629,6631,3,
+        520,260,0,6630,6628,1,0,0,0,6631,6634,1,0,0,0,6632,6630,1,0,0,0,
+        6632,6633,1,0,0,0,6633,6635,1,0,0,0,6634,6632,1,0,0,0,6635,6636,
+        5,2450,0,0,6636,6638,1,0,0,0,6637,6613,1,0,0,0,6637,6626,1,0,0,0,
+        6638,519,1,0,0,0,6639,6641,5,1777,0,0,6640,6642,3,1166,583,0,6641,
+        6640,1,0,0,0,6641,6642,1,0,0,0,6642,6645,1,0,0,0,6643,6644,5,2082,
+        0,0,6644,6646,3,1676,838,0,6645,6643,1,0,0,0,6645,6646,1,0,0,0,6646,
+        6648,1,0,0,0,6647,6649,3,1620,810,0,6648,6647,1,0,0,0,6648,6649,
+        1,0,0,0,6649,6651,1,0,0,0,6650,6652,5,2205,0,0,6651,6650,1,0,0,0,
+        6651,6652,1,0,0,0,6652,521,1,0,0,0,6653,6654,5,2445,0,0,6654,523,
+        1,0,0,0,6655,6656,3,2430,1215,0,6656,6657,5,2442,0,0,6657,6659,1,
+        0,0,0,6658,6655,1,0,0,0,6658,6659,1,0,0,0,6659,6660,1,0,0,0,6660,
+        6661,3,2430,1215,0,6661,525,1,0,0,0,6662,6663,5,42,0,0,6663,6664,
+        5,718,0,0,6664,6667,3,2354,1177,0,6665,6668,3,528,264,0,6666,6668,
+        3,530,265,0,6667,6665,1,0,0,0,6667,6666,1,0,0,0,6668,527,1,0,0,0,
+        6669,6676,3,1298,649,0,6670,6676,3,1296,648,0,6671,6676,3,1300,650,
+        0,6672,6676,3,940,470,0,6673,6676,3,1206,603,0,6674,6676,3,898,449,
+        0,6675,6669,1,0,0,0,6675,6670,1,0,0,0,6675,6671,1,0,0,0,6675,6672,
+        1,0,0,0,6675,6673,1,0,0,0,6675,6674,1,0,0,0,6676,6677,1,0,0,0,6677,
+        6675,1,0,0,0,6677,6678,1,0,0,0,6678,529,1,0,0,0,6679,6701,3,536,
+        268,0,6680,6681,5,1337,0,0,6681,6682,5,2449,0,0,6682,6683,3,522,
+        261,0,6683,6684,5,2450,0,0,6684,6701,1,0,0,0,6685,6701,5,249,0,0,
+        6686,6701,3,1320,660,0,6687,6701,5,2205,0,0,6688,6701,3,532,266,
+        0,6689,6690,5,1561,0,0,6690,6691,5,2143,0,0,6691,6701,3,564,282,
+        0,6692,6701,5,228,0,0,6693,6694,3,534,267,0,6694,6695,5,2218,0,0,
+        6695,6701,1,0,0,0,6696,6697,5,2209,0,0,6697,6698,5,143,0,0,6698,
+        6701,5,1530,0,0,6699,6701,3,538,269,0,6700,6679,1,0,0,0,6700,6680,
+        1,0,0,0,6700,6685,1,0,0,0,6700,6686,1,0,0,0,6700,6687,1,0,0,0,6700,
+        6688,1,0,0,0,6700,6689,1,0,0,0,6700,6692,1,0,0,0,6700,6693,1,0,0,
+        0,6700,6696,1,0,0,0,6700,6699,1,0,0,0,6701,531,1,0,0,0,6702,6703,
+        7,70,0,0,6703,533,1,0,0,0,6704,6705,7,71,0,0,6705,535,1,0,0,0,6706,
+        6713,5,1513,0,0,6707,6708,5,1350,0,0,6708,6714,3,1716,858,0,6709,
+        6710,5,1777,0,0,6710,6714,3,1166,583,0,6711,6714,5,1590,0,0,6712,
+        6714,5,1177,0,0,6713,6707,1,0,0,0,6713,6709,1,0,0,0,6713,6711,1,
+        0,0,0,6713,6712,1,0,0,0,6713,6714,1,0,0,0,6714,6729,1,0,0,0,6715,
+        6728,3,940,470,0,6716,6717,5,2082,0,0,6717,6728,3,1676,838,0,6718,
+        6719,5,1337,0,0,6719,6720,5,2449,0,0,6720,6721,3,522,261,0,6721,
+        6722,5,2450,0,0,6722,6728,1,0,0,0,6723,6728,5,1258,0,0,6724,6728,
+        3,1206,603,0,6725,6728,3,1620,810,0,6726,6728,3,898,449,0,6727,6715,
+        1,0,0,0,6727,6716,1,0,0,0,6727,6718,1,0,0,0,6727,6723,1,0,0,0,6727,
+        6724,1,0,0,0,6727,6725,1,0,0,0,6727,6726,1,0,0,0,6728,6731,1,0,0,
+        0,6729,6727,1,0,0,0,6729,6730,1,0,0,0,6730,537,1,0,0,0,6731,6729,
+        1,0,0,0,6732,6741,3,540,270,0,6733,6741,3,542,271,0,6734,6741,3,
+        546,273,0,6735,6741,3,550,275,0,6736,6741,3,552,276,0,6737,6741,
+        3,554,277,0,6738,6741,3,544,272,0,6739,6741,3,558,279,0,6740,6732,
+        1,0,0,0,6740,6733,1,0,0,0,6740,6734,1,0,0,0,6740,6735,1,0,0,0,6740,
+        6736,1,0,0,0,6740,6737,1,0,0,0,6740,6738,1,0,0,0,6740,6739,1,0,0,
+        0,6741,539,1,0,0,0,6742,6743,5,981,0,0,6743,6744,5,389,0,0,6744,
+        6748,5,84,0,0,6745,6746,5,621,0,0,6746,6747,5,1350,0,0,6747,6749,
+        3,1716,858,0,6748,6745,1,0,0,0,6748,6749,1,0,0,0,6749,6757,1,0,0,
+        0,6750,6758,3,1206,603,0,6751,6754,5,2082,0,0,6752,6755,3,1676,838,
+        0,6753,6755,5,389,0,0,6754,6752,1,0,0,0,6754,6753,1,0,0,0,6755,6758,
+        1,0,0,0,6756,6758,3,898,449,0,6757,6750,1,0,0,0,6757,6751,1,0,0,
+        0,6757,6756,1,0,0,0,6758,541,1,0,0,0,6759,6760,5,21,0,0,6760,6762,
+        5,1350,0,0,6761,6763,3,1716,858,0,6762,6761,1,0,0,0,6762,6763,1,
+        0,0,0,6763,6766,1,0,0,0,6764,6765,5,2082,0,0,6765,6767,3,1676,838,
+        0,6766,6764,1,0,0,0,6766,6767,1,0,0,0,6767,6769,1,0,0,0,6768,6770,
+        3,1620,810,0,6769,6768,1,0,0,0,6769,6770,1,0,0,0,6770,6772,1,0,0,
+        0,6771,6773,3,940,470,0,6772,6771,1,0,0,0,6772,6773,1,0,0,0,6773,
+        543,1,0,0,0,6774,6775,5,228,0,0,6775,6777,5,1350,0,0,6776,6778,3,
+        940,470,0,6777,6776,1,0,0,0,6777,6778,1,0,0,0,6778,545,1,0,0,0,6779,
+        6780,5,981,0,0,6780,6781,5,1350,0,0,6781,6797,3,1716,858,0,6782,
+        6784,3,548,274,0,6783,6782,1,0,0,0,6784,6785,1,0,0,0,6785,6783,1,
+        0,0,0,6785,6786,1,0,0,0,6786,6798,1,0,0,0,6787,6788,5,1337,0,0,6788,
+        6789,5,2449,0,0,6789,6790,3,522,261,0,6790,6791,5,2450,0,0,6791,
+        6798,1,0,0,0,6792,6798,5,228,0,0,6793,6794,5,2209,0,0,6794,6795,
+        5,143,0,0,6795,6798,5,1530,0,0,6796,6798,5,2205,0,0,6797,6783,1,
+        0,0,0,6797,6787,1,0,0,0,6797,6792,1,0,0,0,6797,6793,1,0,0,0,6797,
+        6796,1,0,0,0,6798,547,1,0,0,0,6799,6806,3,1298,649,0,6800,6806,3,
+        1296,648,0,6801,6806,3,1206,603,0,6802,6806,3,898,449,0,6803,6806,
+        3,1620,810,0,6804,6806,3,1300,650,0,6805,6799,1,0,0,0,6805,6800,
+        1,0,0,0,6805,6801,1,0,0,0,6805,6802,1,0,0,0,6805,6803,1,0,0,0,6805,
+        6804,1,0,0,0,6806,549,1,0,0,0,6807,6812,5,1561,0,0,6808,6809,5,1350,
+        0,0,6809,6813,3,1716,858,0,6810,6811,5,1777,0,0,6811,6813,3,1166,
+        583,0,6812,6808,1,0,0,0,6812,6810,1,0,0,0,6813,6814,1,0,0,0,6814,
+        6815,5,2143,0,0,6815,6816,3,562,281,0,6816,551,1,0,0,0,6817,6818,
+        5,469,0,0,6818,6819,5,1350,0,0,6819,6820,3,1716,858,0,6820,553,1,
+        0,0,0,6821,6822,5,1719,0,0,6822,6823,5,1350,0,0,6823,6824,3,560,
+        280,0,6824,6825,5,82,0,0,6825,6826,5,2449,0,0,6826,6831,3,2210,1105,
+        0,6827,6828,5,2455,0,0,6828,6830,3,2210,1105,0,6829,6827,1,0,0,0,
+        6830,6833,1,0,0,0,6831,6829,1,0,0,0,6831,6832,1,0,0,0,6832,6834,
+        1,0,0,0,6833,6831,1,0,0,0,6834,6842,5,2450,0,0,6835,6836,5,780,0,
+        0,6836,6837,5,2449,0,0,6837,6838,3,556,278,0,6838,6839,5,2455,0,
+        0,6839,6840,3,556,278,0,6840,6841,5,2450,0,0,6841,6843,1,0,0,0,6842,
+        6835,1,0,0,0,6842,6843,1,0,0,0,6843,6845,1,0,0,0,6844,6846,3,940,
+        470,0,6845,6844,1,0,0,0,6845,6846,1,0,0,0,6846,555,1,0,0,0,6847,
+        6865,5,1350,0,0,6848,6860,3,1716,858,0,6849,6852,3,1212,606,0,6850,
+        6852,3,1620,810,0,6851,6849,1,0,0,0,6851,6850,1,0,0,0,6852,6853,
+        1,0,0,0,6853,6851,1,0,0,0,6853,6854,1,0,0,0,6854,6861,1,0,0,0,6855,
+        6856,5,1337,0,0,6856,6857,5,2449,0,0,6857,6858,3,522,261,0,6858,
+        6859,5,2450,0,0,6859,6861,1,0,0,0,6860,6851,1,0,0,0,6860,6855,1,
+        0,0,0,6861,6863,1,0,0,0,6862,6864,5,2205,0,0,6863,6862,1,0,0,0,6863,
+        6864,1,0,0,0,6864,6866,1,0,0,0,6865,6848,1,0,0,0,6865,6866,1,0,0,
+        0,6866,557,1,0,0,0,6867,6868,5,981,0,0,6868,6869,5,1777,0,0,6869,
+        6872,3,1166,583,0,6870,6873,5,2205,0,0,6871,6873,3,548,274,0,6872,
+        6870,1,0,0,0,6872,6871,1,0,0,0,6873,559,1,0,0,0,6874,6875,3,1716,
+        858,0,6875,561,1,0,0,0,6876,6877,3,1716,858,0,6877,563,1,0,0,0,6878,
+        6879,3,2354,1177,0,6879,565,1,0,0,0,6880,6881,5,42,0,0,6881,6882,
+        5,747,0,0,6882,6883,5,795,0,0,6883,6887,5,650,0,0,6884,6885,3,2312,
+        1156,0,6885,6886,5,2442,0,0,6886,6888,1,0,0,0,6887,6884,1,0,0,0,
+        6887,6888,1,0,0,0,6888,6889,1,0,0,0,6889,6890,3,2430,1215,0,6890,
+        6891,7,72,0,0,6891,6895,5,2449,0,0,6892,6893,3,2312,1156,0,6893,
+        6894,5,2442,0,0,6894,6896,1,0,0,0,6895,6892,1,0,0,0,6895,6896,1,
+        0,0,0,6896,6897,1,0,0,0,6897,6898,3,2430,1215,0,6898,6899,5,2449,
+        0,0,6899,6900,3,2430,1215,0,6900,6901,5,2450,0,0,6901,6902,5,2450,
+        0,0,6902,567,1,0,0,0,6903,6904,5,321,0,0,6904,6905,5,2239,0,0,6905,
+        6909,3,2380,1190,0,6906,6907,5,692,0,0,6907,6908,5,1206,0,0,6908,
+        6910,5,546,0,0,6909,6906,1,0,0,0,6909,6910,1,0,0,0,6910,6920,1,0,
+        0,0,6911,6921,3,576,288,0,6912,6921,3,578,289,0,6913,6921,3,580,
+        290,0,6914,6921,3,582,291,0,6915,6921,3,584,292,0,6916,6921,3,590,
+        295,0,6917,6921,3,592,296,0,6918,6921,3,594,297,0,6919,6921,3,778,
+        389,0,6920,6911,1,0,0,0,6920,6912,1,0,0,0,6920,6913,1,0,0,0,6920,
+        6914,1,0,0,0,6920,6915,1,0,0,0,6920,6916,1,0,0,0,6920,6917,1,0,0,
+        0,6920,6918,1,0,0,0,6920,6919,1,0,0,0,6921,6922,1,0,0,0,6922,6920,
+        1,0,0,0,6922,6923,1,0,0,0,6923,569,1,0,0,0,6924,6925,5,42,0,0,6925,
+        6926,5,2239,0,0,6926,6938,3,2380,1190,0,6927,6939,3,574,287,0,6928,
+        6939,3,578,289,0,6929,6939,3,580,290,0,6930,6939,3,582,291,0,6931,
+        6939,3,584,292,0,6932,6939,3,588,294,0,6933,6939,3,590,295,0,6934,
+        6939,3,592,296,0,6935,6939,3,596,298,0,6936,6939,3,778,389,0,6937,
+        6939,3,606,303,0,6938,6927,1,0,0,0,6938,6928,1,0,0,0,6938,6929,1,
+        0,0,0,6938,6930,1,0,0,0,6938,6931,1,0,0,0,6938,6932,1,0,0,0,6938,
+        6933,1,0,0,0,6938,6934,1,0,0,0,6938,6935,1,0,0,0,6938,6936,1,0,0,
+        0,6938,6937,1,0,0,0,6939,6940,1,0,0,0,6940,6938,1,0,0,0,6940,6941,
+        1,0,0,0,6941,6953,1,0,0,0,6942,6947,3,2380,1190,0,6943,6944,5,2455,
+        0,0,6944,6946,3,2380,1190,0,6945,6943,1,0,0,0,6946,6949,1,0,0,0,
+        6947,6945,1,0,0,0,6947,6948,1,0,0,0,6948,6950,1,0,0,0,6949,6947,
+        1,0,0,0,6950,6951,3,598,299,0,6951,6953,1,0,0,0,6952,6924,1,0,0,
+        0,6952,6942,1,0,0,0,6953,571,1,0,0,0,6954,6955,5,469,0,0,6955,6956,
+        5,2239,0,0,6956,6959,3,2380,1190,0,6957,6958,5,692,0,0,6958,6960,
+        5,546,0,0,6959,6957,1,0,0,0,6959,6960,1,0,0,0,6960,6962,1,0,0,0,
+        6961,6963,5,179,0,0,6962,6961,1,0,0,0,6962,6963,1,0,0,0,6963,573,
+        1,0,0,0,6964,6967,3,576,288,0,6965,6966,5,1564,0,0,6966,6968,3,2430,
+        1215,0,6967,6965,1,0,0,0,6967,6968,1,0,0,0,6968,575,1,0,0,0,6969,
+        6970,5,686,0,0,6970,6971,5,160,0,0,6971,6972,3,2430,1215,0,6972,
+        577,1,0,0,0,6973,6974,5,686,0,0,6974,6977,7,73,0,0,6975,6976,5,69,
+        0,0,6976,6978,3,2426,1213,0,6977,6975,1,0,0,0,6977,6978,1,0,0,0,
+        6978,579,1,0,0,0,6979,6980,7,74,0,0,6980,6981,5,2082,0,0,6981,6982,
+        3,2430,1215,0,6982,581,1,0,0,0,6983,6986,5,1492,0,0,6984,6987,3,
+        1188,594,0,6985,6987,5,2187,0,0,6986,6984,1,0,0,0,6986,6985,1,0,
+        0,0,6987,6988,1,0,0,0,6988,6989,5,1261,0,0,6989,6990,3,2430,1215,
+        0,6990,583,1,0,0,0,6991,6992,5,1465,0,0,6992,6993,3,2430,1215,0,
+        6993,585,1,0,0,0,6994,6999,3,2334,1167,0,6995,6996,5,2455,0,0,6996,
+        6998,3,2334,1167,0,6997,6995,1,0,0,0,6998,7001,1,0,0,0,6999,6997,
+        1,0,0,0,6999,7000,1,0,0,0,7000,7018,1,0,0,0,7001,6999,1,0,0,0,7002,
+        7014,5,38,0,0,7003,7004,5,534,0,0,7004,7009,3,2334,1167,0,7005,7006,
+        5,2455,0,0,7006,7008,3,2334,1167,0,7007,7005,1,0,0,0,7008,7011,1,
+        0,0,0,7009,7007,1,0,0,0,7009,7010,1,0,0,0,7010,7013,1,0,0,0,7011,
+        7009,1,0,0,0,7012,7003,1,0,0,0,7013,7016,1,0,0,0,7014,7012,1,0,0,
+        0,7014,7015,1,0,0,0,7015,7018,1,0,0,0,7016,7014,1,0,0,0,7017,6994,
+        1,0,0,0,7017,7002,1,0,0,0,7018,587,1,0,0,0,7019,7020,5,389,0,0,7020,
+        7023,5,1595,0,0,7021,7024,5,1134,0,0,7022,7024,3,586,293,0,7023,
+        7021,1,0,0,0,7023,7022,1,0,0,0,7024,589,1,0,0,0,7025,7026,5,1358,
+        0,0,7026,7027,5,552,0,0,7027,591,1,0,0,0,7028,7029,5,7,0,0,7029,
+        7030,7,75,0,0,7030,593,1,0,0,0,7031,7032,5,499,0,0,7032,7033,5,485,
+        0,0,7033,595,1,0,0,0,7034,7044,3,594,297,0,7035,7036,5,621,0,0,7036,
+        7041,3,2436,1218,0,7037,7038,5,2455,0,0,7038,7040,3,2436,1218,0,
+        7039,7037,1,0,0,0,7040,7043,1,0,0,0,7041,7039,1,0,0,0,7041,7042,
+        1,0,0,0,7042,7045,1,0,0,0,7043,7041,1,0,0,0,7044,7035,1,0,0,0,7044,
+        7045,1,0,0,0,7045,7047,1,0,0,0,7046,7048,5,617,0,0,7047,7046,1,0,
+        0,0,7047,7048,1,0,0,0,7048,597,1,0,0,0,7049,7050,5,1591,0,0,7050,
+        7051,5,280,0,0,7051,7055,5,2105,0,0,7052,7053,5,514,0,0,7053,7056,
+        5,2237,0,0,7054,7056,3,2380,1190,0,7055,7052,1,0,0,0,7055,7054,1,
+        0,0,0,7056,7089,1,0,0,0,7057,7058,5,648,0,0,7058,7059,5,280,0,0,
+        7059,7086,5,2105,0,0,7060,7061,5,514,0,0,7061,7087,5,2237,0,0,7062,
+        7070,3,2380,1190,0,7063,7068,5,2310,0,0,7064,7065,5,1139,0,0,7065,
+        7069,5,1597,0,0,7066,7067,5,1595,0,0,7067,7069,3,586,293,0,7068,
+        7064,1,0,0,0,7068,7066,1,0,0,0,7069,7071,1,0,0,0,7070,7063,1,0,0,
+        0,7070,7071,1,0,0,0,7071,7074,1,0,0,0,7072,7073,5,87,0,0,7073,7075,
+        5,1566,0,0,7074,7072,1,0,0,0,7074,7075,1,0,0,0,7075,7084,1,0,0,0,
+        7076,7077,5,86,0,0,7077,7082,5,2248,0,0,7078,7083,5,1358,0,0,7079,
+        7083,5,187,0,0,7080,7081,5,446,0,0,7081,7083,5,998,0,0,7082,7078,
+        1,0,0,0,7082,7079,1,0,0,0,7082,7080,1,0,0,0,7083,7085,1,0,0,0,7084,
+        7076,1,0,0,0,7084,7085,1,0,0,0,7085,7087,1,0,0,0,7086,7060,1,0,0,
+        0,7086,7062,1,0,0,0,7087,7089,1,0,0,0,7088,7049,1,0,0,0,7088,7057,
+        1,0,0,0,7089,599,1,0,0,0,7090,7091,5,2449,0,0,7091,7096,3,2430,1215,
+        0,7092,7093,5,2455,0,0,7093,7095,3,2430,1215,0,7094,7092,1,0,0,0,
+        7095,7098,1,0,0,0,7096,7094,1,0,0,0,7096,7097,1,0,0,0,7097,7099,
+        1,0,0,0,7098,7096,1,0,0,0,7099,7100,5,2450,0,0,7100,601,1,0,0,0,
+        7101,7102,5,1673,0,0,7102,7103,5,292,0,0,7103,7107,5,2474,0,0,7104,
+        7108,5,38,0,0,7105,7108,5,389,0,0,7106,7108,3,600,300,0,7107,7104,
+        1,0,0,0,7107,7105,1,0,0,0,7107,7106,1,0,0,0,7108,603,1,0,0,0,7109,
+        7110,7,72,0,0,7110,7111,5,292,0,0,7111,7112,5,2474,0,0,7112,7113,
+        3,600,300,0,7113,605,1,0,0,0,7114,7121,3,602,301,0,7115,7118,3,604,
+        302,0,7116,7117,5,621,0,0,7117,7119,3,2326,1163,0,7118,7116,1,0,
+        0,0,7118,7119,1,0,0,0,7119,7121,1,0,0,0,7120,7114,1,0,0,0,7120,7115,
+        1,0,0,0,7121,607,1,0,0,0,7122,7123,5,27,0,0,7123,7124,5,817,0,0,
+        7124,7129,5,907,0,0,7125,7130,3,610,305,0,7126,7130,3,632,316,0,
+        7127,7130,3,662,331,0,7128,7130,3,672,336,0,7129,7125,1,0,0,0,7129,
+        7126,1,0,0,0,7129,7127,1,0,0,0,7129,7128,1,0,0,0,7130,609,1,0,0,
+        0,7131,7141,3,612,306,0,7132,7141,3,614,307,0,7133,7141,3,618,309,
+        0,7134,7141,3,620,310,0,7135,7141,3,622,311,0,7136,7141,3,624,312,
+        0,7137,7141,3,626,313,0,7138,7141,3,628,314,0,7139,7141,3,630,315,
+        0,7140,7131,1,0,0,0,7140,7132,1,0,0,0,7140,7133,1,0,0,0,7140,7134,
+        1,0,0,0,7140,7135,1,0,0,0,7140,7136,1,0,0,0,7140,7137,1,0,0,0,7140,
+        7138,1,0,0,0,7140,7139,1,0,0,0,7141,611,1,0,0,0,7142,7153,5,321,
+        0,0,7143,7144,5,821,0,0,7144,7154,5,2445,0,0,7145,7147,5,874,0,0,
+        7146,7145,1,0,0,0,7146,7147,1,0,0,0,7147,7148,1,0,0,0,7148,7149,
+        5,94,0,0,7149,7150,5,821,0,0,7150,7151,5,629,0,0,7151,7152,5,821,
+        0,0,7152,7154,5,2445,0,0,7153,7143,1,0,0,0,7153,7146,1,0,0,0,7154,
+        7155,1,0,0,0,7155,7156,5,686,0,0,7156,7157,5,160,0,0,7157,7158,3,
+        678,339,0,7158,613,1,0,0,0,7159,7160,5,1673,0,0,7160,7161,5,821,
+        0,0,7161,7163,5,1266,0,0,7162,7164,3,616,308,0,7163,7162,1,0,0,0,
+        7163,7164,1,0,0,0,7164,7165,1,0,0,0,7165,7167,3,656,328,0,7166,7168,
+        3,778,389,0,7167,7166,1,0,0,0,7167,7168,1,0,0,0,7168,615,1,0,0,0,
+        7169,7170,5,617,0,0,7170,7171,5,821,0,0,7171,617,1,0,0,0,7172,7173,
+        5,1673,0,0,7173,7174,5,821,0,0,7174,7176,5,218,0,0,7175,7177,3,656,
+        328,0,7176,7175,1,0,0,0,7176,7177,1,0,0,0,7177,7179,1,0,0,0,7178,
+        7180,3,778,389,0,7179,7178,1,0,0,0,7179,7180,1,0,0,0,7180,619,1,
+        0,0,0,7181,7182,5,102,0,0,7182,7185,5,821,0,0,7183,7184,5,2248,0,
+        0,7184,7186,5,2445,0,0,7185,7183,1,0,0,0,7185,7186,1,0,0,0,7186,
+        7188,1,0,0,0,7187,7189,3,616,308,0,7188,7187,1,0,0,0,7188,7189,1,
+        0,0,0,7189,7190,1,0,0,0,7190,7193,3,656,328,0,7191,7192,5,2143,0,
+        0,7192,7194,5,2445,0,0,7193,7191,1,0,0,0,7193,7194,1,0,0,0,7194,
+        621,1,0,0,0,7195,7196,5,42,0,0,7196,7197,5,821,0,0,7197,7199,5,1358,
+        0,0,7198,7200,3,616,308,0,7199,7198,1,0,0,0,7199,7200,1,0,0,0,7200,
+        7201,1,0,0,0,7201,7202,5,686,0,0,7202,7203,5,160,0,0,7203,7204,3,
+        678,339,0,7204,7205,5,1673,0,0,7205,7207,3,678,339,0,7206,7208,3,
+        674,337,0,7207,7206,1,0,0,0,7207,7208,1,0,0,0,7208,623,1,0,0,0,7209,
+        7210,5,947,0,0,7210,7211,5,821,0,0,7211,7213,5,2445,0,0,7212,7214,
+        3,676,338,0,7213,7212,1,0,0,0,7213,7214,1,0,0,0,7214,7215,1,0,0,
+        0,7215,7216,5,49,0,0,7216,7217,5,821,0,0,7217,7219,5,2445,0,0,7218,
+        7220,3,676,338,0,7219,7218,1,0,0,0,7219,7220,1,0,0,0,7220,7221,1,
+        0,0,0,7221,7222,5,780,0,0,7222,7223,5,1022,0,0,7223,7224,5,821,0,
+        0,7224,7225,5,2445,0,0,7225,7226,3,676,338,0,7226,625,1,0,0,0,7227,
+        7228,5,947,0,0,7228,7229,5,821,0,0,7229,7231,5,2445,0,0,7230,7232,
+        3,676,338,0,7231,7230,1,0,0,0,7231,7232,1,0,0,0,7232,7233,1,0,0,
+        0,7233,7234,5,780,0,0,7234,7235,5,545,0,0,7235,7236,5,821,0,0,7236,
+        7237,5,2445,0,0,7237,7239,3,676,338,0,7238,7240,3,674,337,0,7239,
+        7238,1,0,0,0,7239,7240,1,0,0,0,7240,627,1,0,0,0,7241,7243,5,617,
+        0,0,7242,7241,1,0,0,0,7242,7243,1,0,0,0,7243,7244,1,0,0,0,7244,7245,
+        5,2389,0,0,7245,7246,5,821,0,0,7246,7247,5,686,0,0,7247,7248,5,160,
+        0,0,7248,7249,3,678,339,0,7249,7250,5,629,0,0,7250,7251,5,2390,0,
+        0,7251,7253,5,821,0,0,7252,7254,3,616,308,0,7253,7252,1,0,0,0,7253,
+        7254,1,0,0,0,7254,7255,1,0,0,0,7255,7257,3,656,328,0,7256,7258,3,
+        674,337,0,7257,7256,1,0,0,0,7257,7258,1,0,0,0,7258,629,1,0,0,0,7259,
+        7260,5,2391,0,0,7260,7261,5,821,0,0,7261,7262,5,686,0,0,7262,7263,
+        5,160,0,0,7263,7264,3,678,339,0,7264,7265,5,2310,0,0,7265,7266,5,
+        2390,0,0,7266,7268,5,821,0,0,7267,7269,3,616,308,0,7268,7267,1,0,
+        0,0,7268,7269,1,0,0,0,7269,7270,1,0,0,0,7270,7272,3,656,328,0,7271,
+        7273,3,674,337,0,7272,7271,1,0,0,0,7272,7273,1,0,0,0,7273,631,1,
+        0,0,0,7274,7284,3,634,317,0,7275,7284,3,636,318,0,7276,7284,3,642,
+        321,0,7277,7284,3,644,322,0,7278,7284,3,646,323,0,7279,7284,3,648,
+        324,0,7280,7284,3,650,325,0,7281,7284,3,652,326,0,7282,7284,3,654,
+        327,0,7283,7274,1,0,0,0,7283,7275,1,0,0,0,7283,7276,1,0,0,0,7283,
+        7277,1,0,0,0,7283,7278,1,0,0,0,7283,7279,1,0,0,0,7283,7280,1,0,0,
+        0,7283,7281,1,0,0,0,7283,7282,1,0,0,0,7284,633,1,0,0,0,7285,7287,
+        5,1673,0,0,7286,7288,5,506,0,0,7287,7286,1,0,0,0,7287,7288,1,0,0,
+        0,7288,7289,1,0,0,0,7289,7296,5,817,0,0,7290,7291,3,638,319,0,7291,
+        7292,5,2471,0,0,7292,7294,1,0,0,0,7293,7290,1,0,0,0,7293,7294,1,
+        0,0,0,7294,7295,1,0,0,0,7295,7297,3,640,320,0,7296,7293,1,0,0,0,
+        7296,7297,1,0,0,0,7297,7299,1,0,0,0,7298,7300,3,660,330,0,7299,7298,
+        1,0,0,0,7299,7300,1,0,0,0,7300,7302,1,0,0,0,7301,7303,3,658,329,
+        0,7302,7301,1,0,0,0,7302,7303,1,0,0,0,7303,7305,1,0,0,0,7304,7306,
+        3,616,308,0,7305,7304,1,0,0,0,7305,7306,1,0,0,0,7306,7307,1,0,0,
+        0,7307,7309,3,656,328,0,7308,7310,3,674,337,0,7309,7308,1,0,0,0,
+        7309,7310,1,0,0,0,7310,7312,1,0,0,0,7311,7313,3,778,389,0,7312,7311,
+        1,0,0,0,7312,7313,1,0,0,0,7313,635,1,0,0,0,7314,7316,5,321,0,0,7315,
+        7317,5,506,0,0,7316,7315,1,0,0,0,7316,7317,1,0,0,0,7317,7318,1,0,
+        0,0,7318,7325,5,817,0,0,7319,7320,3,638,319,0,7320,7321,5,2471,0,
+        0,7321,7323,1,0,0,0,7322,7319,1,0,0,0,7322,7323,1,0,0,0,7323,7324,
+        1,0,0,0,7324,7326,3,640,320,0,7325,7322,1,0,0,0,7325,7326,1,0,0,
+        0,7326,7328,1,0,0,0,7327,7329,3,660,330,0,7328,7327,1,0,0,0,7328,
+        7329,1,0,0,0,7329,7331,1,0,0,0,7330,7332,3,658,329,0,7331,7330,1,
+        0,0,0,7331,7332,1,0,0,0,7332,7334,1,0,0,0,7333,7335,3,616,308,0,
+        7334,7333,1,0,0,0,7334,7335,1,0,0,0,7335,7336,1,0,0,0,7336,7338,
+        3,656,328,0,7337,7339,3,674,337,0,7338,7337,1,0,0,0,7338,7339,1,
+        0,0,0,7339,7341,1,0,0,0,7340,7342,3,778,389,0,7341,7340,1,0,0,0,
+        7341,7342,1,0,0,0,7342,637,1,0,0,0,7343,7344,5,2445,0,0,7344,639,
+        1,0,0,0,7345,7346,5,2445,0,0,7346,641,1,0,0,0,7347,7349,5,2243,0,
+        0,7348,7350,5,506,0,0,7349,7348,1,0,0,0,7349,7350,1,0,0,0,7350,7351,
+        1,0,0,0,7351,7352,5,817,0,0,7352,7354,5,2445,0,0,7353,7355,3,660,
+        330,0,7354,7353,1,0,0,0,7354,7355,1,0,0,0,7355,7357,1,0,0,0,7356,
+        7358,3,616,308,0,7357,7356,1,0,0,0,7357,7358,1,0,0,0,7358,7359,1,
+        0,0,0,7359,7361,3,656,328,0,7360,7362,3,674,337,0,7361,7360,1,0,
+        0,0,7361,7362,1,0,0,0,7362,643,1,0,0,0,7363,7364,5,1673,0,0,7364,
+        7365,5,2087,0,0,7365,7366,5,2445,0,0,7366,7367,5,621,0,0,7367,7369,
+        5,2445,0,0,7368,7370,3,616,308,0,7369,7368,1,0,0,0,7369,7370,1,0,
+        0,0,7370,7371,1,0,0,0,7371,7373,3,656,328,0,7372,7374,3,674,337,
+        0,7373,7372,1,0,0,0,7373,7374,1,0,0,0,7374,645,1,0,0,0,7375,7377,
+        5,555,0,0,7376,7378,5,506,0,0,7377,7376,1,0,0,0,7377,7378,1,0,0,
+        0,7378,7379,1,0,0,0,7379,7380,5,820,0,0,7380,7381,5,2310,0,0,7381,
+        7382,5,1640,0,0,7382,7383,3,682,341,0,7383,7384,5,2143,0,0,7384,
+        7386,3,1470,735,0,7385,7387,3,616,308,0,7386,7385,1,0,0,0,7386,7387,
+        1,0,0,0,7387,7388,1,0,0,0,7388,7406,3,656,328,0,7389,7390,5,2310,
+        0,0,7390,7391,5,687,0,0,7391,7404,5,739,0,0,7392,7397,5,2445,0,0,
+        7393,7394,5,2455,0,0,7394,7396,5,2445,0,0,7395,7393,1,0,0,0,7396,
+        7399,1,0,0,0,7397,7395,1,0,0,0,7397,7398,1,0,0,0,7398,7405,1,0,0,
+        0,7399,7397,1,0,0,0,7400,7401,5,2449,0,0,7401,7402,3,1916,958,0,
+        7402,7403,5,2450,0,0,7403,7405,1,0,0,0,7404,7392,1,0,0,0,7404,7400,
+        1,0,0,0,7405,7407,1,0,0,0,7406,7389,1,0,0,0,7406,7407,1,0,0,0,7407,
+        647,1,0,0,0,7408,7410,5,701,0,0,7409,7411,5,506,0,0,7410,7409,1,
+        0,0,0,7410,7411,1,0,0,0,7411,7412,1,0,0,0,7412,7413,5,820,0,0,7413,
+        7414,5,2310,0,0,7414,7415,5,1640,0,0,7415,7416,3,682,341,0,7416,
+        7417,5,629,0,0,7417,7419,3,1470,735,0,7418,7420,3,616,308,0,7419,
+        7418,1,0,0,0,7419,7420,1,0,0,0,7420,7421,1,0,0,0,7421,7423,3,656,
+        328,0,7422,7424,3,674,337,0,7423,7422,1,0,0,0,7423,7424,1,0,0,0,
+        7424,649,1,0,0,0,7425,7427,5,1673,0,0,7426,7428,5,506,0,0,7427,7426,
+        1,0,0,0,7427,7428,1,0,0,0,7428,7429,1,0,0,0,7429,7430,5,817,0,0,
+        7430,7431,5,686,0,0,7431,7432,5,160,0,0,7432,7434,3,682,341,0,7433,
+        7435,3,616,308,0,7434,7433,1,0,0,0,7434,7435,1,0,0,0,7435,7436,1,
+        0,0,0,7436,7437,5,951,0,0,7437,7438,5,2248,0,0,7438,7440,3,678,339,
+        0,7439,7441,3,674,337,0,7440,7439,1,0,0,0,7440,7441,1,0,0,0,7441,
+        651,1,0,0,0,7442,7444,5,1673,0,0,7443,7445,5,506,0,0,7444,7443,1,
+        0,0,0,7444,7445,1,0,0,0,7445,7446,1,0,0,0,7446,7447,5,817,0,0,7447,
+        7448,5,686,0,0,7448,7449,5,160,0,0,7449,7451,3,682,341,0,7450,7452,
+        3,616,308,0,7451,7450,1,0,0,0,7451,7452,1,0,0,0,7452,7453,1,0,0,
+        0,7453,7454,5,1590,0,0,7454,7455,5,951,0,0,7455,7456,5,2248,0,0,
+        7456,7457,3,682,341,0,7457,653,1,0,0,0,7458,7460,5,993,0,0,7459,
+        7461,5,506,0,0,7460,7459,1,0,0,0,7460,7461,1,0,0,0,7461,7462,1,0,
+        0,0,7462,7463,5,820,0,0,7463,7464,5,2143,0,0,7464,7465,5,1022,0,
+        0,7465,7466,5,821,0,0,7466,7467,5,2445,0,0,7467,7468,5,686,0,0,7468,
+        7469,5,160,0,0,7469,7470,3,678,339,0,7470,7472,5,629,0,0,7471,7473,
+        5,617,0,0,7472,7471,1,0,0,0,7472,7473,1,0,0,0,7473,7474,1,0,0,0,
+        7474,7475,5,821,0,0,7475,7476,5,686,0,0,7476,7477,5,160,0,0,7477,
+        7492,3,678,339,0,7478,7479,5,2310,0,0,7479,7480,5,687,0,0,7480,7490,
+        5,739,0,0,7481,7486,5,2445,0,0,7482,7483,5,2455,0,0,7483,7485,5,
+        2445,0,0,7484,7482,1,0,0,0,7485,7488,1,0,0,0,7486,7484,1,0,0,0,7486,
+        7487,1,0,0,0,7487,7491,1,0,0,0,7488,7486,1,0,0,0,7489,7491,3,1916,
+        958,0,7490,7481,1,0,0,0,7490,7489,1,0,0,0,7491,7493,1,0,0,0,7492,
+        7478,1,0,0,0,7492,7493,1,0,0,0,7493,7495,1,0,0,0,7494,7496,3,674,
+        337,0,7495,7494,1,0,0,0,7495,7496,1,0,0,0,7496,655,1,0,0,0,7497,
+        7498,5,686,0,0,7498,7502,5,160,0,0,7499,7500,5,561,0,0,7500,7503,
+        5,1765,0,0,7501,7503,3,678,339,0,7502,7499,1,0,0,0,7502,7501,1,0,
+        0,0,7503,657,1,0,0,0,7504,7505,5,2248,0,0,7505,7506,5,2392,0,0,7506,
+        7507,5,2445,0,0,7507,659,1,0,0,0,7508,7509,5,2248,0,0,7509,7510,
+        5,2087,0,0,7510,7511,5,2445,0,0,7511,661,1,0,0,0,7512,7517,3,664,
+        332,0,7513,7517,3,666,333,0,7514,7517,3,668,334,0,7515,7517,3,670,
+        335,0,7516,7512,1,0,0,0,7516,7513,1,0,0,0,7516,7514,1,0,0,0,7516,
+        7515,1,0,0,0,7517,663,1,0,0,0,7518,7519,7,76,0,0,7519,7520,5,1640,
+        0,0,7520,7521,5,2445,0,0,7521,7522,5,621,0,0,7522,7523,5,214,0,0,
+        7523,7525,5,2445,0,0,7524,7526,3,660,330,0,7525,7524,1,0,0,0,7525,
+        7526,1,0,0,0,7526,7528,1,0,0,0,7527,7529,3,616,308,0,7528,7527,1,
+        0,0,0,7528,7529,1,0,0,0,7529,7531,1,0,0,0,7530,7532,3,656,328,0,
+        7531,7530,1,0,0,0,7531,7532,1,0,0,0,7532,7534,1,0,0,0,7533,7535,
+        3,674,337,0,7534,7533,1,0,0,0,7534,7535,1,0,0,0,7535,665,1,0,0,0,
+        7536,7537,5,403,0,0,7537,7538,5,1640,0,0,7538,7539,5,621,0,0,7539,
+        7540,5,214,0,0,7540,7542,5,2445,0,0,7541,7543,3,616,308,0,7542,7541,
+        1,0,0,0,7542,7543,1,0,0,0,7543,7544,1,0,0,0,7544,7546,3,656,328,
+        0,7545,7547,3,674,337,0,7546,7545,1,0,0,0,7546,7547,1,0,0,0,7547,
+        667,1,0,0,0,7548,7549,7,76,0,0,7549,7550,5,1640,0,0,7550,7551,5,
+        2445,0,0,7551,7552,5,621,0,0,7552,7553,5,214,0,0,7553,7555,5,2445,
+        0,0,7554,7556,3,660,330,0,7555,7554,1,0,0,0,7555,7556,1,0,0,0,7556,
+        7557,1,0,0,0,7557,7559,5,2143,0,0,7558,7560,5,874,0,0,7559,7558,
+        1,0,0,0,7559,7560,1,0,0,0,7560,7561,1,0,0,0,7561,7562,5,94,0,0,7562,
+        7563,5,821,0,0,7563,7564,3,800,400,0,7564,669,1,0,0,0,7565,7566,
+        5,403,0,0,7566,7567,5,1640,0,0,7567,7568,5,2445,0,0,7568,7569,5,
+        2463,0,0,7569,7570,5,621,0,0,7570,7571,5,214,0,0,7571,7572,5,2445,
+        0,0,7572,7574,5,629,0,0,7573,7575,5,874,0,0,7574,7573,1,0,0,0,7574,
+        7575,1,0,0,0,7575,7576,1,0,0,0,7576,7577,5,94,0,0,7577,7578,5,821,
+        0,0,7578,7579,3,800,400,0,7579,671,1,0,0,0,7580,7582,5,1794,0,0,
+        7581,7583,5,2143,0,0,7582,7581,1,0,0,0,7582,7583,1,0,0,0,7583,7584,
+        1,0,0,0,7584,7585,5,850,0,0,7585,7586,3,680,340,0,7586,7587,5,621,
+        0,0,7587,7588,5,38,0,0,7588,7589,5,290,0,0,7589,673,1,0,0,0,7590,
+        7591,5,2310,0,0,7591,7594,5,102,0,0,7592,7593,5,2248,0,0,7593,7595,
+        5,2445,0,0,7594,7592,1,0,0,0,7594,7595,1,0,0,0,7595,675,1,0,0,0,
+        7596,7597,5,686,0,0,7597,7598,5,160,0,0,7598,7599,3,678,339,0,7599,
+        677,1,0,0,0,7600,7601,5,2446,0,0,7601,679,1,0,0,0,7602,7603,5,2445,
+        0,0,7603,681,1,0,0,0,7604,7605,5,2446,0,0,7605,683,1,0,0,0,7606,
+        7611,5,46,0,0,7607,7608,5,2085,0,0,7608,7612,3,2368,1184,0,7609,
+        7610,5,718,0,0,7610,7612,3,2354,1177,0,7611,7607,1,0,0,0,7611,7609,
+        1,0,0,0,7612,7614,1,0,0,0,7613,7615,3,686,343,0,7614,7613,1,0,0,
+        0,7614,7615,1,0,0,0,7615,7620,1,0,0,0,7616,7617,5,46,0,0,7617,7618,
+        5,220,0,0,7618,7620,3,478,239,0,7619,7606,1,0,0,0,7619,7616,1,0,
+        0,0,7620,7647,1,0,0,0,7621,7648,3,688,344,0,7622,7648,3,690,345,
+        0,7623,7625,5,527,0,0,7624,7626,5,1951,0,0,7625,7624,1,0,0,0,7625,
+        7626,1,0,0,0,7626,7627,1,0,0,0,7627,7629,5,1748,0,0,7628,7630,3,
+        692,346,0,7629,7628,1,0,0,0,7629,7630,1,0,0,0,7630,7634,1,0,0,0,
+        7631,7632,5,1616,0,0,7632,7633,5,2443,0,0,7633,7635,7,77,0,0,7634,
+        7631,1,0,0,0,7634,7635,1,0,0,0,7635,7648,1,0,0,0,7636,7637,5,863,
+        0,0,7637,7638,5,189,0,0,7638,7640,5,1609,0,0,7639,7641,3,696,348,
+        0,7640,7639,1,0,0,0,7640,7641,1,0,0,0,7641,7648,1,0,0,0,7642,7644,
+        5,403,0,0,7643,7645,5,1951,0,0,7644,7643,1,0,0,0,7644,7645,1,0,0,
+        0,7645,7646,1,0,0,0,7646,7648,5,1748,0,0,7647,7621,1,0,0,0,7647,
+        7622,1,0,0,0,7647,7623,1,0,0,0,7647,7636,1,0,0,0,7647,7642,1,0,0,
+        0,7648,685,1,0,0,0,7649,7666,5,1350,0,0,7650,7651,5,2449,0,0,7651,
+        7652,3,1716,858,0,7652,7653,5,2450,0,0,7653,7667,1,0,0,0,7654,7655,
+        5,621,0,0,7655,7656,5,2449,0,0,7656,7661,3,698,349,0,7657,7658,5,
+        2455,0,0,7658,7660,3,698,349,0,7659,7657,1,0,0,0,7660,7663,1,0,0,
+        0,7661,7659,1,0,0,0,7661,7662,1,0,0,0,7662,7664,1,0,0,0,7663,7661,
+        1,0,0,0,7664,7665,5,2450,0,0,7665,7667,1,0,0,0,7666,7650,1,0,0,0,
+        7666,7654,1,0,0,0,7667,7688,1,0,0,0,7668,7685,5,1777,0,0,7669,7670,
+        5,2449,0,0,7670,7671,3,1166,583,0,7671,7672,5,2450,0,0,7672,7686,
+        1,0,0,0,7673,7674,5,621,0,0,7674,7675,5,2449,0,0,7675,7680,3,700,
+        350,0,7676,7677,5,2455,0,0,7677,7679,3,700,350,0,7678,7676,1,0,0,
+        0,7679,7682,1,0,0,0,7680,7678,1,0,0,0,7680,7681,1,0,0,0,7681,7683,
+        1,0,0,0,7682,7680,1,0,0,0,7683,7684,5,2450,0,0,7684,7686,1,0,0,0,
+        7685,7669,1,0,0,0,7685,7673,1,0,0,0,7686,7688,1,0,0,0,7687,7649,
+        1,0,0,0,7687,7668,1,0,0,0,7688,687,1,0,0,0,7689,7690,5,2255,0,0,
+        7690,7691,5,1532,0,0,7691,7696,5,2209,0,0,7692,7693,5,1673,0,0,7693,
+        7694,5,349,0,0,7694,7695,5,2143,0,0,7695,7697,5,1230,0,0,7696,7692,
+        1,0,0,0,7696,7697,1,0,0,0,7697,7719,1,0,0,0,7698,7699,5,2255,0,0,
+        7699,7710,5,1773,0,0,7700,7701,5,179,0,0,7701,7711,5,579,0,0,7702,
+        7704,5,179,0,0,7703,7705,3,694,347,0,7704,7703,1,0,0,0,7704,7705,
+        1,0,0,0,7705,7707,1,0,0,0,7706,7708,3,2300,1150,0,7707,7706,1,0,
+        0,0,7707,7708,1,0,0,0,7708,7711,1,0,0,0,7709,7711,5,179,0,0,7710,
+        7700,1,0,0,0,7710,7702,1,0,0,0,7710,7709,1,0,0,0,7710,7711,1,0,0,
+        0,7711,7713,1,0,0,0,7712,7714,3,694,347,0,7713,7712,1,0,0,0,7713,
+        7714,1,0,0,0,7714,7716,1,0,0,0,7715,7717,3,2300,1150,0,7716,7715,
+        1,0,0,0,7716,7717,1,0,0,0,7717,7719,1,0,0,0,7718,7689,1,0,0,0,7718,
+        7698,1,0,0,0,7719,689,1,0,0,0,7720,7722,5,260,0,0,7721,7723,5,1951,
+        0,0,7722,7721,1,0,0,0,7722,7723,1,0,0,0,7723,7724,1,0,0,0,7724,7726,
+        5,1748,0,0,7725,7727,3,692,346,0,7726,7725,1,0,0,0,7726,7727,1,0,
+        0,0,7727,691,1,0,0,0,7728,7776,5,621,0,0,7729,7733,5,2085,0,0,7730,
+        7732,3,692,346,0,7731,7730,1,0,0,0,7732,7735,1,0,0,0,7733,7731,1,
+        0,0,0,7733,7734,1,0,0,0,7734,7777,1,0,0,0,7735,7733,1,0,0,0,7736,
+        7755,5,38,0,0,7737,7739,5,714,0,0,7738,7737,1,0,0,0,7738,7739,1,
+        0,0,0,7739,7740,1,0,0,0,7740,7743,5,238,0,0,7741,7742,5,1701,0,0,
+        7742,7744,5,2443,0,0,7743,7741,1,0,0,0,7743,7744,1,0,0,0,7744,7748,
+        1,0,0,0,7745,7747,3,692,346,0,7746,7745,1,0,0,0,7747,7750,1,0,0,
+        0,7748,7746,1,0,0,0,7748,7749,1,0,0,0,7749,7756,1,0,0,0,7750,7748,
+        1,0,0,0,7751,7753,5,874,0,0,7752,7751,1,0,0,0,7752,7753,1,0,0,0,
+        7753,7754,1,0,0,0,7754,7756,5,715,0,0,7755,7738,1,0,0,0,7755,7752,
+        1,0,0,0,7756,7777,1,0,0,0,7757,7760,5,238,0,0,7758,7759,5,1701,0,
+        0,7759,7761,5,2443,0,0,7760,7758,1,0,0,0,7760,7761,1,0,0,0,7761,
+        7766,1,0,0,0,7762,7763,3,2366,1183,0,7763,7764,5,1701,0,0,7764,7765,
+        5,2443,0,0,7765,7767,1,0,0,0,7766,7762,1,0,0,0,7767,7768,1,0,0,0,
+        7768,7766,1,0,0,0,7768,7769,1,0,0,0,7769,7773,1,0,0,0,7770,7772,
+        3,692,346,0,7771,7770,1,0,0,0,7772,7775,1,0,0,0,7773,7771,1,0,0,
+        0,7773,7774,1,0,0,0,7774,7777,1,0,0,0,7775,7773,1,0,0,0,7776,7729,
+        1,0,0,0,7776,7736,1,0,0,0,7776,7757,1,0,0,0,7777,693,1,0,0,0,7778,
+        7779,7,78,0,0,7779,695,1,0,0,0,7780,7782,5,780,0,0,7781,7783,3,2368,
+        1184,0,7782,7781,1,0,0,0,7782,7783,1,0,0,0,7783,697,1,0,0,0,7784,
+        7788,3,2210,1105,0,7785,7786,5,2110,0,0,7786,7788,3,2426,1213,0,
+        7787,7784,1,0,0,0,7787,7785,1,0,0,0,7788,699,1,0,0,0,7789,7793,3,
+        2210,1105,0,7790,7791,5,2110,0,0,7791,7793,3,2426,1213,0,7792,7789,
+        1,0,0,0,7792,7790,1,0,0,0,7793,701,1,0,0,0,7794,7795,5,77,0,0,7795,
+        7796,5,1748,0,0,7796,7799,5,2310,0,0,7797,7800,3,704,352,0,7798,
+        7800,3,706,353,0,7799,7797,1,0,0,0,7799,7798,1,0,0,0,7800,7802,1,
+        0,0,0,7801,7803,3,726,363,0,7802,7801,1,0,0,0,7802,7803,1,0,0,0,
+        7803,703,1,0,0,0,7804,7805,5,238,0,0,7805,7806,3,2368,1184,0,7806,
+        7807,5,2442,0,0,7807,7815,3,2366,1183,0,7808,7809,5,2455,0,0,7809,
+        7810,3,2368,1184,0,7810,7811,5,2442,0,0,7811,7812,3,2366,1183,0,
+        7812,7814,1,0,0,0,7813,7808,1,0,0,0,7814,7817,1,0,0,0,7815,7813,
+        1,0,0,0,7815,7816,1,0,0,0,7816,7818,1,0,0,0,7817,7815,1,0,0,0,7818,
+        7819,3,710,355,0,7819,705,1,0,0,0,7820,7821,5,634,0,0,7821,7826,
+        3,2346,1173,0,7822,7823,5,2455,0,0,7823,7825,3,2346,1173,0,7824,
+        7822,1,0,0,0,7825,7828,1,0,0,0,7826,7824,1,0,0,0,7826,7827,1,0,0,
+        0,7827,7866,1,0,0,0,7828,7826,1,0,0,0,7829,7830,5,1332,0,0,7830,
+        7835,3,2316,1158,0,7831,7832,5,2455,0,0,7832,7834,3,2316,1158,0,
+        7833,7831,1,0,0,0,7834,7837,1,0,0,0,7835,7833,1,0,0,0,7835,7836,
+        1,0,0,0,7836,7866,1,0,0,0,7837,7835,1,0,0,0,7838,7839,5,2167,0,0,
+        7839,7844,3,2340,1170,0,7840,7841,5,2455,0,0,7841,7843,3,2340,1170,
+        0,7842,7840,1,0,0,0,7843,7846,1,0,0,0,7844,7842,1,0,0,0,7844,7845,
+        1,0,0,0,7845,7866,1,0,0,0,7846,7844,1,0,0,0,7847,7848,5,715,0,0,
+        7848,7853,3,2354,1177,0,7849,7850,5,2455,0,0,7850,7852,3,2354,1177,
+        0,7851,7849,1,0,0,0,7852,7855,1,0,0,0,7853,7851,1,0,0,0,7853,7854,
+        1,0,0,0,7854,7866,1,0,0,0,7855,7853,1,0,0,0,7856,7857,5,733,0,0,
+        7857,7862,3,708,354,0,7858,7859,5,2455,0,0,7859,7861,3,708,354,0,
+        7860,7858,1,0,0,0,7861,7864,1,0,0,0,7862,7860,1,0,0,0,7862,7863,
+        1,0,0,0,7863,7866,1,0,0,0,7864,7862,1,0,0,0,7865,7820,1,0,0,0,7865,
+        7829,1,0,0,0,7865,7838,1,0,0,0,7865,7847,1,0,0,0,7865,7856,1,0,0,
+        0,7866,7878,1,0,0,0,7867,7879,3,710,355,0,7868,7871,3,714,357,0,
+        7869,7870,5,2455,0,0,7870,7872,3,722,361,0,7871,7869,1,0,0,0,7871,
+        7872,1,0,0,0,7872,7879,1,0,0,0,7873,7876,3,722,361,0,7874,7875,5,
+        2455,0,0,7875,7877,3,714,357,0,7876,7874,1,0,0,0,7876,7877,1,0,0,
+        0,7877,7879,1,0,0,0,7878,7867,1,0,0,0,7878,7868,1,0,0,0,7878,7873,
+        1,0,0,0,7879,707,1,0,0,0,7880,7881,3,2430,1215,0,7881,709,1,0,0,
+        0,7882,7885,5,2248,0,0,7883,7886,3,712,356,0,7884,7886,5,1230,0,
+        0,7885,7883,1,0,0,0,7885,7884,1,0,0,0,7886,711,1,0,0,0,7887,7888,
+        3,2436,1218,0,7888,713,1,0,0,0,7889,7890,5,389,0,0,7890,7891,5,311,
+        0,0,7891,7892,5,2449,0,0,7892,7893,3,716,358,0,7893,7894,5,2455,
+        0,0,7894,7895,3,718,359,0,7895,7896,5,2455,0,0,7896,7897,3,720,360,
+        0,7897,7898,5,2450,0,0,7898,715,1,0,0,0,7899,7900,5,2443,0,0,7900,
+        717,1,0,0,0,7901,7902,5,2443,0,0,7902,719,1,0,0,0,7903,7904,5,2443,
+        0,0,7904,721,1,0,0,0,7905,7906,5,389,0,0,7906,7907,5,1648,0,0,7907,
+        7908,3,724,362,0,7908,723,1,0,0,0,7909,7910,5,2443,0,0,7910,725,
+        1,0,0,0,7911,7912,5,2310,0,0,7912,7913,7,79,0,0,7913,7914,5,905,
+        0,0,7914,7915,5,1764,0,0,7915,7916,5,2083,0,0,7916,727,1,0,0,0,7917,
+        7918,4,364,2,0,7918,7962,5,85,0,0,7919,7920,5,1414,0,0,7920,7930,
+        3,730,365,0,7921,7922,7,80,0,0,7922,7927,3,742,371,0,7923,7924,5,
+        2455,0,0,7924,7926,3,742,371,0,7925,7923,1,0,0,0,7926,7929,1,0,0,
+        0,7927,7925,1,0,0,0,7927,7928,1,0,0,0,7928,7931,1,0,0,0,7929,7927,
+        1,0,0,0,7930,7921,1,0,0,0,7930,7931,1,0,0,0,7931,7937,1,0,0,0,7932,
+        7934,5,2301,0,0,7933,7935,5,1206,0,0,7934,7933,1,0,0,0,7934,7935,
+        1,0,0,0,7935,7936,1,0,0,0,7936,7938,5,1788,0,0,7937,7932,1,0,0,0,
+        7937,7938,1,0,0,0,7938,7963,1,0,0,0,7939,7940,5,296,0,0,7940,7941,
+        5,999,0,0,7941,7942,3,1028,514,0,7942,7943,5,84,0,0,7943,7948,3,
+        2306,1153,0,7944,7945,5,2455,0,0,7945,7947,3,2306,1153,0,7946,7944,
+        1,0,0,0,7947,7950,1,0,0,0,7948,7946,1,0,0,0,7948,7949,1,0,0,0,7949,
+        7960,1,0,0,0,7950,7948,1,0,0,0,7951,7952,5,160,0,0,7952,7957,3,742,
+        371,0,7953,7954,5,2455,0,0,7954,7956,3,742,371,0,7955,7953,1,0,0,
+        0,7956,7959,1,0,0,0,7957,7955,1,0,0,0,7957,7958,1,0,0,0,7958,7961,
+        1,0,0,0,7959,7957,1,0,0,0,7960,7951,1,0,0,0,7960,7961,1,0,0,0,7961,
+        7963,1,0,0,0,7962,7919,1,0,0,0,7962,7939,1,0,0,0,7963,729,1,0,0,
+        0,7964,7965,3,2428,1214,0,7965,731,1,0,0,0,7966,7977,5,85,0,0,7967,
+        7972,3,738,369,0,7968,7973,3,740,370,0,7969,7970,5,739,0,0,7970,
+        7971,5,1669,0,0,7971,7973,5,336,0,0,7972,7968,1,0,0,0,7972,7969,
+        1,0,0,0,7972,7973,1,0,0,0,7973,7978,1,0,0,0,7974,7978,3,744,372,
+        0,7975,7978,5,1020,0,0,7976,7978,3,734,367,0,7977,7967,1,0,0,0,7977,
+        7974,1,0,0,0,7977,7975,1,0,0,0,7977,7976,1,0,0,0,7978,7981,1,0,0,
+        0,7979,7980,5,160,0,0,7980,7982,7,81,0,0,7981,7979,1,0,0,0,7981,
+        7982,1,0,0,0,7982,7988,1,0,0,0,7983,7985,5,2301,0,0,7984,7986,5,
+        1206,0,0,7985,7984,1,0,0,0,7985,7986,1,0,0,0,7986,7987,1,0,0,0,7987,
+        7989,5,1788,0,0,7988,7983,1,0,0,0,7988,7989,1,0,0,0,7989,7991,1,
+        0,0,0,7990,7992,3,736,368,0,7991,7990,1,0,0,0,7991,7992,1,0,0,0,
+        7992,733,1,0,0,0,7993,7994,4,367,3,0,7994,7995,5,427,0,0,7995,7996,
+        3,740,370,0,7996,735,1,0,0,0,7997,7998,4,368,4,0,7998,7999,5,289,
+        0,0,7999,8000,5,2474,0,0,8000,8001,7,82,0,0,8001,737,1,0,0,0,8002,
+        8008,3,756,378,0,8003,8005,5,38,0,0,8004,8006,5,1744,0,0,8005,8004,
+        1,0,0,0,8005,8006,1,0,0,0,8006,8008,1,0,0,0,8007,8002,1,0,0,0,8007,
+        8003,1,0,0,0,8008,8019,1,0,0,0,8009,8015,5,2455,0,0,8010,8016,3,
+        756,378,0,8011,8013,5,38,0,0,8012,8014,5,1744,0,0,8013,8012,1,0,
+        0,0,8013,8014,1,0,0,0,8014,8016,1,0,0,0,8015,8010,1,0,0,0,8015,8011,
+        1,0,0,0,8016,8018,1,0,0,0,8017,8009,1,0,0,0,8018,8021,1,0,0,0,8019,
+        8017,1,0,0,0,8019,8020,1,0,0,0,8020,8039,1,0,0,0,8021,8019,1,0,0,
+        0,8022,8026,3,2418,1209,0,8023,8024,5,38,0,0,8024,8026,5,1461,0,
+        0,8025,8022,1,0,0,0,8025,8023,1,0,0,0,8026,8035,1,0,0,0,8027,8031,
+        5,2455,0,0,8028,8032,3,2418,1209,0,8029,8030,5,38,0,0,8030,8032,
+        5,1461,0,0,8031,8028,1,0,0,0,8031,8029,1,0,0,0,8032,8034,1,0,0,0,
+        8033,8027,1,0,0,0,8034,8037,1,0,0,0,8035,8033,1,0,0,0,8035,8036,
+        1,0,0,0,8036,8039,1,0,0,0,8037,8035,1,0,0,0,8038,8007,1,0,0,0,8038,
+        8025,1,0,0,0,8039,739,1,0,0,0,8040,8041,5,160,0,0,8041,8046,3,742,
+        371,0,8042,8043,5,2455,0,0,8043,8045,3,742,371,0,8044,8042,1,0,0,
+        0,8045,8048,1,0,0,0,8046,8044,1,0,0,0,8046,8047,1,0,0,0,8047,741,
+        1,0,0,0,8048,8046,1,0,0,0,8049,8050,3,2436,1218,0,8050,743,1,0,0,
+        0,8051,8056,3,746,373,0,8052,8053,5,2455,0,0,8053,8055,3,746,373,
+        0,8054,8052,1,0,0,0,8055,8058,1,0,0,0,8056,8054,1,0,0,0,8056,8057,
+        1,0,0,0,8057,8061,1,0,0,0,8058,8056,1,0,0,0,8059,8061,5,38,0,0,8060,
+        8051,1,0,0,0,8060,8059,1,0,0,0,8061,8062,1,0,0,0,8062,8063,3,748,
+        374,0,8063,745,1,0,0,0,8064,8065,7,58,0,0,8065,747,1,0,0,0,8066,
+        8079,5,1261,0,0,8067,8080,3,752,376,0,8068,8069,5,426,0,0,8069,8080,
+        3,2436,1218,0,8070,8071,5,956,0,0,8071,8072,5,972,0,0,8072,8080,
+        3,750,375,0,8073,8074,4,374,5,0,8074,8075,5,1724,0,0,8075,8076,5,
+        2156,0,0,8076,8077,5,1465,0,0,8077,8080,3,754,377,0,8078,8080,5,
+        389,0,0,8079,8067,1,0,0,0,8079,8068,1,0,0,0,8079,8070,1,0,0,0,8079,
+        8073,1,0,0,0,8079,8078,1,0,0,0,8080,749,1,0,0,0,8081,8082,3,2430,
+        1215,0,8082,8083,5,2442,0,0,8083,8085,1,0,0,0,8084,8081,1,0,0,0,
+        8084,8085,1,0,0,0,8085,8086,1,0,0,0,8086,8087,3,2430,1215,0,8087,
+        751,1,0,0,0,8088,8089,3,2430,1215,0,8089,8090,5,2442,0,0,8090,8092,
+        1,0,0,0,8091,8088,1,0,0,0,8091,8092,1,0,0,0,8092,8093,1,0,0,0,8093,
+        8094,3,2430,1215,0,8094,753,1,0,0,0,8095,8096,3,2430,1215,0,8096,
+        8097,5,2442,0,0,8097,8099,1,0,0,0,8098,8095,1,0,0,0,8098,8099,1,
+        0,0,0,8099,8100,1,0,0,0,8100,8101,3,2430,1215,0,8101,755,1,0,0,0,
+        8102,8103,5,42,0,0,8103,8173,5,1951,0,0,8104,8173,5,220,0,0,8105,
+        8173,5,296,0,0,8106,8107,5,350,0,0,8107,8173,5,862,0,0,8108,8173,
+        5,422,0,0,8109,8173,5,426,0,0,8110,8173,5,718,0,0,8111,8112,5,920,
+        0,0,8112,8173,5,2288,0,0,8113,8114,5,1206,0,0,8114,8173,5,546,0,
+        0,8115,8173,5,1317,0,0,8116,8117,4,378,6,0,8117,8118,5,1411,0,0,
+        8118,8173,5,350,0,0,8119,8173,5,1463,0,0,8120,8173,5,1465,0,0,8121,
+        8122,5,1475,0,0,8122,8123,5,350,0,0,8123,8173,5,862,0,0,8124,8125,
+        5,1475,0,0,8125,8173,5,1798,0,0,8126,8173,5,1595,0,0,8127,8128,5,
+        1598,0,0,8128,8173,5,1647,0,0,8129,8173,5,1655,0,0,8130,8173,5,1669,
+        0,0,8131,8173,5,1798,0,0,8132,8133,5,1951,0,0,8133,8173,5,85,0,0,
+        8134,8135,5,1951,0,0,8135,8173,5,648,0,0,8136,8173,5,2085,0,0,8137,
+        8173,5,2082,0,0,8138,8173,5,2159,0,0,8139,8173,5,2168,0,0,8140,8173,
+        5,2239,0,0,8141,8173,5,2288,0,0,8142,8143,5,42,0,0,8143,8173,5,1655,
+        0,0,8144,8145,5,42,0,0,8145,8173,5,2085,0,0,8146,8147,5,241,0,0,
+        8147,8173,5,2085,0,0,8148,8149,5,403,0,0,8149,8173,5,2085,0,0,8150,
+        8151,5,543,0,0,8151,8173,5,1463,0,0,8152,8153,5,648,0,0,8153,8173,
+        5,426,0,0,8154,8155,5,648,0,0,8155,8173,5,1463,0,0,8156,8157,5,648,
+        0,0,8157,8173,5,1655,0,0,8158,8159,5,648,0,0,8159,8173,5,2085,0,
+        0,8160,8161,5,648,0,0,8161,8173,5,2168,0,0,8162,8163,5,757,0,0,8163,
+        8173,5,2085,0,0,8164,8165,5,882,0,0,8165,8173,5,2085,0,0,8166,8167,
+        5,1649,0,0,8167,8173,5,1655,0,0,8168,8169,5,1649,0,0,8169,8173,5,
+        2085,0,0,8170,8171,5,2209,0,0,8171,8173,5,2085,0,0,8172,8102,1,0,
+        0,0,8172,8104,1,0,0,0,8172,8105,1,0,0,0,8172,8106,1,0,0,0,8172,8108,
+        1,0,0,0,8172,8109,1,0,0,0,8172,8110,1,0,0,0,8172,8111,1,0,0,0,8172,
+        8113,1,0,0,0,8172,8115,1,0,0,0,8172,8116,1,0,0,0,8172,8119,1,0,0,
+        0,8172,8120,1,0,0,0,8172,8121,1,0,0,0,8172,8124,1,0,0,0,8172,8126,
+        1,0,0,0,8172,8127,1,0,0,0,8172,8129,1,0,0,0,8172,8130,1,0,0,0,8172,
+        8131,1,0,0,0,8172,8132,1,0,0,0,8172,8134,1,0,0,0,8172,8136,1,0,0,
+        0,8172,8137,1,0,0,0,8172,8138,1,0,0,0,8172,8139,1,0,0,0,8172,8140,
+        1,0,0,0,8172,8141,1,0,0,0,8172,8142,1,0,0,0,8172,8144,1,0,0,0,8172,
+        8146,1,0,0,0,8172,8148,1,0,0,0,8172,8150,1,0,0,0,8172,8152,1,0,0,
+        0,8172,8154,1,0,0,0,8172,8156,1,0,0,0,8172,8158,1,0,0,0,8172,8160,
+        1,0,0,0,8172,8162,1,0,0,0,8172,8164,1,0,0,0,8172,8166,1,0,0,0,8172,
+        8168,1,0,0,0,8172,8170,1,0,0,0,8173,757,1,0,0,0,8174,8175,5,469,
+        0,0,8175,8176,5,718,0,0,8176,8179,3,2354,1177,0,8177,8178,5,692,
+        0,0,8178,8180,5,546,0,0,8179,8177,1,0,0,0,8179,8180,1,0,0,0,8180,
+        759,1,0,0,0,8181,8182,5,436,0,0,8182,8183,5,1748,0,0,8183,8303,5,
+        629,0,0,8184,8188,5,238,0,0,8185,8186,3,2312,1156,0,8186,8187,5,
+        2442,0,0,8187,8189,1,0,0,0,8188,8185,1,0,0,0,8188,8189,1,0,0,0,8189,
+        8190,1,0,0,0,8190,8191,3,2430,1215,0,8191,8192,5,2442,0,0,8192,8205,
+        3,2430,1215,0,8193,8197,5,2455,0,0,8194,8195,3,2312,1156,0,8195,
+        8196,5,2442,0,0,8196,8198,1,0,0,0,8197,8194,1,0,0,0,8197,8198,1,
+        0,0,0,8198,8199,1,0,0,0,8199,8200,3,2430,1215,0,8200,8201,5,2442,
+        0,0,8201,8202,3,2430,1215,0,8202,8204,1,0,0,0,8203,8193,1,0,0,0,
+        8204,8207,1,0,0,0,8205,8203,1,0,0,0,8205,8206,1,0,0,0,8206,8304,
+        1,0,0,0,8207,8205,1,0,0,0,8208,8212,5,634,0,0,8209,8210,3,2312,1156,
+        0,8210,8211,5,2442,0,0,8211,8213,1,0,0,0,8212,8209,1,0,0,0,8212,
+        8213,1,0,0,0,8213,8214,1,0,0,0,8214,8224,3,2430,1215,0,8215,8219,
+        5,2455,0,0,8216,8217,3,2312,1156,0,8217,8218,5,2442,0,0,8218,8220,
+        1,0,0,0,8219,8216,1,0,0,0,8219,8220,1,0,0,0,8220,8221,1,0,0,0,8221,
+        8223,3,2430,1215,0,8222,8215,1,0,0,0,8223,8226,1,0,0,0,8224,8222,
+        1,0,0,0,8224,8225,1,0,0,0,8225,8304,1,0,0,0,8226,8224,1,0,0,0,8227,
+        8231,5,1332,0,0,8228,8229,3,2312,1156,0,8229,8230,5,2442,0,0,8230,
+        8232,1,0,0,0,8231,8228,1,0,0,0,8231,8232,1,0,0,0,8232,8233,1,0,0,
+        0,8233,8243,3,2430,1215,0,8234,8238,5,2455,0,0,8235,8236,3,2312,
+        1156,0,8236,8237,5,2442,0,0,8237,8239,1,0,0,0,8238,8235,1,0,0,0,
+        8238,8239,1,0,0,0,8239,8240,1,0,0,0,8240,8242,3,2430,1215,0,8241,
+        8234,1,0,0,0,8242,8245,1,0,0,0,8243,8241,1,0,0,0,8243,8244,1,0,0,
+        0,8244,8304,1,0,0,0,8245,8243,1,0,0,0,8246,8250,5,2167,0,0,8247,
+        8248,3,2312,1156,0,8248,8249,5,2442,0,0,8249,8251,1,0,0,0,8250,8247,
+        1,0,0,0,8250,8251,1,0,0,0,8251,8252,1,0,0,0,8252,8262,3,2430,1215,
+        0,8253,8257,5,2455,0,0,8254,8255,3,2312,1156,0,8255,8256,5,2442,
+        0,0,8256,8258,1,0,0,0,8257,8254,1,0,0,0,8257,8258,1,0,0,0,8258,8259,
+        1,0,0,0,8259,8261,3,2430,1215,0,8260,8253,1,0,0,0,8261,8264,1,0,
+        0,0,8262,8260,1,0,0,0,8262,8263,1,0,0,0,8263,8304,1,0,0,0,8264,8262,
+        1,0,0,0,8265,8269,5,715,0,0,8266,8267,3,2312,1156,0,8267,8268,5,
+        2442,0,0,8268,8270,1,0,0,0,8269,8266,1,0,0,0,8269,8270,1,0,0,0,8270,
+        8271,1,0,0,0,8271,8281,3,2430,1215,0,8272,8276,5,2455,0,0,8273,8274,
+        3,2312,1156,0,8274,8275,5,2442,0,0,8275,8277,1,0,0,0,8276,8273,1,
+        0,0,0,8276,8277,1,0,0,0,8277,8278,1,0,0,0,8278,8280,3,2430,1215,
+        0,8279,8272,1,0,0,0,8280,8283,1,0,0,0,8281,8279,1,0,0,0,8281,8282,
+        1,0,0,0,8282,8304,1,0,0,0,8283,8281,1,0,0,0,8284,8288,5,733,0,0,
+        8285,8286,3,2312,1156,0,8286,8287,5,2442,0,0,8287,8289,1,0,0,0,8288,
+        8285,1,0,0,0,8288,8289,1,0,0,0,8289,8290,1,0,0,0,8290,8300,3,2430,
+        1215,0,8291,8295,5,2455,0,0,8292,8293,3,2312,1156,0,8293,8294,5,
+        2442,0,0,8294,8296,1,0,0,0,8295,8292,1,0,0,0,8295,8296,1,0,0,0,8296,
+        8297,1,0,0,0,8297,8299,3,2430,1215,0,8298,8291,1,0,0,0,8299,8302,
+        1,0,0,0,8300,8298,1,0,0,0,8300,8301,1,0,0,0,8301,8304,1,0,0,0,8302,
+        8300,1,0,0,0,8303,8184,1,0,0,0,8303,8208,1,0,0,0,8303,8227,1,0,0,
+        0,8303,8246,1,0,0,0,8303,8265,1,0,0,0,8303,8284,1,0,0,0,8304,8306,
+        1,0,0,0,8305,8307,5,617,0,0,8306,8305,1,0,0,0,8306,8307,1,0,0,0,
+        8307,761,1,0,0,0,8308,8309,5,469,0,0,8309,8313,5,732,0,0,8310,8311,
+        3,2312,1156,0,8311,8312,5,2442,0,0,8312,8314,1,0,0,0,8313,8310,1,
+        0,0,0,8313,8314,1,0,0,0,8314,8315,1,0,0,0,8315,8317,3,2430,1215,
+        0,8316,8318,5,617,0,0,8317,8316,1,0,0,0,8317,8318,1,0,0,0,8318,763,
+        1,0,0,0,8319,8320,5,469,0,0,8320,8321,5,747,0,0,8321,8322,5,795,
+        0,0,8322,8326,5,650,0,0,8323,8324,3,2312,1156,0,8324,8325,5,2442,
+        0,0,8325,8327,1,0,0,0,8326,8323,1,0,0,0,8326,8327,1,0,0,0,8327,8328,
+        1,0,0,0,8328,8329,3,2430,1215,0,8329,765,1,0,0,0,8330,8331,5,606,
+        0,0,8331,8332,5,2085,0,0,8332,8337,3,2368,1184,0,8333,8334,5,2455,
+        0,0,8334,8336,3,2368,1184,0,8335,8333,1,0,0,0,8336,8339,1,0,0,0,
+        8337,8335,1,0,0,0,8337,8338,1,0,0,0,8338,8340,1,0,0,0,8339,8337,
+        1,0,0,0,8340,8359,5,2143,0,0,8341,8342,7,83,0,0,8342,8347,3,2100,
+        1050,0,8343,8344,5,1576,0,0,8344,8345,5,1413,0,0,8345,8347,3,768,
+        384,0,8346,8341,1,0,0,0,8346,8343,1,0,0,0,8347,8350,1,0,0,0,8348,
+        8349,7,17,0,0,8349,8351,5,2158,0,0,8350,8348,1,0,0,0,8350,8351,1,
+        0,0,0,8351,8360,1,0,0,0,8352,8353,5,112,0,0,8353,8357,5,469,0,0,
+        8354,8355,5,1561,0,0,8355,8356,5,2143,0,0,8356,8358,3,2368,1184,
+        0,8357,8354,1,0,0,0,8357,8358,1,0,0,0,8358,8360,1,0,0,0,8359,8346,
+        1,0,0,0,8359,8352,1,0,0,0,8360,767,1,0,0,0,8361,8366,3,2428,1214,
+        0,8362,8363,5,2442,0,0,8363,8365,3,2430,1215,0,8364,8362,1,0,0,0,
+        8365,8368,1,0,0,0,8366,8364,1,0,0,0,8366,8367,1,0,0,0,8367,769,1,
+        0,0,0,8368,8366,1,0,0,0,8369,8383,5,1477,0,0,8370,8371,7,84,0,0,
+        8371,8384,3,2430,1215,0,8372,8374,5,2082,0,0,8373,8375,5,1673,0,
+        0,8374,8373,1,0,0,0,8374,8375,1,0,0,0,8375,8376,1,0,0,0,8376,8379,
+        3,2430,1215,0,8377,8378,5,2239,0,0,8378,8380,3,2430,1215,0,8379,
+        8377,1,0,0,0,8379,8380,1,0,0,0,8380,8384,1,0,0,0,8381,8384,5,1520,
+        0,0,8382,8384,5,369,0,0,8383,8370,1,0,0,0,8383,8372,1,0,0,0,8383,
+        8381,1,0,0,0,8383,8382,1,0,0,0,8384,771,1,0,0,0,8385,8397,5,1060,
+        0,0,8386,8388,3,738,369,0,8387,8389,3,740,370,0,8388,8387,1,0,0,
+        0,8388,8389,1,0,0,0,8389,8398,1,0,0,0,8390,8398,3,744,372,0,8391,
+        8398,5,1020,0,0,8392,8393,5,427,0,0,8393,8395,5,868,0,0,8394,8396,
+        3,740,370,0,8395,8394,1,0,0,0,8395,8396,1,0,0,0,8396,8398,1,0,0,
+        0,8397,8386,1,0,0,0,8397,8390,1,0,0,0,8397,8391,1,0,0,0,8397,8392,
+        1,0,0,0,8398,8404,1,0,0,0,8399,8401,5,2301,0,0,8400,8402,5,1206,
+        0,0,8401,8400,1,0,0,0,8401,8402,1,0,0,0,8402,8403,1,0,0,0,8403,8405,
+        5,1788,0,0,8404,8399,1,0,0,0,8404,8405,1,0,0,0,8405,8407,1,0,0,0,
+        8406,8408,3,778,389,0,8407,8406,1,0,0,0,8407,8408,1,0,0,0,8408,773,
+        1,0,0,0,8409,8410,5,1561,0,0,8410,8411,3,752,376,0,8411,8412,5,2143,
+        0,0,8412,8413,3,752,376,0,8413,775,1,0,0,0,8414,8426,5,648,0,0,8415,
+        8417,5,2455,0,0,8416,8415,1,0,0,0,8416,8417,1,0,0,0,8417,8424,1,
+        0,0,0,8418,8425,3,2334,1167,0,8419,8425,3,2418,1209,0,8420,8422,
+        3,2416,1208,0,8421,8423,3,2386,1193,0,8422,8421,1,0,0,0,8422,8423,
+        1,0,0,0,8423,8425,1,0,0,0,8424,8418,1,0,0,0,8424,8419,1,0,0,0,8424,
+        8420,1,0,0,0,8425,8427,1,0,0,0,8426,8416,1,0,0,0,8427,8428,1,0,0,
+        0,8428,8426,1,0,0,0,8428,8429,1,0,0,0,8429,8432,1,0,0,0,8430,8431,
+        5,1261,0,0,8431,8433,3,2382,1191,0,8432,8430,1,0,0,0,8432,8433,1,
+        0,0,0,8433,8434,1,0,0,0,8434,8437,5,2143,0,0,8435,8438,3,2332,1166,
+        0,8436,8438,5,1475,0,0,8437,8435,1,0,0,0,8437,8436,1,0,0,0,8438,
+        8446,1,0,0,0,8439,8442,5,2455,0,0,8440,8443,3,2332,1166,0,8441,8443,
+        5,1475,0,0,8442,8440,1,0,0,0,8442,8441,1,0,0,0,8443,8445,1,0,0,0,
+        8444,8439,1,0,0,0,8445,8448,1,0,0,0,8446,8444,1,0,0,0,8446,8447,
+        1,0,0,0,8447,8452,1,0,0,0,8448,8446,1,0,0,0,8449,8450,5,2310,0,0,
+        8450,8451,7,85,0,0,8451,8453,5,1274,0,0,8452,8449,1,0,0,0,8452,8453,
+        1,0,0,0,8453,8457,1,0,0,0,8454,8455,5,2310,0,0,8455,8456,5,675,0,
+        0,8456,8458,5,1274,0,0,8457,8454,1,0,0,0,8457,8458,1,0,0,0,8458,
+        8462,1,0,0,0,8459,8460,5,2310,0,0,8460,8461,5,648,0,0,8461,8463,
+        5,1274,0,0,8462,8459,1,0,0,0,8462,8463,1,0,0,0,8463,8465,1,0,0,0,
+        8464,8466,3,778,389,0,8465,8464,1,0,0,0,8465,8466,1,0,0,0,8466,777,
+        1,0,0,0,8467,8468,5,289,0,0,8468,8469,5,2474,0,0,8469,8470,7,82,
+        0,0,8470,779,1,0,0,0,8471,8480,5,1591,0,0,8472,8475,3,782,391,0,
+        8473,8475,3,786,393,0,8474,8472,1,0,0,0,8474,8473,1,0,0,0,8475,8477,
+        1,0,0,0,8476,8478,3,778,389,0,8477,8476,1,0,0,0,8477,8478,1,0,0,
+        0,8478,8481,1,0,0,0,8479,8481,3,790,395,0,8480,8474,1,0,0,0,8480,
+        8479,1,0,0,0,8481,781,1,0,0,0,8482,8487,3,2418,1209,0,8483,8487,
+        3,2334,1167,0,8484,8485,5,38,0,0,8485,8487,5,1461,0,0,8486,8482,
+        1,0,0,0,8486,8483,1,0,0,0,8486,8484,1,0,0,0,8487,8488,1,0,0,0,8488,
+        8489,5,629,0,0,8489,8490,3,784,392,0,8490,783,1,0,0,0,8491,8494,
+        3,2430,1215,0,8492,8494,5,1475,0,0,8493,8491,1,0,0,0,8493,8492,1,
+        0,0,0,8494,8502,1,0,0,0,8495,8498,5,2455,0,0,8496,8499,3,2430,1215,
+        0,8497,8499,5,1475,0,0,8498,8496,1,0,0,0,8498,8497,1,0,0,0,8499,
+        8501,1,0,0,0,8500,8495,1,0,0,0,8501,8504,1,0,0,0,8502,8500,1,0,0,
+        0,8502,8503,1,0,0,0,8503,785,1,0,0,0,8504,8502,1,0,0,0,8505,8511,
+        3,2416,1208,0,8506,8508,5,38,0,0,8507,8509,5,1461,0,0,8508,8507,
+        1,0,0,0,8508,8509,1,0,0,0,8509,8511,1,0,0,0,8510,8505,1,0,0,0,8510,
+        8506,1,0,0,0,8511,8522,1,0,0,0,8512,8518,5,2455,0,0,8513,8519,3,
+        2416,1208,0,8514,8516,5,38,0,0,8515,8517,5,1461,0,0,8516,8515,1,
+        0,0,0,8516,8517,1,0,0,0,8517,8519,1,0,0,0,8518,8513,1,0,0,0,8518,
+        8514,1,0,0,0,8519,8521,1,0,0,0,8520,8512,1,0,0,0,8521,8524,1,0,0,
+        0,8522,8520,1,0,0,0,8522,8523,1,0,0,0,8523,8525,1,0,0,0,8524,8522,
+        1,0,0,0,8525,8526,3,788,394,0,8526,8527,5,629,0,0,8527,8531,3,784,
+        392,0,8528,8529,5,179,0,0,8529,8532,5,287,0,0,8530,8532,5,617,0,
+        0,8531,8528,1,0,0,0,8531,8530,1,0,0,0,8531,8532,1,0,0,0,8532,787,
+        1,0,0,0,8533,8578,5,1261,0,0,8534,8535,3,2312,1156,0,8535,8536,5,
+        2442,0,0,8536,8538,1,0,0,0,8537,8534,1,0,0,0,8537,8538,1,0,0,0,8538,
+        8539,1,0,0,0,8539,8579,3,2430,1215,0,8540,8541,5,2239,0,0,8541,8546,
+        3,2430,1215,0,8542,8543,5,2455,0,0,8543,8545,3,2430,1215,0,8544,
+        8542,1,0,0,0,8545,8548,1,0,0,0,8546,8544,1,0,0,0,8546,8547,1,0,0,
+        0,8547,8579,1,0,0,0,8548,8546,1,0,0,0,8549,8550,5,426,0,0,8550,8579,
+        3,798,399,0,8551,8552,5,483,0,0,8552,8579,3,1466,733,0,8553,8554,
+        5,956,0,0,8554,8558,5,972,0,0,8555,8556,3,2312,1156,0,8556,8557,
+        5,2442,0,0,8557,8559,1,0,0,0,8558,8555,1,0,0,0,8558,8559,1,0,0,0,
+        8559,8560,1,0,0,0,8560,8579,3,2430,1215,0,8561,8562,5,793,0,0,8562,
+        8566,7,86,0,0,8563,8564,3,2312,1156,0,8564,8565,5,2442,0,0,8565,
+        8567,1,0,0,0,8566,8563,1,0,0,0,8566,8567,1,0,0,0,8567,8568,1,0,0,
+        0,8568,8579,3,2430,1215,0,8569,8570,5,1724,0,0,8570,8571,5,2156,
+        0,0,8571,8575,5,1465,0,0,8572,8573,3,2312,1156,0,8573,8574,5,2442,
+        0,0,8574,8576,1,0,0,0,8575,8572,1,0,0,0,8575,8576,1,0,0,0,8576,8577,
+        1,0,0,0,8577,8579,3,2430,1215,0,8578,8537,1,0,0,0,8578,8540,1,0,
+        0,0,8578,8549,1,0,0,0,8578,8551,1,0,0,0,8578,8553,1,0,0,0,8578,8561,
+        1,0,0,0,8578,8569,1,0,0,0,8579,789,1,0,0,0,8580,8585,3,2334,1167,
+        0,8581,8582,5,2455,0,0,8582,8584,3,2334,1167,0,8583,8581,1,0,0,0,
+        8584,8587,1,0,0,0,8585,8583,1,0,0,0,8585,8586,1,0,0,0,8586,8590,
+        1,0,0,0,8587,8585,1,0,0,0,8588,8590,5,38,0,0,8589,8580,1,0,0,0,8589,
+        8588,1,0,0,0,8590,8591,1,0,0,0,8591,8592,5,629,0,0,8592,8597,3,792,
+        396,0,8593,8594,5,2455,0,0,8594,8596,3,792,396,0,8595,8593,1,0,0,
+        0,8596,8599,1,0,0,0,8597,8595,1,0,0,0,8597,8598,1,0,0,0,8598,791,
+        1,0,0,0,8599,8597,1,0,0,0,8600,8604,7,87,0,0,8601,8602,3,2312,1156,
+        0,8602,8603,5,2442,0,0,8603,8605,1,0,0,0,8604,8601,1,0,0,0,8604,
+        8605,1,0,0,0,8605,8606,1,0,0,0,8606,8607,3,2430,1215,0,8607,793,
+        1,0,0,0,8608,8609,5,321,0,0,8609,8610,5,422,0,0,8610,8612,3,2428,
+        1214,0,8611,8613,3,832,416,0,8612,8611,1,0,0,0,8613,8614,1,0,0,0,
+        8614,8612,1,0,0,0,8614,8615,1,0,0,0,8615,8619,1,0,0,0,8616,8620,
+        3,834,417,0,8617,8620,3,838,419,0,8618,8620,3,840,420,0,8619,8616,
+        1,0,0,0,8619,8617,1,0,0,0,8619,8618,1,0,0,0,8620,8621,1,0,0,0,8621,
+        8619,1,0,0,0,8621,8622,1,0,0,0,8622,795,1,0,0,0,8623,8626,5,321,
+        0,0,8624,8625,5,1309,0,0,8625,8627,5,1564,0,0,8626,8624,1,0,0,0,
+        8626,8627,1,0,0,0,8627,8628,1,0,0,0,8628,8629,5,426,0,0,8629,8633,
+        3,798,399,0,8630,8631,5,1683,0,0,8631,8632,5,2474,0,0,8632,8634,
+        7,21,0,0,8633,8630,1,0,0,0,8633,8634,1,0,0,0,8634,8635,1,0,0,0,8635,
+        8636,5,69,0,0,8636,8637,3,800,400,0,8637,797,1,0,0,0,8638,8639,3,
+        2436,1218,0,8639,799,1,0,0,0,8640,8641,5,2445,0,0,8641,801,1,0,0,
+        0,8642,8643,5,321,0,0,8643,8644,5,747,0,0,8644,8645,5,795,0,0,8645,
+        8649,5,650,0,0,8646,8647,3,2312,1156,0,8647,8648,5,2442,0,0,8648,
+        8650,1,0,0,0,8649,8646,1,0,0,0,8649,8650,1,0,0,0,8650,8651,1,0,0,
+        0,8651,8652,3,2430,1215,0,8652,8656,5,2449,0,0,8653,8654,3,2312,
+        1156,0,8654,8655,5,2442,0,0,8655,8657,1,0,0,0,8656,8653,1,0,0,0,
+        8656,8657,1,0,0,0,8657,8658,1,0,0,0,8658,8659,3,2430,1215,0,8659,
+        8660,5,2449,0,0,8660,8661,3,2430,1215,0,8661,8673,5,2450,0,0,8662,
+        8666,5,2455,0,0,8663,8664,3,2312,1156,0,8664,8665,5,2442,0,0,8665,
+        8667,1,0,0,0,8666,8663,1,0,0,0,8666,8667,1,0,0,0,8667,8668,1,0,0,
+        0,8668,8669,3,2430,1215,0,8669,8670,5,2449,0,0,8670,8671,3,2430,
+        1215,0,8671,8672,5,2450,0,0,8672,8674,1,0,0,0,8673,8662,1,0,0,0,
+        8674,8675,1,0,0,0,8675,8673,1,0,0,0,8675,8676,1,0,0,0,8676,8677,
+        1,0,0,0,8677,8678,5,2450,0,0,8678,803,1,0,0,0,8679,8680,5,469,0,
+        0,8680,8684,5,675,0,0,8681,8682,3,2312,1156,0,8682,8683,5,2442,0,
+        0,8683,8685,1,0,0,0,8684,8681,1,0,0,0,8684,8685,1,0,0,0,8685,8686,
+        1,0,0,0,8686,8687,3,2430,1215,0,8687,805,1,0,0,0,8688,8689,5,42,
+        0,0,8689,8690,5,850,0,0,8690,8706,3,828,414,0,8691,8693,5,249,0,
+        0,8692,8694,3,822,411,0,8693,8692,1,0,0,0,8693,8694,1,0,0,0,8694,
+        8698,1,0,0,0,8695,8697,3,824,412,0,8696,8695,1,0,0,0,8697,8700,1,
+        0,0,0,8698,8696,1,0,0,0,8698,8699,1,0,0,0,8699,8703,1,0,0,0,8700,
+        8698,1,0,0,0,8701,8702,5,1589,0,0,8702,8704,5,1675,0,0,8703,8701,
+        1,0,0,0,8703,8704,1,0,0,0,8704,8707,1,0,0,0,8705,8707,3,820,410,
+        0,8706,8691,1,0,0,0,8706,8705,1,0,0,0,8707,807,1,0,0,0,8708,8709,
+        5,469,0,0,8709,8710,5,793,0,0,8710,8714,7,88,0,0,8711,8712,3,2312,
+        1156,0,8712,8713,5,2442,0,0,8713,8715,1,0,0,0,8714,8711,1,0,0,0,
+        8714,8715,1,0,0,0,8715,8716,1,0,0,0,8716,8717,3,2430,1215,0,8717,
+        809,1,0,0,0,8718,8719,5,469,0,0,8719,8720,5,850,0,0,8720,8721,3,
+        828,414,0,8721,811,1,0,0,0,8722,8725,5,321,0,0,8723,8724,5,1309,
+        0,0,8724,8726,5,1564,0,0,8725,8723,1,0,0,0,8725,8726,1,0,0,0,8726,
+        8729,1,0,0,0,8727,8728,5,49,0,0,8728,8730,7,89,0,0,8729,8727,1,0,
+        0,0,8729,8730,1,0,0,0,8730,8732,1,0,0,0,8731,8733,5,1105,0,0,8732,
+        8731,1,0,0,0,8732,8733,1,0,0,0,8733,8734,1,0,0,0,8734,8748,5,793,
+        0,0,8735,8736,7,86,0,0,8736,8740,5,997,0,0,8737,8738,3,2312,1156,
+        0,8738,8739,5,2442,0,0,8739,8741,1,0,0,0,8740,8737,1,0,0,0,8740,
+        8741,1,0,0,0,8741,8742,1,0,0,0,8742,8749,3,2430,1215,0,8743,8746,
+        5,206,0,0,8744,8745,5,1627,0,0,8745,8747,3,2430,1215,0,8746,8744,
+        1,0,0,0,8746,8747,1,0,0,0,8747,8749,1,0,0,0,8748,8735,1,0,0,0,8748,
+        8743,1,0,0,0,8749,8753,1,0,0,0,8750,8751,5,1683,0,0,8751,8752,5,
+        2474,0,0,8752,8754,7,21,0,0,8753,8750,1,0,0,0,8753,8754,1,0,0,0,
+        8754,8756,1,0,0,0,8755,8757,3,1740,870,0,8756,8755,1,0,0,0,8756,
+        8757,1,0,0,0,8757,8775,1,0,0,0,8758,8759,5,1571,0,0,8759,8770,5,
+        2449,0,0,8760,8761,5,2449,0,0,8761,8763,5,2445,0,0,8762,8764,5,2455,
+        0,0,8763,8762,1,0,0,0,8763,8764,1,0,0,0,8764,8767,1,0,0,0,8765,8768,
+        3,2430,1215,0,8766,8768,5,2454,0,0,8767,8765,1,0,0,0,8767,8766,1,
+        0,0,0,8768,8769,1,0,0,0,8769,8771,5,2450,0,0,8770,8760,1,0,0,0,8771,
+        8772,1,0,0,0,8772,8770,1,0,0,0,8772,8773,1,0,0,0,8773,8774,1,0,0,
+        0,8774,8776,5,2450,0,0,8775,8758,1,0,0,0,8775,8776,1,0,0,0,8776,
+        8792,1,0,0,0,8777,8788,5,2248,0,0,8778,8779,5,119,0,0,8779,8780,
+        5,2449,0,0,8780,8781,3,2430,1215,0,8781,8782,5,2455,0,0,8782,8783,
+        3,1470,735,0,8783,8784,5,2450,0,0,8784,8789,1,0,0,0,8785,8786,7,
+        90,0,0,8786,8789,3,1916,958,0,8787,8789,5,2445,0,0,8788,8778,1,0,
+        0,0,8788,8785,1,0,0,0,8788,8787,1,0,0,0,8789,8793,1,0,0,0,8790,8791,
+        5,69,0,0,8791,8793,5,2445,0,0,8792,8777,1,0,0,0,8792,8790,1,0,0,
+        0,8793,813,1,0,0,0,8794,8797,5,321,0,0,8795,8796,5,1309,0,0,8796,
+        8798,5,1564,0,0,8797,8795,1,0,0,0,8797,8798,1,0,0,0,8798,8800,1,
+        0,0,0,8799,8801,7,20,0,0,8800,8799,1,0,0,0,8800,8801,1,0,0,0,8801,
+        8802,1,0,0,0,8802,8803,5,850,0,0,8803,8804,3,816,408,0,8804,815,
+        1,0,0,0,8805,8806,3,828,414,0,8806,8807,7,22,0,0,8807,8810,3,2426,
+        1213,0,8808,8809,5,739,0,0,8809,8811,3,798,399,0,8810,8808,1,0,0,
+        0,8810,8811,1,0,0,0,8811,8814,1,0,0,0,8812,8813,5,34,0,0,8813,8815,
+        3,2426,1213,0,8814,8812,1,0,0,0,8814,8815,1,0,0,0,8815,8818,1,0,
+        0,0,8816,8817,5,325,0,0,8817,8819,3,818,409,0,8818,8816,1,0,0,0,
+        8818,8819,1,0,0,0,8819,817,1,0,0,0,8820,8821,3,2430,1215,0,8821,
+        8822,5,2442,0,0,8822,8824,1,0,0,0,8823,8820,1,0,0,0,8823,8824,1,
+        0,0,0,8824,8825,1,0,0,0,8825,8826,3,2430,1215,0,8826,819,1,0,0,0,
+        8827,8828,4,410,7,0,8828,8829,7,20,0,0,8829,821,1,0,0,0,8830,8831,
+        4,411,8,0,8831,8832,5,378,0,0,8832,823,1,0,0,0,8833,8834,3,2320,
+        1160,0,8834,8835,5,2474,0,0,8835,8836,3,826,413,0,8836,825,1,0,0,
+        0,8837,8840,3,2436,1218,0,8838,8840,5,2445,0,0,8839,8837,1,0,0,0,
+        8839,8838,1,0,0,0,8840,827,1,0,0,0,8841,8842,3,2436,1218,0,8842,
+        8843,5,2442,0,0,8843,8845,1,0,0,0,8844,8841,1,0,0,0,8844,8845,1,
+        0,0,0,8845,8846,1,0,0,0,8846,8847,3,2436,1218,0,8847,829,1,0,0,0,
+        8848,8849,5,42,0,0,8849,8850,5,422,0,0,8850,8895,3,2428,1214,0,8851,
+        8856,5,21,0,0,8852,8857,3,832,416,0,8853,8857,3,834,417,0,8854,8857,
+        3,838,419,0,8855,8857,3,840,420,0,8856,8852,1,0,0,0,8856,8853,1,
+        0,0,0,8856,8854,1,0,0,0,8856,8855,1,0,0,0,8857,8859,1,0,0,0,8858,
+        8851,1,0,0,0,8859,8860,1,0,0,0,8860,8858,1,0,0,0,8860,8861,1,0,0,
+        0,8861,8896,1,0,0,0,8862,8888,5,469,0,0,8863,8864,5,847,0,0,8864,
+        8866,3,2428,1214,0,8865,8867,7,91,0,0,8866,8865,1,0,0,0,8866,8867,
+        1,0,0,0,8867,8889,1,0,0,0,8868,8869,5,675,0,0,8869,8889,3,2428,1214,
+        0,8870,8871,5,83,0,0,8871,8886,3,2428,1214,0,8872,8873,5,847,0,0,
+        8873,8884,3,2428,1214,0,8874,8875,5,237,0,0,8875,8881,3,2366,1183,
+        0,8876,8877,5,2455,0,0,8877,8878,5,237,0,0,8878,8880,3,2366,1183,
+        0,8879,8876,1,0,0,0,8880,8883,1,0,0,0,8881,8879,1,0,0,0,8881,8882,
+        1,0,0,0,8882,8885,1,0,0,0,8883,8881,1,0,0,0,8884,8874,1,0,0,0,8884,
+        8885,1,0,0,0,8885,8887,1,0,0,0,8886,8872,1,0,0,0,8886,8887,1,0,0,
+        0,8887,8889,1,0,0,0,8888,8863,1,0,0,0,8888,8868,1,0,0,0,8888,8870,
+        1,0,0,0,8889,8891,1,0,0,0,8890,8862,1,0,0,0,8891,8892,1,0,0,0,8892,
+        8890,1,0,0,0,8892,8893,1,0,0,0,8893,8896,1,0,0,0,8894,8896,5,249,
+        0,0,8895,8858,1,0,0,0,8895,8890,1,0,0,0,8895,8894,1,0,0,0,8896,831,
+        1,0,0,0,8897,8898,5,847,0,0,8898,8899,3,2428,1214,0,8899,8920,5,
+        786,0,0,8900,8901,3,1122,561,0,8901,8902,5,2442,0,0,8902,8903,3,
+        2366,1183,0,8903,8921,1,0,0,0,8904,8905,5,2449,0,0,8905,8906,3,1122,
+        561,0,8906,8907,5,2442,0,0,8907,8915,3,2366,1183,0,8908,8909,5,2455,
+        0,0,8909,8910,3,1122,561,0,8910,8911,5,2442,0,0,8911,8912,3,2366,
+        1183,0,8912,8914,1,0,0,0,8913,8908,1,0,0,0,8914,8917,1,0,0,0,8915,
+        8913,1,0,0,0,8915,8916,1,0,0,0,8916,8918,1,0,0,0,8917,8915,1,0,0,
+        0,8918,8919,5,2450,0,0,8919,8921,1,0,0,0,8920,8900,1,0,0,0,8920,
+        8904,1,0,0,0,8921,8925,1,0,0,0,8922,8923,5,1704,0,0,8923,8924,5,
+        2302,0,0,8924,8926,5,1230,0,0,8925,8922,1,0,0,0,8925,8926,1,0,0,
+        0,8926,833,1,0,0,0,8927,8928,5,675,0,0,8928,8929,3,2428,1214,0,8929,
+        8930,5,2449,0,0,8930,8934,3,2428,1214,0,8931,8932,5,202,0,0,8932,
+        8933,5,1248,0,0,8933,8935,3,2428,1214,0,8934,8931,1,0,0,0,8935,8936,
+        1,0,0,0,8936,8934,1,0,0,0,8936,8937,1,0,0,0,8937,8939,1,0,0,0,8938,
+        8940,3,836,418,0,8939,8938,1,0,0,0,8939,8940,1,0,0,0,8940,8941,1,
+        0,0,0,8941,8942,5,2450,0,0,8942,835,1,0,0,0,8943,8944,5,795,0,0,
+        8944,8945,5,817,0,0,8945,8946,3,842,421,0,8946,8947,5,1530,0,0,8947,
+        8948,3,2428,1214,0,8948,8950,1,0,0,0,8949,8943,1,0,0,0,8950,8951,
+        1,0,0,0,8951,8949,1,0,0,0,8951,8952,1,0,0,0,8952,837,1,0,0,0,8953,
+        8954,5,83,0,0,8954,8955,3,2428,1214,0,8955,8956,5,419,0,0,8956,8957,
+        3,842,421,0,8957,8959,1,0,0,0,8958,8953,1,0,0,0,8959,8960,1,0,0,
+        0,8960,8958,1,0,0,0,8960,8961,1,0,0,0,8961,839,1,0,0,0,8962,8963,
+        5,83,0,0,8963,8969,3,2428,1214,0,8964,8965,5,847,0,0,8965,8966,3,
+        2428,1214,0,8966,8967,5,419,0,0,8967,8968,3,842,421,0,8968,8970,
+        1,0,0,0,8969,8964,1,0,0,0,8970,8971,1,0,0,0,8971,8969,1,0,0,0,8971,
+        8972,1,0,0,0,8972,841,1,0,0,0,8973,8986,3,2366,1183,0,8974,8975,
+        5,2449,0,0,8975,8980,3,2366,1183,0,8976,8977,5,2455,0,0,8977,8979,
+        3,2366,1183,0,8978,8976,1,0,0,0,8979,8982,1,0,0,0,8980,8978,1,0,
+        0,0,8980,8981,1,0,0,0,8981,8983,1,0,0,0,8982,8980,1,0,0,0,8983,8984,
+        5,2450,0,0,8984,8986,1,0,0,0,8985,8973,1,0,0,0,8985,8974,1,0,0,0,
+        8986,843,1,0,0,0,8987,8988,5,42,0,0,8988,8989,5,2288,0,0,8989,9022,
+        3,2368,1184,0,8990,8991,5,21,0,0,8991,9023,3,864,432,0,8992,8993,
+        5,981,0,0,8993,8994,5,286,0,0,8994,8995,3,2336,1168,0,8995,8996,
+        7,51,0,0,8996,9023,1,0,0,0,8997,9014,5,469,0,0,8998,8999,5,286,0,
+        0,8999,9015,3,2336,1168,0,9000,9001,5,1453,0,0,9001,9015,5,817,0,
+        0,9002,9003,5,2185,0,0,9003,9004,5,2449,0,0,9004,9009,3,2366,1183,
+        0,9005,9006,5,2455,0,0,9006,9008,3,2366,1183,0,9007,9005,1,0,0,0,
+        9008,9011,1,0,0,0,9009,9007,1,0,0,0,9009,9010,1,0,0,0,9010,9012,
+        1,0,0,0,9011,9009,1,0,0,0,9012,9013,5,2450,0,0,9013,9015,1,0,0,0,
+        9014,8998,1,0,0,0,9014,9000,1,0,0,0,9014,9002,1,0,0,0,9015,9023,
+        1,0,0,0,9016,9023,5,249,0,0,9017,9018,5,1507,0,0,9018,9023,7,11,
+        0,0,9019,9021,3,846,423,0,9020,9019,1,0,0,0,9020,9021,1,0,0,0,9021,
+        9023,1,0,0,0,9022,8990,1,0,0,0,9022,8992,1,0,0,0,9022,8997,1,0,0,
+        0,9022,9016,1,0,0,0,9022,9017,1,0,0,0,9022,9020,1,0,0,0,9023,845,
+        1,0,0,0,9024,9025,4,423,9,0,9025,9026,7,20,0,0,9026,847,1,0,0,0,
+        9027,9030,5,321,0,0,9028,9029,5,1309,0,0,9029,9031,5,1564,0,0,9030,
+        9028,1,0,0,0,9030,9031,1,0,0,0,9031,9036,1,0,0,0,9032,9034,5,1139,
+        0,0,9033,9032,1,0,0,0,9033,9034,1,0,0,0,9034,9035,1,0,0,0,9035,9037,
+        5,617,0,0,9036,9033,1,0,0,0,9036,9037,1,0,0,0,9037,9039,1,0,0,0,
+        9038,9040,3,850,425,0,9039,9038,1,0,0,0,9039,9040,1,0,0,0,9040,9041,
+        1,0,0,0,9041,9045,5,2288,0,0,9042,9043,3,2312,1156,0,9043,9044,5,
+        2442,0,0,9044,9046,1,0,0,0,9045,9042,1,0,0,0,9045,9046,1,0,0,0,9046,
+        9047,1,0,0,0,9047,9051,3,2430,1215,0,9048,9049,5,692,0,0,9049,9050,
+        5,1206,0,0,9050,9052,5,546,0,0,9051,9048,1,0,0,0,9051,9052,1,0,0,
+        0,9052,9063,1,0,0,0,9053,9054,5,1683,0,0,9054,9061,5,2474,0,0,9055,
+        9062,5,949,0,0,9056,9058,5,2378,0,0,9057,9056,1,0,0,0,9057,9058,
+        1,0,0,0,9058,9059,1,0,0,0,9059,9062,5,351,0,0,9060,9062,5,1134,0,
+        0,9061,9055,1,0,0,0,9061,9057,1,0,0,0,9061,9060,1,0,0,0,9062,9064,
+        1,0,0,0,9063,9053,1,0,0,0,9063,9064,1,0,0,0,9064,9066,1,0,0,0,9065,
+        9067,3,852,426,0,9066,9065,1,0,0,0,9066,9067,1,0,0,0,9067,9071,1,
+        0,0,0,9068,9069,5,389,0,0,9069,9070,5,2375,0,0,9070,9072,3,2430,
+        1215,0,9071,9068,1,0,0,0,9071,9072,1,0,0,0,9072,9075,1,0,0,0,9073,
+        9074,5,117,0,0,9074,9076,7,92,0,0,9075,9073,1,0,0,0,9075,9076,1,
+        0,0,0,9076,9077,1,0,0,0,9077,9078,5,69,0,0,9078,9080,3,1888,944,
+        0,9079,9081,3,2090,1045,0,9080,9079,1,0,0,0,9080,9081,1,0,0,0,9081,
+        9083,1,0,0,0,9082,9084,7,93,0,0,9083,9082,1,0,0,0,9083,9084,1,0,
+        0,0,9084,849,1,0,0,0,9085,9092,5,484,0,0,9086,9088,5,482,0,0,9087,
+        9089,5,484,0,0,9088,9087,1,0,0,0,9088,9089,1,0,0,0,9089,9092,1,0,
+        0,0,9090,9092,5,1133,0,0,9091,9085,1,0,0,0,9091,9086,1,0,0,0,9091,
+        9090,1,0,0,0,9092,851,1,0,0,0,9093,9097,3,854,427,0,9094,9097,3,
+        856,428,0,9095,9097,3,868,434,0,9096,9093,1,0,0,0,9096,9094,1,0,
+        0,0,9096,9095,1,0,0,0,9097,853,1,0,0,0,9098,9112,5,2449,0,0,9099,
+        9101,5,2455,0,0,9100,9099,1,0,0,0,9100,9101,1,0,0,0,9101,9110,1,
+        0,0,0,9102,9106,3,2296,1148,0,9103,9105,3,858,429,0,9104,9103,1,
+        0,0,0,9105,9108,1,0,0,0,9106,9104,1,0,0,0,9106,9107,1,0,0,0,9107,
+        9111,1,0,0,0,9108,9106,1,0,0,0,9109,9111,3,864,432,0,9110,9102,1,
+        0,0,0,9110,9109,1,0,0,0,9111,9113,1,0,0,0,9112,9100,1,0,0,0,9113,
+        9114,1,0,0,0,9114,9112,1,0,0,0,9114,9115,1,0,0,0,9115,9116,1,0,0,
+        0,9116,9117,5,2450,0,0,9117,855,1,0,0,0,9118,9122,5,1248,0,0,9119,
+        9120,3,2312,1156,0,9120,9121,5,2442,0,0,9121,9123,1,0,0,0,9122,9119,
+        1,0,0,0,9122,9123,1,0,0,0,9123,9124,1,0,0,0,9124,9148,3,2430,1215,
+        0,9125,9126,5,2310,0,0,9126,9127,5,1240,0,0,9127,9139,7,94,0,0,9128,
+        9140,5,389,0,0,9129,9130,5,2449,0,0,9130,9135,5,2482,0,0,9131,9132,
+        5,2455,0,0,9132,9134,5,2482,0,0,9133,9131,1,0,0,0,9134,9137,1,0,
+        0,0,9135,9133,1,0,0,0,9135,9136,1,0,0,0,9136,9138,1,0,0,0,9137,9135,
+        1,0,0,0,9138,9140,5,2450,0,0,9139,9128,1,0,0,0,9139,9129,1,0,0,0,
+        9140,9149,1,0,0,0,9141,9145,5,2179,0,0,9142,9143,3,2312,1156,0,9143,
+        9144,5,2442,0,0,9144,9146,1,0,0,0,9145,9142,1,0,0,0,9145,9146,1,
+        0,0,0,9146,9147,1,0,0,0,9147,9149,3,2430,1215,0,9148,9125,1,0,0,
+        0,9148,9141,1,0,0,0,9149,9167,1,0,0,0,9150,9159,5,2449,0,0,9151,
+        9153,5,2455,0,0,9152,9151,1,0,0,0,9152,9153,1,0,0,0,9153,9157,1,
+        0,0,0,9154,9158,3,864,432,0,9155,9156,5,2482,0,0,9156,9158,3,858,
+        429,0,9157,9154,1,0,0,0,9157,9155,1,0,0,0,9158,9160,1,0,0,0,9159,
+        9152,1,0,0,0,9160,9161,1,0,0,0,9161,9159,1,0,0,0,9161,9162,1,0,0,
+        0,9162,9163,1,0,0,0,9163,9164,5,2450,0,0,9164,9166,1,0,0,0,9165,
+        9150,1,0,0,0,9166,9169,1,0,0,0,9167,9165,1,0,0,0,9167,9168,1,0,0,
+        0,9168,857,1,0,0,0,9169,9167,1,0,0,0,9170,9171,5,286,0,0,9171,9173,
+        3,2336,1168,0,9172,9170,1,0,0,0,9172,9173,1,0,0,0,9173,9183,1,0,
+        0,0,9174,9176,5,1206,0,0,9175,9174,1,0,0,0,9175,9176,1,0,0,0,9176,
+        9177,1,0,0,0,9177,9184,5,1230,0,0,9178,9184,5,2185,0,0,9179,9180,
+        5,1453,0,0,9180,9184,5,817,0,0,9181,9184,3,1734,867,0,9182,9184,
+        3,1730,865,0,9183,9175,1,0,0,0,9183,9178,1,0,0,0,9183,9179,1,0,0,
+        0,9183,9181,1,0,0,0,9183,9182,1,0,0,0,9184,9186,1,0,0,0,9185,9187,
+        3,866,433,0,9186,9185,1,0,0,0,9186,9187,1,0,0,0,9187,859,1,0,0,0,
+        9188,9189,5,1630,0,0,9189,9190,5,786,0,0,9190,9202,3,2368,1184,0,
+        9191,9192,5,2310,0,0,9192,9202,5,1603,0,0,9193,9194,5,286,0,0,9194,
+        9196,3,2336,1168,0,9195,9193,1,0,0,0,9195,9196,1,0,0,0,9196,9197,
+        1,0,0,0,9197,9199,3,1734,867,0,9198,9200,3,866,433,0,9199,9198,1,
+        0,0,0,9199,9200,1,0,0,0,9200,9202,1,0,0,0,9201,9188,1,0,0,0,9201,
+        9191,1,0,0,0,9201,9195,1,0,0,0,9202,861,1,0,0,0,9203,9204,5,1630,
+        0,0,9204,9205,5,621,0,0,9205,9206,5,2449,0,0,9206,9207,3,2436,1218,
+        0,9207,9208,5,2450,0,0,9208,9209,5,786,0,0,9209,9210,3,2368,1184,
+        0,9210,9239,1,0,0,0,9211,9212,5,1532,0,0,9212,9213,5,2449,0,0,9213,
+        9214,3,2436,1218,0,9214,9215,5,2450,0,0,9215,9216,5,2310,0,0,9216,
+        9217,5,1603,0,0,9217,9239,1,0,0,0,9218,9219,5,286,0,0,9219,9221,
+        3,2336,1168,0,9220,9218,1,0,0,0,9220,9221,1,0,0,0,9221,9222,1,0,
+        0,0,9222,9223,5,619,0,0,9223,9224,5,817,0,0,9224,9229,5,2449,0,0,
+        9225,9227,5,2455,0,0,9226,9225,1,0,0,0,9226,9227,1,0,0,0,9227,9228,
+        1,0,0,0,9228,9230,3,2436,1218,0,9229,9226,1,0,0,0,9230,9231,1,0,
+        0,0,9231,9229,1,0,0,0,9231,9232,1,0,0,0,9232,9233,1,0,0,0,9233,9234,
+        5,2450,0,0,9234,9236,3,1734,867,0,9235,9237,3,866,433,0,9236,9235,
+        1,0,0,0,9236,9237,1,0,0,0,9237,9239,1,0,0,0,9238,9203,1,0,0,0,9238,
+        9211,1,0,0,0,9238,9220,1,0,0,0,9239,863,1,0,0,0,9240,9241,7,95,0,
+        0,9241,9243,3,2336,1168,0,9242,9240,1,0,0,0,9242,9243,1,0,0,0,9243,
+        9275,1,0,0,0,9244,9245,5,2185,0,0,9245,9246,5,2449,0,0,9246,9251,
+        3,2366,1183,0,9247,9248,5,2455,0,0,9248,9250,3,2366,1183,0,9249,
+        9247,1,0,0,0,9250,9253,1,0,0,0,9251,9249,1,0,0,0,9251,9252,1,0,0,
+        0,9252,9254,1,0,0,0,9253,9251,1,0,0,0,9254,9255,5,2450,0,0,9255,
+        9276,1,0,0,0,9256,9257,5,1453,0,0,9257,9258,5,817,0,0,9258,9259,
+        5,2449,0,0,9259,9264,3,2366,1183,0,9260,9261,5,2455,0,0,9261,9263,
+        3,2366,1183,0,9262,9260,1,0,0,0,9263,9266,1,0,0,0,9264,9262,1,0,
+        0,0,9264,9265,1,0,0,0,9265,9267,1,0,0,0,9266,9264,1,0,0,0,9267,9268,
+        5,2450,0,0,9268,9276,1,0,0,0,9269,9276,3,1732,866,0,9270,9271,5,
+        200,0,0,9271,9272,5,2449,0,0,9272,9273,3,2096,1048,0,9273,9274,5,
+        2450,0,0,9274,9276,1,0,0,0,9275,9244,1,0,0,0,9275,9256,1,0,0,0,9275,
+        9269,1,0,0,0,9275,9270,1,0,0,0,9276,9278,1,0,0,0,9277,9279,3,866,
+        433,0,9278,9277,1,0,0,0,9278,9279,1,0,0,0,9279,9281,1,0,0,0,9280,
+        9282,3,940,470,0,9281,9280,1,0,0,0,9281,9282,1,0,0,0,9282,865,1,
+        0,0,0,9283,9285,5,1206,0,0,9284,9283,1,0,0,0,9284,9285,1,0,0,0,9285,
+        9286,1,0,0,0,9286,9294,5,394,0,0,9287,9288,5,743,0,0,9288,9294,7,
+        69,0,0,9289,9294,7,51,0,0,9290,9294,7,17,0,0,9291,9294,7,96,0,0,
+        9292,9294,3,1604,802,0,9293,9284,1,0,0,0,9293,9287,1,0,0,0,9293,
+        9289,1,0,0,0,9293,9290,1,0,0,0,9293,9291,1,0,0,0,9293,9292,1,0,0,
+        0,9294,9295,1,0,0,0,9295,9293,1,0,0,0,9295,9296,1,0,0,0,9296,867,
+        1,0,0,0,9297,9298,5,1248,0,0,9298,9300,5,2353,0,0,9299,9301,3,870,
+        435,0,9300,9299,1,0,0,0,9300,9301,1,0,0,0,9301,9302,1,0,0,0,9302,
+        9303,5,2310,0,0,9303,9304,5,1240,0,0,9304,9317,7,94,0,0,9305,9318,
+        5,389,0,0,9306,9307,5,2449,0,0,9307,9312,3,2100,1050,0,9308,9309,
+        5,2455,0,0,9309,9311,3,2100,1050,0,9310,9308,1,0,0,0,9311,9314,1,
+        0,0,0,9312,9310,1,0,0,0,9312,9313,1,0,0,0,9313,9315,1,0,0,0,9314,
+        9312,1,0,0,0,9315,9316,5,2450,0,0,9316,9318,1,0,0,0,9317,9305,1,
+        0,0,0,9317,9306,1,0,0,0,9318,869,1,0,0,0,9319,9320,5,2347,0,0,9320,
+        9322,3,872,436,0,9321,9319,1,0,0,0,9321,9322,1,0,0,0,9322,9323,1,
+        0,0,0,9323,9329,5,486,0,0,9324,9330,3,874,437,0,9325,9326,3,872,
+        436,0,9326,9327,5,2460,0,0,9327,9328,3,874,437,0,9328,9330,1,0,0,
+        0,9329,9324,1,0,0,0,9329,9325,1,0,0,0,9330,9336,1,0,0,0,9331,9332,
+        5,1765,0,0,9332,9333,5,38,0,0,9333,9334,5,2268,0,0,9334,9335,5,69,
+        0,0,9335,9337,7,97,0,0,9336,9331,1,0,0,0,9336,9337,1,0,0,0,9337,
+        9341,1,0,0,0,9338,9339,3,1322,661,0,9339,9340,5,1140,0,0,9340,9342,
+        1,0,0,0,9341,9338,1,0,0,0,9341,9342,1,0,0,0,9342,9346,1,0,0,0,9343,
+        9344,3,1322,661,0,9344,9345,5,56,0,0,9345,9347,1,0,0,0,9346,9343,
+        1,0,0,0,9346,9347,1,0,0,0,9347,871,1,0,0,0,9348,9349,5,2446,0,0,
+        9349,873,1,0,0,0,9350,9351,5,2446,0,0,9351,875,1,0,0,0,9352,9353,
+        5,42,0,0,9353,9354,5,2082,0,0,9354,9387,3,1676,838,0,9355,9357,5,
+        389,0,0,9356,9358,3,1190,595,0,9357,9356,1,0,0,0,9357,9358,1,0,0,
+        0,9358,9360,1,0,0,0,9359,9361,3,1208,604,0,9360,9359,1,0,0,0,9360,
+        9361,1,0,0,0,9361,9388,1,0,0,0,9362,9363,5,955,0,0,9363,9364,5,559,
+        0,0,9364,9388,3,1188,594,0,9365,9366,5,1569,0,0,9366,9388,3,1188,
+        594,0,9367,9388,5,228,0,0,9368,9369,5,1686,0,0,9369,9372,5,1716,
+        0,0,9370,9371,5,815,0,0,9371,9373,3,1188,594,0,9372,9370,1,0,0,0,
+        9372,9373,1,0,0,0,9373,9388,1,0,0,0,9374,9375,5,1561,0,0,9375,9376,
+        5,2143,0,0,9376,9388,3,890,445,0,9377,9378,3,1392,696,0,9378,9379,
+        5,102,0,0,9379,9388,1,0,0,0,9380,9388,3,878,439,0,9381,9388,3,880,
+        440,0,9382,9388,3,882,441,0,9383,9388,3,886,443,0,9384,9388,3,934,
+        467,0,9385,9388,3,888,444,0,9386,9388,3,908,454,0,9387,9355,1,0,
+        0,0,9387,9362,1,0,0,0,9387,9365,1,0,0,0,9387,9367,1,0,0,0,9387,9368,
+        1,0,0,0,9387,9374,1,0,0,0,9387,9377,1,0,0,0,9387,9380,1,0,0,0,9387,
+        9381,1,0,0,0,9387,9382,1,0,0,0,9387,9383,1,0,0,0,9387,9384,1,0,0,
+        0,9387,9385,1,0,0,0,9387,9386,1,0,0,0,9388,877,1,0,0,0,9389,9392,
+        5,21,0,0,9390,9393,3,926,463,0,9391,9393,3,928,464,0,9392,9390,1,
+        0,0,0,9392,9391,1,0,0,0,9393,9436,1,0,0,0,9394,9395,5,469,0,0,9395,
+        9398,7,98,0,0,9396,9399,3,1470,735,0,9397,9399,5,2443,0,0,9398,9396,
+        1,0,0,0,9398,9397,1,0,0,0,9399,9402,1,0,0,0,9400,9401,5,815,0,0,
+        9401,9403,3,1188,594,0,9402,9400,1,0,0,0,9402,9403,1,0,0,0,9403,
+        9436,1,0,0,0,9404,9405,5,1686,0,0,9405,9408,5,2091,0,0,9406,9409,
+        3,1470,735,0,9407,9409,5,2443,0,0,9408,9406,1,0,0,0,9408,9407,1,
+        0,0,0,9409,9412,1,0,0,0,9410,9411,5,815,0,0,9411,9413,3,1188,594,
+        0,9412,9410,1,0,0,0,9412,9413,1,0,0,0,9413,9436,1,0,0,0,9414,9415,
+        5,1561,0,0,9415,9416,5,352,0,0,9416,9421,3,1470,735,0,9417,9418,
+        5,2455,0,0,9418,9420,3,1470,735,0,9419,9417,1,0,0,0,9420,9423,1,
+        0,0,0,9421,9419,1,0,0,0,9421,9422,1,0,0,0,9422,9424,1,0,0,0,9423,
+        9421,1,0,0,0,9424,9425,5,2143,0,0,9425,9430,3,1470,735,0,9426,9427,
+        5,2455,0,0,9427,9429,3,1470,735,0,9428,9426,1,0,0,0,9429,9432,1,
+        0,0,0,9430,9428,1,0,0,0,9430,9431,1,0,0,0,9431,9436,1,0,0,0,9432,
+        9430,1,0,0,0,9433,9434,7,98,0,0,9434,9436,3,694,347,0,9435,9389,
+        1,0,0,0,9435,9394,1,0,0,0,9435,9404,1,0,0,0,9435,9414,1,0,0,0,9435,
+        9433,1,0,0,0,9436,879,1,0,0,0,9437,9444,3,898,449,0,9438,9440,5,
+        1139,0,0,9439,9438,1,0,0,0,9439,9440,1,0,0,0,9440,9441,1,0,0,0,9441,
+        9442,5,617,0,0,9442,9444,5,885,0,0,9443,9437,1,0,0,0,9443,9439,1,
+        0,0,0,9444,881,1,0,0,0,9445,9446,5,2082,0,0,9446,9449,5,650,0,0,
+        9447,9450,3,884,442,0,9448,9450,5,2445,0,0,9449,9447,1,0,0,0,9449,
+        9448,1,0,0,0,9450,883,1,0,0,0,9451,9452,3,2436,1218,0,9452,885,1,
+        0,0,0,9453,9463,5,1258,0,0,9454,9456,5,1245,0,0,9455,9457,7,99,0,
+        0,9456,9455,1,0,0,0,9456,9457,1,0,0,0,9457,9463,1,0,0,0,9458,9459,
+        5,1507,0,0,9459,9463,7,11,0,0,9460,9463,5,1389,0,0,9461,9463,5,2094,
+        0,0,9462,9453,1,0,0,0,9462,9454,1,0,0,0,9462,9458,1,0,0,0,9462,9460,
+        1,0,0,0,9462,9461,1,0,0,0,9463,887,1,0,0,0,9464,9465,5,606,0,0,9465,
+        9466,7,100,0,0,9466,889,1,0,0,0,9467,9468,3,1676,838,0,9468,891,
+        1,0,0,0,9469,9471,5,321,0,0,9470,9472,7,101,0,0,9471,9470,1,0,0,
+        0,9471,9472,1,0,0,0,9472,9476,1,0,0,0,9473,9477,3,894,447,0,9474,
+        9477,3,904,452,0,9475,9477,3,906,453,0,9476,9473,1,0,0,0,9476,9474,
+        1,0,0,0,9476,9475,1,0,0,0,9477,893,1,0,0,0,9478,9479,5,2082,0,0,
+        9479,9483,3,2430,1215,0,9480,9481,5,692,0,0,9481,9482,5,1206,0,0,
+        9482,9484,5,546,0,0,9483,9480,1,0,0,0,9483,9484,1,0,0,0,9484,9486,
+        1,0,0,0,9485,9487,3,926,463,0,9486,9485,1,0,0,0,9486,9487,1,0,0,
+        0,9487,9505,1,0,0,0,9488,9489,5,955,0,0,9489,9490,5,559,0,0,9490,
+        9504,3,1188,594,0,9491,9492,5,146,0,0,9492,9504,3,1188,594,0,9493,
+        9504,3,898,449,0,9494,9495,5,617,0,0,9495,9504,5,885,0,0,9496,9504,
+        7,78,0,0,9497,9498,5,506,0,0,9498,9504,3,896,448,0,9499,9504,5,389,
+        0,0,9500,9504,3,900,450,0,9501,9504,3,902,451,0,9502,9504,3,888,
+        444,0,9503,9488,1,0,0,0,9503,9491,1,0,0,0,9503,9493,1,0,0,0,9503,
+        9494,1,0,0,0,9503,9496,1,0,0,0,9503,9497,1,0,0,0,9503,9499,1,0,0,
+        0,9503,9500,1,0,0,0,9503,9501,1,0,0,0,9503,9502,1,0,0,0,9504,9507,
+        1,0,0,0,9505,9503,1,0,0,0,9505,9506,1,0,0,0,9506,895,1,0,0,0,9507,
+        9505,1,0,0,0,9508,9509,5,2248,0,0,9509,9510,5,2445,0,0,9510,897,
+        1,0,0,0,9511,9512,7,102,0,0,9512,899,1,0,0,0,9513,9514,5,559,0,0,
+        9514,9515,5,907,0,0,9515,9522,5,874,0,0,9516,9523,5,90,0,0,9517,
+        9520,5,2182,0,0,9518,9519,5,1701,0,0,9519,9521,3,1188,594,0,9520,
+        9518,1,0,0,0,9520,9521,1,0,0,0,9521,9523,1,0,0,0,9522,9516,1,0,0,
+        0,9522,9517,1,0,0,0,9522,9523,1,0,0,0,9523,901,1,0,0,0,9524,9525,
+        5,1647,0,0,9525,9526,5,1716,0,0,9526,9527,5,907,0,0,9527,9528,7,
+        103,0,0,9528,903,1,0,0,0,9529,9530,5,2094,0,0,9530,9531,5,2082,0,
+        0,9531,9535,3,2430,1215,0,9532,9533,5,692,0,0,9533,9534,5,1206,0,
+        0,9534,9536,5,546,0,0,9535,9532,1,0,0,0,9535,9536,1,0,0,0,9536,9538,
+        1,0,0,0,9537,9539,3,928,464,0,9538,9537,1,0,0,0,9538,9539,1,0,0,
+        0,9539,9541,1,0,0,0,9540,9542,3,882,441,0,9541,9540,1,0,0,0,9541,
+        9542,1,0,0,0,9542,9544,1,0,0,0,9543,9545,3,900,450,0,9544,9543,1,
+        0,0,0,9544,9545,1,0,0,0,9545,905,1,0,0,0,9546,9547,5,2180,0,0,9547,
+        9548,5,2082,0,0,9548,9552,3,2430,1215,0,9549,9550,5,692,0,0,9550,
+        9551,5,1206,0,0,9551,9553,5,546,0,0,9552,9549,1,0,0,0,9552,9553,
+        1,0,0,0,9553,9555,1,0,0,0,9554,9556,3,926,463,0,9555,9554,1,0,0,
+        0,9555,9556,1,0,0,0,9556,9558,1,0,0,0,9557,9559,3,900,450,0,9558,
+        9557,1,0,0,0,9558,9559,1,0,0,0,9559,9561,1,0,0,0,9560,9562,3,908,
+        454,0,9561,9560,1,0,0,0,9561,9562,1,0,0,0,9562,907,1,0,0,0,9563,
+        9564,5,1585,0,0,9564,9565,7,104,0,0,9565,909,1,0,0,0,9566,9567,5,
+        321,0,0,9567,9568,5,2082,0,0,9568,9569,5,1673,0,0,9569,9573,3,2430,
+        1215,0,9570,9571,5,739,0,0,9571,9572,5,1679,0,0,9572,9574,3,2430,
+        1215,0,9573,9570,1,0,0,0,9573,9574,1,0,0,0,9574,9596,1,0,0,0,9575,
+        9576,5,2248,0,0,9576,9577,5,2092,0,0,9577,9587,5,2449,0,0,9578,9579,
+        5,352,0,0,9579,9584,3,448,224,0,9580,9581,5,2455,0,0,9581,9583,3,
+        448,224,0,9582,9580,1,0,0,0,9583,9586,1,0,0,0,9584,9582,1,0,0,0,
+        9584,9585,1,0,0,0,9585,9588,1,0,0,0,9586,9584,1,0,0,0,9587,9578,
+        1,0,0,0,9587,9588,1,0,0,0,9588,9590,1,0,0,0,9589,9591,3,912,456,
+        0,9590,9589,1,0,0,0,9591,9592,1,0,0,0,9592,9590,1,0,0,0,9592,9593,
+        1,0,0,0,9593,9594,1,0,0,0,9594,9595,5,2450,0,0,9595,9597,1,0,0,0,
+        9596,9575,1,0,0,0,9596,9597,1,0,0,0,9597,911,1,0,0,0,9598,9599,5,
+        955,0,0,9599,9600,5,559,0,0,9600,9618,3,1188,594,0,9601,9602,5,146,
+        0,0,9602,9604,3,2422,1211,0,9603,9605,5,813,0,0,9604,9603,1,0,0,
+        0,9604,9605,1,0,0,0,9605,9618,1,0,0,0,9606,9618,3,898,449,0,9607,
+        9608,5,617,0,0,9608,9618,5,885,0,0,9609,9618,3,914,457,0,9610,9618,
+        3,916,458,0,9611,9618,5,1258,0,0,9612,9618,5,1245,0,0,9613,9618,
+        3,900,450,0,9614,9618,3,902,451,0,9615,9618,3,888,444,0,9616,9618,
+        3,1476,738,0,9617,9598,1,0,0,0,9617,9601,1,0,0,0,9617,9606,1,0,0,
+        0,9617,9607,1,0,0,0,9617,9609,1,0,0,0,9617,9610,1,0,0,0,9617,9611,
+        1,0,0,0,9617,9612,1,0,0,0,9617,9613,1,0,0,0,9617,9614,1,0,0,0,9617,
+        9615,1,0,0,0,9617,9616,1,0,0,0,9618,913,1,0,0,0,9619,9625,5,506,
+        0,0,9620,9622,3,896,448,0,9621,9620,1,0,0,0,9621,9622,1,0,0,0,9622,
+        9623,1,0,0,0,9623,9626,5,505,0,0,9624,9626,5,387,0,0,9625,9621,1,
+        0,0,0,9625,9624,1,0,0,0,9626,915,1,0,0,0,9627,9629,5,389,0,0,9628,
+        9630,3,918,459,0,9629,9628,1,0,0,0,9629,9630,1,0,0,0,9630,9632,1,
+        0,0,0,9631,9633,3,922,461,0,9632,9631,1,0,0,0,9632,9633,1,0,0,0,
+        9633,9635,1,0,0,0,9634,9636,3,924,462,0,9635,9634,1,0,0,0,9635,9636,
+        1,0,0,0,9636,9638,1,0,0,0,9637,9639,3,1216,608,0,9638,9637,1,0,0,
+        0,9638,9639,1,0,0,0,9639,9641,1,0,0,0,9640,9642,3,1208,604,0,9641,
+        9640,1,0,0,0,9641,9642,1,0,0,0,9642,917,1,0,0,0,9643,9654,5,2085,
+        0,0,9644,9645,5,258,0,0,9645,9651,5,621,0,0,9646,9652,5,1255,0,0,
+        9647,9648,5,1486,0,0,9648,9652,3,920,460,0,9649,9650,5,64,0,0,9650,
+        9652,3,920,460,0,9651,9646,1,0,0,0,9651,9647,1,0,0,0,9651,9649,1,
+        0,0,0,9652,9655,1,0,0,0,9653,9655,5,1075,0,0,9654,9644,1,0,0,0,9654,
+        9653,1,0,0,0,9655,919,1,0,0,0,9656,9657,7,105,0,0,9657,921,1,0,0,
+        0,9658,9663,5,718,0,0,9659,9660,5,258,0,0,9660,9661,5,29,0,0,9661,
+        9664,3,920,460,0,9662,9664,5,1075,0,0,9663,9659,1,0,0,0,9663,9662,
+        1,0,0,0,9664,923,1,0,0,0,9665,9667,5,747,0,0,9666,9668,3,1194,597,
+        0,9667,9666,1,0,0,0,9667,9668,1,0,0,0,9668,9693,1,0,0,0,9669,9691,
+        5,2098,0,0,9670,9675,3,2366,1183,0,9671,9672,5,2455,0,0,9672,9674,
+        3,2366,1183,0,9673,9671,1,0,0,0,9674,9677,1,0,0,0,9675,9673,1,0,
+        0,0,9675,9676,1,0,0,0,9676,9692,1,0,0,0,9677,9675,1,0,0,0,9678,9679,
+        3,2366,1183,0,9679,9680,5,2248,0,0,9680,9688,3,730,365,0,9681,9682,
+        5,2455,0,0,9682,9683,3,2366,1183,0,9683,9684,5,2248,0,0,9684,9685,
+        3,730,365,0,9685,9687,1,0,0,0,9686,9681,1,0,0,0,9687,9690,1,0,0,
+        0,9688,9686,1,0,0,0,9688,9689,1,0,0,0,9689,9692,1,0,0,0,9690,9688,
+        1,0,0,0,9691,9670,1,0,0,0,9691,9678,1,0,0,0,9692,9694,1,0,0,0,9693,
+        9669,1,0,0,0,9693,9694,1,0,0,0,9694,9698,1,0,0,0,9695,9696,5,1139,
+        0,0,9696,9698,5,747,0,0,9697,9665,1,0,0,0,9697,9695,1,0,0,0,9698,
+        925,1,0,0,0,9699,9701,5,352,0,0,9700,9702,5,2455,0,0,9701,9700,1,
+        0,0,0,9701,9702,1,0,0,0,9702,9703,1,0,0,0,9703,9704,3,930,465,0,
+        9704,927,1,0,0,0,9705,9707,5,2091,0,0,9706,9708,5,2455,0,0,9707,
+        9706,1,0,0,0,9707,9708,1,0,0,0,9708,9709,1,0,0,0,9709,9710,3,930,
+        465,0,9710,929,1,0,0,0,9711,9713,5,2445,0,0,9712,9711,1,0,0,0,9712,
+        9713,1,0,0,0,9713,9716,1,0,0,0,9714,9715,5,1701,0,0,9715,9717,3,
+        1188,594,0,9716,9714,1,0,0,0,9716,9717,1,0,0,0,9717,9719,1,0,0,0,
+        9718,9720,5,1589,0,0,9719,9718,1,0,0,0,9719,9720,1,0,0,0,9720,9722,
+        1,0,0,0,9721,9723,3,934,467,0,9722,9721,1,0,0,0,9722,9723,1,0,0,
+        0,9723,931,1,0,0,0,9724,9737,3,1470,735,0,9725,9726,5,2449,0,0,9726,
+        9731,3,1470,735,0,9727,9728,5,2455,0,0,9728,9730,3,1470,735,0,9729,
+        9727,1,0,0,0,9730,9733,1,0,0,0,9731,9729,1,0,0,0,9731,9732,1,0,0,
+        0,9732,9734,1,0,0,0,9733,9731,1,0,0,0,9734,9735,5,2450,0,0,9735,
+        9737,1,0,0,0,9736,9724,1,0,0,0,9736,9725,1,0,0,0,9737,9740,1,0,0,
+        0,9738,9739,5,1701,0,0,9739,9741,3,1188,594,0,9740,9738,1,0,0,0,
+        9740,9741,1,0,0,0,9741,9744,1,0,0,0,9742,9743,5,146,0,0,9743,9745,
+        3,1188,594,0,9744,9742,1,0,0,0,9744,9745,1,0,0,0,9745,9747,1,0,0,
+        0,9746,9748,5,1589,0,0,9747,9746,1,0,0,0,9747,9748,1,0,0,0,9748,
+        933,1,0,0,0,9749,9759,5,93,0,0,9750,9760,5,1246,0,0,9751,9754,5,
+        1261,0,0,9752,9753,5,1026,0,0,9753,9755,3,1188,594,0,9754,9752,1,
+        0,0,0,9754,9755,1,0,0,0,9755,9757,1,0,0,0,9756,9758,3,936,468,0,
+        9757,9756,1,0,0,0,9757,9758,1,0,0,0,9758,9760,1,0,0,0,9759,9750,
+        1,0,0,0,9759,9751,1,0,0,0,9760,935,1,0,0,0,9761,9764,5,931,0,0,9762,
+        9765,5,2187,0,0,9763,9765,3,1188,594,0,9764,9762,1,0,0,0,9764,9763,
+        1,0,0,0,9765,937,1,0,0,0,9766,9767,5,158,0,0,9767,9768,7,69,0,0,
+        9768,939,1,0,0,0,9769,9785,5,1150,0,0,9770,9782,5,1335,0,0,9771,
+        9773,5,2443,0,0,9772,9774,3,942,471,0,9773,9772,1,0,0,0,9773,9774,
+        1,0,0,0,9774,9783,1,0,0,0,9775,9776,5,2449,0,0,9776,9777,5,399,0,
+        0,9777,9779,5,2443,0,0,9778,9780,3,942,471,0,9779,9778,1,0,0,0,9779,
+        9780,1,0,0,0,9780,9781,1,0,0,0,9781,9783,5,2450,0,0,9782,9771,1,
+        0,0,0,9782,9775,1,0,0,0,9782,9783,1,0,0,0,9783,9785,1,0,0,0,9784,
+        9769,1,0,0,0,9784,9770,1,0,0,0,9785,941,1,0,0,0,9786,9787,5,761,
+        0,0,9787,9788,7,106,0,0,9788,943,1,0,0,0,9789,9790,5,42,0,0,9790,
+        9791,5,920,0,0,9791,9792,5,2288,0,0,9792,9818,3,2368,1184,0,9793,
+        9819,3,1206,603,0,9794,9819,3,952,476,0,9795,9819,3,1190,595,0,9796,
+        9801,3,1660,830,0,9797,9798,5,2455,0,0,9798,9800,3,1660,830,0,9799,
+        9797,1,0,0,0,9800,9803,1,0,0,0,9801,9799,1,0,0,0,9801,9802,1,0,0,
+        0,9802,9819,1,0,0,0,9803,9801,1,0,0,0,9804,9809,3,1662,831,0,9805,
+        9806,5,2455,0,0,9806,9808,3,1662,831,0,9807,9805,1,0,0,0,9808,9811,
+        1,0,0,0,9809,9807,1,0,0,0,9809,9810,1,0,0,0,9810,9819,1,0,0,0,9811,
+        9809,1,0,0,0,9812,9819,3,940,470,0,9813,9819,3,898,449,0,9814,9819,
+        3,1296,648,0,9815,9819,3,1298,649,0,9816,9819,3,1300,650,0,9817,
+        9819,3,1376,688,0,9818,9793,1,0,0,0,9818,9794,1,0,0,0,9818,9795,
+        1,0,0,0,9818,9796,1,0,0,0,9818,9804,1,0,0,0,9818,9812,1,0,0,0,9818,
+        9813,1,0,0,0,9818,9814,1,0,0,0,9818,9815,1,0,0,0,9818,9816,1,0,0,
+        0,9818,9817,1,0,0,0,9818,9819,1,0,0,0,9819,9821,1,0,0,0,9820,9822,
+        3,1582,791,0,9821,9820,1,0,0,0,9821,9822,1,0,0,0,9822,9826,1,0,0,
+        0,9823,9824,5,2248,0,0,9824,9825,5,718,0,0,9825,9827,3,1206,603,
+        0,9826,9823,1,0,0,0,9826,9827,1,0,0,0,9827,9829,1,0,0,0,9828,9830,
+        3,946,473,0,9829,9828,1,0,0,0,9829,9830,1,0,0,0,9830,9838,1,0,0,
+        0,9831,9832,3,1320,660,0,9832,9833,5,1486,0,0,9833,9834,5,1593,0,
+        0,9834,9839,1,0,0,0,9835,9839,5,249,0,0,9836,9837,5,282,0,0,9837,
+        9839,5,628,0,0,9838,9831,1,0,0,0,9838,9835,1,0,0,0,9838,9836,1,0,
+        0,0,9838,9839,1,0,0,0,9839,945,1,0,0,0,9840,9841,3,948,474,0,9841,
+        947,1,0,0,0,9842,9869,5,1533,0,0,9843,9870,5,579,0,0,9844,9870,5,
+        250,0,0,9845,9870,5,617,0,0,9846,9847,5,1261,0,0,9847,9870,7,107,
+        0,0,9848,9849,5,1739,0,0,9849,9850,5,2310,0,0,9850,9870,3,2100,1050,
+        0,9851,9852,5,1026,0,0,9852,9870,3,2100,1050,0,9853,9854,5,2310,
+        0,0,9854,9855,5,1453,0,0,9855,9870,5,817,0,0,9856,9858,5,2248,0,
+        0,9857,9859,5,389,0,0,9858,9857,1,0,0,0,9858,9859,1,0,0,0,9859,9860,
+        1,0,0,0,9860,9861,5,914,0,0,9861,9862,5,1598,0,0,9862,9864,5,1647,
+        0,0,9863,9865,3,950,475,0,9864,9863,1,0,0,0,9864,9865,1,0,0,0,9865,
+        9870,1,0,0,0,9866,9867,5,2248,0,0,9867,9868,7,108,0,0,9868,9870,
+        5,287,0,0,9869,9843,1,0,0,0,9869,9844,1,0,0,0,9869,9845,1,0,0,0,
+        9869,9846,1,0,0,0,9869,9848,1,0,0,0,9869,9851,1,0,0,0,9869,9853,
+        1,0,0,0,9869,9856,1,0,0,0,9869,9866,1,0,0,0,9870,9871,1,0,0,0,9871,
+        9869,1,0,0,0,9871,9872,1,0,0,0,9872,949,1,0,0,0,9873,9874,3,2436,
+        1218,0,9874,951,1,0,0,0,9875,9876,5,981,0,0,9876,9877,5,2449,0,0,
+        9877,9881,3,2366,1183,0,9878,9879,5,505,0,0,9879,9882,3,1674,837,
+        0,9880,9882,5,387,0,0,9881,9878,1,0,0,0,9881,9880,1,0,0,0,9881,9882,
+        1,0,0,0,9882,9883,1,0,0,0,9883,9884,5,2450,0,0,9884,953,1,0,0,0,
+        9885,9886,5,42,0,0,9886,9887,5,920,0,0,9887,9888,5,2288,0,0,9888,
+        9890,5,889,0,0,9889,9891,5,617,0,0,9890,9889,1,0,0,0,9890,9891,1,
+        0,0,0,9891,9892,1,0,0,0,9892,9893,5,1261,0,0,9893,9902,3,2368,1184,
+        0,9894,9903,3,1206,603,0,9895,9903,3,956,478,0,9896,9903,3,940,470,
+        0,9897,9903,3,898,449,0,9898,9903,3,1296,648,0,9899,9903,3,1300,
+        650,0,9900,9903,3,958,479,0,9901,9903,3,1376,688,0,9902,9894,1,0,
+        0,0,9902,9895,1,0,0,0,9902,9896,1,0,0,0,9902,9897,1,0,0,0,9902,9898,
+        1,0,0,0,9902,9899,1,0,0,0,9902,9900,1,0,0,0,9902,9901,1,0,0,0,9902,
+        9903,1,0,0,0,9903,9905,1,0,0,0,9904,9906,3,960,480,0,9905,9904,1,
+        0,0,0,9905,9906,1,0,0,0,9906,9908,1,0,0,0,9907,9909,3,966,483,0,
+        9908,9907,1,0,0,0,9908,9909,1,0,0,0,9909,955,1,0,0,0,9910,9911,5,
+        21,0,0,9911,9912,5,2449,0,0,9912,9913,3,2366,1183,0,9913,9914,5,
+        2450,0,0,9914,957,1,0,0,0,9915,9916,5,993,0,0,9916,9918,3,1212,606,
+        0,9917,9919,3,940,470,0,9918,9917,1,0,0,0,9918,9919,1,0,0,0,9919,
+        959,1,0,0,0,9920,9953,5,21,0,0,9921,9922,5,1240,0,0,9922,9928,5,
+        690,0,0,9923,9924,5,1453,0,0,9924,9928,5,817,0,0,9925,9928,5,1603,
+        0,0,9926,9928,5,1655,0,0,9927,9921,1,0,0,0,9927,9923,1,0,0,0,9927,
+        9925,1,0,0,0,9927,9926,1,0,0,0,9928,9940,1,0,0,0,9929,9930,5,2449,
+        0,0,9930,9935,3,2366,1183,0,9931,9932,5,2455,0,0,9932,9934,3,2366,
+        1183,0,9933,9931,1,0,0,0,9934,9937,1,0,0,0,9935,9933,1,0,0,0,9935,
+        9936,1,0,0,0,9936,9938,1,0,0,0,9937,9935,1,0,0,0,9938,9939,5,2450,
+        0,0,9939,9941,1,0,0,0,9940,9929,1,0,0,0,9940,9941,1,0,0,0,9941,9954,
+        1,0,0,0,9942,9943,5,2449,0,0,9943,9948,3,2366,1183,0,9944,9945,5,
+        2455,0,0,9945,9947,3,2366,1183,0,9946,9944,1,0,0,0,9947,9950,1,0,
+        0,0,9948,9946,1,0,0,0,9948,9949,1,0,0,0,9949,9951,1,0,0,0,9950,9948,
+        1,0,0,0,9951,9952,5,2450,0,0,9952,9954,1,0,0,0,9953,9927,1,0,0,0,
+        9953,9942,1,0,0,0,9954,9956,1,0,0,0,9955,9957,3,964,482,0,9956,9955,
+        1,0,0,0,9956,9957,1,0,0,0,9957,961,1,0,0,0,9958,9959,5,321,0,0,9959,
+        9960,5,920,0,0,9960,9961,5,2288,0,0,9961,9962,5,889,0,0,9962,9963,
+        5,1261,0,0,9963,9973,3,2368,1184,0,9964,9970,3,1206,603,0,9965,9966,
+        5,2082,0,0,9966,9970,3,2430,1215,0,9967,9970,3,898,449,0,9968,9970,
+        7,109,0,0,9969,9964,1,0,0,0,9969,9965,1,0,0,0,9969,9967,1,0,0,0,
+        9969,9968,1,0,0,0,9970,9971,1,0,0,0,9971,9969,1,0,0,0,9971,9972,
+        1,0,0,0,9972,9974,1,0,0,0,9973,9969,1,0,0,0,9973,9974,1,0,0,0,9974,
+        9976,1,0,0,0,9975,9977,3,940,470,0,9976,9975,1,0,0,0,9976,9977,1,
+        0,0,0,9977,10018,1,0,0,0,9978,9994,5,2310,0,0,9979,9981,5,2455,0,
+        0,9980,9979,1,0,0,0,9980,9981,1,0,0,0,9981,9990,1,0,0,0,9982,9983,
+        5,1240,0,0,9983,9991,5,690,0,0,9984,9985,5,1453,0,0,9985,9991,5,
+        817,0,0,9986,9991,5,1603,0,0,9987,9991,5,1655,0,0,9988,9989,5,242,
+        0,0,9989,9991,5,1629,0,0,9990,9982,1,0,0,0,9990,9984,1,0,0,0,9990,
+        9986,1,0,0,0,9990,9987,1,0,0,0,9990,9988,1,0,0,0,9991,9993,1,0,0,
+        0,9992,9980,1,0,0,0,9993,9996,1,0,0,0,9994,9992,1,0,0,0,9994,9995,
+        1,0,0,0,9995,10008,1,0,0,0,9996,9994,1,0,0,0,9997,10002,5,2449,0,
+        0,9998,10000,5,2455,0,0,9999,9998,1,0,0,0,9999,10000,1,0,0,0,10000,
+        10001,1,0,0,0,10001,10003,3,2436,1218,0,10002,9999,1,0,0,0,10003,
+        10004,1,0,0,0,10004,10002,1,0,0,0,10004,10005,1,0,0,0,10005,10006,
+        1,0,0,0,10006,10007,5,2450,0,0,10007,10009,1,0,0,0,10008,9997,1,
+        0,0,0,10008,10009,1,0,0,0,10009,10011,1,0,0,0,10010,10012,3,964,
+        482,0,10011,10010,1,0,0,0,10011,10012,1,0,0,0,10012,10014,1,0,0,
+        0,10013,10015,3,966,483,0,10014,10013,1,0,0,0,10014,10015,1,0,0,
+        0,10015,10017,1,0,0,0,10016,9978,1,0,0,0,10017,10020,1,0,0,0,10018,
+        10016,1,0,0,0,10018,10019,1,0,0,0,10019,963,1,0,0,0,10020,10018,
+        1,0,0,0,10021,10022,7,110,0,0,10022,10023,5,1022,0,0,10023,10024,
+        5,2259,0,0,10024,965,1,0,0,0,10025,10026,5,1477,0,0,10026,10028,
+        5,699,0,0,10027,10029,7,111,0,0,10028,10027,1,0,0,0,10028,10029,
+        1,0,0,0,10029,967,1,0,0,0,10030,10031,5,321,0,0,10031,10032,5,920,
+        0,0,10032,10033,5,2364,0,0,10033,10038,3,978,489,0,10034,10035,5,
+        2449,0,0,10035,10036,3,2384,1192,0,10036,10037,5,2450,0,0,10037,
+        10039,1,0,0,0,10038,10034,1,0,0,0,10038,10039,1,0,0,0,10039,10041,
+        1,0,0,0,10040,10042,3,976,488,0,10041,10040,1,0,0,0,10041,10042,
+        1,0,0,0,10042,10044,1,0,0,0,10043,10045,3,974,487,0,10044,10043,
+        1,0,0,0,10044,10045,1,0,0,0,10045,10048,1,0,0,0,10046,10047,7,17,
+        0,0,10047,10049,5,1474,0,0,10048,10046,1,0,0,0,10048,10049,1,0,0,
+        0,10049,10052,1,0,0,0,10050,10053,3,984,492,0,10051,10053,3,986,
+        493,0,10052,10050,1,0,0,0,10052,10051,1,0,0,0,10053,969,1,0,0,0,
+        10054,10055,5,42,0,0,10055,10056,5,920,0,0,10056,10057,5,2364,0,
+        0,10057,10065,3,978,489,0,10058,10066,3,976,488,0,10059,10066,3,
+        974,487,0,10060,10061,7,17,0,0,10061,10066,5,1474,0,0,10062,10066,
+        5,249,0,0,10063,10066,5,1513,0,0,10064,10066,5,2205,0,0,10065,10058,
+        1,0,0,0,10065,10059,1,0,0,0,10065,10060,1,0,0,0,10065,10062,1,0,
+        0,0,10065,10063,1,0,0,0,10065,10064,1,0,0,0,10066,971,1,0,0,0,10067,
+        10068,5,469,0,0,10068,10069,5,920,0,0,10069,10070,5,2364,0,0,10070,
+        10071,3,978,489,0,10071,973,1,0,0,0,10072,10074,5,1533,0,0,10073,
+        10075,7,112,0,0,10074,10073,1,0,0,0,10074,10075,1,0,0,0,10075,10087,
+        1,0,0,0,10076,10085,5,1261,0,0,10077,10086,5,406,0,0,10078,10086,
+        5,242,0,0,10079,10086,5,868,0,0,10080,10081,5,351,0,0,10081,10086,
+        5,992,0,0,10082,10083,5,868,0,0,10083,10084,5,351,0,0,10084,10086,
+        5,992,0,0,10085,10077,1,0,0,0,10085,10078,1,0,0,0,10085,10079,1,
+        0,0,0,10085,10080,1,0,0,0,10085,10082,1,0,0,0,10086,10088,1,0,0,
+        0,10087,10076,1,0,0,0,10087,10088,1,0,0,0,10088,975,1,0,0,0,10089,
+        10090,5,1371,0,0,10090,10099,3,2422,1211,0,10091,10092,5,1374,0,
+        0,10092,10099,3,2422,1211,0,10093,10094,5,1622,0,0,10094,10099,3,
+        2422,1211,0,10095,10096,5,2082,0,0,10096,10099,3,1676,838,0,10097,
+        10099,7,109,0,0,10098,10089,1,0,0,0,10098,10091,1,0,0,0,10098,10093,
+        1,0,0,0,10098,10095,1,0,0,0,10098,10097,1,0,0,0,10099,10100,1,0,
+        0,0,10100,10098,1,0,0,0,10100,10101,1,0,0,0,10101,977,1,0,0,0,10102,
+        10105,3,2428,1214,0,10103,10104,5,2442,0,0,10104,10106,3,2430,1215,
+        0,10105,10103,1,0,0,0,10105,10106,1,0,0,0,10106,979,1,0,0,0,10107,
+        10110,3,2428,1214,0,10108,10109,5,2442,0,0,10109,10111,3,2430,1215,
+        0,10110,10108,1,0,0,0,10110,10111,1,0,0,0,10111,981,1,0,0,0,10112,
+        10117,3,2428,1214,0,10113,10114,5,2442,0,0,10114,10116,3,2430,1215,
+        0,10115,10113,1,0,0,0,10116,10119,1,0,0,0,10117,10115,1,0,0,0,10117,
+        10118,1,0,0,0,10118,983,1,0,0,0,10119,10117,1,0,0,0,10120,10121,
+        5,1261,0,0,10121,10122,3,2368,1184,0,10122,10123,5,2449,0,0,10123,
+        10124,3,2384,1192,0,10124,10125,5,2450,0,0,10125,985,1,0,0,0,10126,
+        10127,5,69,0,0,10127,10128,3,1916,958,0,10128,987,1,0,0,0,10129,
+        10130,5,42,0,0,10130,10131,5,1268,0,0,10131,10135,3,980,490,0,10132,
+        10136,3,996,498,0,10133,10136,3,1008,504,0,10134,10136,5,249,0,0,
+        10135,10132,1,0,0,0,10135,10133,1,0,0,0,10135,10134,1,0,0,0,10136,
+        989,1,0,0,0,10137,10138,5,469,0,0,10138,10139,5,1268,0,0,10139,10141,
+        3,980,490,0,10140,10142,5,617,0,0,10141,10140,1,0,0,0,10141,10142,
+        1,0,0,0,10142,991,1,0,0,0,10143,10146,5,321,0,0,10144,10145,5,1309,
+        0,0,10145,10147,5,1564,0,0,10146,10144,1,0,0,0,10146,10147,1,0,0,
+        0,10147,10148,1,0,0,0,10148,10149,5,1268,0,0,10149,10150,3,980,490,
+        0,10150,10151,5,133,0,0,10151,10156,3,994,497,0,10152,10153,5,2455,
+        0,0,10153,10155,3,994,497,0,10154,10152,1,0,0,0,10155,10158,1,0,
+        0,0,10156,10154,1,0,0,0,10156,10157,1,0,0,0,10157,10162,1,0,0,0,
+        10158,10156,1,0,0,0,10159,10160,5,1683,0,0,10160,10161,5,2474,0,
+        0,10161,10163,7,21,0,0,10162,10159,1,0,0,0,10162,10163,1,0,0,0,10163,
+        993,1,0,0,0,10164,10165,5,2449,0,0,10165,10170,3,2402,1201,0,10166,
+        10167,5,2455,0,0,10167,10169,3,2402,1201,0,10168,10166,1,0,0,0,10169,
+        10172,1,0,0,0,10170,10168,1,0,0,0,10170,10171,1,0,0,0,10171,10173,
+        1,0,0,0,10172,10170,1,0,0,0,10173,10174,5,2450,0,0,10174,10176,5,
+        1588,0,0,10175,10177,5,2449,0,0,10176,10175,1,0,0,0,10176,10177,
+        1,0,0,0,10177,10178,1,0,0,0,10178,10180,3,2402,1201,0,10179,10181,
+        5,2450,0,0,10180,10179,1,0,0,0,10180,10181,1,0,0,0,10181,10183,1,
+        0,0,0,10182,10184,3,998,499,0,10183,10182,1,0,0,0,10183,10184,1,
+        0,0,0,10184,10185,1,0,0,0,10185,10186,3,1006,503,0,10186,995,1,0,
+        0,0,10187,10188,5,21,0,0,10188,10189,5,133,0,0,10189,10190,3,994,
+        497,0,10190,997,1,0,0,0,10191,10192,5,48,0,0,10192,10193,5,2143,
+        0,0,10193,10196,3,1000,500,0,10194,10196,3,1004,502,0,10195,10191,
+        1,0,0,0,10195,10194,1,0,0,0,10196,999,1,0,0,0,10197,10202,3,1002,
+        501,0,10198,10199,5,2455,0,0,10199,10201,3,1002,501,0,10200,10198,
+        1,0,0,0,10201,10204,1,0,0,0,10202,10200,1,0,0,0,10202,10203,1,0,
+        0,0,10203,1001,1,0,0,0,10204,10202,1,0,0,0,10205,10206,3,2376,1188,
+        0,10206,10207,5,2449,0,0,10207,10212,3,2402,1201,0,10208,10209,5,
+        2455,0,0,10209,10211,3,2402,1201,0,10210,10208,1,0,0,0,10211,10214,
+        1,0,0,0,10212,10210,1,0,0,0,10212,10213,1,0,0,0,10213,10215,1,0,
+        0,0,10214,10212,1,0,0,0,10215,10216,5,2450,0,0,10216,1003,1,0,0,
+        0,10217,10218,5,2310,0,0,10218,10219,5,718,0,0,10219,10220,5,296,
+        0,0,10220,10221,5,2455,0,0,10221,10222,5,1624,0,0,10222,10223,5,
+        296,0,0,10223,10227,3,2318,1159,0,10224,10225,5,260,0,0,10225,10226,
+        5,48,0,0,10226,10228,5,351,0,0,10227,10224,1,0,0,0,10227,10228,1,
+        0,0,0,10228,10232,1,0,0,0,10229,10230,5,2310,0,0,10230,10231,5,237,
+        0,0,10231,10233,5,296,0,0,10232,10229,1,0,0,0,10232,10233,1,0,0,
+        0,10233,1005,1,0,0,0,10234,10235,5,2248,0,0,10235,10236,3,982,491,
+        0,10236,1007,1,0,0,0,10237,10238,5,469,0,0,10238,10239,5,133,0,0,
+        10239,10240,5,2449,0,0,10240,10245,3,2402,1201,0,10241,10242,5,2455,
+        0,0,10242,10244,3,2402,1201,0,10243,10241,1,0,0,0,10244,10247,1,
+        0,0,0,10245,10243,1,0,0,0,10245,10246,1,0,0,0,10246,10248,1,0,0,
+        0,10247,10245,1,0,0,0,10248,10250,5,2450,0,0,10249,10251,5,617,0,
+        0,10250,10249,1,0,0,0,10250,10251,1,0,0,0,10251,1009,1,0,0,0,10252,
+        10253,5,321,0,0,10253,10254,5,920,0,0,10254,10258,5,2288,0,0,10255,
+        10256,5,692,0,0,10256,10257,5,1206,0,0,10257,10259,5,546,0,0,10258,
+        10255,1,0,0,0,10258,10259,1,0,0,0,10259,10260,1,0,0,0,10260,10263,
+        3,2368,1184,0,10261,10262,5,1248,0,0,10262,10264,3,2340,1170,0,10263,
+        10261,1,0,0,0,10263,10264,1,0,0,0,10264,10282,1,0,0,0,10265,10268,
+        5,2449,0,0,10266,10269,3,1012,506,0,10267,10269,3,1014,507,0,10268,
+        10266,1,0,0,0,10268,10267,1,0,0,0,10269,10277,1,0,0,0,10270,10273,
+        5,2455,0,0,10271,10274,3,1012,506,0,10272,10274,3,1014,507,0,10273,
+        10271,1,0,0,0,10273,10272,1,0,0,0,10274,10276,1,0,0,0,10275,10270,
+        1,0,0,0,10276,10279,1,0,0,0,10277,10275,1,0,0,0,10277,10278,1,0,
+        0,0,10278,10280,1,0,0,0,10279,10277,1,0,0,0,10280,10281,5,2450,0,
+        0,10281,10283,1,0,0,0,10282,10265,1,0,0,0,10282,10283,1,0,0,0,10283,
+        10304,1,0,0,0,10284,10285,5,1261,0,0,10285,10286,5,1436,0,0,10286,
+        10290,5,2085,0,0,10287,10288,7,2,0,0,10288,10289,5,1525,0,0,10289,
+        10291,5,1439,0,0,10290,10287,1,0,0,0,10290,10291,1,0,0,0,10291,10305,
+        1,0,0,0,10292,10294,3,1214,607,0,10293,10292,1,0,0,0,10293,10294,
+        1,0,0,0,10294,10296,1,0,0,0,10295,10297,7,109,0,0,10296,10295,1,
+        0,0,0,10296,10297,1,0,0,0,10297,10299,1,0,0,0,10298,10300,3,940,
+        470,0,10299,10298,1,0,0,0,10299,10300,1,0,0,0,10300,10302,1,0,0,
+        0,10301,10303,3,938,469,0,10302,10301,1,0,0,0,10302,10303,1,0,0,
+        0,10303,10305,1,0,0,0,10304,10284,1,0,0,0,10304,10293,1,0,0,0,10305,
+        10323,1,0,0,0,10306,10307,5,2248,0,0,10307,10317,5,718,0,0,10308,
+        10312,3,1206,603,0,10309,10310,5,2082,0,0,10310,10312,3,2430,1215,
+        0,10311,10308,1,0,0,0,10311,10309,1,0,0,0,10312,10313,1,0,0,0,10313,
+        10311,1,0,0,0,10313,10314,1,0,0,0,10314,10316,1,0,0,0,10315,10311,
+        1,0,0,0,10316,10319,1,0,0,0,10317,10315,1,0,0,0,10317,10318,1,0,
+        0,0,10318,10324,1,0,0,0,10319,10317,1,0,0,0,10320,10321,5,2248,0,
+        0,10321,10322,5,1139,0,0,10322,10324,5,718,0,0,10323,10306,1,0,0,
+        0,10323,10320,1,0,0,0,10323,10324,1,0,0,0,10324,10326,1,0,0,0,10325,
+        10327,3,1016,508,0,10326,10325,1,0,0,0,10326,10327,1,0,0,0,10327,
+        10329,1,0,0,0,10328,10330,3,1708,854,0,10329,10328,1,0,0,0,10329,
+        10330,1,0,0,0,10330,10335,1,0,0,0,10331,10332,7,17,0,0,10332,10333,
+        5,1261,0,0,10333,10334,5,1486,0,0,10334,10336,5,261,0,0,10335,10331,
+        1,0,0,0,10335,10336,1,0,0,0,10336,10338,1,0,0,0,10337,10339,3,1018,
+        509,0,10338,10337,1,0,0,0,10338,10339,1,0,0,0,10339,10343,1,0,0,
+        0,10340,10341,7,17,0,0,10341,10342,5,263,0,0,10342,10344,5,1533,
+        0,0,10343,10340,1,0,0,0,10343,10344,1,0,0,0,10344,10346,1,0,0,0,
+        10345,10347,3,2270,1135,0,10346,10345,1,0,0,0,10346,10347,1,0,0,
+        0,10347,10348,1,0,0,0,10348,10349,5,69,0,0,10349,10350,3,1888,944,
+        0,10350,1011,1,0,0,0,10351,10352,5,1630,0,0,10352,10353,5,621,0,
+        0,10353,10354,5,2449,0,0,10354,10355,3,2428,1214,0,10355,10356,5,
+        2450,0,0,10356,10360,5,786,0,0,10357,10358,3,2312,1156,0,10358,10359,
+        5,2442,0,0,10359,10361,1,0,0,0,10360,10357,1,0,0,0,10360,10361,1,
+        0,0,0,10361,10362,1,0,0,0,10362,10363,3,2428,1214,0,10363,1013,1,
+        0,0,0,10364,10367,3,2428,1214,0,10365,10367,3,2426,1213,0,10366,
+        10364,1,0,0,0,10366,10365,1,0,0,0,10367,10370,1,0,0,0,10368,10369,
+        5,505,0,0,10369,10371,3,1674,837,0,10370,10368,1,0,0,0,10370,10371,
+        1,0,0,0,10371,10374,1,0,0,0,10372,10375,3,2270,1135,0,10373,10375,
+        3,1012,506,0,10374,10372,1,0,0,0,10374,10373,1,0,0,0,10374,10375,
+        1,0,0,0,10375,1015,1,0,0,0,10376,10377,5,1021,0,0,10377,10417,5,
+        1533,0,0,10378,10412,5,1533,0,0,10379,10413,7,113,0,0,10380,10381,
+        5,1261,0,0,10381,10413,7,114,0,0,10382,10383,5,1739,0,0,10383,10386,
+        5,2310,0,0,10384,10386,5,1026,0,0,10385,10382,1,0,0,0,10385,10384,
+        1,0,0,0,10386,10387,1,0,0,0,10387,10413,3,2100,1050,0,10388,10392,
+        5,2310,0,0,10389,10390,5,1453,0,0,10390,10393,5,817,0,0,10391,10393,
+        5,1603,0,0,10392,10389,1,0,0,0,10392,10391,1,0,0,0,10393,10413,1,
+        0,0,0,10394,10407,5,2248,0,0,10395,10397,5,389,0,0,10396,10398,7,
+        115,0,0,10397,10396,1,0,0,0,10397,10398,1,0,0,0,10398,10399,1,0,
+        0,0,10399,10400,5,1598,0,0,10400,10408,5,1647,0,0,10401,10403,7,
+        115,0,0,10402,10401,1,0,0,0,10402,10403,1,0,0,0,10403,10404,1,0,
+        0,0,10404,10405,5,1598,0,0,10405,10406,5,1647,0,0,10406,10408,3,
+        2310,1155,0,10407,10395,1,0,0,0,10407,10402,1,0,0,0,10408,10413,
+        1,0,0,0,10409,10410,5,2248,0,0,10410,10411,7,108,0,0,10411,10413,
+        5,287,0,0,10412,10379,1,0,0,0,10412,10380,1,0,0,0,10412,10385,1,
+        0,0,0,10412,10388,1,0,0,0,10412,10394,1,0,0,0,10412,10409,1,0,0,
+        0,10413,10414,1,0,0,0,10414,10412,1,0,0,0,10414,10415,1,0,0,0,10415,
+        10417,1,0,0,0,10416,10376,1,0,0,0,10416,10378,1,0,0,0,10417,1017,
+        1,0,0,0,10418,10419,7,17,0,0,10419,10420,5,1486,0,0,10420,10422,
+        5,1593,0,0,10421,10423,3,1020,510,0,10422,10421,1,0,0,0,10422,10423,
+        1,0,0,0,10423,1019,1,0,0,0,10424,10443,5,2205,0,0,10425,10429,5,
+        112,0,0,10426,10427,5,114,0,0,10427,10429,5,2310,0,0,10428,10425,
+        1,0,0,0,10428,10426,1,0,0,0,10429,10430,1,0,0,0,10430,10431,5,336,
+        0,0,10431,10444,5,483,0,0,10432,10436,5,112,0,0,10433,10434,5,114,
+        0,0,10434,10436,5,2310,0,0,10435,10432,1,0,0,0,10435,10433,1,0,0,
+        0,10436,10437,1,0,0,0,10437,10438,5,483,0,0,10438,10444,3,1466,733,
+        0,10439,10440,5,114,0,0,10440,10441,5,2310,0,0,10441,10442,5,1230,
+        0,0,10442,10444,5,483,0,0,10443,10428,1,0,0,0,10443,10435,1,0,0,
+        0,10443,10439,1,0,0,0,10444,1021,1,0,0,0,10445,10446,5,469,0,0,10446,
+        10447,5,920,0,0,10447,10448,5,2288,0,0,10448,10451,3,2368,1184,0,
+        10449,10450,5,1449,0,0,10450,10452,5,2085,0,0,10451,10449,1,0,0,
+        0,10451,10452,1,0,0,0,10452,1023,1,0,0,0,10453,10454,5,469,0,0,10454,
+        10455,5,920,0,0,10455,10456,5,2288,0,0,10456,10459,5,889,0,0,10457,
+        10458,5,692,0,0,10458,10460,5,546,0,0,10459,10457,1,0,0,0,10459,
+        10460,1,0,0,0,10460,10461,1,0,0,0,10461,10462,5,1261,0,0,10462,10463,
+        3,2368,1184,0,10463,1025,1,0,0,0,10464,10467,5,321,0,0,10465,10466,
+        5,1309,0,0,10466,10468,5,1564,0,0,10467,10465,1,0,0,0,10467,10468,
+        1,0,0,0,10468,10469,1,0,0,0,10469,10470,5,296,0,0,10470,10471,3,
+        1028,514,0,10471,10475,5,2248,0,0,10472,10473,3,2376,1188,0,10473,
+        10474,5,2442,0,0,10474,10476,1,0,0,0,10475,10472,1,0,0,0,10475,10476,
+        1,0,0,0,10476,10477,1,0,0,0,10477,10482,3,2316,1158,0,10478,10479,
+        5,742,0,0,10479,10483,7,73,0,0,10480,10481,5,5,0,0,10481,10483,5,
+        644,0,0,10482,10478,1,0,0,0,10482,10480,1,0,0,0,10482,10483,1,0,
+        0,0,10483,1027,1,0,0,0,10484,10485,3,2430,1215,0,10485,1029,1,0,
+        0,0,10486,10487,5,321,0,0,10487,10488,5,220,0,0,10488,10489,3,478,
+        239,0,10489,10490,5,2449,0,0,10490,10491,3,2366,1183,0,10491,10493,
+        3,2402,1201,0,10492,10494,5,1711,0,0,10493,10492,1,0,0,0,10493,10494,
+        1,0,0,0,10494,10503,1,0,0,0,10495,10496,5,2455,0,0,10496,10497,3,
+        2366,1183,0,10497,10499,3,2402,1201,0,10498,10500,5,1711,0,0,10499,
+        10498,1,0,0,0,10499,10500,1,0,0,0,10500,10502,1,0,0,0,10501,10495,
+        1,0,0,0,10502,10505,1,0,0,0,10503,10501,1,0,0,0,10503,10504,1,0,
+        0,0,10504,10506,1,0,0,0,10505,10503,1,0,0,0,10506,10526,5,2450,0,
+        0,10507,10525,3,1206,603,0,10508,10509,5,1701,0,0,10509,10525,3,
+        1188,594,0,10510,10511,5,2082,0,0,10511,10525,3,1676,838,0,10512,
+        10525,5,718,0,0,10513,10514,5,1697,0,0,10514,10516,5,2085,0,0,10515,
+        10513,1,0,0,0,10515,10516,1,0,0,0,10516,10517,1,0,0,0,10517,10518,
+        5,662,0,0,10518,10522,5,2443,0,0,10519,10520,5,661,0,0,10520,10521,
+        5,786,0,0,10521,10523,3,2100,1050,0,10522,10519,1,0,0,0,10522,10523,
+        1,0,0,0,10523,10525,1,0,0,0,10524,10507,1,0,0,0,10524,10508,1,0,
+        0,0,10524,10510,1,0,0,0,10524,10512,1,0,0,0,10524,10515,1,0,0,0,
+        10525,10528,1,0,0,0,10526,10524,1,0,0,0,10526,10527,1,0,0,0,10527,
+        10530,1,0,0,0,10528,10526,1,0,0,0,10529,10531,3,940,470,0,10530,
+        10529,1,0,0,0,10530,10531,1,0,0,0,10531,10533,1,0,0,0,10532,10534,
+        7,116,0,0,10533,10532,1,0,0,0,10533,10534,1,0,0,0,10534,10536,1,
+        0,0,0,10535,10537,7,109,0,0,10536,10535,1,0,0,0,10536,10537,1,0,
+        0,0,10537,1031,1,0,0,0,10538,10540,5,321,0,0,10539,10541,5,909,0,
+        0,10540,10539,1,0,0,0,10540,10541,1,0,0,0,10541,10542,1,0,0,0,10542,
+        10543,5,1465,0,0,10543,10544,3,2430,1215,0,10544,10547,5,859,0,0,
+        10545,10548,3,1034,517,0,10546,10548,3,1036,518,0,10547,10545,1,
+        0,0,0,10547,10546,1,0,0,0,10548,10549,1,0,0,0,10549,10547,1,0,0,
+        0,10549,10550,1,0,0,0,10550,10552,1,0,0,0,10551,10553,3,778,389,
+        0,10552,10551,1,0,0,0,10552,10553,1,0,0,0,10553,1033,1,0,0,0,10554,
+        10555,7,117,0,0,10555,10563,7,118,0,0,10556,10560,5,1458,0,0,10557,
+        10561,3,1188,594,0,10558,10561,5,2187,0,0,10559,10561,5,389,0,0,
+        10560,10557,1,0,0,0,10560,10558,1,0,0,0,10560,10559,1,0,0,0,10561,
+        10563,1,0,0,0,10562,10554,1,0,0,0,10562,10556,1,0,0,0,10563,1035,
+        1,0,0,0,10564,10568,7,119,0,0,10565,10569,3,2100,1050,0,10566,10569,
+        5,2187,0,0,10567,10569,5,389,0,0,10568,10565,1,0,0,0,10568,10566,
+        1,0,0,0,10568,10567,1,0,0,0,10569,10582,1,0,0,0,10570,10574,5,1362,
+        0,0,10571,10575,3,2346,1173,0,10572,10575,5,1230,0,0,10573,10575,
+        5,389,0,0,10574,10571,1,0,0,0,10574,10572,1,0,0,0,10574,10573,1,
+        0,0,0,10575,10582,1,0,0,0,10576,10579,5,1361,0,0,10577,10580,3,2100,
+        1050,0,10578,10580,5,389,0,0,10579,10577,1,0,0,0,10579,10578,1,0,
+        0,0,10580,10582,1,0,0,0,10581,10564,1,0,0,0,10581,10570,1,0,0,0,
+        10581,10576,1,0,0,0,10582,1037,1,0,0,0,10583,10584,5,321,0,0,10584,
+        10585,5,879,0,0,10585,10586,5,1465,0,0,10586,10589,3,2430,1215,0,
+        10587,10590,3,1040,520,0,10588,10590,3,1042,521,0,10589,10587,1,
+        0,0,0,10589,10588,1,0,0,0,10589,10590,1,0,0,0,10590,1039,1,0,0,0,
+        10591,10592,5,629,0,0,10592,10593,3,2430,1215,0,10593,1041,1,0,0,
+        0,10594,10595,5,706,0,0,10595,10596,3,2430,1215,0,10596,1043,1,0,
+        0,0,10597,10600,5,321,0,0,10598,10599,5,1309,0,0,10599,10601,5,1564,
+        0,0,10600,10598,1,0,0,0,10600,10601,1,0,0,0,10601,10603,1,0,0,0,
+        10602,10604,7,28,0,0,10603,10602,1,0,0,0,10603,10604,1,0,0,0,10604,
+        10605,1,0,0,0,10605,10607,5,1317,0,0,10606,10608,3,2430,1215,0,10607,
+        10606,1,0,0,0,10607,10608,1,0,0,0,10608,10614,1,0,0,0,10609,10611,
+        5,629,0,0,10610,10612,7,28,0,0,10611,10610,1,0,0,0,10611,10612,1,
+        0,0,0,10612,10613,1,0,0,0,10613,10615,3,2430,1215,0,10614,10609,
+        1,0,0,0,10614,10615,1,0,0,0,10615,10619,1,0,0,0,10616,10617,5,621,
+        0,0,10617,10618,5,183,0,0,10618,10620,3,2430,1215,0,10619,10616,
+        1,0,0,0,10619,10620,1,0,0,0,10620,10623,1,0,0,0,10621,10622,5,1261,
+        0,0,10622,10624,3,1794,897,0,10623,10621,1,0,0,0,10623,10624,1,0,
+        0,0,10624,1045,1,0,0,0,10625,10627,5,321,0,0,10626,10628,5,210,0,
+        0,10627,10626,1,0,0,0,10627,10628,1,0,0,0,10628,10629,1,0,0,0,10629,
+        10630,5,1576,0,0,10630,10631,5,1413,0,0,10631,10636,3,2430,1215,
+        0,10632,10633,5,621,0,0,10633,10634,5,1411,0,0,10634,10635,5,350,
+        0,0,10635,10637,3,2430,1215,0,10636,10632,1,0,0,0,10636,10637,1,
+        0,0,0,10637,10642,1,0,0,0,10638,10639,5,69,0,0,10639,10640,5,1248,
+        0,0,10640,10641,7,83,0,0,10641,10643,3,2100,1050,0,10642,10638,1,
+        0,0,0,10642,10643,1,0,0,0,10643,10648,1,0,0,0,10644,10649,5,1449,
+        0,0,10645,10646,5,656,0,0,10646,10647,5,606,0,0,10647,10649,5,350,
+        0,0,10648,10644,1,0,0,0,10648,10645,1,0,0,0,10648,10649,1,0,0,0,
+        10649,1047,1,0,0,0,10650,10651,5,321,0,0,10651,10652,5,1595,0,0,
+        10652,10654,3,2334,1167,0,10653,10655,3,1536,768,0,10654,10653,1,
+        0,0,0,10654,10655,1,0,0,0,10655,10657,1,0,0,0,10656,10658,3,778,
+        389,0,10657,10656,1,0,0,0,10657,10658,1,0,0,0,10658,1049,1,0,0,0,
+        10659,10669,5,321,0,0,10660,10661,7,120,0,0,10661,10670,5,2094,0,
+        0,10662,10670,5,2387,0,0,10663,10670,5,2377,0,0,10664,10666,5,2381,
+        0,0,10665,10664,1,0,0,0,10665,10666,1,0,0,0,10666,10667,1,0,0,0,
+        10667,10670,5,2373,0,0,10668,10670,5,2381,0,0,10669,10660,1,0,0,
+        0,10669,10662,1,0,0,0,10669,10663,1,0,0,0,10669,10665,1,0,0,0,10669,
+        10668,1,0,0,0,10669,10670,1,0,0,0,10670,10671,1,0,0,0,10671,10675,
+        5,2085,0,0,10672,10673,3,2312,1156,0,10673,10674,5,2442,0,0,10674,
+        10676,1,0,0,0,10675,10672,1,0,0,0,10675,10676,1,0,0,0,10676,10677,
+        1,0,0,0,10677,10681,3,1122,561,0,10678,10679,5,692,0,0,10679,10680,
+        5,1206,0,0,10680,10682,5,546,0,0,10681,10678,1,0,0,0,10681,10682,
+        1,0,0,0,10682,10693,1,0,0,0,10683,10684,5,1683,0,0,10684,10691,5,
+        2474,0,0,10685,10692,5,949,0,0,10686,10688,5,2378,0,0,10687,10686,
+        1,0,0,0,10687,10688,1,0,0,0,10688,10689,1,0,0,0,10689,10692,5,351,
+        0,0,10690,10692,5,1134,0,0,10691,10685,1,0,0,0,10691,10687,1,0,0,
+        0,10691,10690,1,0,0,0,10692,10694,1,0,0,0,10693,10683,1,0,0,0,10693,
+        10694,1,0,0,0,10694,10698,1,0,0,0,10695,10699,3,1074,537,0,10696,
+        10699,3,1052,526,0,10697,10699,3,1062,531,0,10698,10695,1,0,0,0,
+        10698,10696,1,0,0,0,10698,10697,1,0,0,0,10699,10701,1,0,0,0,10700,
+        10702,3,1546,773,0,10701,10700,1,0,0,0,10701,10702,1,0,0,0,10702,
+        10705,1,0,0,0,10703,10704,5,1339,0,0,10704,10706,3,2368,1184,0,10705,
+        10703,1,0,0,0,10705,10706,1,0,0,0,10706,10709,1,0,0,0,10707,10708,
+        5,2218,0,0,10708,10710,5,1488,0,0,10709,10707,1,0,0,0,10709,10710,
+        1,0,0,0,10710,1051,1,0,0,0,10711,10712,5,1248,0,0,10712,10717,5,
+        2353,0,0,10713,10714,5,2449,0,0,10714,10715,3,1070,535,0,10715,10716,
+        5,2450,0,0,10716,10718,1,0,0,0,10717,10713,1,0,0,0,10717,10718,1,
+        0,0,0,10718,10721,1,0,0,0,10719,10720,5,2353,0,0,10720,10722,3,1058,
+        529,0,10721,10719,1,0,0,0,10721,10722,1,0,0,0,10722,10724,1,0,0,
+        0,10723,10725,3,1060,530,0,10724,10723,1,0,0,0,10724,10725,1,0,0,
+        0,10725,10727,1,0,0,0,10726,10728,3,1054,527,0,10727,10726,1,0,0,
+        0,10727,10728,1,0,0,0,10728,10733,1,0,0,0,10729,10730,5,1261,0,0,
+        10730,10731,5,242,0,0,10731,10732,7,121,0,0,10732,10734,5,1609,0,
+        0,10733,10729,1,0,0,0,10733,10734,1,0,0,0,10734,10736,1,0,0,0,10735,
+        10737,3,1068,534,0,10736,10735,1,0,0,0,10736,10737,1,0,0,0,10737,
+        10739,1,0,0,0,10738,10740,3,1066,533,0,10739,10738,1,0,0,0,10739,
+        10740,1,0,0,0,10740,10742,1,0,0,0,10741,10743,3,1214,607,0,10742,
+        10741,1,0,0,0,10742,10743,1,0,0,0,10743,10745,1,0,0,0,10744,10746,
+        3,1096,548,0,10745,10744,1,0,0,0,10745,10746,1,0,0,0,10746,1053,
+        1,0,0,0,10747,10748,5,2290,0,0,10748,10749,5,238,0,0,10749,10750,
+        5,2449,0,0,10750,10751,3,2366,1183,0,10751,10752,5,69,0,0,10752,
+        10753,5,2449,0,0,10753,10754,3,2100,1050,0,10754,10764,5,2450,0,
+        0,10755,10756,5,2455,0,0,10756,10757,3,2366,1183,0,10757,10758,5,
+        69,0,0,10758,10759,5,2449,0,0,10759,10760,3,2100,1050,0,10760,10761,
+        5,2450,0,0,10761,10763,1,0,0,0,10762,10755,1,0,0,0,10763,10766,1,
+        0,0,0,10764,10762,1,0,0,0,10764,10765,1,0,0,0,10765,10767,1,0,0,
+        0,10766,10764,1,0,0,0,10767,10768,5,2450,0,0,10768,1055,1,0,0,0,
+        10769,10771,5,2353,0,0,10770,10772,5,237,0,0,10771,10770,1,0,0,0,
+        10771,10772,1,0,0,0,10772,10773,1,0,0,0,10773,10775,3,2366,1183,
+        0,10774,10776,3,1058,529,0,10775,10774,1,0,0,0,10775,10776,1,0,0,
+        0,10776,10778,1,0,0,0,10777,10779,3,1060,530,0,10778,10777,1,0,0,
+        0,10778,10779,1,0,0,0,10779,1057,1,0,0,0,10780,10781,5,1765,0,0,
+        10781,10805,5,69,0,0,10782,10783,5,1240,0,0,10783,10806,5,1553,0,
+        0,10784,10786,7,122,0,0,10785,10784,1,0,0,0,10785,10786,1,0,0,0,
+        10786,10790,1,0,0,0,10787,10791,5,215,0,0,10788,10789,5,124,0,0,
+        10789,10791,5,2354,0,0,10790,10787,1,0,0,0,10790,10788,1,0,0,0,10791,
+        10803,1,0,0,0,10792,10797,3,1654,827,0,10793,10794,5,2449,0,0,10794,
+        10795,3,1666,833,0,10795,10796,5,2450,0,0,10796,10798,1,0,0,0,10797,
+        10793,1,0,0,0,10797,10798,1,0,0,0,10798,10804,1,0,0,0,10799,10800,
+        5,2449,0,0,10800,10801,3,1666,833,0,10801,10802,5,2450,0,0,10802,
+        10804,1,0,0,0,10803,10792,1,0,0,0,10803,10799,1,0,0,0,10803,10804,
+        1,0,0,0,10804,10806,1,0,0,0,10805,10782,1,0,0,0,10805,10785,1,0,
+        0,0,10806,10812,1,0,0,0,10807,10808,5,1765,0,0,10808,10809,5,2268,
+        0,0,10809,10810,5,69,0,0,10810,10812,7,97,0,0,10811,10780,1,0,0,
+        0,10811,10807,1,0,0,0,10812,1059,1,0,0,0,10813,10814,5,2347,0,0,
+        10814,10816,5,2446,0,0,10815,10813,1,0,0,0,10815,10816,1,0,0,0,10816,
+        10817,1,0,0,0,10817,10818,5,486,0,0,10818,10820,3,2430,1215,0,10819,
+        10815,1,0,0,0,10819,10820,1,0,0,0,10820,10826,1,0,0,0,10821,10822,
+        3,1322,661,0,10822,10823,7,123,0,0,10823,10825,1,0,0,0,10824,10821,
+        1,0,0,0,10825,10828,1,0,0,0,10826,10824,1,0,0,0,10826,10827,1,0,
+        0,0,10827,1061,1,0,0,0,10828,10826,1,0,0,0,10829,10833,5,1248,0,
+        0,10830,10831,3,2312,1156,0,10831,10832,5,2442,0,0,10832,10834,1,
+        0,0,0,10833,10830,1,0,0,0,10833,10834,1,0,0,0,10834,10835,1,0,0,
+        0,10835,10837,3,1064,532,0,10836,10838,3,1072,536,0,10837,10836,
+        1,0,0,0,10837,10838,1,0,0,0,10838,10850,1,0,0,0,10839,10840,5,2449,
+        0,0,10840,10845,3,1070,535,0,10841,10842,5,2455,0,0,10842,10844,
+        3,1070,535,0,10843,10841,1,0,0,0,10844,10847,1,0,0,0,10845,10843,
+        1,0,0,0,10845,10846,1,0,0,0,10846,10848,1,0,0,0,10847,10845,1,0,
+        0,0,10848,10849,5,2450,0,0,10849,10851,1,0,0,0,10850,10839,1,0,0,
+        0,10850,10851,1,0,0,0,10851,10856,1,0,0,0,10852,10853,5,1261,0,0,
+        10853,10854,5,242,0,0,10854,10855,7,121,0,0,10855,10857,5,1609,0,
+        0,10856,10852,1,0,0,0,10856,10857,1,0,0,0,10857,10859,1,0,0,0,10858,
+        10860,3,1068,534,0,10859,10858,1,0,0,0,10859,10860,1,0,0,0,10860,
+        10862,1,0,0,0,10861,10863,3,1066,533,0,10862,10861,1,0,0,0,10862,
+        10863,1,0,0,0,10863,10865,1,0,0,0,10864,10866,3,1214,607,0,10865,
+        10864,1,0,0,0,10865,10866,1,0,0,0,10866,10868,1,0,0,0,10867,10869,
+        3,1096,548,0,10868,10867,1,0,0,0,10868,10869,1,0,0,0,10869,1063,
+        1,0,0,0,10870,10871,3,2436,1218,0,10871,1065,1,0,0,0,10872,10874,
+        5,1249,0,0,10873,10875,3,2354,1177,0,10874,10873,1,0,0,0,10874,10875,
+        1,0,0,0,10875,10876,1,0,0,0,10876,10880,5,2449,0,0,10877,10881,3,
+        1206,603,0,10878,10879,5,2082,0,0,10879,10881,3,1676,838,0,10880,
+        10877,1,0,0,0,10880,10878,1,0,0,0,10881,10882,1,0,0,0,10882,10880,
+        1,0,0,0,10882,10883,1,0,0,0,10883,10884,1,0,0,0,10884,10885,5,2450,
+        0,0,10885,1067,1,0,0,0,10886,10887,5,1240,0,0,10887,10888,5,687,
+        0,0,10888,10893,5,786,0,0,10889,10890,5,1951,0,0,10890,10894,5,641,
+        0,0,10891,10892,5,1453,0,0,10892,10894,5,817,0,0,10893,10889,1,0,
+        0,0,10893,10891,1,0,0,0,10894,1069,1,0,0,0,10895,10898,3,2366,1183,
+        0,10896,10898,3,2306,1153,0,10897,10895,1,0,0,0,10897,10896,1,0,
+        0,0,10898,10901,1,0,0,0,10899,10900,5,389,0,0,10900,10902,3,2100,
+        1050,0,10901,10899,1,0,0,0,10901,10902,1,0,0,0,10902,10912,1,0,0,
+        0,10903,10908,3,858,429,0,10904,10905,5,2455,0,0,10905,10907,3,858,
+        429,0,10906,10904,1,0,0,0,10907,10910,1,0,0,0,10908,10906,1,0,0,
+        0,10908,10909,1,0,0,0,10909,10913,1,0,0,0,10910,10908,1,0,0,0,10911,
+        10913,3,860,430,0,10912,10903,1,0,0,0,10912,10911,1,0,0,0,10912,
+        10913,1,0,0,0,10913,10918,1,0,0,0,10914,10918,3,864,432,0,10915,
+        10918,3,862,431,0,10916,10918,3,1718,859,0,10917,10897,1,0,0,0,10917,
+        10914,1,0,0,0,10917,10915,1,0,0,0,10917,10916,1,0,0,0,10918,1071,
+        1,0,0,0,10919,10921,5,1206,0,0,10920,10919,1,0,0,0,10920,10921,1,
+        0,0,0,10921,10922,1,0,0,0,10922,10923,5,1782,0,0,10923,10924,5,82,
+        0,0,10924,10925,5,38,0,0,10925,10926,5,849,0,0,10926,1073,1,0,0,
+        0,10927,10928,5,2449,0,0,10928,10933,3,1124,562,0,10929,10930,5,
+        2455,0,0,10930,10932,3,1124,562,0,10931,10929,1,0,0,0,10932,10935,
+        1,0,0,0,10933,10931,1,0,0,0,10933,10934,1,0,0,0,10934,10936,1,0,
+        0,0,10935,10933,1,0,0,0,10936,10937,5,2450,0,0,10937,10939,1,0,0,
+        0,10938,10927,1,0,0,0,10938,10939,1,0,0,0,10939,10941,1,0,0,0,10940,
+        10942,3,1076,538,0,10941,10940,1,0,0,0,10941,10942,1,0,0,0,10942,
+        1075,1,0,0,0,10943,10945,3,1078,539,0,10944,10943,1,0,0,0,10945,
+        10946,1,0,0,0,10946,10944,1,0,0,0,10946,10947,1,0,0,0,10947,1077,
+        1,0,0,0,10948,10964,3,1080,540,0,10949,10964,3,1086,543,0,10950,
+        10951,5,389,0,0,10951,10952,5,2375,0,0,10952,10964,3,1094,547,0,
+        10953,10954,5,1261,0,0,10954,10959,5,242,0,0,10955,10956,7,124,0,
+        0,10956,10960,5,2376,0,0,10957,10958,7,121,0,0,10958,10960,5,1609,
+        0,0,10959,10955,1,0,0,0,10959,10957,1,0,0,0,10960,10964,1,0,0,0,
+        10961,10964,3,1214,607,0,10962,10964,3,1096,548,0,10963,10948,1,
+        0,0,0,10963,10949,1,0,0,0,10963,10950,1,0,0,0,10963,10953,1,0,0,
+        0,10963,10961,1,0,0,0,10963,10962,1,0,0,0,10964,1079,1,0,0,0,10965,
+        10968,3,1082,541,0,10966,10968,3,1084,542,0,10967,10965,1,0,0,0,
+        10967,10966,1,0,0,0,10968,1081,1,0,0,0,10969,10970,5,1139,0,0,10970,
+        10976,5,469,0,0,10971,10972,5,2204,0,0,10972,10973,3,2422,1211,0,
+        10973,10974,5,366,0,0,10974,10975,5,2380,0,0,10975,10977,1,0,0,0,
+        10976,10971,1,0,0,0,10976,10977,1,0,0,0,10977,1083,1,0,0,0,10978,
+        10979,5,1139,0,0,10979,10991,5,403,0,0,10980,10982,5,880,0,0,10981,
+        10980,1,0,0,0,10981,10982,1,0,0,0,10982,10992,1,0,0,0,10983,10984,
+        5,2204,0,0,10984,10985,3,2422,1211,0,10985,10986,5,366,0,0,10986,
+        10987,5,33,0,0,10987,10989,5,757,0,0,10988,10990,5,880,0,0,10989,
+        10988,1,0,0,0,10989,10990,1,0,0,0,10990,10992,1,0,0,0,10991,10981,
+        1,0,0,0,10991,10983,1,0,0,0,10992,1085,1,0,0,0,10993,10994,3,1088,
+        544,0,10994,10995,3,1090,545,0,10995,10996,3,1092,546,0,10996,1087,
+        1,0,0,0,10997,10998,5,1139,0,0,10998,11004,5,469,0,0,10999,11000,
+        5,2204,0,0,11000,11001,3,2422,1211,0,11001,11002,5,366,0,0,11002,
+        11003,5,2380,0,0,11003,11005,1,0,0,0,11004,10999,1,0,0,0,11004,11005,
+        1,0,0,0,11005,1089,1,0,0,0,11006,11007,5,1139,0,0,11007,11019,5,
+        403,0,0,11008,11010,5,880,0,0,11009,11008,1,0,0,0,11009,11010,1,
+        0,0,0,11010,11020,1,0,0,0,11011,11012,5,2204,0,0,11012,11013,3,2422,
+        1211,0,11013,11014,5,366,0,0,11014,11015,5,33,0,0,11015,11017,5,
+        757,0,0,11016,11018,5,880,0,0,11017,11016,1,0,0,0,11017,11018,1,
+        0,0,0,11018,11020,1,0,0,0,11019,11009,1,0,0,0,11019,11011,1,0,0,
+        0,11020,1091,1,0,0,0,11021,11022,5,2379,0,0,11022,11023,5,2248,0,
+        0,11023,11024,5,2386,0,0,11024,11025,5,2287,0,0,11025,11026,5,2388,
+        0,0,11026,1093,1,0,0,0,11027,11028,3,2428,1214,0,11028,1095,1,0,
+        0,0,11029,11060,3,1680,840,0,11030,11060,3,1098,549,0,11031,11060,
+        3,1100,550,0,11032,11060,3,1126,563,0,11033,11060,3,1102,551,0,11034,
+        11060,7,109,0,0,11035,11060,3,118,59,0,11036,11060,3,940,470,0,11037,
+        11060,3,534,267,0,11038,11060,7,116,0,0,11039,11060,3,1602,801,0,
+        11040,11060,3,1284,642,0,11041,11060,3,1120,560,0,11042,11060,3,
+        1286,643,0,11043,11060,3,1214,607,0,11044,11045,5,1608,0,0,11045,
+        11060,5,63,0,0,11046,11047,5,69,0,0,11047,11060,3,1888,944,0,11048,
+        11049,5,621,0,0,11049,11050,5,538,0,0,11050,11051,5,2310,0,0,11051,
+        11055,5,2085,0,0,11052,11053,3,2312,1156,0,11053,11054,5,2442,0,
+        0,11054,11056,1,0,0,0,11055,11052,1,0,0,0,11055,11056,1,0,0,0,11056,
+        11057,1,0,0,0,11057,11060,3,1122,561,0,11058,11060,3,2270,1135,0,
+        11059,11029,1,0,0,0,11059,11030,1,0,0,0,11059,11031,1,0,0,0,11059,
+        11032,1,0,0,0,11059,11033,1,0,0,0,11059,11034,1,0,0,0,11059,11035,
+        1,0,0,0,11059,11036,1,0,0,0,11059,11037,1,0,0,0,11059,11038,1,0,
+        0,0,11059,11039,1,0,0,0,11059,11040,1,0,0,0,11059,11041,1,0,0,0,
+        11059,11042,1,0,0,0,11059,11043,1,0,0,0,11059,11044,1,0,0,0,11059,
+        11046,1,0,0,0,11059,11048,1,0,0,0,11059,11058,1,0,0,0,11060,1097,
+        1,0,0,0,11061,11062,5,1507,0,0,11062,11063,7,11,0,0,11063,1099,1,
+        0,0,0,11064,11065,5,719,0,0,11065,11066,7,100,0,0,11066,1101,1,0,
+        0,0,11067,11069,5,224,0,0,11068,11070,3,1104,552,0,11069,11068,1,
+        0,0,0,11069,11070,1,0,0,0,11070,11071,1,0,0,0,11071,11077,3,1110,
+        555,0,11072,11074,3,1116,558,0,11073,11072,1,0,0,0,11073,11074,1,
+        0,0,0,11074,11075,1,0,0,0,11075,11076,5,1261,0,0,11076,11078,5,868,
+        0,0,11077,11073,1,0,0,0,11077,11078,1,0,0,0,11078,11085,1,0,0,0,
+        11079,11081,3,1116,558,0,11080,11079,1,0,0,0,11080,11081,1,0,0,0,
+        11081,11082,1,0,0,0,11082,11083,5,1261,0,0,11083,11084,5,351,0,0,
+        11084,11086,5,992,0,0,11085,11080,1,0,0,0,11085,11086,1,0,0,0,11086,
+        11088,1,0,0,0,11087,11089,3,1118,559,0,11088,11087,1,0,0,0,11088,
+        11089,1,0,0,0,11089,1103,1,0,0,0,11090,11091,3,2312,1156,0,11091,
+        11092,5,2442,0,0,11092,11094,1,0,0,0,11093,11090,1,0,0,0,11093,11094,
+        1,0,0,0,11094,11095,1,0,0,0,11095,11096,3,1122,561,0,11096,11101,
+        3,1106,553,0,11097,11098,5,2455,0,0,11098,11100,3,1106,553,0,11099,
+        11097,1,0,0,0,11100,11103,1,0,0,0,11101,11099,1,0,0,0,11101,11102,
+        1,0,0,0,11102,1105,1,0,0,0,11103,11101,1,0,0,0,11104,11108,5,795,
+        0,0,11105,11106,3,2312,1156,0,11106,11107,5,2442,0,0,11107,11109,
+        1,0,0,0,11108,11105,1,0,0,0,11108,11109,1,0,0,0,11109,11110,1,0,
+        0,0,11110,11111,3,1122,561,0,11111,11112,5,1261,0,0,11112,11113,
+        5,2449,0,0,11113,11114,3,1108,554,0,11114,11115,5,2450,0,0,11115,
+        1107,1,0,0,0,11116,11117,3,2100,1050,0,11117,1109,1,0,0,0,11118,
+        11120,5,160,0,0,11119,11121,7,125,0,0,11120,11119,1,0,0,0,11120,
+        11121,1,0,0,0,11121,11122,1,0,0,0,11122,11123,5,1305,0,0,11123,11124,
+        3,1112,556,0,11124,1111,1,0,0,0,11125,11138,3,1114,557,0,11126,11127,
+        5,2449,0,0,11127,11132,3,1114,557,0,11128,11129,5,2455,0,0,11129,
+        11131,3,1114,557,0,11130,11128,1,0,0,0,11131,11134,1,0,0,0,11132,
+        11130,1,0,0,0,11132,11133,1,0,0,0,11133,11135,1,0,0,0,11134,11132,
+        1,0,0,0,11135,11136,5,2450,0,0,11136,11138,1,0,0,0,11137,11125,1,
+        0,0,0,11137,11126,1,0,0,0,11138,1113,1,0,0,0,11139,11140,5,2449,
+        0,0,11140,11145,3,2366,1183,0,11141,11142,5,2455,0,0,11142,11144,
+        3,2366,1183,0,11143,11141,1,0,0,0,11144,11147,1,0,0,0,11145,11143,
+        1,0,0,0,11145,11146,1,0,0,0,11146,11148,1,0,0,0,11147,11145,1,0,
+        0,0,11148,11149,5,2450,0,0,11149,1115,1,0,0,0,11150,11151,7,126,
+        0,0,11151,1117,1,0,0,0,11152,11153,5,2310,0,0,11153,11154,5,920,
+        0,0,11154,11159,5,2364,0,0,11155,11156,5,2449,0,0,11156,11157,3,
+        978,489,0,11157,11158,5,2450,0,0,11158,11160,1,0,0,0,11159,11155,
+        1,0,0,0,11159,11160,1,0,0,0,11160,11165,1,0,0,0,11161,11162,5,2308,
+        0,0,11162,11163,5,920,0,0,11163,11165,5,2364,0,0,11164,11152,1,0,
+        0,0,11164,11161,1,0,0,0,11165,1119,1,0,0,0,11166,11167,5,429,0,0,
+        11167,11168,5,886,0,0,11168,11186,5,1565,0,0,11169,11170,5,499,0,
+        0,11170,11171,5,886,0,0,11171,11183,5,1565,0,0,11172,11176,5,38,
+        0,0,11173,11174,5,40,0,0,11174,11176,5,1217,0,0,11175,11172,1,0,
+        0,0,11175,11173,1,0,0,0,11176,11177,1,0,0,0,11177,11184,5,820,0,
+        0,11178,11180,5,1139,0,0,11179,11178,1,0,0,0,11179,11180,1,0,0,0,
+        11180,11181,1,0,0,0,11181,11182,5,1346,0,0,11182,11184,5,802,0,0,
+        11183,11175,1,0,0,0,11183,11179,1,0,0,0,11183,11184,1,0,0,0,11184,
+        11186,1,0,0,0,11185,11166,1,0,0,0,11185,11169,1,0,0,0,11186,1121,
+        1,0,0,0,11187,11188,3,2428,1214,0,11188,1123,1,0,0,0,11189,11196,
+        3,864,432,0,11190,11196,3,862,431,0,11191,11196,3,1690,845,0,11192,
+        11196,3,1700,850,0,11193,11196,3,1684,842,0,11194,11196,3,1718,859,
+        0,11195,11189,1,0,0,0,11195,11190,1,0,0,0,11195,11191,1,0,0,0,11195,
+        11192,1,0,0,0,11195,11193,1,0,0,0,11195,11194,1,0,0,0,11196,1125,
+        1,0,0,0,11197,11206,3,1128,564,0,11198,11206,3,1130,565,0,11199,
+        11206,3,1132,566,0,11200,11206,3,1140,570,0,11201,11206,3,1142,571,
+        0,11202,11206,3,1144,572,0,11203,11206,3,1146,573,0,11204,11206,
+        3,1150,575,0,11205,11197,1,0,0,0,11205,11198,1,0,0,0,11205,11199,
+        1,0,0,0,11205,11200,1,0,0,0,11205,11201,1,0,0,0,11205,11202,1,0,
+        0,0,11205,11203,1,0,0,0,11205,11204,1,0,0,0,11206,1127,1,0,0,0,11207,
+        11208,5,1350,0,0,11208,11209,5,160,0,0,11209,11210,5,1497,0,0,11210,
+        11211,5,2449,0,0,11211,11216,3,2366,1183,0,11212,11213,5,2455,0,
+        0,11213,11215,3,2366,1183,0,11214,11212,1,0,0,0,11215,11218,1,0,
+        0,0,11216,11214,1,0,0,0,11216,11217,1,0,0,0,11217,11219,1,0,0,0,
+        11218,11216,1,0,0,0,11219,11239,5,2450,0,0,11220,11221,5,777,0,0,
+        11221,11222,5,2449,0,0,11222,11223,3,2100,1050,0,11223,11237,5,2450,
+        0,0,11224,11225,5,1765,0,0,11225,11226,5,739,0,0,11226,11227,5,2449,
+        0,0,11227,11232,3,1676,838,0,11228,11229,5,2455,0,0,11229,11231,
+        3,1676,838,0,11230,11228,1,0,0,0,11231,11234,1,0,0,0,11232,11230,
+        1,0,0,0,11232,11233,1,0,0,0,11233,11235,1,0,0,0,11234,11232,1,0,
+        0,0,11235,11236,5,2450,0,0,11236,11238,1,0,0,0,11237,11224,1,0,0,
+        0,11237,11238,1,0,0,0,11238,11240,1,0,0,0,11239,11220,1,0,0,0,11239,
+        11240,1,0,0,0,11240,11241,1,0,0,0,11241,11242,5,2449,0,0,11242,11244,
+        5,1350,0,0,11243,11245,3,1716,858,0,11244,11243,1,0,0,0,11244,11245,
+        1,0,0,0,11245,11246,1,0,0,0,11246,11247,3,1176,588,0,11247,11258,
+        3,1182,591,0,11248,11249,5,2455,0,0,11249,11251,5,1350,0,0,11250,
+        11252,3,1716,858,0,11251,11250,1,0,0,0,11251,11252,1,0,0,0,11252,
+        11253,1,0,0,0,11253,11254,3,1176,588,0,11254,11255,3,1182,591,0,
+        11255,11257,1,0,0,0,11256,11248,1,0,0,0,11257,11260,1,0,0,0,11258,
+        11256,1,0,0,0,11258,11259,1,0,0,0,11259,11261,1,0,0,0,11260,11258,
+        1,0,0,0,11261,11262,5,2450,0,0,11262,1129,1,0,0,0,11263,11264,5,
+        1350,0,0,11264,11265,5,160,0,0,11265,11266,5,863,0,0,11266,11267,
+        5,2449,0,0,11267,11268,3,2366,1183,0,11268,11285,5,2450,0,0,11269,
+        11283,5,95,0,0,11270,11271,5,1765,0,0,11271,11272,5,739,0,0,11272,
+        11273,5,2449,0,0,11273,11278,3,1676,838,0,11274,11275,5,2455,0,0,
+        11275,11277,3,1676,838,0,11276,11274,1,0,0,0,11277,11280,1,0,0,0,
+        11278,11276,1,0,0,0,11278,11279,1,0,0,0,11279,11281,1,0,0,0,11280,
+        11278,1,0,0,0,11281,11282,5,2450,0,0,11282,11284,1,0,0,0,11283,11270,
+        1,0,0,0,11283,11284,1,0,0,0,11284,11286,1,0,0,0,11285,11269,1,0,
+        0,0,11285,11286,1,0,0,0,11286,11309,1,0,0,0,11287,11288,5,2449,0,
+        0,11288,11290,5,1350,0,0,11289,11291,3,1716,858,0,11290,11289,1,
+        0,0,0,11290,11291,1,0,0,0,11291,11292,1,0,0,0,11292,11293,3,1180,
+        590,0,11293,11304,3,1182,591,0,11294,11295,5,2455,0,0,11295,11297,
+        5,1350,0,0,11296,11298,3,1716,858,0,11297,11296,1,0,0,0,11297,11298,
+        1,0,0,0,11298,11299,1,0,0,0,11299,11300,3,1180,590,0,11300,11301,
+        3,1182,591,0,11301,11303,1,0,0,0,11302,11294,1,0,0,0,11303,11306,
+        1,0,0,0,11304,11302,1,0,0,0,11304,11305,1,0,0,0,11305,11307,1,0,
+        0,0,11306,11304,1,0,0,0,11307,11308,5,2450,0,0,11308,11310,1,0,0,
+        0,11309,11287,1,0,0,0,11309,11310,1,0,0,0,11310,1131,1,0,0,0,11311,
+        11312,5,1350,0,0,11312,11313,5,160,0,0,11313,11314,5,661,0,0,11314,
+        11315,5,2449,0,0,11315,11320,3,2366,1183,0,11316,11317,5,2455,0,
+        0,11317,11319,3,2366,1183,0,11318,11316,1,0,0,0,11319,11322,1,0,
+        0,0,11320,11318,1,0,0,0,11320,11321,1,0,0,0,11321,11323,1,0,0,0,
+        11322,11320,1,0,0,0,11323,11326,5,2450,0,0,11324,11327,3,1134,567,
+        0,11325,11327,3,1136,568,0,11326,11324,1,0,0,0,11326,11325,1,0,0,
+        0,11327,1133,1,0,0,0,11328,11329,5,2449,0,0,11329,11331,5,1350,0,
+        0,11330,11332,3,1716,858,0,11331,11330,1,0,0,0,11331,11332,1,0,0,
+        0,11332,11334,1,0,0,0,11333,11335,3,1184,592,0,11334,11333,1,0,0,
+        0,11334,11335,1,0,0,0,11335,11346,1,0,0,0,11336,11337,5,2455,0,0,
+        11337,11339,5,1350,0,0,11338,11340,3,1716,858,0,11339,11338,1,0,
+        0,0,11339,11340,1,0,0,0,11340,11342,1,0,0,0,11341,11343,3,1184,592,
+        0,11342,11341,1,0,0,0,11342,11343,1,0,0,0,11343,11345,1,0,0,0,11344,
+        11336,1,0,0,0,11345,11348,1,0,0,0,11346,11344,1,0,0,0,11346,11347,
+        1,0,0,0,11347,11349,1,0,0,0,11348,11346,1,0,0,0,11349,11350,5,2450,
+        0,0,11350,1135,1,0,0,0,11351,11352,5,1352,0,0,11352,11366,3,1138,
+        569,0,11353,11354,5,1765,0,0,11354,11355,5,739,0,0,11355,11356,5,
+        2449,0,0,11356,11361,3,1676,838,0,11357,11358,5,2455,0,0,11358,11360,
+        3,1676,838,0,11359,11357,1,0,0,0,11360,11363,1,0,0,0,11361,11359,
+        1,0,0,0,11361,11362,1,0,0,0,11362,11364,1,0,0,0,11363,11361,1,0,
+        0,0,11364,11365,5,2450,0,0,11365,11367,1,0,0,0,11366,11353,1,0,0,
+        0,11366,11367,1,0,0,0,11367,11370,1,0,0,0,11368,11371,3,1190,595,
+        0,11369,11371,3,1620,810,0,11370,11368,1,0,0,0,11370,11369,1,0,0,
+        0,11370,11371,1,0,0,0,11371,11386,1,0,0,0,11372,11373,5,1322,0,0,
+        11373,11374,5,1765,0,0,11374,11375,5,739,0,0,11375,11376,5,2449,
+        0,0,11376,11381,3,1676,838,0,11377,11378,5,2455,0,0,11378,11380,
+        3,1676,838,0,11379,11377,1,0,0,0,11380,11383,1,0,0,0,11381,11379,
+        1,0,0,0,11381,11382,1,0,0,0,11382,11384,1,0,0,0,11383,11381,1,0,
+        0,0,11384,11385,5,2450,0,0,11385,11387,1,0,0,0,11386,11372,1,0,0,
+        0,11386,11387,1,0,0,0,11387,1137,1,0,0,0,11388,11389,5,2443,0,0,
+        11389,1139,1,0,0,0,11390,11391,5,1350,0,0,11391,11392,5,160,0,0,
+        11392,11393,5,1497,0,0,11393,11394,5,2449,0,0,11394,11399,3,2366,
+        1183,0,11395,11396,5,2455,0,0,11396,11398,3,2366,1183,0,11397,11395,
+        1,0,0,0,11398,11401,1,0,0,0,11399,11397,1,0,0,0,11399,11400,1,0,
+        0,0,11400,11402,1,0,0,0,11401,11399,1,0,0,0,11402,11422,5,2450,0,
+        0,11403,11404,5,777,0,0,11404,11405,5,2449,0,0,11405,11406,3,2100,
+        1050,0,11406,11420,5,2450,0,0,11407,11408,5,1765,0,0,11408,11409,
+        5,739,0,0,11409,11410,5,2449,0,0,11410,11415,3,1676,838,0,11411,
+        11412,5,2455,0,0,11412,11414,3,1676,838,0,11413,11411,1,0,0,0,11414,
+        11417,1,0,0,0,11415,11413,1,0,0,0,11415,11416,1,0,0,0,11416,11418,
+        1,0,0,0,11417,11415,1,0,0,0,11418,11419,5,2450,0,0,11419,11421,1,
+        0,0,0,11420,11407,1,0,0,0,11420,11421,1,0,0,0,11421,11423,1,0,0,
+        0,11422,11403,1,0,0,0,11422,11423,1,0,0,0,11423,11427,1,0,0,0,11424,
+        11428,3,1160,580,0,11425,11428,3,1162,581,0,11426,11428,3,1164,582,
+        0,11427,11424,1,0,0,0,11427,11425,1,0,0,0,11427,11426,1,0,0,0,11428,
+        11429,1,0,0,0,11429,11430,5,2449,0,0,11430,11435,3,1152,576,0,11431,
+        11432,5,2455,0,0,11432,11434,3,1152,576,0,11433,11431,1,0,0,0,11434,
+        11437,1,0,0,0,11435,11433,1,0,0,0,11435,11436,1,0,0,0,11436,11438,
+        1,0,0,0,11437,11435,1,0,0,0,11438,11439,5,2450,0,0,11439,1141,1,
+        0,0,0,11440,11441,5,1350,0,0,11441,11442,5,160,0,0,11442,11443,5,
+        863,0,0,11443,11444,5,2449,0,0,11444,11445,3,2366,1183,0,11445,11449,
+        5,2450,0,0,11446,11450,3,1160,580,0,11447,11450,3,1162,581,0,11448,
+        11450,3,1164,582,0,11449,11446,1,0,0,0,11449,11447,1,0,0,0,11449,
+        11448,1,0,0,0,11450,11451,1,0,0,0,11451,11452,5,2449,0,0,11452,11457,
+        3,1154,577,0,11453,11454,5,2455,0,0,11454,11456,3,1154,577,0,11455,
+        11453,1,0,0,0,11456,11459,1,0,0,0,11457,11455,1,0,0,0,11457,11458,
+        1,0,0,0,11458,11460,1,0,0,0,11459,11457,1,0,0,0,11460,11461,5,2450,
+        0,0,11461,1143,1,0,0,0,11462,11463,5,1350,0,0,11463,11464,5,160,
+        0,0,11464,11465,5,661,0,0,11465,11468,5,2449,0,0,11466,11467,5,2455,
+        0,0,11467,11469,3,2366,1183,0,11468,11466,1,0,0,0,11469,11470,1,
+        0,0,0,11470,11468,1,0,0,0,11470,11471,1,0,0,0,11471,11472,1,0,0,
+        0,11472,11476,5,2450,0,0,11473,11477,3,1160,580,0,11474,11477,3,
+        1162,581,0,11475,11477,3,1164,582,0,11476,11473,1,0,0,0,11476,11474,
+        1,0,0,0,11476,11475,1,0,0,0,11477,11480,1,0,0,0,11478,11481,3,1134,
+        567,0,11479,11481,3,1136,568,0,11480,11478,1,0,0,0,11480,11479,1,
+        0,0,0,11481,1145,1,0,0,0,11482,11483,5,1350,0,0,11483,11484,5,160,
+        0,0,11484,11485,5,1529,0,0,11485,11486,5,2449,0,0,11486,11487,3,
+        2336,1168,0,11487,11499,5,2450,0,0,11488,11489,5,2449,0,0,11489,
+        11494,3,1148,574,0,11490,11491,5,2455,0,0,11491,11493,3,1148,574,
+        0,11492,11490,1,0,0,0,11493,11496,1,0,0,0,11494,11492,1,0,0,0,11494,
+        11495,1,0,0,0,11495,11497,1,0,0,0,11496,11494,1,0,0,0,11497,11498,
+        5,2450,0,0,11498,11500,1,0,0,0,11499,11488,1,0,0,0,11499,11500,1,
+        0,0,0,11500,1147,1,0,0,0,11501,11503,5,1350,0,0,11502,11504,3,1716,
+        858,0,11503,11502,1,0,0,0,11503,11504,1,0,0,0,11504,11505,1,0,0,
+        0,11505,11506,3,1182,591,0,11506,1149,1,0,0,0,11507,11508,5,1350,
+        0,0,11508,11509,5,160,0,0,11509,11520,5,1951,0,0,11510,11511,5,1352,
+        0,0,11511,11521,5,2443,0,0,11512,11517,3,1148,574,0,11513,11514,
+        5,2455,0,0,11514,11516,3,1148,574,0,11515,11513,1,0,0,0,11516,11519,
+        1,0,0,0,11517,11515,1,0,0,0,11517,11518,1,0,0,0,11518,11521,1,0,
+        0,0,11519,11517,1,0,0,0,11520,11510,1,0,0,0,11520,11512,1,0,0,0,
+        11520,11521,1,0,0,0,11521,1151,1,0,0,0,11522,11524,5,1350,0,0,11523,
+        11525,3,1716,858,0,11524,11523,1,0,0,0,11524,11525,1,0,0,0,11525,
+        11527,1,0,0,0,11526,11528,3,1176,588,0,11527,11526,1,0,0,0,11527,
+        11528,1,0,0,0,11528,11529,1,0,0,0,11529,11562,3,1182,591,0,11530,
+        11555,5,2449,0,0,11531,11536,3,1168,584,0,11532,11533,5,2455,0,0,
+        11533,11535,3,1168,584,0,11534,11532,1,0,0,0,11535,11538,1,0,0,0,
+        11536,11534,1,0,0,0,11536,11537,1,0,0,0,11537,11556,1,0,0,0,11538,
+        11536,1,0,0,0,11539,11544,3,1170,585,0,11540,11541,5,2455,0,0,11541,
+        11543,3,1170,585,0,11542,11540,1,0,0,0,11543,11546,1,0,0,0,11544,
+        11542,1,0,0,0,11544,11545,1,0,0,0,11545,11556,1,0,0,0,11546,11544,
+        1,0,0,0,11547,11552,3,1172,586,0,11548,11549,5,2455,0,0,11549,11551,
+        3,1172,586,0,11550,11548,1,0,0,0,11551,11554,1,0,0,0,11552,11550,
+        1,0,0,0,11552,11553,1,0,0,0,11553,11556,1,0,0,0,11554,11552,1,0,
+        0,0,11555,11531,1,0,0,0,11555,11539,1,0,0,0,11555,11547,1,0,0,0,
+        11556,11557,1,0,0,0,11557,11558,5,2450,0,0,11558,11561,1,0,0,0,11559,
+        11561,3,1174,587,0,11560,11530,1,0,0,0,11560,11559,1,0,0,0,11561,
+        11563,1,0,0,0,11562,11560,1,0,0,0,11562,11563,1,0,0,0,11563,1153,
+        1,0,0,0,11564,11566,5,1350,0,0,11565,11567,3,1716,858,0,11566,11565,
+        1,0,0,0,11566,11567,1,0,0,0,11567,11569,1,0,0,0,11568,11570,3,1180,
+        590,0,11569,11568,1,0,0,0,11569,11570,1,0,0,0,11570,11571,1,0,0,
+        0,11571,11604,3,1182,591,0,11572,11597,5,2449,0,0,11573,11578,3,
+        1168,584,0,11574,11575,5,2455,0,0,11575,11577,3,1168,584,0,11576,
+        11574,1,0,0,0,11577,11580,1,0,0,0,11578,11576,1,0,0,0,11578,11579,
+        1,0,0,0,11579,11598,1,0,0,0,11580,11578,1,0,0,0,11581,11586,3,1170,
+        585,0,11582,11583,5,2455,0,0,11583,11585,3,1170,585,0,11584,11582,
+        1,0,0,0,11585,11588,1,0,0,0,11586,11584,1,0,0,0,11586,11587,1,0,
+        0,0,11587,11598,1,0,0,0,11588,11586,1,0,0,0,11589,11594,3,1172,586,
+        0,11590,11591,5,2455,0,0,11591,11593,3,1172,586,0,11592,11590,1,
+        0,0,0,11593,11596,1,0,0,0,11594,11592,1,0,0,0,11594,11595,1,0,0,
+        0,11595,11598,1,0,0,0,11596,11594,1,0,0,0,11597,11573,1,0,0,0,11597,
+        11581,1,0,0,0,11597,11589,1,0,0,0,11598,11599,1,0,0,0,11599,11600,
+        5,2450,0,0,11600,11603,1,0,0,0,11601,11603,3,1174,587,0,11602,11572,
+        1,0,0,0,11602,11601,1,0,0,0,11603,11605,1,0,0,0,11604,11602,1,0,
+        0,0,11604,11605,1,0,0,0,11605,1155,1,0,0,0,11606,11607,5,1777,0,
+        0,11607,11638,5,2092,0,0,11608,11633,5,2449,0,0,11609,11614,3,1168,
+        584,0,11610,11611,5,2455,0,0,11611,11613,3,1168,584,0,11612,11610,
+        1,0,0,0,11613,11616,1,0,0,0,11614,11612,1,0,0,0,11614,11615,1,0,
+        0,0,11615,11634,1,0,0,0,11616,11614,1,0,0,0,11617,11622,3,1170,585,
+        0,11618,11619,5,2455,0,0,11619,11621,3,1170,585,0,11620,11618,1,
+        0,0,0,11621,11624,1,0,0,0,11622,11620,1,0,0,0,11622,11623,1,0,0,
+        0,11623,11634,1,0,0,0,11624,11622,1,0,0,0,11625,11630,3,1172,586,
+        0,11626,11627,5,2455,0,0,11627,11629,3,1172,586,0,11628,11626,1,
+        0,0,0,11629,11632,1,0,0,0,11630,11628,1,0,0,0,11630,11631,1,0,0,
+        0,11631,11634,1,0,0,0,11632,11630,1,0,0,0,11633,11609,1,0,0,0,11633,
+        11617,1,0,0,0,11633,11625,1,0,0,0,11634,11635,1,0,0,0,11635,11636,
+        5,2450,0,0,11636,11639,1,0,0,0,11637,11639,3,1158,579,0,11638,11608,
+        1,0,0,0,11638,11637,1,0,0,0,11639,1157,1,0,0,0,11640,11641,5,2443,
+        0,0,11641,1159,1,0,0,0,11642,11643,5,1777,0,0,11643,11644,5,160,
+        0,0,11644,11645,5,1497,0,0,11645,11646,5,2449,0,0,11646,11651,3,
+        2366,1183,0,11647,11648,5,2455,0,0,11648,11650,3,2366,1183,0,11649,
+        11647,1,0,0,0,11650,11653,1,0,0,0,11651,11649,1,0,0,0,11651,11652,
+        1,0,0,0,11652,11654,1,0,0,0,11653,11651,1,0,0,0,11654,11656,5,2450,
+        0,0,11655,11657,3,1156,578,0,11656,11655,1,0,0,0,11656,11657,1,0,
+        0,0,11657,1161,1,0,0,0,11658,11659,5,1777,0,0,11659,11660,5,160,
+        0,0,11660,11661,5,863,0,0,11661,11662,5,2449,0,0,11662,11663,3,2366,
+        1183,0,11663,11665,5,2450,0,0,11664,11666,3,1156,578,0,11665,11664,
+        1,0,0,0,11665,11666,1,0,0,0,11666,1163,1,0,0,0,11667,11668,5,1777,
+        0,0,11668,11669,5,160,0,0,11669,11670,5,661,0,0,11670,11671,5,2449,
+        0,0,11671,11676,3,2366,1183,0,11672,11673,5,2455,0,0,11673,11675,
+        3,2366,1183,0,11674,11672,1,0,0,0,11675,11678,1,0,0,0,11676,11674,
+        1,0,0,0,11676,11677,1,0,0,0,11677,11679,1,0,0,0,11678,11676,1,0,
+        0,0,11679,11698,5,2450,0,0,11680,11681,5,1776,0,0,11681,11695,5,
+        2443,0,0,11682,11683,5,1765,0,0,11683,11684,5,739,0,0,11684,11685,
+        5,2449,0,0,11685,11690,3,1676,838,0,11686,11687,5,2455,0,0,11687,
+        11689,3,1676,838,0,11688,11686,1,0,0,0,11689,11692,1,0,0,0,11690,
+        11688,1,0,0,0,11690,11691,1,0,0,0,11691,11693,1,0,0,0,11692,11690,
+        1,0,0,0,11693,11694,5,2450,0,0,11694,11696,1,0,0,0,11695,11682,1,
+        0,0,0,11695,11696,1,0,0,0,11696,11699,1,0,0,0,11697,11699,3,1156,
+        578,0,11698,11680,1,0,0,0,11698,11697,1,0,0,0,11698,11699,1,0,0,
+        0,11699,1165,1,0,0,0,11700,11701,3,1716,858,0,11701,1167,1,0,0,0,
+        11702,11704,5,1777,0,0,11703,11705,3,1166,583,0,11704,11703,1,0,
+        0,0,11704,11705,1,0,0,0,11705,11706,1,0,0,0,11706,11708,3,1176,588,
+        0,11707,11709,3,1184,592,0,11708,11707,1,0,0,0,11708,11709,1,0,0,
+        0,11709,1169,1,0,0,0,11710,11712,5,1777,0,0,11711,11713,3,1166,583,
+        0,11712,11711,1,0,0,0,11712,11713,1,0,0,0,11713,11714,1,0,0,0,11714,
+        11716,3,1180,590,0,11715,11717,3,1184,592,0,11716,11715,1,0,0,0,
+        11716,11717,1,0,0,0,11717,1171,1,0,0,0,11718,11720,5,1777,0,0,11719,
+        11721,3,1166,583,0,11720,11719,1,0,0,0,11720,11721,1,0,0,0,11721,
+        11723,1,0,0,0,11722,11724,3,1184,592,0,11723,11722,1,0,0,0,11723,
+        11724,1,0,0,0,11724,1173,1,0,0,0,11725,11726,5,1776,0,0,11726,11740,
+        5,2443,0,0,11727,11728,5,1765,0,0,11728,11729,5,739,0,0,11729,11730,
+        5,2449,0,0,11730,11735,3,1676,838,0,11731,11732,5,2455,0,0,11732,
+        11734,3,1676,838,0,11733,11731,1,0,0,0,11734,11737,1,0,0,0,11735,
+        11733,1,0,0,0,11735,11736,1,0,0,0,11736,11738,1,0,0,0,11737,11735,
+        1,0,0,0,11738,11739,5,2450,0,0,11739,11741,1,0,0,0,11740,11727,1,
+        0,0,0,11740,11741,1,0,0,0,11741,1175,1,0,0,0,11742,11743,5,2259,
+        0,0,11743,11744,5,846,0,0,11744,11745,5,2100,0,0,11745,11746,5,2449,
+        0,0,11746,11747,3,1178,589,0,11747,11748,5,2450,0,0,11748,1177,1,
+        0,0,0,11749,11754,3,2210,1105,0,11750,11751,5,2455,0,0,11751,11753,
+        3,2210,1105,0,11752,11750,1,0,0,0,11753,11756,1,0,0,0,11754,11752,
+        1,0,0,0,11754,11755,1,0,0,0,11755,11768,1,0,0,0,11756,11754,1,0,
+        0,0,11757,11758,5,2110,0,0,11758,11764,3,2210,1105,0,11759,11760,
+        5,2455,0,0,11760,11761,5,2110,0,0,11761,11763,3,2210,1105,0,11762,
+        11759,1,0,0,0,11763,11766,1,0,0,0,11764,11762,1,0,0,0,11764,11765,
+        1,0,0,0,11765,11768,1,0,0,0,11766,11764,1,0,0,0,11767,11749,1,0,
+        0,0,11767,11757,1,0,0,0,11768,1179,1,0,0,0,11769,11770,5,2259,0,
+        0,11770,11790,5,2449,0,0,11771,11776,3,2210,1105,0,11772,11773,5,
+        2455,0,0,11773,11775,3,2210,1105,0,11774,11772,1,0,0,0,11775,11778,
+        1,0,0,0,11776,11774,1,0,0,0,11776,11777,1,0,0,0,11777,11791,1,0,
+        0,0,11778,11776,1,0,0,0,11779,11780,5,2110,0,0,11780,11786,3,2210,
+        1105,0,11781,11782,5,2455,0,0,11782,11783,5,2110,0,0,11783,11785,
+        3,2210,1105,0,11784,11781,1,0,0,0,11785,11788,1,0,0,0,11786,11784,
+        1,0,0,0,11786,11787,1,0,0,0,11787,11791,1,0,0,0,11788,11786,1,0,
+        0,0,11789,11791,5,389,0,0,11790,11771,1,0,0,0,11790,11779,1,0,0,
+        0,11790,11789,1,0,0,0,11791,11792,1,0,0,0,11792,11793,5,2450,0,0,
+        11793,1181,1,0,0,0,11794,11796,7,127,0,0,11795,11794,1,0,0,0,11795,
+        11796,1,0,0,0,11796,11798,1,0,0,0,11797,11799,3,1210,605,0,11798,
+        11797,1,0,0,0,11798,11799,1,0,0,0,11799,11801,1,0,0,0,11800,11802,
+        3,1098,549,0,11801,11800,1,0,0,0,11801,11802,1,0,0,0,11802,11804,
+        1,0,0,0,11803,11805,3,1100,550,0,11804,11803,1,0,0,0,11804,11805,
+        1,0,0,0,11805,11807,1,0,0,0,11806,11808,3,1212,606,0,11807,11806,
+        1,0,0,0,11807,11808,1,0,0,0,11808,11811,1,0,0,0,11809,11812,3,1190,
+        595,0,11810,11812,3,1620,810,0,11811,11809,1,0,0,0,11811,11810,1,
+        0,0,0,11811,11812,1,0,0,0,11812,11814,1,0,0,0,11813,11815,3,1192,
+        596,0,11814,11813,1,0,0,0,11814,11815,1,0,0,0,11815,11817,1,0,0,
+        0,11816,11818,3,1216,608,0,11817,11816,1,0,0,0,11817,11818,1,0,0,
+        0,11818,11823,1,0,0,0,11819,11821,5,1322,0,0,11820,11822,3,1212,
+        606,0,11821,11820,1,0,0,0,11821,11822,1,0,0,0,11822,11824,1,0,0,
+        0,11823,11819,1,0,0,0,11823,11824,1,0,0,0,11824,11830,1,0,0,0,11825,
+        11829,3,1660,830,0,11826,11829,3,1650,825,0,11827,11829,3,1710,855,
+        0,11828,11825,1,0,0,0,11828,11826,1,0,0,0,11828,11827,1,0,0,0,11829,
+        11832,1,0,0,0,11830,11828,1,0,0,0,11830,11831,1,0,0,0,11831,1183,
+        1,0,0,0,11832,11830,1,0,0,0,11833,11834,5,2082,0,0,11834,11855,3,
+        1676,838,0,11835,11838,5,1322,0,0,11836,11837,5,2082,0,0,11837,11839,
+        3,1676,838,0,11838,11836,1,0,0,0,11838,11839,1,0,0,0,11839,11855,
+        1,0,0,0,11840,11855,3,1190,595,0,11841,11855,3,1620,810,0,11842,
+        11855,3,1192,596,0,11843,11855,3,1186,593,0,11844,11845,5,2269,0,
+        0,11845,11846,3,1678,839,0,11846,11847,5,1765,0,0,11847,11849,5,
+        69,0,0,11848,11850,7,122,0,0,11849,11848,1,0,0,0,11849,11850,1,0,
+        0,0,11850,11851,1,0,0,0,11851,11852,5,869,0,0,11852,11853,3,1654,
+        827,0,11853,11855,1,0,0,0,11854,11833,1,0,0,0,11854,11835,1,0,0,
+        0,11854,11840,1,0,0,0,11854,11841,1,0,0,0,11854,11842,1,0,0,0,11854,
+        11843,1,0,0,0,11854,11844,1,0,0,0,11855,11856,1,0,0,0,11856,11854,
+        1,0,0,0,11856,11857,1,0,0,0,11857,1185,1,0,0,0,11858,11859,5,869,
+        0,0,11859,11860,5,2449,0,0,11860,11861,3,1656,828,0,11861,11862,
+        5,2450,0,0,11862,11863,5,1765,0,0,11863,11865,5,69,0,0,11864,11866,
+        7,122,0,0,11865,11864,1,0,0,0,11865,11866,1,0,0,0,11866,11880,1,
+        0,0,0,11867,11873,3,1654,827,0,11868,11869,5,2449,0,0,11869,11870,
+        5,2082,0,0,11870,11871,3,1676,838,0,11871,11872,5,2450,0,0,11872,
+        11874,1,0,0,0,11873,11868,1,0,0,0,11873,11874,1,0,0,0,11874,11881,
+        1,0,0,0,11875,11876,5,2449,0,0,11876,11877,5,2082,0,0,11877,11878,
+        3,1676,838,0,11878,11879,5,2450,0,0,11879,11881,1,0,0,0,11880,11867,
+        1,0,0,0,11880,11875,1,0,0,0,11881,1187,1,0,0,0,11882,11884,5,2443,
+        0,0,11883,11885,7,128,0,0,11884,11883,1,0,0,0,11884,11885,1,0,0,
+        0,11885,1189,1,0,0,0,11886,11900,5,258,0,0,11887,11901,5,106,0,0,
+        11888,11898,5,621,0,0,11889,11899,5,1255,0,0,11890,11892,7,129,0,
+        0,11891,11893,7,105,0,0,11892,11891,1,0,0,0,11892,11893,1,0,0,0,
+        11893,11899,1,0,0,0,11894,11895,5,38,0,0,11895,11899,5,1267,0,0,
+        11896,11897,5,425,0,0,11897,11899,5,1267,0,0,11898,11889,1,0,0,0,
+        11898,11890,1,0,0,0,11898,11894,1,0,0,0,11898,11896,1,0,0,0,11899,
+        11901,1,0,0,0,11900,11887,1,0,0,0,11900,11888,1,0,0,0,11900,11901,
+        1,0,0,0,11901,11928,1,0,0,0,11902,11903,5,1608,0,0,11903,11904,5,
+        1765,0,0,11904,11906,5,258,0,0,11905,11907,7,130,0,0,11906,11905,
+        1,0,0,0,11906,11907,1,0,0,0,11907,11928,1,0,0,0,11908,11909,5,237,
+        0,0,11909,11910,5,1765,0,0,11910,11916,5,258,0,0,11911,11912,5,621,
+        0,0,11912,11914,7,129,0,0,11913,11915,7,105,0,0,11914,11913,1,0,
+        0,0,11914,11915,1,0,0,0,11915,11917,1,0,0,0,11916,11911,1,0,0,0,
+        11916,11917,1,0,0,0,11917,11924,1,0,0,0,11918,11920,5,1139,0,0,11919,
+        11918,1,0,0,0,11919,11920,1,0,0,0,11920,11921,1,0,0,0,11921,11922,
+        5,1608,0,0,11922,11923,5,847,0,0,11923,11925,5,881,0,0,11924,11919,
+        1,0,0,0,11924,11925,1,0,0,0,11925,11928,1,0,0,0,11926,11928,5,1075,
+        0,0,11927,11886,1,0,0,0,11927,11902,1,0,0,0,11927,11908,1,0,0,0,
+        11927,11926,1,0,0,0,11928,1191,1,0,0,0,11929,11931,3,1204,602,0,
+        11930,11929,1,0,0,0,11931,11932,1,0,0,0,11932,11930,1,0,0,0,11932,
+        11933,1,0,0,0,11933,11949,1,0,0,0,11934,11936,5,747,0,0,11935,11937,
+        3,1194,597,0,11936,11935,1,0,0,0,11936,11937,1,0,0,0,11937,11941,
+        1,0,0,0,11938,11939,5,1139,0,0,11939,11941,5,747,0,0,11940,11934,
+        1,0,0,0,11940,11938,1,0,0,0,11941,11945,1,0,0,0,11942,11944,3,1204,
+        602,0,11943,11942,1,0,0,0,11944,11947,1,0,0,0,11945,11943,1,0,0,
+        0,11945,11946,1,0,0,0,11946,11949,1,0,0,0,11947,11945,1,0,0,0,11948,
+        11930,1,0,0,0,11948,11940,1,0,0,0,11949,1193,1,0,0,0,11950,11955,
+        3,1196,598,0,11951,11955,3,1198,599,0,11952,11955,3,1200,600,0,11953,
+        11955,3,1202,601,0,11954,11950,1,0,0,0,11954,11951,1,0,0,0,11954,
+        11952,1,0,0,0,11954,11953,1,0,0,0,11955,11956,1,0,0,0,11956,11954,
+        1,0,0,0,11956,11957,1,0,0,0,11957,1195,1,0,0,0,11958,11959,5,942,
+        0,0,11959,11965,5,621,0,0,11960,11966,5,449,0,0,11961,11963,7,131,
+        0,0,11962,11964,7,105,0,0,11963,11962,1,0,0,0,11963,11964,1,0,0,
+        0,11964,11966,1,0,0,0,11965,11960,1,0,0,0,11965,11961,1,0,0,0,11966,
+        11970,1,0,0,0,11967,11968,5,1139,0,0,11968,11970,5,942,0,0,11969,
+        11958,1,0,0,0,11969,11967,1,0,0,0,11970,1197,1,0,0,0,11971,11972,
+        5,1455,0,0,11972,11973,7,132,0,0,11973,1199,1,0,0,0,11974,11983,
+        5,448,0,0,11975,11984,5,91,0,0,11976,11981,5,160,0,0,11977,11978,
+        5,1603,0,0,11978,11982,5,1497,0,0,11979,11982,5,1350,0,0,11980,11982,
+        5,1777,0,0,11981,11977,1,0,0,0,11981,11979,1,0,0,0,11981,11980,1,
+        0,0,0,11982,11984,1,0,0,0,11983,11975,1,0,0,0,11983,11976,1,0,0,
+        0,11983,11984,1,0,0,0,11984,11993,1,0,0,0,11985,11986,5,621,0,0,
+        11986,11991,5,1666,0,0,11987,11992,5,389,0,0,11988,11992,5,38,0,
+        0,11989,11992,3,2428,1214,0,11990,11992,5,1134,0,0,11991,11987,1,
+        0,0,0,11991,11988,1,0,0,0,11991,11989,1,0,0,0,11991,11990,1,0,0,
+        0,11992,11994,1,0,0,0,11993,11985,1,0,0,0,11993,11994,1,0,0,0,11994,
+        1201,1,0,0,0,11995,11997,5,475,0,0,11996,11998,5,38,0,0,11997,11996,
+        1,0,0,0,11997,11998,1,0,0,0,11998,12002,1,0,0,0,11999,12000,5,1139,
+        0,0,12000,12002,5,475,0,0,12001,11995,1,0,0,0,12001,11999,1,0,0,
+        0,12002,1203,1,0,0,0,12003,12005,5,747,0,0,12004,12006,3,1196,598,
+        0,12005,12004,1,0,0,0,12005,12006,1,0,0,0,12006,12010,1,0,0,0,12007,
+        12008,5,1139,0,0,12008,12010,5,747,0,0,12009,12003,1,0,0,0,12009,
+        12007,1,0,0,0,12010,12011,1,0,0,0,12011,12012,5,2449,0,0,12012,12013,
+        3,2384,1192,0,12013,12014,5,2450,0,0,12014,1205,1,0,0,0,12015,12016,
+        5,1371,0,0,12016,12026,5,2443,0,0,12017,12018,5,1374,0,0,12018,12026,
+        5,2443,0,0,12019,12020,5,744,0,0,12020,12026,5,2443,0,0,12021,12022,
+        5,932,0,0,12022,12026,5,2443,0,0,12023,12026,3,1208,604,0,12024,
+        12026,3,690,345,0,12025,12015,1,0,0,0,12025,12017,1,0,0,0,12025,
+        12019,1,0,0,0,12025,12021,1,0,0,0,12025,12023,1,0,0,0,12025,12024,
+        1,0,0,0,12026,12027,1,0,0,0,12027,12025,1,0,0,0,12027,12028,1,0,
+        0,0,12028,1207,1,0,0,0,12029,12030,5,1764,0,0,12030,12058,5,2449,
+        0,0,12031,12032,5,741,0,0,12032,12059,3,1188,594,0,12033,12034,5,
+        1026,0,0,12034,12059,3,1188,594,0,12035,12036,5,953,0,0,12036,12059,
+        7,133,0,0,12037,12038,5,924,0,0,12038,12059,7,133,0,0,12039,12040,
+        5,1372,0,0,12040,12059,5,2443,0,0,12041,12042,5,626,0,0,12042,12059,
+        5,2443,0,0,12043,12044,5,625,0,0,12044,12045,5,654,0,0,12045,12059,
+        5,2443,0,0,12046,12049,5,1270,0,0,12047,12050,3,1188,594,0,12048,
+        12050,5,1230,0,0,12049,12047,1,0,0,0,12049,12048,1,0,0,0,12050,12059,
+        1,0,0,0,12051,12052,5,157,0,0,12052,12059,7,134,0,0,12053,12054,
+        5,607,0,0,12054,12059,7,135,0,0,12055,12056,5,186,0,0,12056,12059,
+        7,135,0,0,12057,12059,5,505,0,0,12058,12031,1,0,0,0,12058,12033,
+        1,0,0,0,12058,12035,1,0,0,0,12058,12037,1,0,0,0,12058,12039,1,0,
+        0,0,12058,12041,1,0,0,0,12058,12043,1,0,0,0,12058,12046,1,0,0,0,
+        12058,12051,1,0,0,0,12058,12053,1,0,0,0,12058,12055,1,0,0,0,12058,
+        12057,1,0,0,0,12059,12060,1,0,0,0,12060,12058,1,0,0,0,12060,12061,
+        1,0,0,0,12061,12062,1,0,0,0,12062,12063,5,2450,0,0,12063,1209,1,
+        0,0,0,12064,12065,5,1647,0,0,12065,12066,5,324,0,0,12066,12067,7,
+        69,0,0,12067,1211,1,0,0,0,12068,12080,3,1206,603,0,12069,12075,5,
+        2082,0,0,12070,12076,3,2430,1215,0,12071,12073,5,1673,0,0,12072,
+        12071,1,0,0,0,12072,12073,1,0,0,0,12073,12074,1,0,0,0,12074,12076,
+        3,2428,1214,0,12075,12070,1,0,0,0,12075,12072,1,0,0,0,12076,12080,
+        1,0,0,0,12077,12080,3,1190,595,0,12078,12080,3,898,449,0,12079,12068,
+        1,0,0,0,12079,12069,1,0,0,0,12079,12077,1,0,0,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,1213,1,0,0,0,12083,12127,3,1210,605,0,12084,12127,3,1212,606,
+        0,12085,12127,3,1190,595,0,12086,12127,3,1192,596,0,12087,12127,
+        3,1216,608,0,12088,12103,5,1308,0,0,12089,12091,5,666,0,0,12090,
+        12092,3,1212,606,0,12091,12090,1,0,0,0,12091,12092,1,0,0,0,12092,
+        12093,1,0,0,0,12093,12104,3,1232,616,0,12094,12096,5,718,0,0,12095,
+        12097,3,1212,606,0,12096,12095,1,0,0,0,12096,12097,1,0,0,0,12097,
+        12099,1,0,0,0,12098,12100,3,1616,808,0,12099,12098,1,0,0,0,12099,
+        12100,1,0,0,0,12100,12104,1,0,0,0,12101,12102,5,561,0,0,12102,12104,
+        3,1234,617,0,12103,12089,1,0,0,0,12103,12094,1,0,0,0,12103,12101,
+        1,0,0,0,12104,12127,1,0,0,0,12105,12106,5,561,0,0,12106,12107,5,
+        1350,0,0,12107,12108,5,84,0,0,12108,12111,3,1234,617,0,12109,12110,
+        5,1551,0,0,12110,12112,5,859,0,0,12111,12109,1,0,0,0,12111,12112,
+        1,0,0,0,12112,12127,1,0,0,0,12113,12114,5,220,0,0,12114,12115,3,
+        478,239,0,12115,12116,5,2449,0,0,12116,12121,3,2366,1183,0,12117,
+        12118,5,2455,0,0,12118,12120,3,2366,1183,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,2450,0,0,12125,12127,1,
+        0,0,0,12126,12083,1,0,0,0,12126,12084,1,0,0,0,12126,12085,1,0,0,
+        0,12126,12086,1,0,0,0,12126,12087,1,0,0,0,12126,12088,1,0,0,0,12126,
+        12105,1,0,0,0,12126,12113,1,0,0,0,12127,1215,1,0,0,0,12128,12138,
+        5,698,0,0,12129,12130,5,21,0,0,12130,12131,5,1414,0,0,12131,12139,
+        3,1218,609,0,12132,12133,7,136,0,0,12133,12134,5,1414,0,0,12134,
+        12139,3,1218,609,0,12135,12139,5,402,0,0,12136,12139,5,498,0,0,12137,
+        12139,5,428,0,0,12138,12129,1,0,0,0,12138,12132,1,0,0,0,12138,12135,
+        1,0,0,0,12138,12136,1,0,0,0,12138,12137,1,0,0,0,12139,1217,1,0,0,
+        0,12140,12144,3,1220,610,0,12141,12144,3,1222,611,0,12142,12144,
+        3,1228,614,0,12143,12140,1,0,0,0,12143,12141,1,0,0,0,12143,12142,
+        1,0,0,0,12144,1219,1,0,0,0,12145,12146,3,1190,595,0,12146,12147,
+        3,1226,613,0,12147,12148,3,1224,612,0,12148,12165,1,0,0,0,12149,
+        12150,7,137,0,0,12150,12151,5,1765,0,0,12151,12155,5,258,0,0,12152,
+        12156,5,29,0,0,12153,12154,5,621,0,0,12154,12156,5,1486,0,0,12155,
+        12152,1,0,0,0,12155,12153,1,0,0,0,12156,12157,1,0,0,0,12157,12158,
+        5,1608,0,0,12158,12159,5,33,0,0,12159,12160,3,1230,615,0,12160,12161,
+        5,1248,0,0,12161,12162,5,1139,0,0,12162,12163,5,979,0,0,12163,12165,
+        1,0,0,0,12164,12145,1,0,0,0,12164,12149,1,0,0,0,12165,1221,1,0,0,
+        0,12166,12167,5,2106,0,0,12167,12168,5,2143,0,0,12168,12182,3,1676,
+        838,0,12169,12171,3,1226,613,0,12170,12169,1,0,0,0,12170,12171,1,
+        0,0,0,12171,12174,1,0,0,0,12172,12173,5,1261,0,0,12173,12175,3,2346,
+        1173,0,12174,12172,1,0,0,0,12174,12175,1,0,0,0,12175,12183,1,0,0,
+        0,12176,12177,5,1507,0,0,12177,12179,5,1260,0,0,12178,12180,3,1226,
+        613,0,12179,12178,1,0,0,0,12179,12180,1,0,0,0,12180,12181,1,0,0,
+        0,12181,12183,3,1224,612,0,12182,12170,1,0,0,0,12182,12176,1,0,0,
+        0,12183,1223,1,0,0,0,12184,12185,5,33,0,0,12185,12186,3,1230,615,
+        0,12186,12190,5,1248,0,0,12187,12188,5,1139,0,0,12188,12191,7,138,
+        0,0,12189,12191,5,324,0,0,12190,12187,1,0,0,0,12190,12189,1,0,0,
+        0,12191,12195,1,0,0,0,12192,12193,5,1261,0,0,12193,12195,3,2346,
+        1173,0,12194,12184,1,0,0,0,12194,12192,1,0,0,0,12195,1225,1,0,0,
+        0,12196,12197,7,139,0,0,12197,1227,1,0,0,0,12198,12199,5,1673,0,
+        0,12199,12201,5,747,0,0,12200,12202,3,1194,597,0,12201,12200,1,0,
+        0,0,12201,12202,1,0,0,0,12202,12209,1,0,0,0,12203,12204,5,981,0,
+        0,12204,12205,5,747,0,0,12205,12209,3,1196,598,0,12206,12207,5,1139,
+        0,0,12207,12209,5,747,0,0,12208,12198,1,0,0,0,12208,12203,1,0,0,
+        0,12208,12206,1,0,0,0,12209,12211,1,0,0,0,12210,12212,5,1647,0,0,
+        12211,12210,1,0,0,0,12211,12212,1,0,0,0,12212,12213,1,0,0,0,12213,
+        12214,3,1224,612,0,12214,1229,1,0,0,0,12215,12216,3,2422,1211,0,
+        12216,12217,7,140,0,0,12217,1231,1,0,0,0,12218,12220,3,1190,595,
+        0,12219,12218,1,0,0,0,12219,12220,1,0,0,0,12220,12222,1,0,0,0,12221,
+        12223,3,1192,596,0,12222,12221,1,0,0,0,12222,12223,1,0,0,0,12223,
+        12225,1,0,0,0,12224,12226,3,1216,608,0,12225,12224,1,0,0,0,12225,
+        12226,1,0,0,0,12226,1233,1,0,0,0,12227,12230,5,2449,0,0,12228,12229,
+        5,2168,0,0,12229,12231,3,1236,618,0,12230,12228,1,0,0,0,12230,12231,
+        1,0,0,0,12231,12232,1,0,0,0,12232,12233,3,1238,619,0,12233,12235,
+        5,2450,0,0,12234,12236,3,940,470,0,12235,12234,1,0,0,0,12235,12236,
+        1,0,0,0,12236,12243,1,0,0,0,12237,12238,5,1551,0,0,12238,12241,5,
+        859,0,0,12239,12242,3,2422,1211,0,12240,12242,5,2187,0,0,12241,12239,
+        1,0,0,0,12241,12240,1,0,0,0,12242,12244,1,0,0,0,12243,12237,1,0,
+        0,0,12243,12244,1,0,0,0,12244,12246,1,0,0,0,12245,12247,3,1192,596,
+        0,12246,12245,1,0,0,0,12246,12247,1,0,0,0,12247,1235,1,0,0,0,12248,
+        12249,7,141,0,0,12249,1237,1,0,0,0,12250,12251,5,389,0,0,12251,12252,
+        5,426,0,0,12252,12254,3,1282,641,0,12253,12250,1,0,0,0,12253,12254,
+        1,0,0,0,12254,12273,1,0,0,0,12255,12256,5,4,0,0,12256,12271,5,1337,
+        0,0,12257,12258,5,2449,0,0,12258,12259,5,2445,0,0,12259,12272,5,
+        2450,0,0,12260,12262,5,2449,0,0,12261,12263,3,1240,620,0,12262,12261,
+        1,0,0,0,12263,12264,1,0,0,0,12264,12262,1,0,0,0,12264,12265,1,0,
+        0,0,12265,12266,1,0,0,0,12266,12267,5,2450,0,0,12267,12272,1,0,0,
+        0,12268,12269,5,2248,0,0,12269,12270,5,215,0,0,12270,12272,3,1888,
+        944,0,12271,12257,1,0,0,0,12271,12260,1,0,0,0,12271,12268,1,0,0,
+        0,12272,12274,1,0,0,0,12273,12255,1,0,0,0,12273,12274,1,0,0,0,12274,
+        12287,1,0,0,0,12275,12276,5,877,0,0,12276,12277,5,2449,0,0,12277,
+        12282,3,1282,641,0,12278,12279,5,2455,0,0,12279,12281,3,1282,641,
+        0,12280,12278,1,0,0,0,12281,12284,1,0,0,0,12282,12280,1,0,0,0,12282,
+        12283,1,0,0,0,12283,12285,1,0,0,0,12284,12282,1,0,0,0,12285,12286,
+        5,2450,0,0,12286,12288,1,0,0,0,12287,12275,1,0,0,0,12287,12288,1,
+        0,0,0,12288,1239,1,0,0,0,12289,12290,5,1515,0,0,12290,12291,5,405,
+        0,0,12291,12292,5,160,0,0,12292,12311,5,1023,0,0,12293,12294,5,237,
+        0,0,12294,12295,5,2151,0,0,12295,12296,5,2449,0,0,12296,12301,3,
+        1242,621,0,12297,12298,5,2455,0,0,12298,12300,3,1242,621,0,12299,
+        12297,1,0,0,0,12300,12303,1,0,0,0,12301,12299,1,0,0,0,12301,12302,
+        1,0,0,0,12302,12304,1,0,0,0,12303,12301,1,0,0,0,12304,12305,5,2450,
+        0,0,12305,12311,1,0,0,0,12306,12311,3,1266,633,0,12307,12311,3,1272,
+        636,0,12308,12311,3,1274,637,0,12309,12311,3,1276,638,0,12310,12289,
+        1,0,0,0,12310,12293,1,0,0,0,12310,12306,1,0,0,0,12310,12307,1,0,
+        0,0,12310,12308,1,0,0,0,12310,12309,1,0,0,0,12311,1241,1,0,0,0,12312,
+        12313,3,2366,1183,0,12313,12348,5,629,0,0,12314,12349,5,1230,0,0,
+        12315,12316,5,284,0,0,12316,12349,3,2426,1213,0,12317,12321,7,142,
+        0,0,12318,12322,3,1244,622,0,12319,12320,5,284,0,0,12320,12322,3,
+        2426,1213,0,12321,12318,1,0,0,0,12321,12319,1,0,0,0,12322,12349,
+        1,0,0,0,12323,12324,5,629,0,0,12324,12325,5,2449,0,0,12325,12330,
+        3,1282,641,0,12326,12327,5,2455,0,0,12327,12329,3,1282,641,0,12328,
+        12326,1,0,0,0,12329,12332,1,0,0,0,12330,12328,1,0,0,0,12330,12331,
+        1,0,0,0,12331,12333,1,0,0,0,12332,12330,1,0,0,0,12333,12334,5,2450,
+        0,0,12334,12341,1,0,0,0,12335,12341,5,215,0,0,12336,12341,5,142,
+        0,0,12337,12338,5,195,0,0,12338,12339,5,2474,0,0,12339,12341,3,2372,
+        1186,0,12340,12323,1,0,0,0,12340,12335,1,0,0,0,12340,12336,1,0,0,
+        0,12340,12337,1,0,0,0,12341,12349,1,0,0,0,12342,12343,5,1740,0,0,
+        12343,12344,3,1246,623,0,12344,12345,5,2449,0,0,12345,12346,5,2443,
+        0,0,12346,12347,5,2450,0,0,12347,12349,1,0,0,0,12348,12314,1,0,0,
+        0,12348,12315,1,0,0,0,12348,12317,1,0,0,0,12348,12340,1,0,0,0,12348,
+        12342,1,0,0,0,12349,1243,1,0,0,0,12350,12352,3,2366,1183,0,12351,
+        12353,3,2340,1170,0,12352,12351,1,0,0,0,12352,12353,1,0,0,0,12353,
+        12356,1,0,0,0,12354,12355,5,1206,0,0,12355,12357,5,1230,0,0,12356,
+        12354,1,0,0,0,12356,12357,1,0,0,0,12357,12359,1,0,0,0,12358,12360,
+        3,1758,879,0,12359,12358,1,0,0,0,12359,12360,1,0,0,0,12360,1245,
+        1,0,0,0,12361,12366,3,1248,624,0,12362,12363,5,2455,0,0,12363,12365,
+        3,1248,624,0,12364,12362,1,0,0,0,12365,12368,1,0,0,0,12366,12364,
+        1,0,0,0,12366,12367,1,0,0,0,12367,1247,1,0,0,0,12368,12366,1,0,0,
+        0,12369,12376,3,1244,622,0,12370,12375,3,1250,625,0,12371,12375,
+        3,1252,626,0,12372,12375,3,1260,630,0,12373,12375,3,1264,632,0,12374,
+        12370,1,0,0,0,12374,12371,1,0,0,0,12374,12372,1,0,0,0,12374,12373,
+        1,0,0,0,12375,12378,1,0,0,0,12376,12374,1,0,0,0,12376,12377,1,0,
+        0,0,12377,1249,1,0,0,0,12378,12376,1,0,0,0,12379,12381,5,1420,0,
+        0,12380,12379,1,0,0,0,12380,12381,1,0,0,0,12381,12382,1,0,0,0,12382,
+        12384,5,2449,0,0,12383,12385,5,2452,0,0,12384,12383,1,0,0,0,12384,
+        12385,1,0,0,0,12385,12387,1,0,0,0,12386,12388,7,143,0,0,12387,12386,
+        1,0,0,0,12387,12388,1,0,0,0,12388,12390,1,0,0,0,12389,12391,5,2443,
+        0,0,12390,12389,1,0,0,0,12390,12391,1,0,0,0,12391,12398,1,0,0,0,
+        12392,12399,5,2464,0,0,12393,12395,5,2471,0,0,12394,12396,7,143,
+        0,0,12395,12394,1,0,0,0,12395,12396,1,0,0,0,12396,12397,1,0,0,0,
+        12397,12399,5,2443,0,0,12398,12392,1,0,0,0,12398,12393,1,0,0,0,12399,
+        12400,1,0,0,0,12400,12401,5,2450,0,0,12401,1251,1,0,0,0,12402,12404,
+        5,2202,0,0,12403,12402,1,0,0,0,12403,12404,1,0,0,0,12404,12405,1,
+        0,0,0,12405,12407,5,770,0,0,12406,12408,5,561,0,0,12407,12406,1,
+        0,0,0,12407,12408,1,0,0,0,12408,12410,1,0,0,0,12409,12411,5,2443,
+        0,0,12410,12409,1,0,0,0,12410,12411,1,0,0,0,12411,12413,1,0,0,0,
+        12412,12414,3,1254,627,0,12413,12412,1,0,0,0,12413,12414,1,0,0,0,
+        12414,12492,1,0,0,0,12415,12432,7,144,0,0,12416,12417,5,2449,0,0,
+        12417,12420,5,2443,0,0,12418,12419,5,2455,0,0,12419,12421,5,2443,
+        0,0,12420,12418,1,0,0,0,12420,12421,1,0,0,0,12421,12422,1,0,0,0,
+        12422,12433,5,2450,0,0,12423,12427,5,561,0,0,12424,12425,5,2449,
+        0,0,12425,12426,5,2443,0,0,12426,12428,5,2450,0,0,12427,12424,1,
+        0,0,0,12427,12428,1,0,0,0,12428,12430,1,0,0,0,12429,12431,3,1254,
+        627,0,12430,12429,1,0,0,0,12430,12431,1,0,0,0,12431,12433,1,0,0,
+        0,12432,12416,1,0,0,0,12432,12423,1,0,0,0,12433,12492,1,0,0,0,12434,
+        12492,5,1283,0,0,12435,12437,5,1284,0,0,12436,12438,5,314,0,0,12437,
+        12436,1,0,0,0,12437,12438,1,0,0,0,12438,12492,1,0,0,0,12439,12441,
+        5,608,0,0,12440,12442,5,561,0,0,12441,12440,1,0,0,0,12441,12442,
+        1,0,0,0,12442,12444,1,0,0,0,12443,12445,5,2443,0,0,12444,12443,1,
+        0,0,0,12444,12445,1,0,0,0,12445,12447,1,0,0,0,12446,12448,3,1254,
+        627,0,12447,12446,1,0,0,0,12447,12448,1,0,0,0,12448,12492,1,0,0,
+        0,12449,12492,5,465,0,0,12450,12452,5,128,0,0,12451,12453,5,561,
+        0,0,12452,12451,1,0,0,0,12452,12453,1,0,0,0,12453,12455,1,0,0,0,
+        12454,12456,5,2443,0,0,12455,12454,1,0,0,0,12455,12456,1,0,0,0,12456,
+        12458,1,0,0,0,12457,12459,3,1254,627,0,12458,12457,1,0,0,0,12458,
+        12459,1,0,0,0,12459,12492,1,0,0,0,12460,12492,5,125,0,0,12461,12463,
+        5,1500,0,0,12462,12464,5,2443,0,0,12463,12462,1,0,0,0,12463,12464,
+        1,0,0,0,12464,12492,1,0,0,0,12465,12467,5,196,0,0,12466,12468,5,
+        561,0,0,12467,12466,1,0,0,0,12467,12468,1,0,0,0,12468,12472,1,0,
+        0,0,12469,12470,5,2449,0,0,12470,12471,5,2443,0,0,12471,12473,5,
+        2450,0,0,12472,12469,1,0,0,0,12472,12473,1,0,0,0,12473,12475,1,0,
+        0,0,12474,12476,3,1254,627,0,12475,12474,1,0,0,0,12475,12476,1,0,
+        0,0,12476,12478,1,0,0,0,12477,12479,3,1256,628,0,12478,12477,1,0,
+        0,0,12478,12479,1,0,0,0,12479,12481,1,0,0,0,12480,12482,3,1258,629,
+        0,12481,12480,1,0,0,0,12481,12482,1,0,0,0,12482,12492,1,0,0,0,12483,
+        12484,7,145,0,0,12484,12487,5,2449,0,0,12485,12486,5,2443,0,0,12486,
+        12488,5,2455,0,0,12487,12485,1,0,0,0,12487,12488,1,0,0,0,12488,12489,
+        1,0,0,0,12489,12490,5,2443,0,0,12490,12492,5,2450,0,0,12491,12403,
+        1,0,0,0,12491,12415,1,0,0,0,12491,12434,1,0,0,0,12491,12435,1,0,
+        0,0,12491,12439,1,0,0,0,12491,12449,1,0,0,0,12491,12450,1,0,0,0,
+        12491,12460,1,0,0,0,12491,12461,1,0,0,0,12491,12465,1,0,0,0,12491,
+        12483,1,0,0,0,12492,1253,1,0,0,0,12493,12494,5,503,0,0,12494,12495,
+        5,160,0,0,12495,12498,3,2426,1213,0,12496,12497,5,49,0,0,12497,12499,
+        3,2426,1213,0,12498,12496,1,0,0,0,12498,12499,1,0,0,0,12499,12519,
+        1,0,0,0,12500,12501,5,2096,0,0,12501,12504,5,160,0,0,12502,12505,
+        3,2426,1213,0,12503,12505,5,2305,0,0,12504,12502,1,0,0,0,12504,12503,
+        1,0,0,0,12505,12516,1,0,0,0,12506,12508,5,1275,0,0,12507,12506,1,
+        0,0,0,12507,12508,1,0,0,0,12508,12509,1,0,0,0,12509,12510,5,503,
+        0,0,12510,12511,5,160,0,0,12511,12514,3,2426,1213,0,12512,12513,
+        5,49,0,0,12513,12515,3,2426,1213,0,12514,12512,1,0,0,0,12514,12515,
+        1,0,0,0,12515,12517,1,0,0,0,12516,12507,1,0,0,0,12516,12517,1,0,
+        0,0,12517,12519,1,0,0,0,12518,12493,1,0,0,0,12518,12500,1,0,0,0,
+        12519,1255,1,0,0,0,12520,12521,7,146,0,0,12521,1257,1,0,0,0,12522,
+        12524,5,363,0,0,12523,12522,1,0,0,0,12523,12524,1,0,0,0,12524,12539,
+        1,0,0,0,12525,12540,5,361,0,0,12526,12533,5,2110,0,0,12527,12529,
+        5,2310,0,0,12528,12530,5,874,0,0,12529,12528,1,0,0,0,12529,12530,
+        1,0,0,0,12530,12531,1,0,0,0,12531,12532,5,2114,0,0,12532,12534,5,
+        2365,0,0,12533,12527,1,0,0,0,12533,12534,1,0,0,0,12534,12535,1,0,
+        0,0,12535,12536,5,913,0,0,12536,12540,3,2426,1213,0,12537,12538,
+        5,777,0,0,12538,12540,7,147,0,0,12539,12525,1,0,0,0,12539,12526,
+        1,0,0,0,12539,12537,1,0,0,0,12540,1259,1,0,0,0,12541,12542,7,148,
+        0,0,12542,12543,3,1262,631,0,12543,1261,1,0,0,0,12544,12550,6,631,
+        -1,0,12545,12551,3,1778,889,0,12546,12547,5,2449,0,0,12547,12548,
+        5,2443,0,0,12548,12549,5,2464,0,0,12549,12551,5,2450,0,0,12550,12545,
+        1,0,0,0,12550,12546,1,0,0,0,12551,12552,1,0,0,0,12552,12556,3,2118,
+        1059,0,12553,12557,3,2426,1213,0,12554,12557,5,2440,0,0,12555,12557,
+        5,141,0,0,12556,12553,1,0,0,0,12556,12554,1,0,0,0,12556,12555,1,
+        0,0,0,12557,12563,1,0,0,0,12558,12559,10,1,0,0,12559,12560,7,149,
+        0,0,12560,12562,3,1262,631,2,12561,12558,1,0,0,0,12562,12565,1,0,
+        0,0,12563,12561,1,0,0,0,12563,12564,1,0,0,0,12564,1263,1,0,0,0,12565,
+        12563,1,0,0,0,12566,12567,5,865,0,0,12567,12568,3,1282,641,0,12568,
+        1265,1,0,0,0,12569,12598,5,1515,0,0,12570,12571,5,603,0,0,12571,
+        12599,5,2443,0,0,12572,12573,5,2264,0,0,12573,12599,5,2443,0,0,12574,
+        12575,5,405,0,0,12575,12581,5,160,0,0,12576,12578,5,418,0,0,12577,
+        12576,1,0,0,0,12577,12578,1,0,0,0,12578,12579,1,0,0,0,12579,12582,
+        5,1023,0,0,12580,12582,3,2426,1213,0,12581,12577,1,0,0,0,12581,12580,
+        1,0,0,0,12582,12599,1,0,0,0,12583,12585,5,2350,0,0,12584,12586,5,
+        2449,0,0,12585,12584,1,0,0,0,12585,12586,1,0,0,0,12586,12587,1,0,
+        0,0,12587,12592,3,2430,1215,0,12588,12589,5,2455,0,0,12589,12591,
+        3,2430,1215,0,12590,12588,1,0,0,0,12591,12594,1,0,0,0,12592,12590,
+        1,0,0,0,12592,12593,1,0,0,0,12593,12596,1,0,0,0,12594,12592,1,0,
+        0,0,12595,12597,5,2450,0,0,12596,12595,1,0,0,0,12596,12597,1,0,0,
+        0,12597,12599,1,0,0,0,12598,12570,1,0,0,0,12598,12572,1,0,0,0,12598,
+        12574,1,0,0,0,12598,12583,1,0,0,0,12599,12603,1,0,0,0,12600,12602,
+        3,1268,634,0,12601,12600,1,0,0,0,12602,12605,1,0,0,0,12603,12601,
+        1,0,0,0,12603,12604,1,0,0,0,12604,12612,1,0,0,0,12605,12603,1,0,
+        0,0,12606,12608,3,1268,634,0,12607,12606,1,0,0,0,12608,12609,1,0,
+        0,0,12609,12607,1,0,0,0,12609,12610,1,0,0,0,12610,12612,1,0,0,0,
+        12611,12569,1,0,0,0,12611,12607,1,0,0,0,12612,1267,1,0,0,0,12613,
+        12614,5,195,0,0,12614,12651,3,2372,1186,0,12615,12616,5,561,0,0,
+        12616,12617,5,2264,0,0,12617,12651,5,351,0,0,12618,12619,5,1444,
+        0,0,12619,12651,3,1282,641,0,12620,12621,5,351,0,0,12621,12622,5,
+        786,0,0,12622,12623,7,150,0,0,12623,12651,5,510,0,0,12624,12625,
+        5,165,0,0,12625,12651,7,151,0,0,12626,12627,5,1769,0,0,12627,12628,
+        5,1702,0,0,12628,12629,5,67,0,0,12629,12630,5,739,0,0,12630,12651,
+        7,152,0,0,12631,12632,5,868,0,0,12632,12633,5,2302,0,0,12633,12651,
+        3,1262,631,0,12634,12651,3,1270,635,0,12635,12637,5,1509,0,0,12636,
+        12638,5,2474,0,0,12637,12636,1,0,0,0,12637,12638,1,0,0,0,12638,12639,
+        1,0,0,0,12639,12651,5,2443,0,0,12640,12651,5,431,0,0,12641,12642,
+        5,362,0,0,12642,12651,5,2443,0,0,12643,12644,5,1704,0,0,12644,12651,
+        5,2443,0,0,12645,12646,5,785,0,0,12646,12651,7,153,0,0,12647,12651,
+        7,154,0,0,12648,12649,5,453,0,0,12649,12651,5,2443,0,0,12650,12613,
+        1,0,0,0,12650,12615,1,0,0,0,12650,12618,1,0,0,0,12650,12620,1,0,
+        0,0,12650,12624,1,0,0,0,12650,12626,1,0,0,0,12650,12631,1,0,0,0,
+        12650,12634,1,0,0,0,12650,12635,1,0,0,0,12650,12640,1,0,0,0,12650,
+        12641,1,0,0,0,12650,12643,1,0,0,0,12650,12645,1,0,0,0,12650,12647,
+        1,0,0,0,12650,12648,1,0,0,0,12651,1269,1,0,0,0,12652,12659,7,155,
+        0,0,12653,12655,7,156,0,0,12654,12656,3,1282,641,0,12655,12654,1,
+        0,0,0,12655,12656,1,0,0,0,12656,12657,1,0,0,0,12657,12659,3,1470,
+        735,0,12658,12652,1,0,0,0,12658,12653,1,0,0,0,12659,1271,1,0,0,0,
+        12660,12662,5,589,0,0,12661,12663,5,694,0,0,12662,12661,1,0,0,0,
+        12662,12663,1,0,0,0,12663,12667,1,0,0,0,12664,12665,5,330,0,0,12665,
+        12666,7,2,0,0,12666,12668,5,494,0,0,12667,12664,1,0,0,0,12667,12668,
+        1,0,0,0,12668,12670,1,0,0,0,12669,12671,3,1254,627,0,12670,12669,
+        1,0,0,0,12670,12671,1,0,0,0,12671,12673,1,0,0,0,12672,12674,3,1256,
+        628,0,12673,12672,1,0,0,0,12673,12674,1,0,0,0,12674,12680,1,0,0,
+        0,12675,12676,5,38,0,0,12676,12677,5,589,0,0,12677,12678,5,1325,
+        0,0,12678,12679,5,2103,0,0,12679,12681,5,589,0,0,12680,12675,1,0,
+        0,0,12680,12681,1,0,0,0,12681,12687,1,0,0,0,12682,12683,5,965,0,
+        0,12683,12684,5,588,0,0,12684,12685,5,2259,0,0,12685,12686,5,67,
+        0,0,12686,12688,5,1230,0,0,12687,12682,1,0,0,0,12687,12688,1,0,0,
+        0,12688,12695,1,0,0,0,12689,12690,5,1551,0,0,12690,12691,5,1609,
+        0,0,12691,12692,5,2310,0,0,12692,12693,5,38,0,0,12693,12694,5,1230,
+        0,0,12694,12696,5,589,0,0,12695,12689,1,0,0,0,12695,12696,1,0,0,
+        0,12696,12701,1,0,0,0,12697,12698,5,363,0,0,12698,12699,7,157,0,
+        0,12699,12700,5,913,0,0,12700,12702,3,2426,1213,0,12701,12697,1,
+        0,0,0,12701,12702,1,0,0,0,12702,12711,1,0,0,0,12703,12704,5,1229,
+        0,0,12704,12708,7,158,0,0,12705,12709,3,2426,1213,0,12706,12709,
+        5,2440,0,0,12707,12709,5,141,0,0,12708,12705,1,0,0,0,12708,12706,
+        1,0,0,0,12708,12707,1,0,0,0,12709,12712,1,0,0,0,12710,12712,5,1136,
+        0,0,12711,12703,1,0,0,0,12711,12710,1,0,0,0,12711,12712,1,0,0,0,
+        12712,12714,1,0,0,0,12713,12715,5,2449,0,0,12714,12713,1,0,0,0,12714,
+        12715,1,0,0,0,12715,12717,1,0,0,0,12716,12718,3,1246,623,0,12717,
+        12716,1,0,0,0,12717,12718,1,0,0,0,12718,12720,1,0,0,0,12719,12721,
+        5,2450,0,0,12720,12719,1,0,0,0,12720,12721,1,0,0,0,12721,1273,1,
+        0,0,0,12722,12723,5,506,0,0,12723,12779,7,159,0,0,12724,12779,5,
+        1119,0,0,12725,12727,5,883,0,0,12726,12728,3,1282,641,0,12727,12726,
+        1,0,0,0,12727,12728,1,0,0,0,12728,12729,1,0,0,0,12729,12779,3,1470,
+        735,0,12730,12736,5,259,0,0,12731,12733,5,500,0,0,12732,12734,7,
+        160,0,0,12733,12732,1,0,0,0,12733,12734,1,0,0,0,12734,12737,1,0,
+        0,0,12735,12737,5,430,0,0,12736,12731,1,0,0,0,12736,12735,1,0,0,
+        0,12736,12737,1,0,0,0,12737,12779,1,0,0,0,12738,12739,5,658,0,0,
+        12739,12740,7,161,0,0,12740,12744,5,2287,0,0,12741,12745,5,247,0,
+        0,12742,12745,5,829,0,0,12743,12745,3,2426,1213,0,12744,12741,1,
+        0,0,0,12744,12742,1,0,0,0,12744,12743,1,0,0,0,12745,12779,1,0,0,
+        0,12746,12779,5,1118,0,0,12747,12748,5,378,0,0,12748,12749,5,2474,
+        0,0,12749,12750,5,2449,0,0,12750,12751,5,2443,0,0,12751,12752,5,
+        2455,0,0,12752,12753,5,2443,0,0,12753,12779,5,2450,0,0,12754,12755,
+        5,359,0,0,12755,12756,5,779,0,0,12756,12757,5,2085,0,0,12757,12779,
+        3,2368,1184,0,12758,12759,5,2093,0,0,12759,12779,3,2368,1184,0,12760,
+        12761,5,794,0,0,12761,12762,5,2449,0,0,12762,12763,3,2312,1156,0,
+        12763,12764,5,2455,0,0,12764,12765,3,2368,1184,0,12765,12766,5,2455,
+        0,0,12766,12767,5,2443,0,0,12767,12768,5,2450,0,0,12768,12779,1,
+        0,0,0,12769,12770,5,2312,0,0,12770,12779,5,2443,0,0,12771,12772,
+        5,1335,0,0,12772,12779,5,2443,0,0,12773,12774,5,2287,0,0,12774,12779,
+        3,2426,1213,0,12775,12779,5,507,0,0,12776,12777,5,370,0,0,12777,
+        12779,3,2426,1213,0,12778,12722,1,0,0,0,12778,12724,1,0,0,0,12778,
+        12725,1,0,0,0,12778,12730,1,0,0,0,12778,12738,1,0,0,0,12778,12746,
+        1,0,0,0,12778,12747,1,0,0,0,12778,12754,1,0,0,0,12778,12758,1,0,
+        0,0,12778,12760,1,0,0,0,12778,12769,1,0,0,0,12778,12771,1,0,0,0,
+        12778,12773,1,0,0,0,12778,12775,1,0,0,0,12778,12776,1,0,0,0,12779,
+        1275,1,0,0,0,12780,12785,3,2430,1215,0,12781,12782,5,2442,0,0,12782,
+        12784,3,2430,1215,0,12783,12781,1,0,0,0,12784,12787,1,0,0,0,12785,
+        12783,1,0,0,0,12785,12786,1,0,0,0,12786,12788,1,0,0,0,12787,12785,
+        1,0,0,0,12788,12872,7,162,0,0,12789,12873,3,2368,1184,0,12790,12873,
+        3,1278,639,0,12791,12792,5,2475,0,0,12792,12797,3,1278,639,0,12793,
+        12794,5,2455,0,0,12794,12796,3,1278,639,0,12795,12793,1,0,0,0,12796,
+        12799,1,0,0,0,12797,12795,1,0,0,0,12797,12798,1,0,0,0,12798,12800,
+        1,0,0,0,12799,12797,1,0,0,0,12800,12801,5,2476,0,0,12801,12873,1,
+        0,0,0,12802,12803,3,1244,622,0,12803,12806,3,2402,1201,0,12804,12805,
+        5,241,0,0,12805,12807,3,2426,1213,0,12806,12804,1,0,0,0,12806,12807,
+        1,0,0,0,12807,12813,1,0,0,0,12808,12809,5,2455,0,0,12809,12810,5,
+        241,0,0,12810,12812,3,2426,1213,0,12811,12808,1,0,0,0,12812,12815,
+        1,0,0,0,12813,12811,1,0,0,0,12813,12814,1,0,0,0,12814,12873,1,0,
+        0,0,12815,12813,1,0,0,0,12816,12873,5,1656,0,0,12817,12873,5,2099,
+        0,0,12818,12873,5,1505,0,0,12819,12873,5,1282,0,0,12820,12873,5,
+        1343,0,0,12821,12822,5,753,0,0,12822,12823,3,2426,1213,0,12823,12824,
+        5,1318,0,0,12824,12825,3,2426,1213,0,12825,12873,1,0,0,0,12826,12873,
+        3,1282,641,0,12827,12829,5,405,0,0,12828,12827,1,0,0,0,12828,12829,
+        1,0,0,0,12829,12851,1,0,0,0,12830,12831,5,589,0,0,12831,12832,5,
+        2096,0,0,12832,12833,5,160,0,0,12833,12834,5,193,0,0,12834,12835,
+        5,526,0,0,12835,12836,5,160,0,0,12836,12852,5,193,0,0,12837,12838,
+        5,234,0,0,12838,12843,5,790,0,0,12839,12840,5,911,0,0,12840,12843,
+        5,820,0,0,12841,12843,5,861,0,0,12842,12837,1,0,0,0,12842,12839,
+        1,0,0,0,12842,12841,1,0,0,0,12843,12844,1,0,0,0,12844,12845,5,2096,
+        0,0,12845,12846,5,160,0,0,12846,12852,5,193,0,0,12847,12848,5,1230,
+        0,0,12848,12849,5,396,0,0,12849,12850,5,69,0,0,12850,12852,5,193,
+        0,0,12851,12830,1,0,0,0,12851,12842,1,0,0,0,12851,12847,1,0,0,0,
+        12852,12873,1,0,0,0,12853,12854,5,1659,0,0,12854,12870,3,2426,1213,
+        0,12855,12856,5,2310,0,0,12856,12857,5,1660,0,0,12857,12858,3,2426,
+        1213,0,12858,12859,5,2474,0,0,12859,12867,3,2426,1213,0,12860,12861,
+        5,2455,0,0,12861,12862,3,2426,1213,0,12862,12863,5,2474,0,0,12863,
+        12864,3,2426,1213,0,12864,12866,1,0,0,0,12865,12860,1,0,0,0,12866,
+        12869,1,0,0,0,12867,12865,1,0,0,0,12867,12868,1,0,0,0,12868,12871,
+        1,0,0,0,12869,12867,1,0,0,0,12870,12855,1,0,0,0,12870,12871,1,0,
+        0,0,12871,12873,1,0,0,0,12872,12789,1,0,0,0,12872,12790,1,0,0,0,
+        12872,12791,1,0,0,0,12872,12802,1,0,0,0,12872,12816,1,0,0,0,12872,
+        12817,1,0,0,0,12872,12818,1,0,0,0,12872,12819,1,0,0,0,12872,12820,
+        1,0,0,0,12872,12821,1,0,0,0,12872,12826,1,0,0,0,12872,12828,1,0,
+        0,0,12872,12853,1,0,0,0,12873,12875,1,0,0,0,12874,12876,3,1276,638,
+        0,12875,12874,1,0,0,0,12875,12876,1,0,0,0,12876,1277,1,0,0,0,12877,
+        12878,5,2461,0,0,12878,12883,3,1280,640,0,12879,12880,5,2455,0,0,
+        12880,12882,3,1280,640,0,12881,12879,1,0,0,0,12882,12885,1,0,0,0,
+        12883,12881,1,0,0,0,12883,12884,1,0,0,0,12884,12886,1,0,0,0,12885,
+        12883,1,0,0,0,12886,12887,5,2462,0,0,12887,1279,1,0,0,0,12888,12889,
+        3,2430,1215,0,12889,12890,5,2464,0,0,12890,12916,1,0,0,0,12891,12892,
+        3,2430,1215,0,12892,12893,5,2471,0,0,12893,12894,5,2475,0,0,12894,
+        12899,3,2430,1215,0,12895,12896,5,2455,0,0,12896,12898,3,2430,1215,
+        0,12897,12895,1,0,0,0,12898,12901,1,0,0,0,12899,12897,1,0,0,0,12899,
+        12900,1,0,0,0,12900,12902,1,0,0,0,12901,12899,1,0,0,0,12902,12903,
+        5,2476,0,0,12903,12916,1,0,0,0,12904,12905,5,2475,0,0,12905,12910,
+        3,2430,1215,0,12906,12907,5,2455,0,0,12907,12909,3,2430,1215,0,12908,
+        12906,1,0,0,0,12909,12912,1,0,0,0,12910,12908,1,0,0,0,12910,12911,
+        1,0,0,0,12911,12913,1,0,0,0,12912,12910,1,0,0,0,12913,12914,5,2476,
+        0,0,12914,12916,1,0,0,0,12915,12888,1,0,0,0,12915,12891,1,0,0,0,
+        12915,12904,1,0,0,0,12916,1281,1,0,0,0,12917,12918,3,798,399,0,12918,
+        12919,5,2471,0,0,12919,12920,5,2445,0,0,12920,12933,1,0,0,0,12921,
+        12923,3,798,399,0,12922,12924,3,752,376,0,12923,12922,1,0,0,0,12923,
+        12924,1,0,0,0,12924,12925,1,0,0,0,12925,12926,5,2471,0,0,12926,12928,
+        1,0,0,0,12927,12921,1,0,0,0,12927,12928,1,0,0,0,12928,12929,1,0,
+        0,0,12929,12933,5,2445,0,0,12930,12933,3,2426,1213,0,12931,12933,
+        3,2352,1176,0,12932,12917,1,0,0,0,12932,12927,1,0,0,0,12932,12930,
+        1,0,0,0,12932,12931,1,0,0,0,12933,1283,1,0,0,0,12934,12936,7,17,
+        0,0,12935,12934,1,0,0,0,12935,12936,1,0,0,0,12936,12937,1,0,0,0,
+        12937,12938,5,1608,0,0,12938,12939,5,992,0,0,12939,1285,1,0,0,0,
+        12940,12941,5,606,0,0,12941,12943,5,64,0,0,12942,12944,3,2430,1215,
+        0,12943,12942,1,0,0,0,12943,12944,1,0,0,0,12944,12949,1,0,0,0,12945,
+        12946,5,1139,0,0,12946,12947,5,606,0,0,12947,12949,5,64,0,0,12948,
+        12940,1,0,0,0,12948,12945,1,0,0,0,12949,1287,1,0,0,0,12950,12953,
+        5,2443,0,0,12951,12953,3,2428,1214,0,12952,12950,1,0,0,0,12952,12951,
+        1,0,0,0,12953,1289,1,0,0,0,12954,12955,5,21,0,0,12955,12956,5,1791,
+        0,0,12956,12959,5,889,0,0,12957,12960,3,1292,646,0,12958,12960,3,
+        1294,647,0,12959,12957,1,0,0,0,12959,12958,1,0,0,0,12960,12970,1,
+        0,0,0,12961,12962,5,2455,0,0,12962,12963,5,1791,0,0,12963,12966,
+        5,889,0,0,12964,12967,3,1292,646,0,12965,12967,3,1294,647,0,12966,
+        12964,1,0,0,0,12966,12965,1,0,0,0,12967,12969,1,0,0,0,12968,12961,
+        1,0,0,0,12969,12972,1,0,0,0,12970,12968,1,0,0,0,12970,12971,1,0,
+        0,0,12971,12995,1,0,0,0,12972,12970,1,0,0,0,12973,12974,5,469,0,
+        0,12974,12975,5,1791,0,0,12975,12979,5,889,0,0,12976,12980,3,1294,
+        647,0,12977,12978,5,650,0,0,12978,12980,3,1288,644,0,12979,12976,
+        1,0,0,0,12979,12977,1,0,0,0,12980,12991,1,0,0,0,12981,12982,5,2455,
+        0,0,12982,12983,5,1791,0,0,12983,12987,5,889,0,0,12984,12988,3,1294,
+        647,0,12985,12986,5,650,0,0,12986,12988,3,1288,644,0,12987,12984,
+        1,0,0,0,12987,12985,1,0,0,0,12988,12990,1,0,0,0,12989,12981,1,0,
+        0,0,12990,12993,1,0,0,0,12991,12989,1,0,0,0,12991,12992,1,0,0,0,
+        12992,12995,1,0,0,0,12993,12991,1,0,0,0,12994,12954,1,0,0,0,12994,
+        12973,1,0,0,0,12995,1291,1,0,0,0,12996,12997,5,650,0,0,12997,12998,
+        3,1288,644,0,12998,12999,5,2449,0,0,12999,13002,3,2366,1183,0,13000,
+        13001,5,1139,0,0,13001,13003,5,889,0,0,13002,13000,1,0,0,0,13002,
+        13003,1,0,0,0,13003,13012,1,0,0,0,13004,13005,5,2455,0,0,13005,13008,
+        3,2366,1183,0,13006,13007,5,1139,0,0,13007,13009,5,889,0,0,13008,
+        13006,1,0,0,0,13008,13009,1,0,0,0,13009,13011,1,0,0,0,13010,13004,
+        1,0,0,0,13011,13014,1,0,0,0,13012,13010,1,0,0,0,13012,13013,1,0,
+        0,0,13013,13015,1,0,0,0,13014,13012,1,0,0,0,13015,13017,5,2450,0,
+        0,13016,13018,5,44,0,0,13017,13016,1,0,0,0,13017,13018,1,0,0,0,13018,
+        1293,1,0,0,0,13019,13020,5,351,0,0,13020,13035,5,2449,0,0,13021,
+        13023,5,2455,0,0,13022,13021,1,0,0,0,13022,13023,1,0,0,0,13023,13033,
+        1,0,0,0,13024,13034,5,38,0,0,13025,13026,5,1453,0,0,13026,13034,
+        5,817,0,0,13027,13029,5,2185,0,0,13028,13030,5,718,0,0,13029,13028,
+        1,0,0,0,13029,13030,1,0,0,0,13030,13034,1,0,0,0,13031,13032,5,619,
+        0,0,13032,13034,5,817,0,0,13033,13024,1,0,0,0,13033,13025,1,0,0,
+        0,13033,13027,1,0,0,0,13033,13031,1,0,0,0,13034,13036,1,0,0,0,13035,
+        13022,1,0,0,0,13036,13037,1,0,0,0,13037,13035,1,0,0,0,13037,13038,
+        1,0,0,0,13038,13039,1,0,0,0,13039,13040,5,2450,0,0,13040,13041,5,
+        238,0,0,13041,1295,1,0,0,0,13042,13043,5,39,0,0,13043,13056,5,559,
+        0,0,13044,13051,5,2449,0,0,13045,13046,5,1701,0,0,13046,13052,3,
+        1188,594,0,13047,13048,5,352,0,0,13048,13052,5,2445,0,0,13049,13050,
+        5,760,0,0,13050,13052,5,2443,0,0,13051,13045,1,0,0,0,13051,13047,
+        1,0,0,0,13051,13049,1,0,0,0,13052,13053,1,0,0,0,13053,13051,1,0,
+        0,0,13053,13054,1,0,0,0,13054,13055,1,0,0,0,13055,13057,5,2450,0,
+        0,13056,13044,1,0,0,0,13056,13057,1,0,0,0,13057,1297,1,0,0,0,13058,
+        13059,5,377,0,0,13059,13062,5,2206,0,0,13060,13061,5,815,0,0,13061,
+        13063,3,1188,594,0,13062,13060,1,0,0,0,13062,13063,1,0,0,0,13063,
+        1299,1,0,0,0,13064,13065,5,1686,0,0,13065,13067,5,1716,0,0,13066,
+        13068,5,246,0,0,13067,13066,1,0,0,0,13067,13068,1,0,0,0,13068,13070,
+        1,0,0,0,13069,13071,5,179,0,0,13070,13069,1,0,0,0,13070,13071,1,
+        0,0,0,13071,13073,1,0,0,0,13072,13074,5,200,0,0,13073,13072,1,0,
+        0,0,13073,13074,1,0,0,0,13074,1301,1,0,0,0,13075,13077,7,163,0,0,
+        13076,13075,1,0,0,0,13076,13077,1,0,0,0,13077,13078,1,0,0,0,13078,
+        13079,5,1516,0,0,13079,1303,1,0,0,0,13080,13082,5,2213,0,0,13081,
+        13083,5,1206,0,0,13082,13081,1,0,0,0,13082,13083,1,0,0,0,13083,13084,
+        1,0,0,0,13084,13085,5,706,0,0,13085,13086,5,351,0,0,13086,13087,
+        1,0,0,0,13087,13088,3,1680,840,0,13088,1305,1,0,0,0,13089,13090,
+        5,2161,0,0,13090,13091,5,2085,0,0,13091,13098,3,2368,1184,0,13092,
+        13096,7,164,0,0,13093,13094,5,920,0,0,13094,13095,5,2288,0,0,13095,
+        13097,5,889,0,0,13096,13093,1,0,0,0,13096,13097,1,0,0,0,13097,13099,
+        1,0,0,0,13098,13092,1,0,0,0,13098,13099,1,0,0,0,13099,13108,1,0,
+        0,0,13100,13102,5,469,0,0,13101,13103,5,38,0,0,13102,13101,1,0,0,
+        0,13102,13103,1,0,0,0,13103,13106,1,0,0,0,13104,13106,5,1589,0,0,
+        13105,13100,1,0,0,0,13105,13104,1,0,0,0,13106,13107,1,0,0,0,13107,
+        13109,5,1764,0,0,13108,13105,1,0,0,0,13108,13109,1,0,0,0,13109,13111,
+        1,0,0,0,13110,13112,5,179,0,0,13111,13110,1,0,0,0,13111,13112,1,
+        0,0,0,13112,1307,1,0,0,0,13113,13114,5,469,0,0,13114,13115,5,2085,
+        0,0,13115,13118,3,2368,1184,0,13116,13117,5,692,0,0,13117,13119,
+        5,546,0,0,13118,13116,1,0,0,0,13118,13119,1,0,0,0,13119,13122,1,
+        0,0,0,13120,13121,5,69,0,0,13121,13123,3,2368,1184,0,13122,13120,
+        1,0,0,0,13122,13123,1,0,0,0,13123,13126,1,0,0,0,13124,13125,5,179,
+        0,0,13125,13127,7,95,0,0,13126,13124,1,0,0,0,13126,13127,1,0,0,0,
+        13127,13129,1,0,0,0,13128,13130,5,1477,0,0,13129,13128,1,0,0,0,13129,
+        13130,1,0,0,0,13130,13133,1,0,0,0,13131,13132,5,69,0,0,13132,13134,
+        3,2296,1148,0,13133,13131,1,0,0,0,13133,13134,1,0,0,0,13134,13136,
+        1,0,0,0,13135,13137,5,617,0,0,13136,13135,1,0,0,0,13136,13137,1,
+        0,0,0,13137,1309,1,0,0,0,13138,13139,5,469,0,0,13139,13140,5,2082,
+        0,0,13140,13143,3,2430,1215,0,13141,13142,5,692,0,0,13142,13144,
+        5,546,0,0,13143,13141,1,0,0,0,13143,13144,1,0,0,0,13144,13149,1,
+        0,0,0,13145,13147,7,165,0,0,13146,13148,5,1492,0,0,13147,13146,1,
+        0,0,0,13147,13148,1,0,0,0,13148,13150,1,0,0,0,13149,13145,1,0,0,
+        0,13149,13150,1,0,0,0,13150,13152,1,0,0,0,13151,13153,3,1314,657,
+        0,13152,13151,1,0,0,0,13152,13153,1,0,0,0,13153,1311,1,0,0,0,13154,
+        13155,5,469,0,0,13155,13156,5,2082,0,0,13156,13157,5,1673,0,0,13157,
+        13159,3,2430,1215,0,13158,13160,3,1314,657,0,13159,13158,1,0,0,0,
+        13159,13160,1,0,0,0,13160,1313,1,0,0,0,13161,13162,5,706,0,0,13162,
+        13165,5,295,0,0,13163,13164,7,166,0,0,13164,13166,5,353,0,0,13165,
+        13163,1,0,0,0,13165,13166,1,0,0,0,13166,13169,1,0,0,0,13167,13168,
+        5,179,0,0,13168,13170,5,287,0,0,13169,13167,1,0,0,0,13169,13170,
+        1,0,0,0,13170,1315,1,0,0,0,13171,13172,5,469,0,0,13172,13173,5,2288,
+        0,0,13173,13176,3,2368,1184,0,13174,13175,5,692,0,0,13175,13177,
+        5,546,0,0,13176,13174,1,0,0,0,13176,13177,1,0,0,0,13177,13180,1,
+        0,0,0,13178,13179,5,179,0,0,13179,13181,5,286,0,0,13180,13178,1,
+        0,0,0,13180,13181,1,0,0,0,13181,1317,1,0,0,0,13182,13183,5,241,0,
+        0,13183,13184,5,1261,0,0,13184,13185,5,237,0,0,13185,13186,3,2366,
+        1183,0,13186,13187,5,786,0,0,13187,13188,3,2426,1213,0,13188,1319,
+        1,0,0,0,13189,13190,7,17,0,0,13190,1321,1,0,0,0,13191,13192,7,167,
+        0,0,13192,1323,1,0,0,0,13193,13195,5,42,0,0,13194,13196,5,1475,0,
+        0,13195,13194,1,0,0,0,13195,13196,1,0,0,0,13196,13197,1,0,0,0,13197,
+        13201,5,1798,0,0,13198,13199,3,2312,1156,0,13199,13200,5,2442,0,
+        0,13200,13202,1,0,0,0,13201,13198,1,0,0,0,13201,13202,1,0,0,0,13202,
+        13203,1,0,0,0,13203,13204,3,2374,1187,0,13204,13205,7,168,0,0,13205,
+        1325,1,0,0,0,13206,13209,5,321,0,0,13207,13208,5,1309,0,0,13208,
+        13210,5,1564,0,0,13209,13207,1,0,0,0,13209,13210,1,0,0,0,13210,13211,
+        1,0,0,0,13211,13212,5,1475,0,0,13212,13213,5,1798,0,0,13213,13214,
+        3,2374,1187,0,13214,13218,5,621,0,0,13215,13216,3,2312,1156,0,13216,
+        13217,5,2442,0,0,13217,13219,1,0,0,0,13218,13215,1,0,0,0,13218,13219,
+        1,0,0,0,13219,13220,1,0,0,0,13220,13223,3,2376,1188,0,13221,13222,
+        5,2458,0,0,13222,13224,3,2360,1180,0,13223,13221,1,0,0,0,13223,13224,
+        1,0,0,0,13224,13254,1,0,0,0,13225,13228,5,321,0,0,13226,13227,5,
+        1309,0,0,13227,13229,5,1564,0,0,13228,13226,1,0,0,0,13228,13229,
+        1,0,0,0,13229,13230,1,0,0,0,13230,13234,5,1798,0,0,13231,13232,3,
+        2312,1156,0,13232,13233,5,2442,0,0,13233,13235,1,0,0,0,13234,13231,
+        1,0,0,0,13234,13235,1,0,0,0,13235,13236,1,0,0,0,13236,13237,3,2374,
+        1187,0,13237,13241,5,621,0,0,13238,13239,3,2312,1156,0,13239,13240,
+        5,2442,0,0,13240,13242,1,0,0,0,13241,13238,1,0,0,0,13241,13242,1,
+        0,0,0,13242,13243,1,0,0,0,13243,13251,3,2376,1188,0,13244,13248,
+        5,2458,0,0,13245,13246,3,2312,1156,0,13246,13247,5,2442,0,0,13247,
+        13249,1,0,0,0,13248,13245,1,0,0,0,13248,13249,1,0,0,0,13249,13250,
+        1,0,0,0,13250,13252,3,2360,1180,0,13251,13244,1,0,0,0,13251,13252,
+        1,0,0,0,13252,13254,1,0,0,0,13253,13206,1,0,0,0,13253,13225,1,0,
+        0,0,13254,1327,1,0,0,0,13255,13257,5,469,0,0,13256,13258,5,1475,
+        0,0,13257,13256,1,0,0,0,13257,13258,1,0,0,0,13258,13259,1,0,0,0,
+        13259,13263,5,1798,0,0,13260,13261,3,2312,1156,0,13261,13262,5,2442,
+        0,0,13262,13264,1,0,0,0,13263,13260,1,0,0,0,13263,13264,1,0,0,0,
+        13264,13265,1,0,0,0,13265,13267,3,2374,1187,0,13266,13268,5,617,
+        0,0,13267,13266,1,0,0,0,13267,13268,1,0,0,0,13268,1329,1,0,0,0,13269,
+        13270,5,321,0,0,13270,13273,5,1718,0,0,13271,13272,5,2474,0,0,13272,
+        13274,3,1332,666,0,13273,13271,1,0,0,0,13273,13274,1,0,0,0,13274,
+        13275,1,0,0,0,13275,13286,5,629,0,0,13276,13279,5,1393,0,0,13277,
+        13278,5,2474,0,0,13278,13280,3,1334,667,0,13279,13277,1,0,0,0,13279,
+        13280,1,0,0,0,13280,13283,1,0,0,0,13281,13282,5,69,0,0,13282,13284,
+        5,303,0,0,13283,13281,1,0,0,0,13283,13284,1,0,0,0,13284,13287,1,
+        0,0,0,13285,13287,5,943,0,0,13286,13276,1,0,0,0,13286,13285,1,0,
+        0,0,13287,1331,1,0,0,0,13288,13289,5,2445,0,0,13289,1333,1,0,0,0,
+        13290,13291,5,2445,0,0,13291,1335,1,0,0,0,13292,13293,5,241,0,0,
+        13293,13294,5,1261,0,0,13294,13295,5,2085,0,0,13295,13296,3,2368,
+        1184,0,13296,13297,5,786,0,0,13297,13298,3,2426,1213,0,13298,1337,
+        1,0,0,0,13299,13300,5,241,0,0,13300,13301,5,1261,0,0,13301,13302,
+        5,920,0,0,13302,13303,5,2288,0,0,13303,13304,3,2368,1184,0,13304,
+        13305,5,786,0,0,13305,13306,3,2426,1213,0,13306,1339,1,0,0,0,13307,
+        13308,5,42,0,0,13308,13309,5,45,0,0,13309,13313,5,2288,0,0,13310,
+        13311,3,2312,1156,0,13311,13312,5,2442,0,0,13312,13314,1,0,0,0,13313,
+        13310,1,0,0,0,13313,13314,1,0,0,0,13314,13315,1,0,0,0,13315,13322,
+        3,2430,1215,0,13316,13317,5,1561,0,0,13317,13318,5,2143,0,0,13318,
+        13323,3,2430,1215,0,13319,13323,5,249,0,0,13320,13323,3,1342,671,
+        0,13321,13323,3,1348,674,0,13322,13316,1,0,0,0,13322,13319,1,0,0,
+        0,13322,13320,1,0,0,0,13322,13321,1,0,0,0,13323,1341,1,0,0,0,13324,
+        13325,5,21,0,0,13325,13326,5,166,0,0,13326,13327,5,934,0,0,13327,
+        13328,5,650,0,0,13328,13331,5,2449,0,0,13329,13332,5,38,0,0,13330,
+        13332,3,1346,673,0,13331,13329,1,0,0,0,13331,13330,1,0,0,0,13331,
+        13332,1,0,0,0,13332,13333,1,0,0,0,13333,13334,5,2450,0,0,13334,13335,
+        5,849,0,0,13335,13336,5,2449,0,0,13336,13341,3,1344,672,0,13337,
+        13338,5,2455,0,0,13338,13340,3,1344,672,0,13339,13337,1,0,0,0,13340,
+        13343,1,0,0,0,13341,13339,1,0,0,0,13341,13342,1,0,0,0,13342,13344,
+        1,0,0,0,13343,13341,1,0,0,0,13344,13345,5,2450,0,0,13345,1343,1,
+        0,0,0,13346,13347,3,2430,1215,0,13347,13348,5,2442,0,0,13348,13350,
+        1,0,0,0,13349,13346,1,0,0,0,13349,13350,1,0,0,0,13350,13351,1,0,
+        0,0,13351,13352,3,2430,1215,0,13352,13353,5,2442,0,0,13353,13355,
+        1,0,0,0,13354,13349,1,0,0,0,13354,13355,1,0,0,0,13355,13356,1,0,
+        0,0,13356,13357,3,2430,1215,0,13357,1345,1,0,0,0,13358,13363,3,2430,
+        1215,0,13359,13360,5,2455,0,0,13360,13362,3,2430,1215,0,13361,13359,
+        1,0,0,0,13362,13365,1,0,0,0,13363,13361,1,0,0,0,13363,13364,1,0,
+        0,0,13364,1347,1,0,0,0,13365,13363,1,0,0,0,13366,13367,5,469,0,0,
+        13367,13368,5,166,0,0,13368,13369,5,934,0,0,13369,13370,5,650,0,
+        0,13370,13373,5,2449,0,0,13371,13374,5,38,0,0,13372,13374,3,1346,
+        673,0,13373,13371,1,0,0,0,13373,13372,1,0,0,0,13373,13374,1,0,0,
+        0,13374,13375,1,0,0,0,13375,13376,5,2450,0,0,13376,13377,5,849,0,
+        0,13377,13378,5,2449,0,0,13378,13383,3,1344,672,0,13379,13380,5,
+        2455,0,0,13380,13382,3,1344,672,0,13381,13379,1,0,0,0,13382,13385,
+        1,0,0,0,13383,13381,1,0,0,0,13383,13384,1,0,0,0,13384,13386,1,0,
+        0,0,13385,13383,1,0,0,0,13386,13387,5,2450,0,0,13387,1349,1,0,0,
+        0,13388,13389,5,42,0,0,13389,13390,5,83,0,0,13390,13394,5,422,0,
+        0,13391,13392,3,2312,1156,0,13392,13393,5,2442,0,0,13393,13395,1,
+        0,0,0,13394,13391,1,0,0,0,13394,13395,1,0,0,0,13395,13396,1,0,0,
+        0,13396,13401,3,2430,1215,0,13397,13398,5,1561,0,0,13398,13399,5,
+        2143,0,0,13399,13402,3,2430,1215,0,13400,13402,5,249,0,0,13401,13397,
+        1,0,0,0,13401,13400,1,0,0,0,13402,1351,1,0,0,0,13403,13404,5,42,
+        0,0,13404,13405,5,85,0,0,13405,13406,5,1414,0,0,13406,13408,3,2430,
+        1215,0,13407,13409,5,21,0,0,13408,13407,1,0,0,0,13408,13409,1,0,
+        0,0,13409,13423,1,0,0,0,13410,13412,3,420,210,0,13411,13410,1,0,
+        0,0,13411,13412,1,0,0,0,13412,13414,1,0,0,0,13413,13415,3,422,211,
+        0,13414,13413,1,0,0,0,13414,13415,1,0,0,0,13415,13417,1,0,0,0,13416,
+        13418,3,438,219,0,13417,13416,1,0,0,0,13417,13418,1,0,0,0,13418,
+        13424,1,0,0,0,13419,13420,5,1260,0,0,13420,13422,5,2137,0,0,13421,
+        13419,1,0,0,0,13421,13422,1,0,0,0,13422,13424,1,0,0,0,13423,13411,
+        1,0,0,0,13423,13421,1,0,0,0,13424,13426,1,0,0,0,13425,13427,5,469,
+        0,0,13426,13425,1,0,0,0,13426,13427,1,0,0,0,13427,13441,1,0,0,0,
+        13428,13430,3,420,210,0,13429,13428,1,0,0,0,13429,13430,1,0,0,0,
+        13430,13432,1,0,0,0,13431,13433,3,422,211,0,13432,13431,1,0,0,0,
+        13432,13433,1,0,0,0,13433,13435,1,0,0,0,13434,13436,3,438,219,0,
+        13435,13434,1,0,0,0,13435,13436,1,0,0,0,13436,13442,1,0,0,0,13437,
+        13438,5,1260,0,0,13438,13440,5,2137,0,0,13439,13437,1,0,0,0,13439,
+        13440,1,0,0,0,13440,13442,1,0,0,0,13441,13429,1,0,0,0,13441,13439,
+        1,0,0,0,13442,13451,1,0,0,0,13443,13449,5,266,0,0,13444,13450,5,
+        469,0,0,13445,13446,5,2445,0,0,13446,13447,5,530,0,0,13447,13448,
+        5,1392,0,0,13448,13450,7,57,0,0,13449,13444,1,0,0,0,13449,13445,
+        1,0,0,0,13450,13452,1,0,0,0,13451,13443,1,0,0,0,13451,13452,1,0,
+        0,0,13452,1353,1,0,0,0,13453,13454,5,42,0,0,13454,13455,5,220,0,
+        0,13455,13462,3,478,239,0,13456,13463,3,1206,603,0,13457,13458,5,
+        1701,0,0,13458,13463,3,1188,594,0,13459,13463,3,1296,648,0,13460,
+        13463,3,1298,649,0,13461,13463,3,1376,688,0,13462,13456,1,0,0,0,
+        13462,13457,1,0,0,0,13462,13459,1,0,0,0,13462,13460,1,0,0,0,13462,
+        13461,1,0,0,0,13463,13464,1,0,0,0,13464,13462,1,0,0,0,13464,13465,
+        1,0,0,0,13465,13467,1,0,0,0,13466,13468,3,940,470,0,13467,13466,
+        1,0,0,0,13467,13468,1,0,0,0,13468,1355,1,0,0,0,13469,13470,5,469,
+        0,0,13470,13471,5,45,0,0,13471,13475,5,2288,0,0,13472,13473,3,2312,
+        1156,0,13473,13474,5,2442,0,0,13474,13476,1,0,0,0,13475,13472,1,
+        0,0,0,13475,13476,1,0,0,0,13476,13477,1,0,0,0,13477,13478,3,2430,
+        1215,0,13478,1357,1,0,0,0,13479,13480,5,469,0,0,13480,13481,5,83,
+        0,0,13481,13485,5,422,0,0,13482,13483,3,2312,1156,0,13483,13484,
+        5,2442,0,0,13484,13486,1,0,0,0,13485,13482,1,0,0,0,13485,13486,1,
+        0,0,0,13486,13487,1,0,0,0,13487,13488,3,2430,1215,0,13488,1359,1,
+        0,0,0,13489,13490,5,469,0,0,13490,13491,5,85,0,0,13491,13492,5,1414,
+        0,0,13492,13493,3,2430,1215,0,13493,1361,1,0,0,0,13494,13495,5,469,
+        0,0,13495,13496,5,606,0,0,13496,13497,5,64,0,0,13497,13498,3,2430,
+        1215,0,13498,1363,1,0,0,0,13499,13500,5,469,0,0,13500,13501,5,220,
+        0,0,13501,13508,3,478,239,0,13502,13503,5,706,0,0,13503,13506,5,
+        2083,0,0,13504,13505,5,179,0,0,13505,13507,5,287,0,0,13506,13504,
+        1,0,0,0,13506,13507,1,0,0,0,13507,13509,1,0,0,0,13508,13502,1,0,
+        0,0,13508,13509,1,0,0,0,13509,1365,1,0,0,0,13510,13511,5,469,0,0,
+        13511,13512,5,296,0,0,13512,13513,3,2430,1215,0,13513,1367,1,0,0,
+        0,13514,13515,5,469,0,0,13515,13516,5,426,0,0,13516,13517,3,2430,
+        1215,0,13517,1369,1,0,0,0,13518,13519,5,469,0,0,13519,13520,5,441,
+        0,0,13520,13529,3,2430,1215,0,13521,13523,5,617,0,0,13522,13521,
+        1,0,0,0,13522,13523,1,0,0,0,13523,13524,1,0,0,0,13524,13527,5,706,
+        0,0,13525,13527,5,540,0,0,13526,13522,1,0,0,0,13526,13525,1,0,0,
+        0,13527,13528,1,0,0,0,13528,13530,5,295,0,0,13529,13526,1,0,0,0,
+        13529,13530,1,0,0,0,13530,1371,1,0,0,0,13531,13532,5,469,0,0,13532,
+        13533,5,483,0,0,13533,13535,3,2430,1215,0,13534,13536,5,179,0,0,
+        13535,13534,1,0,0,0,13535,13536,1,0,0,0,13536,1373,1,0,0,0,13537,
+        13538,5,2161,0,0,13538,13539,5,220,0,0,13539,13542,3,478,239,0,13540,
+        13541,7,169,0,0,13541,13543,5,1764,0,0,13542,13540,1,0,0,0,13542,
+        13543,1,0,0,0,13543,1375,1,0,0,0,13544,13545,7,109,0,0,13545,1377,
+        1,0,0,0,13546,13547,3,2430,1215,0,13547,1379,1,0,0,0,13548,13549,
+        5,42,0,0,13549,13565,3,1382,691,0,13550,13566,3,1384,692,0,13551,
+        13566,3,1390,695,0,13552,13566,3,1406,703,0,13553,13566,3,1416,708,
+        0,13554,13566,3,1434,717,0,13555,13566,3,1438,719,0,13556,13566,
+        3,1454,727,0,13557,13566,3,1458,729,0,13558,13566,3,1460,730,0,13559,
+        13566,3,1472,736,0,13560,13566,3,1474,737,0,13561,13566,3,1476,738,
+        0,13562,13566,3,1478,739,0,13563,13566,3,1484,742,0,13564,13566,
+        3,1486,743,0,13565,13550,1,0,0,0,13565,13551,1,0,0,0,13565,13552,
+        1,0,0,0,13565,13553,1,0,0,0,13565,13554,1,0,0,0,13565,13555,1,0,
+        0,0,13565,13556,1,0,0,0,13565,13557,1,0,0,0,13565,13558,1,0,0,0,
+        13565,13559,1,0,0,0,13565,13560,1,0,0,0,13565,13561,1,0,0,0,13565,
+        13562,1,0,0,0,13565,13563,1,0,0,0,13565,13564,1,0,0,0,13566,1381,
+        1,0,0,0,13567,13569,5,1411,0,0,13568,13567,1,0,0,0,13568,13569,1,
+        0,0,0,13569,13570,1,0,0,0,13570,13572,5,350,0,0,13571,13573,3,1378,
+        689,0,13572,13571,1,0,0,0,13572,13573,1,0,0,0,13573,1383,1,0,0,0,
+        13574,13577,5,989,0,0,13575,13576,7,170,0,0,13576,13578,5,350,0,
+        0,13577,13575,1,0,0,0,13577,13578,1,0,0,0,13578,13594,1,0,0,0,13579,
+        13582,5,1266,0,0,13580,13581,5,1507,0,0,13581,13583,5,2315,0,0,13582,
+        13580,1,0,0,0,13582,13583,1,0,0,0,13583,13585,1,0,0,0,13584,13586,
+        3,1386,693,0,13585,13584,1,0,0,0,13585,13586,1,0,0,0,13586,13588,
+        1,0,0,0,13587,13589,3,1388,694,0,13588,13587,1,0,0,0,13588,13589,
+        1,0,0,0,13589,13594,1,0,0,0,13590,13591,5,1266,0,0,13591,13592,5,
+        1507,0,0,13592,13594,5,1260,0,0,13593,13574,1,0,0,0,13593,13579,
+        1,0,0,0,13593,13590,1,0,0,0,13594,1385,1,0,0,0,13595,13596,7,63,
+        0,0,13596,1387,1,0,0,0,13597,13598,7,171,0,0,13598,1389,1,0,0,0,
+        13599,13605,3,1394,697,0,13600,13605,3,1402,701,0,13601,13602,3,
+        1392,696,0,13602,13603,5,102,0,0,13603,13605,1,0,0,0,13604,13599,
+        1,0,0,0,13604,13600,1,0,0,0,13604,13601,1,0,0,0,13605,1391,1,0,0,
+        0,13606,13607,7,172,0,0,13607,1393,1,0,0,0,13608,13610,5,1518,0,
+        0,13609,13611,5,95,0,0,13610,13609,1,0,0,0,13610,13611,1,0,0,0,13611,
+        13614,1,0,0,0,13612,13613,5,629,0,0,13613,13615,5,2445,0,0,13614,
+        13612,1,0,0,0,13614,13615,1,0,0,0,13615,13638,1,0,0,0,13616,13621,
+        3,1396,698,0,13617,13621,3,1398,699,0,13618,13619,5,883,0,0,13619,
+        13621,5,2445,0,0,13620,13616,1,0,0,0,13620,13617,1,0,0,0,13620,13618,
+        1,0,0,0,13620,13621,1,0,0,0,13621,13631,1,0,0,0,13622,13628,5,2097,
+        0,0,13623,13624,5,40,0,0,13624,13625,5,2443,0,0,13625,13628,5,306,
+        0,0,13626,13628,3,940,470,0,13627,13622,1,0,0,0,13627,13623,1,0,
+        0,0,13627,13626,1,0,0,0,13628,13629,1,0,0,0,13629,13627,1,0,0,0,
+        13629,13630,1,0,0,0,13630,13632,1,0,0,0,13631,13627,1,0,0,0,13631,
+        13632,1,0,0,0,13632,13639,1,0,0,0,13633,13635,5,297,0,0,13634,13636,
+        5,389,0,0,13635,13634,1,0,0,0,13635,13636,1,0,0,0,13636,13639,1,
+        0,0,0,13637,13639,5,174,0,0,13638,13620,1,0,0,0,13638,13633,1,0,
+        0,0,13638,13637,1,0,0,0,13639,1395,1,0,0,0,13640,13642,5,1736,0,
+        0,13641,13640,1,0,0,0,13641,13642,1,0,0,0,13642,13643,1,0,0,0,13643,
+        13663,5,350,0,0,13644,13651,5,2204,0,0,13645,13652,5,174,0,0,13646,
+        13647,5,2114,0,0,13647,13652,5,2445,0,0,13648,13649,5,190,0,0,13649,
+        13652,5,2443,0,0,13650,13652,5,283,0,0,13651,13645,1,0,0,0,13651,
+        13646,1,0,0,0,13651,13648,1,0,0,0,13651,13650,1,0,0,0,13652,13660,
+        1,0,0,0,13653,13654,5,2248,0,0,13654,13655,5,102,0,0,13655,13660,
+        5,298,0,0,13656,13657,5,1709,0,0,13657,13658,5,2114,0,0,13658,13660,
+        5,2445,0,0,13659,13644,1,0,0,0,13659,13653,1,0,0,0,13659,13656,1,
+        0,0,0,13660,13661,1,0,0,0,13661,13659,1,0,0,0,13661,13662,1,0,0,
+        0,13662,13664,1,0,0,0,13663,13659,1,0,0,0,13663,13664,1,0,0,0,13664,
+        1397,1,0,0,0,13665,13666,5,2082,0,0,13666,13671,3,1676,838,0,13667,
+        13668,5,2455,0,0,13668,13670,3,1676,838,0,13669,13667,1,0,0,0,13670,
+        13673,1,0,0,0,13671,13669,1,0,0,0,13671,13672,1,0,0,0,13672,13687,
+        1,0,0,0,13673,13671,1,0,0,0,13674,13675,5,352,0,0,13675,13687,5,
+        2445,0,0,13676,13682,3,1468,734,0,13677,13678,5,2455,0,0,13678,13681,
+        5,2445,0,0,13679,13681,3,1468,734,0,13680,13677,1,0,0,0,13680,13679,
+        1,0,0,0,13681,13684,1,0,0,0,13682,13680,1,0,0,0,13682,13683,1,0,
+        0,0,13683,13687,1,0,0,0,13684,13682,1,0,0,0,13685,13687,3,1400,700,
+        0,13686,13665,1,0,0,0,13686,13674,1,0,0,0,13686,13676,1,0,0,0,13686,
+        13685,1,0,0,0,13687,1399,1,0,0,0,13688,13689,4,700,11,0,13689,13710,
+        5,1736,0,0,13690,13691,5,2082,0,0,13691,13696,3,1676,838,0,13692,
+        13693,5,2455,0,0,13693,13695,3,1676,838,0,13694,13692,1,0,0,0,13695,
+        13698,1,0,0,0,13696,13694,1,0,0,0,13696,13697,1,0,0,0,13697,13711,
+        1,0,0,0,13698,13696,1,0,0,0,13699,13700,5,352,0,0,13700,13711,5,
+        2445,0,0,13701,13707,3,1468,734,0,13702,13703,5,2455,0,0,13703,13706,
+        5,2445,0,0,13704,13706,3,1468,734,0,13705,13702,1,0,0,0,13705,13704,
+        1,0,0,0,13706,13709,1,0,0,0,13707,13705,1,0,0,0,13707,13708,1,0,
+        0,0,13708,13711,1,0,0,0,13709,13707,1,0,0,0,13710,13690,1,0,0,0,
+        13710,13699,1,0,0,0,13710,13701,1,0,0,0,13711,13712,1,0,0,0,13712,
+        13715,5,2204,0,0,13713,13714,5,283,0,0,13714,13716,5,2310,0,0,13715,
+        13713,1,0,0,0,13715,13716,1,0,0,0,13716,13717,1,0,0,0,13717,13718,
+        5,298,0,0,13718,1401,1,0,0,0,13719,13754,5,1518,0,0,13720,13721,
+        5,905,0,0,13721,13722,5,1736,0,0,13722,13744,5,350,0,0,13723,13724,
+        5,2248,0,0,13724,13725,5,336,0,0,13725,13739,5,883,0,0,13726,13729,
+        5,439,0,0,13727,13728,5,629,0,0,13728,13730,5,1669,0,0,13729,13727,
+        1,0,0,0,13729,13730,1,0,0,0,13730,13739,1,0,0,0,13731,13739,5,1088,
+        0,0,13732,13733,5,2204,0,0,13733,13734,5,190,0,0,13734,13739,5,2443,
+        0,0,13735,13736,5,2204,0,0,13736,13739,5,283,0,0,13737,13739,3,940,
+        470,0,13738,13723,1,0,0,0,13738,13726,1,0,0,0,13738,13731,1,0,0,
+        0,13738,13732,1,0,0,0,13738,13735,1,0,0,0,13738,13737,1,0,0,0,13739,
+        13740,1,0,0,0,13740,13738,1,0,0,0,13740,13741,1,0,0,0,13741,13745,
+        1,0,0,0,13742,13745,5,598,0,0,13743,13745,5,174,0,0,13744,13738,
+        1,0,0,0,13744,13742,1,0,0,0,13744,13743,1,0,0,0,13744,13745,1,0,
+        0,0,13745,13755,1,0,0,0,13746,13747,5,2143,0,0,13747,13748,5,886,
+        0,0,13748,13752,5,1736,0,0,13749,13753,3,1404,702,0,13750,13751,
+        5,815,0,0,13751,13753,5,688,0,0,13752,13749,1,0,0,0,13752,13750,
+        1,0,0,0,13753,13755,1,0,0,0,13754,13720,1,0,0,0,13754,13746,1,0,
+        0,0,13755,1403,1,0,0,0,13756,13757,3,2436,1218,0,13757,1405,1,0,
+        0,0,13758,13759,5,1561,0,0,13759,13760,5,590,0,0,13760,13765,3,1470,
+        735,0,13761,13762,5,2455,0,0,13762,13764,3,1470,735,0,13763,13761,
+        1,0,0,0,13764,13767,1,0,0,0,13765,13763,1,0,0,0,13765,13766,1,0,
+        0,0,13766,13768,1,0,0,0,13767,13765,1,0,0,0,13768,13769,5,2143,0,
+        0,13769,13770,3,1470,735,0,13770,13776,1,0,0,0,13771,13776,3,1408,
+        704,0,13772,13776,3,1410,705,0,13773,13776,3,1412,706,0,13774,13776,
+        3,1414,707,0,13775,13758,1,0,0,0,13775,13771,1,0,0,0,13775,13772,
+        1,0,0,0,13775,13773,1,0,0,0,13775,13774,1,0,0,0,13776,1407,1,0,0,
+        0,13777,13778,5,321,0,0,13778,13781,5,352,0,0,13779,13782,3,1470,
+        735,0,13780,13782,3,1468,734,0,13781,13779,1,0,0,0,13781,13780,1,
+        0,0,0,13782,13790,1,0,0,0,13783,13786,5,2455,0,0,13784,13787,3,1470,
+        735,0,13785,13787,3,1468,734,0,13786,13784,1,0,0,0,13786,13785,1,
+        0,0,0,13787,13789,1,0,0,0,13788,13783,1,0,0,0,13789,13792,1,0,0,
+        0,13790,13788,1,0,0,0,13790,13791,1,0,0,0,13791,13795,1,0,0,0,13792,
+        13790,1,0,0,0,13793,13794,5,69,0,0,13794,13796,5,1022,0,0,13795,
+        13793,1,0,0,0,13795,13796,1,0,0,0,13796,1409,1,0,0,0,13797,13800,
+        5,352,0,0,13798,13801,3,1470,735,0,13799,13801,3,1468,734,0,13800,
+        13798,1,0,0,0,13800,13799,1,0,0,0,13801,13809,1,0,0,0,13802,13805,
+        5,2455,0,0,13803,13806,3,1470,735,0,13804,13806,3,1468,734,0,13805,
+        13803,1,0,0,0,13805,13804,1,0,0,0,13806,13808,1,0,0,0,13807,13802,
+        1,0,0,0,13808,13811,1,0,0,0,13809,13807,1,0,0,0,13809,13810,1,0,
+        0,0,13810,13823,1,0,0,0,13811,13809,1,0,0,0,13812,13824,5,1258,0,
+        0,13813,13816,5,1245,0,0,13814,13815,5,621,0,0,13815,13817,5,469,
+        0,0,13816,13814,1,0,0,0,13816,13817,1,0,0,0,13817,13824,1,0,0,0,
+        13818,13819,5,1569,0,0,13819,13824,3,1188,594,0,13820,13824,3,934,
+        467,0,13821,13822,5,508,0,0,13822,13824,5,102,0,0,13823,13812,1,
+        0,0,0,13823,13813,1,0,0,0,13823,13818,1,0,0,0,13823,13820,1,0,0,
+        0,13823,13821,1,0,0,0,13824,1411,1,0,0,0,13825,13828,5,2091,0,0,
+        13826,13829,3,1470,735,0,13827,13829,3,1468,734,0,13828,13826,1,
+        0,0,0,13828,13827,1,0,0,0,13829,13837,1,0,0,0,13830,13833,5,2455,
+        0,0,13831,13834,3,1470,735,0,13832,13834,3,1468,734,0,13833,13831,
+        1,0,0,0,13833,13832,1,0,0,0,13834,13836,1,0,0,0,13835,13830,1,0,
+        0,0,13836,13839,1,0,0,0,13837,13835,1,0,0,0,13837,13838,1,0,0,0,
+        13838,13848,1,0,0,0,13839,13837,1,0,0,0,13840,13841,5,1569,0,0,13841,
+        13849,3,1188,594,0,13842,13849,3,934,467,0,13843,13844,5,469,0,0,
+        13844,13845,5,706,0,0,13845,13849,5,353,0,0,13846,13849,5,1258,0,
+        0,13847,13849,5,1245,0,0,13848,13840,1,0,0,0,13848,13842,1,0,0,0,
+        13848,13843,1,0,0,0,13848,13846,1,0,0,0,13848,13847,1,0,0,0,13849,
+        1413,1,0,0,0,13850,13851,5,993,0,0,13851,13854,5,352,0,0,13852,13855,
+        3,1470,735,0,13853,13855,3,1468,734,0,13854,13852,1,0,0,0,13854,
+        13853,1,0,0,0,13855,13863,1,0,0,0,13856,13859,5,2455,0,0,13857,13860,
+        3,1470,735,0,13858,13860,3,1468,734,0,13859,13857,1,0,0,0,13859,
+        13858,1,0,0,0,13860,13862,1,0,0,0,13861,13856,1,0,0,0,13862,13865,
+        1,0,0,0,13863,13861,1,0,0,0,13863,13864,1,0,0,0,13864,13868,1,0,
+        0,0,13865,13863,1,0,0,0,13866,13867,5,2143,0,0,13867,13869,3,1470,
+        735,0,13868,13866,1,0,0,0,13868,13869,1,0,0,0,13869,13871,1,0,0,
+        0,13870,13872,5,1589,0,0,13871,13870,1,0,0,0,13871,13872,1,0,0,0,
+        13872,13874,1,0,0,0,13873,13875,5,815,0,0,13874,13873,1,0,0,0,13874,
+        13875,1,0,0,0,13875,1415,1,0,0,0,13876,13878,5,66,0,0,13877,13879,
+        5,910,0,0,13878,13877,1,0,0,0,13878,13879,1,0,0,0,13879,13882,1,
+        0,0,0,13880,13882,5,1059,0,0,13881,13876,1,0,0,0,13881,13880,1,0,
+        0,0,13882,13933,1,0,0,0,13883,13885,5,1139,0,0,13884,13883,1,0,0,
+        0,13884,13885,1,0,0,0,13885,13886,1,0,0,0,13886,13887,5,617,0,0,
+        13887,13933,5,885,0,0,13888,13889,5,1673,0,0,13889,13890,5,1736,
+        0,0,13890,13891,5,1120,0,0,13891,13896,5,621,0,0,13892,13893,5,351,
+        0,0,13893,13897,5,98,0,0,13894,13895,5,868,0,0,13895,13897,5,1387,
+        0,0,13896,13892,1,0,0,0,13896,13894,1,0,0,0,13897,13933,1,0,0,0,
+        13898,13899,5,1561,0,0,13899,13900,5,590,0,0,13900,13905,3,1470,
+        735,0,13901,13902,5,2455,0,0,13902,13904,3,1470,735,0,13903,13901,
+        1,0,0,0,13904,13907,1,0,0,0,13905,13903,1,0,0,0,13905,13906,1,0,
+        0,0,13906,13908,1,0,0,0,13907,13905,1,0,0,0,13908,13909,5,2143,0,
+        0,13909,13910,3,1470,735,0,13910,13933,1,0,0,0,13911,13913,5,212,
+        0,0,13912,13914,5,2175,0,0,13913,13912,1,0,0,0,13913,13914,1,0,0,
+        0,13914,13915,1,0,0,0,13915,13916,5,883,0,0,13916,13921,3,1432,716,
+        0,13917,13918,5,2455,0,0,13918,13920,3,1432,716,0,13919,13917,1,
+        0,0,0,13920,13923,1,0,0,0,13921,13919,1,0,0,0,13921,13922,1,0,0,
+        0,13922,13926,1,0,0,0,13923,13921,1,0,0,0,13924,13925,5,2200,0,0,
+        13925,13927,5,352,0,0,13926,13924,1,0,0,0,13926,13927,1,0,0,0,13927,
+        13933,1,0,0,0,13928,13933,3,1418,709,0,13929,13933,3,1422,711,0,
+        13930,13933,3,1424,712,0,13931,13933,3,1426,713,0,13932,13881,1,
+        0,0,0,13932,13884,1,0,0,0,13932,13888,1,0,0,0,13932,13898,1,0,0,
+        0,13932,13911,1,0,0,0,13932,13928,1,0,0,0,13932,13929,1,0,0,0,13932,
+        13930,1,0,0,0,13932,13931,1,0,0,0,13933,1417,1,0,0,0,13934,13936,
+        5,21,0,0,13935,13937,5,1736,0,0,13936,13935,1,0,0,0,13936,13937,
+        1,0,0,0,13937,13938,1,0,0,0,13938,13974,5,883,0,0,13939,13940,5,
+        760,0,0,13940,13944,5,2445,0,0,13941,13942,5,2104,0,0,13942,13944,
+        5,2443,0,0,13943,13939,1,0,0,0,13943,13941,1,0,0,0,13943,13944,1,
+        0,0,0,13944,13946,1,0,0,0,13945,13947,3,1420,710,0,13946,13945,1,
+        0,0,0,13947,13948,1,0,0,0,13948,13946,1,0,0,0,13948,13949,1,0,0,
+        0,13949,13975,1,0,0,0,13950,13951,5,937,0,0,13951,13953,3,1470,735,
+        0,13952,13954,5,1589,0,0,13953,13952,1,0,0,0,13953,13954,1,0,0,0,
+        13954,13962,1,0,0,0,13955,13956,5,2455,0,0,13956,13958,3,1470,735,
+        0,13957,13959,5,1589,0,0,13958,13957,1,0,0,0,13958,13959,1,0,0,0,
+        13959,13961,1,0,0,0,13960,13955,1,0,0,0,13961,13964,1,0,0,0,13962,
+        13960,1,0,0,0,13962,13963,1,0,0,0,13963,13965,1,0,0,0,13964,13962,
+        1,0,0,0,13965,13966,5,2143,0,0,13966,13971,3,1432,716,0,13967,13968,
+        5,2455,0,0,13968,13970,3,1432,716,0,13969,13967,1,0,0,0,13970,13973,
+        1,0,0,0,13971,13969,1,0,0,0,13971,13972,1,0,0,0,13972,13975,1,0,
+        0,0,13973,13971,1,0,0,0,13974,13943,1,0,0,0,13974,13950,1,0,0,0,
+        13975,1419,1,0,0,0,13976,13977,5,650,0,0,13977,13979,5,2443,0,0,
+        13978,13976,1,0,0,0,13978,13979,1,0,0,0,13979,13980,1,0,0,0,13980,
+        13981,3,932,466,0,13981,1421,1,0,0,0,13982,13984,5,469,0,0,13983,
+        13985,5,1736,0,0,13984,13983,1,0,0,0,13984,13985,1,0,0,0,13985,13986,
+        1,0,0,0,13986,14004,5,883,0,0,13987,13992,3,1432,716,0,13988,13989,
+        5,2455,0,0,13989,13991,3,1432,716,0,13990,13988,1,0,0,0,13991,13994,
+        1,0,0,0,13992,13990,1,0,0,0,13992,13993,1,0,0,0,13993,14005,1,0,
+        0,0,13994,13992,1,0,0,0,13995,13996,5,937,0,0,13996,14001,3,1470,
+        735,0,13997,13998,5,2455,0,0,13998,14000,3,1470,735,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,14005,1,0,0,0,14003,14001,1,0,0,0,14004,13987,1,0,0,0,
+        14004,13995,1,0,0,0,14005,1423,1,0,0,0,14006,14007,5,1795,0,0,14007,
+        14008,5,38,0,0,14008,14009,5,884,0,0,14009,14010,5,2143,0,0,14010,
+        14011,5,146,0,0,14011,14012,5,2443,0,0,14012,1425,1,0,0,0,14013,
+        14014,3,1428,714,0,14014,14015,5,1791,0,0,14015,14019,5,889,0,0,
+        14016,14020,5,351,0,0,14017,14020,3,1294,647,0,14018,14020,3,1430,
+        715,0,14019,14016,1,0,0,0,14019,14017,1,0,0,0,14019,14018,1,0,0,
+        0,14020,1427,1,0,0,0,14021,14022,7,9,0,0,14022,1429,1,0,0,0,14023,
+        14024,5,351,0,0,14024,14025,5,621,0,0,14025,14026,5,1462,0,0,14026,
+        14027,5,1565,0,0,14027,1431,1,0,0,0,14028,14029,5,650,0,0,14029,
+        14043,5,2443,0,0,14030,14031,5,2449,0,0,14031,14036,3,1470,735,0,
+        14032,14033,5,2455,0,0,14033,14035,3,1470,735,0,14034,14032,1,0,
+        0,0,14035,14038,1,0,0,0,14036,14034,1,0,0,0,14036,14037,1,0,0,0,
+        14037,14039,1,0,0,0,14038,14036,1,0,0,0,14039,14040,5,2450,0,0,14040,
+        14043,1,0,0,0,14041,14043,3,1470,735,0,14042,14028,1,0,0,0,14042,
+        14030,1,0,0,0,14042,14041,1,0,0,0,14043,1433,1,0,0,0,14044,14046,
+        5,321,0,0,14045,14047,7,173,0,0,14046,14045,1,0,0,0,14046,14047,
+        1,0,0,0,14047,14048,1,0,0,0,14048,14049,5,1736,0,0,14049,14050,5,
+        298,0,0,14050,14051,5,69,0,0,14051,14053,3,1470,735,0,14052,14054,
+        5,1589,0,0,14053,14052,1,0,0,0,14053,14054,1,0,0,0,14054,14066,1,
+        0,0,0,14055,14056,5,102,0,0,14056,14057,5,298,0,0,14057,14063,5,
+        2143,0,0,14058,14060,3,1470,735,0,14059,14061,5,1589,0,0,14060,14059,
+        1,0,0,0,14060,14061,1,0,0,0,14061,14064,1,0,0,0,14062,14064,3,1436,
+        718,0,14063,14058,1,0,0,0,14063,14062,1,0,0,0,14064,14066,1,0,0,
+        0,14065,14044,1,0,0,0,14065,14055,1,0,0,0,14066,1435,1,0,0,0,14067,
+        14073,5,2145,0,0,14068,14069,5,69,0,0,14069,14071,3,1470,735,0,14070,
+        14072,5,1589,0,0,14071,14070,1,0,0,0,14071,14072,1,0,0,0,14072,14074,
+        1,0,0,0,14073,14068,1,0,0,0,14073,14074,1,0,0,0,14074,14076,1,0,
+        0,0,14075,14077,7,63,0,0,14076,14075,1,0,0,0,14076,14077,1,0,0,0,
+        14077,1437,1,0,0,0,14078,14086,3,1440,720,0,14079,14086,3,1442,721,
+        0,14080,14086,3,1444,722,0,14081,14086,3,1446,723,0,14082,14086,
+        3,1448,724,0,14083,14086,3,1450,725,0,14084,14086,3,1452,726,0,14085,
+        14078,1,0,0,0,14085,14079,1,0,0,0,14085,14080,1,0,0,0,14085,14081,
+        1,0,0,0,14085,14082,1,0,0,0,14085,14083,1,0,0,0,14085,14084,1,0,
+        0,0,14086,14088,1,0,0,0,14087,14089,3,940,470,0,14088,14087,1,0,
+        0,0,14088,14089,1,0,0,0,14089,1439,1,0,0,0,14090,14092,5,13,0,0,
+        14091,14093,7,173,0,0,14092,14091,1,0,0,0,14092,14093,1,0,0,0,14093,
+        14094,1,0,0,0,14094,14095,5,1736,0,0,14095,14098,5,350,0,0,14096,
+        14097,5,598,0,0,14097,14099,5,61,0,0,14098,14096,1,0,0,0,14098,14099,
+        1,0,0,0,14099,1441,1,0,0,0,14100,14101,5,1673,0,0,14101,14102,5,
+        1736,0,0,14102,14103,5,350,0,0,14103,14104,5,2143,0,0,14104,14105,
+        5,925,0,0,14105,14106,7,174,0,0,14106,1443,1,0,0,0,14107,14110,5,
+        1540,0,0,14108,14109,5,1309,0,0,14109,14111,5,1564,0,0,14110,14108,
+        1,0,0,0,14110,14111,1,0,0,0,14111,14112,1,0,0,0,14112,14113,7,173,
+        0,0,14113,14114,5,883,0,0,14114,1445,1,0,0,0,14115,14116,7,175,0,
+        0,14116,14117,5,2143,0,0,14117,14146,5,1794,0,0,14118,14139,5,2143,
+        0,0,14119,14121,7,173,0,0,14120,14119,1,0,0,0,14120,14121,1,0,0,
+        0,14121,14122,1,0,0,0,14122,14128,5,1453,0,0,14123,14125,5,1394,
+        0,0,14124,14123,1,0,0,0,14124,14125,1,0,0,0,14125,14126,1,0,0,0,
+        14126,14128,5,1736,0,0,14127,14120,1,0,0,0,14127,14124,1,0,0,0,14128,
+        14135,1,0,0,0,14129,14131,7,2,0,0,14130,14129,1,0,0,0,14130,14131,
+        1,0,0,0,14131,14132,1,0,0,0,14132,14133,5,1669,0,0,14133,14134,5,
+        1687,0,0,14134,14136,7,0,0,0,14135,14130,1,0,0,0,14135,14136,1,0,
+        0,0,14136,14140,1,0,0,0,14137,14138,5,886,0,0,14138,14140,5,1736,
+        0,0,14139,14127,1,0,0,0,14139,14137,1,0,0,0,14140,14144,1,0,0,0,
+        14141,14142,5,886,0,0,14142,14144,5,1736,0,0,14143,14118,1,0,0,0,
+        14143,14141,1,0,0,0,14144,14147,1,0,0,0,14145,14147,5,174,0,0,14146,
+        14143,1,0,0,0,14146,14145,1,0,0,0,14146,14147,1,0,0,0,14147,1447,
+        1,0,0,0,14148,14149,5,1739,0,0,14149,14150,5,886,0,0,14150,14151,
+        5,1736,0,0,14151,14153,5,61,0,0,14152,14154,5,699,0,0,14153,14152,
+        1,0,0,0,14153,14154,1,0,0,0,14154,14156,1,0,0,0,14155,14157,5,1088,
+        0,0,14156,14155,1,0,0,0,14156,14157,1,0,0,0,14157,14169,1,0,0,0,
+        14158,14159,5,1022,0,0,14159,14160,5,1453,0,0,14160,14170,3,2436,
+        1218,0,14161,14163,5,741,0,0,14162,14164,5,2443,0,0,14163,14162,
+        1,0,0,0,14163,14164,1,0,0,0,14164,14170,1,0,0,0,14165,14166,5,1704,
+        0,0,14166,14167,5,571,0,0,14167,14170,5,2149,0,0,14168,14170,5,598,
+        0,0,14169,14158,1,0,0,0,14169,14161,1,0,0,0,14169,14165,1,0,0,0,
+        14169,14168,1,0,0,0,14169,14170,1,0,0,0,14170,1449,1,0,0,0,14171,
+        14172,7,176,0,0,14172,14173,5,886,0,0,14173,14174,5,1736,0,0,14174,
+        14175,5,61,0,0,14175,1451,1,0,0,0,14176,14177,5,300,0,0,14177,14178,
+        5,2143,0,0,14178,14179,7,177,0,0,14179,14180,5,1736,0,0,14180,1453,
+        1,0,0,0,14181,14182,5,389,0,0,14182,14183,5,483,0,0,14183,14184,
+        5,2474,0,0,14184,14228,3,1466,733,0,14185,14186,5,1673,0,0,14186,
+        14187,5,389,0,0,14187,14188,7,101,0,0,14188,14228,5,2082,0,0,14189,
+        14190,5,389,0,0,14190,14191,5,2082,0,0,14191,14228,3,1676,838,0,
+        14192,14193,5,389,0,0,14193,14194,5,2094,0,0,14194,14197,5,2082,
+        0,0,14195,14198,3,1676,838,0,14196,14198,3,884,442,0,14197,14195,
+        1,0,0,0,14197,14196,1,0,0,0,14198,14228,1,0,0,0,14199,14200,5,1561,
+        0,0,14200,14201,5,645,0,0,14201,14202,5,2143,0,0,14202,14205,3,1464,
+        732,0,14203,14204,5,2442,0,0,14204,14206,3,1462,731,0,14205,14203,
+        1,0,0,0,14206,14207,1,0,0,0,14207,14205,1,0,0,0,14207,14208,1,0,
+        0,0,14208,14228,1,0,0,0,14209,14210,5,499,0,0,14210,14211,5,143,
+        0,0,14211,14212,5,190,0,0,14212,14219,5,2147,0,0,14213,14214,5,2248,
+        0,0,14214,14215,5,590,0,0,14215,14217,3,1470,735,0,14216,14218,5,
+        1589,0,0,14217,14216,1,0,0,0,14217,14218,1,0,0,0,14218,14220,1,0,
+        0,0,14219,14213,1,0,0,0,14219,14220,1,0,0,0,14220,14228,1,0,0,0,
+        14221,14222,5,429,0,0,14222,14223,5,143,0,0,14223,14224,5,190,0,
+        0,14224,14228,5,2147,0,0,14225,14228,3,888,444,0,14226,14228,3,1456,
+        728,0,14227,14181,1,0,0,0,14227,14185,1,0,0,0,14227,14189,1,0,0,
+        0,14227,14192,1,0,0,0,14227,14199,1,0,0,0,14227,14209,1,0,0,0,14227,
+        14221,1,0,0,0,14227,14225,1,0,0,0,14227,14226,1,0,0,0,14228,1455,
+        1,0,0,0,14229,14230,5,1673,0,0,14230,14231,5,2121,0,0,14231,14232,
+        5,2474,0,0,14232,14233,5,2445,0,0,14233,1457,1,0,0,0,14234,14235,
+        3,1320,660,0,14235,14236,5,760,0,0,14236,14237,5,2445,0,0,14237,
+        1459,1,0,0,0,14238,14239,5,657,0,0,14239,14240,7,178,0,0,14240,1461,
+        1,0,0,0,14241,14242,3,2430,1215,0,14242,1463,1,0,0,0,14243,14244,
+        3,2430,1215,0,14244,1465,1,0,0,0,14245,14246,3,2436,1218,0,14246,
+        1467,1,0,0,0,14247,14248,5,2443,0,0,14248,1469,1,0,0,0,14249,14250,
+        5,2445,0,0,14250,1471,1,0,0,0,14251,14252,5,1443,0,0,14252,14253,
+        5,964,0,0,14253,14254,5,303,0,0,14254,14258,3,2430,1215,0,14255,
+        14256,5,2310,0,0,14256,14257,7,179,0,0,14257,14259,5,1526,0,0,14258,
+        14255,1,0,0,0,14258,14259,1,0,0,0,14259,14263,1,0,0,0,14260,14261,
+        5,621,0,0,14261,14262,5,350,0,0,14262,14264,3,2430,1215,0,14263,
+        14260,1,0,0,0,14263,14264,1,0,0,0,14264,1473,1,0,0,0,14265,14266,
+        5,469,0,0,14266,14267,5,964,0,0,14267,14268,5,303,0,0,14268,14269,
+        3,2430,1215,0,14269,1475,1,0,0,0,14270,14271,7,180,0,0,14271,14272,
+        5,896,0,0,14272,14273,5,2315,0,0,14273,14274,5,1471,0,0,14274,1477,
+        1,0,0,0,14275,14278,3,1480,740,0,14276,14278,3,1482,741,0,14277,
+        14275,1,0,0,0,14277,14276,1,0,0,0,14278,1479,1,0,0,0,14279,14280,
+        5,1673,0,0,14280,14281,5,837,0,0,14281,14282,5,2474,0,0,14282,14283,
+        7,181,0,0,14283,1481,1,0,0,0,14284,14285,5,1673,0,0,14285,14286,
+        5,838,0,0,14286,14287,5,2474,0,0,14287,14288,5,2445,0,0,14288,1483,
+        1,0,0,0,14289,14290,5,1469,0,0,14290,14291,7,182,0,0,14291,14292,
+        5,393,0,0,14292,14293,5,2474,0,0,14293,14294,3,2430,1215,0,14294,
+        1485,1,0,0,0,14295,14296,5,2213,0,0,14296,14297,5,1797,0,0,14297,
+        14298,7,100,0,0,14298,1487,1,0,0,0,14299,14301,5,42,0,0,14300,14302,
+        5,1681,0,0,14301,14300,1,0,0,0,14301,14302,1,0,0,0,14302,14304,1,
+        0,0,0,14303,14305,5,1475,0,0,14304,14303,1,0,0,0,14304,14305,1,0,
+        0,0,14305,14306,1,0,0,0,14306,14307,5,350,0,0,14307,14308,5,862,
+        0,0,14308,14319,3,2362,1181,0,14309,14310,5,280,0,0,14310,14311,
+        5,2143,0,0,14311,14312,3,2380,1190,0,14312,14313,5,686,0,0,14313,
+        14314,5,160,0,0,14314,14316,3,1490,745,0,14315,14317,3,1492,746,
+        0,14316,14315,1,0,0,0,14316,14317,1,0,0,0,14317,14320,1,0,0,0,14318,
+        14320,3,1492,746,0,14319,14309,1,0,0,0,14319,14318,1,0,0,0,14320,
+        1489,1,0,0,0,14321,14326,3,2430,1215,0,14322,14326,3,2422,1211,0,
+        14323,14324,5,2259,0,0,14324,14326,5,2445,0,0,14325,14321,1,0,0,
+        0,14325,14322,1,0,0,0,14325,14323,1,0,0,0,14326,1491,1,0,0,0,14327,
+        14328,5,86,0,0,14328,14329,5,160,0,0,14329,14330,3,2380,1190,0,14330,
+        14331,5,686,0,0,14331,14332,5,160,0,0,14332,14333,3,1490,745,0,14333,
+        1493,1,0,0,0,14334,14335,5,321,0,0,14335,14336,5,1627,0,0,14336,
+        14337,5,89,0,0,14337,14343,3,2312,1156,0,14338,14342,3,1050,525,
+        0,14339,14342,3,848,424,0,14340,14342,3,776,388,0,14341,14338,1,
+        0,0,0,14341,14339,1,0,0,0,14341,14340,1,0,0,0,14342,14345,1,0,0,
+        0,14343,14341,1,0,0,0,14343,14344,1,0,0,0,14344,1495,1,0,0,0,14345,
+        14343,1,0,0,0,14346,14347,5,321,0,0,14347,14348,5,350,0,0,14348,
+        14387,3,1378,689,0,14349,14350,5,2239,0,0,14350,14351,7,183,0,0,
+        14351,14352,5,686,0,0,14352,14353,5,160,0,0,14353,14388,3,1490,745,
+        0,14354,14355,5,298,0,0,14355,14388,5,1589,0,0,14356,14357,7,184,
+        0,0,14357,14388,5,2443,0,0,14358,14360,5,1002,0,0,14359,14358,1,
+        0,0,0,14359,14360,1,0,0,0,14360,14361,1,0,0,0,14361,14362,5,193,
+        0,0,14362,14363,5,1673,0,0,14363,14388,3,2372,1186,0,14364,14365,
+        5,1673,0,0,14365,14366,5,389,0,0,14366,14367,7,101,0,0,14367,14388,
+        5,2082,0,0,14368,14388,3,1498,749,0,14369,14388,3,1502,751,0,14370,
+        14388,3,1456,728,0,14371,14373,7,101,0,0,14372,14371,1,0,0,0,14372,
+        14373,1,0,0,0,14373,14374,1,0,0,0,14374,14375,5,2232,0,0,14375,14376,
+        5,2082,0,0,14376,14377,3,884,442,0,14377,14378,5,352,0,0,14378,14383,
+        3,930,465,0,14379,14380,5,2455,0,0,14380,14382,3,930,465,0,14381,
+        14379,1,0,0,0,14382,14385,1,0,0,0,14383,14381,1,0,0,0,14383,14384,
+        1,0,0,0,14384,14388,1,0,0,0,14385,14383,1,0,0,0,14386,14388,3,1504,
+        752,0,14387,14349,1,0,0,0,14387,14354,1,0,0,0,14387,14356,1,0,0,
+        0,14387,14359,1,0,0,0,14387,14364,1,0,0,0,14387,14368,1,0,0,0,14387,
+        14369,1,0,0,0,14387,14370,1,0,0,0,14387,14372,1,0,0,0,14387,14386,
+        1,0,0,0,14388,14389,1,0,0,0,14389,14387,1,0,0,0,14389,14390,1,0,
+        0,0,14390,1497,1,0,0,0,14391,14392,5,883,0,0,14392,14397,3,1500,
+        750,0,14393,14394,5,2455,0,0,14394,14396,3,1500,750,0,14395,14393,
+        1,0,0,0,14396,14399,1,0,0,0,14397,14395,1,0,0,0,14397,14398,1,0,
+        0,0,14398,14407,1,0,0,0,14399,14397,1,0,0,0,14400,14401,7,185,0,
+        0,14401,14407,5,2443,0,0,14402,14407,5,66,0,0,14403,14407,5,1059,
+        0,0,14404,14405,5,617,0,0,14405,14407,5,885,0,0,14406,14391,1,0,
+        0,0,14406,14400,1,0,0,0,14406,14402,1,0,0,0,14406,14403,1,0,0,0,
+        14406,14404,1,0,0,0,14407,1499,1,0,0,0,14408,14409,5,650,0,0,14409,
+        14411,5,2443,0,0,14410,14408,1,0,0,0,14410,14411,1,0,0,0,14411,14412,
+        1,0,0,0,14412,14413,3,448,224,0,14413,1501,1,0,0,0,14414,14415,5,
+        559,0,0,14415,14416,5,907,0,0,14416,14433,5,874,0,0,14417,14419,
+        5,1802,0,0,14418,14417,1,0,0,0,14418,14419,1,0,0,0,14419,14420,1,
+        0,0,0,14420,14421,5,352,0,0,14421,14426,3,448,224,0,14422,14423,
+        5,2455,0,0,14423,14425,3,448,224,0,14424,14422,1,0,0,0,14425,14428,
+        1,0,0,0,14426,14424,1,0,0,0,14426,14427,1,0,0,0,14427,14433,1,0,
+        0,0,14428,14426,1,0,0,0,14429,14433,3,1514,757,0,14430,14433,3,1516,
+        758,0,14431,14433,3,1518,759,0,14432,14414,1,0,0,0,14432,14418,1,
+        0,0,0,14432,14429,1,0,0,0,14432,14430,1,0,0,0,14432,14431,1,0,0,
+        0,14433,1503,1,0,0,0,14434,14435,5,499,0,0,14435,14436,5,1411,0,
+        0,14436,14449,5,350,0,0,14437,14439,5,1644,0,0,14438,14440,3,1506,
+        753,0,14439,14438,1,0,0,0,14439,14440,1,0,0,0,14440,14443,1,0,0,
+        0,14441,14442,5,1951,0,0,14442,14444,3,1510,755,0,14443,14441,1,
+        0,0,0,14443,14444,1,0,0,0,14444,14447,1,0,0,0,14445,14446,5,1802,
+        0,0,14446,14448,3,1510,755,0,14447,14445,1,0,0,0,14447,14448,1,0,
+        0,0,14448,14450,1,0,0,0,14449,14437,1,0,0,0,14449,14450,1,0,0,0,
+        14450,14452,1,0,0,0,14451,14453,3,1512,756,0,14452,14451,1,0,0,0,
+        14452,14453,1,0,0,0,14453,1505,1,0,0,0,14454,14455,5,591,0,0,14455,
+        14468,5,2474,0,0,14456,14457,5,2449,0,0,14457,14462,3,1508,754,0,
+        14458,14459,5,2455,0,0,14459,14461,3,1508,754,0,14460,14458,1,0,
+        0,0,14461,14464,1,0,0,0,14462,14460,1,0,0,0,14462,14463,1,0,0,0,
+        14463,14465,1,0,0,0,14464,14462,1,0,0,0,14465,14466,5,2450,0,0,14466,
+        14469,1,0,0,0,14467,14469,5,1134,0,0,14468,14456,1,0,0,0,14468,14467,
+        1,0,0,0,14469,1507,1,0,0,0,14470,14473,5,2445,0,0,14471,14472,5,
+        2455,0,0,14472,14474,5,2445,0,0,14473,14471,1,0,0,0,14473,14474,
+        1,0,0,0,14474,1509,1,0,0,0,14475,14479,5,353,0,0,14476,14477,5,1701,
+        0,0,14477,14480,3,1188,594,0,14478,14480,3,934,467,0,14479,14476,
+        1,0,0,0,14479,14478,1,0,0,0,14480,14481,1,0,0,0,14481,14479,1,0,
+        0,0,14481,14482,1,0,0,0,14482,1511,1,0,0,0,14483,14484,5,874,0,0,
+        14484,14485,5,2180,0,0,14485,14486,7,100,0,0,14486,1513,1,0,0,0,
+        14487,14488,5,389,0,0,14488,14489,5,2082,0,0,14489,14492,3,1676,
+        838,0,14490,14491,5,352,0,0,14491,14493,3,930,465,0,14492,14490,
+        1,0,0,0,14492,14493,1,0,0,0,14493,14495,1,0,0,0,14494,14496,3,900,
+        450,0,14495,14494,1,0,0,0,14495,14496,1,0,0,0,14496,1515,1,0,0,0,
+        14497,14499,7,101,0,0,14498,14497,1,0,0,0,14498,14499,1,0,0,0,14499,
+        14500,1,0,0,0,14500,14508,5,389,0,0,14501,14502,5,2094,0,0,14502,
+        14509,5,2082,0,0,14503,14504,5,874,0,0,14504,14505,5,2094,0,0,14505,
+        14506,5,2082,0,0,14506,14507,5,621,0,0,14507,14509,7,186,0,0,14508,
+        14501,1,0,0,0,14508,14503,1,0,0,0,14509,14510,1,0,0,0,14510,14520,
+        3,1676,838,0,14511,14512,5,2091,0,0,14512,14517,3,448,224,0,14513,
+        14514,5,2455,0,0,14514,14516,3,448,224,0,14515,14513,1,0,0,0,14516,
+        14519,1,0,0,0,14517,14515,1,0,0,0,14517,14518,1,0,0,0,14518,14521,
+        1,0,0,0,14519,14517,1,0,0,0,14520,14511,1,0,0,0,14520,14521,1,0,
+        0,0,14521,14523,1,0,0,0,14522,14524,3,900,450,0,14523,14522,1,0,
+        0,0,14523,14524,1,0,0,0,14524,1517,1,0,0,0,14525,14527,7,101,0,0,
+        14526,14525,1,0,0,0,14526,14527,1,0,0,0,14527,14528,1,0,0,0,14528,
+        14529,5,2180,0,0,14529,14530,5,2082,0,0,14530,14540,3,1676,838,0,
+        14531,14532,5,352,0,0,14532,14537,3,448,224,0,14533,14534,5,2455,
+        0,0,14534,14536,3,448,224,0,14535,14533,1,0,0,0,14536,14539,1,0,
+        0,0,14537,14535,1,0,0,0,14537,14538,1,0,0,0,14538,14541,1,0,0,0,
+        14539,14537,1,0,0,0,14540,14531,1,0,0,0,14540,14541,1,0,0,0,14541,
+        1519,1,0,0,0,14542,14543,5,469,0,0,14543,14546,5,350,0,0,14544,14545,
+        5,706,0,0,14545,14547,5,103,0,0,14546,14544,1,0,0,0,14546,14547,
+        1,0,0,0,14547,14549,1,0,0,0,14548,14550,5,1159,0,0,14549,14548,1,
+        0,0,0,14549,14550,1,0,0,0,14550,1521,1,0,0,0,14551,14553,5,321,0,
+        0,14552,14554,5,1681,0,0,14553,14552,1,0,0,0,14553,14554,1,0,0,0,
+        14554,14556,1,0,0,0,14555,14557,5,1475,0,0,14556,14555,1,0,0,0,14556,
+        14557,1,0,0,0,14557,14558,1,0,0,0,14558,14559,5,350,0,0,14559,14560,
+        5,862,0,0,14560,14576,3,2360,1180,0,14561,14562,5,280,0,0,14562,
+        14571,5,2143,0,0,14563,14572,5,341,0,0,14564,14565,3,2380,1190,0,
+        14565,14566,5,686,0,0,14566,14567,5,160,0,0,14567,14569,3,1490,745,
+        0,14568,14570,3,1492,746,0,14569,14568,1,0,0,0,14569,14570,1,0,0,
+        0,14570,14572,1,0,0,0,14571,14563,1,0,0,0,14571,14564,1,0,0,0,14572,
+        14575,1,0,0,0,14573,14575,3,1492,746,0,14574,14561,1,0,0,0,14574,
+        14573,1,0,0,0,14575,14578,1,0,0,0,14576,14574,1,0,0,0,14576,14577,
+        1,0,0,0,14577,14581,1,0,0,0,14578,14576,1,0,0,0,14579,14580,5,2248,
+        0,0,14580,14582,5,2445,0,0,14581,14579,1,0,0,0,14581,14582,1,0,0,
+        0,14582,1523,1,0,0,0,14583,14585,5,469,0,0,14584,14586,5,1475,0,
+        0,14585,14584,1,0,0,0,14585,14586,1,0,0,0,14586,14587,1,0,0,0,14587,
+        14588,5,350,0,0,14588,14589,5,862,0,0,14589,14590,3,2360,1180,0,
+        14590,1525,1,0,0,0,14591,14592,5,42,0,0,14592,14593,5,2082,0,0,14593,
+        14594,5,1673,0,0,14594,14595,3,2430,1215,0,14595,14596,3,1528,764,
+        0,14596,1527,1,0,0,0,14597,14625,3,916,458,0,14598,14599,5,955,0,
+        0,14599,14600,5,559,0,0,14600,14625,3,1188,594,0,14601,14602,5,1569,
+        0,0,14602,14625,3,1188,594,0,14603,14625,5,228,0,0,14604,14605,5,
+        1686,0,0,14605,14608,5,1716,0,0,14606,14607,5,815,0,0,14607,14609,
+        3,1188,594,0,14608,14606,1,0,0,0,14608,14609,1,0,0,0,14609,14625,
+        1,0,0,0,14610,14611,5,1561,0,0,14611,14612,5,2143,0,0,14612,14625,
+        3,2430,1215,0,14613,14614,7,172,0,0,14614,14625,5,102,0,0,14615,
+        14625,3,878,439,0,14616,14625,3,880,440,0,14617,14625,3,882,441,
+        0,14618,14625,3,886,443,0,14619,14625,3,934,467,0,14620,14625,3,
+        888,444,0,14621,14625,3,908,454,0,14622,14625,3,1530,765,0,14623,
+        14625,3,1476,738,0,14624,14597,1,0,0,0,14624,14598,1,0,0,0,14624,
+        14601,1,0,0,0,14624,14603,1,0,0,0,14624,14604,1,0,0,0,14624,14610,
+        1,0,0,0,14624,14613,1,0,0,0,14624,14615,1,0,0,0,14624,14616,1,0,
+        0,0,14624,14617,1,0,0,0,14624,14618,1,0,0,0,14624,14619,1,0,0,0,
+        14624,14620,1,0,0,0,14624,14621,1,0,0,0,14624,14622,1,0,0,0,14624,
+        14623,1,0,0,0,14625,1529,1,0,0,0,14626,14651,5,506,0,0,14627,14633,
+        5,1245,0,0,14628,14630,3,896,448,0,14629,14628,1,0,0,0,14629,14630,
+        1,0,0,0,14630,14631,1,0,0,0,14631,14634,5,505,0,0,14632,14634,5,
+        387,0,0,14633,14629,1,0,0,0,14633,14632,1,0,0,0,14634,14652,1,0,
+        0,0,14635,14641,5,1258,0,0,14636,14638,3,896,448,0,14637,14636,1,
+        0,0,0,14637,14638,1,0,0,0,14638,14639,1,0,0,0,14639,14642,7,187,
+        0,0,14640,14642,5,387,0,0,14641,14637,1,0,0,0,14641,14640,1,0,0,
+        0,14642,14644,1,0,0,0,14643,14645,3,1532,766,0,14644,14643,1,0,0,
+        0,14644,14645,1,0,0,0,14645,14652,1,0,0,0,14646,14647,5,598,0,0,
+        14647,14649,7,188,0,0,14648,14650,3,1532,766,0,14649,14648,1,0,0,
+        0,14649,14650,1,0,0,0,14650,14652,1,0,0,0,14651,14627,1,0,0,0,14651,
+        14635,1,0,0,0,14651,14646,1,0,0,0,14652,1531,1,0,0,0,14653,14654,
+        5,591,0,0,14654,14655,5,2474,0,0,14655,14656,5,2449,0,0,14656,14657,
+        5,2445,0,0,14657,14658,5,2455,0,0,14658,14665,5,2445,0,0,14659,14660,
+        5,2455,0,0,14660,14661,5,2445,0,0,14661,14662,5,2455,0,0,14662,14664,
+        5,2445,0,0,14663,14659,1,0,0,0,14664,14667,1,0,0,0,14665,14663,1,
+        0,0,0,14665,14666,1,0,0,0,14666,14668,1,0,0,0,14667,14665,1,0,0,
+        0,14668,14670,5,2450,0,0,14669,14671,5,815,0,0,14670,14669,1,0,0,
+        0,14670,14671,1,0,0,0,14671,1533,1,0,0,0,14672,14673,5,42,0,0,14673,
+        14674,5,1595,0,0,14674,14675,3,2334,1167,0,14675,14677,3,1536,768,
+        0,14676,14678,3,778,389,0,14677,14676,1,0,0,0,14677,14678,1,0,0,
+        0,14678,1535,1,0,0,0,14679,14680,5,1206,0,0,14680,14699,5,686,0,
+        0,14681,14696,5,686,0,0,14682,14683,5,160,0,0,14683,14697,3,2428,
+        1214,0,14684,14685,5,2248,0,0,14685,14688,3,2428,1214,0,14686,14687,
+        5,2442,0,0,14687,14689,3,2430,1215,0,14688,14686,1,0,0,0,14688,14689,
+        1,0,0,0,14689,14697,1,0,0,0,14690,14697,5,562,0,0,14691,14694,5,
+        644,0,0,14692,14693,5,69,0,0,14693,14695,5,2445,0,0,14694,14692,
+        1,0,0,0,14694,14695,1,0,0,0,14695,14697,1,0,0,0,14696,14682,1,0,
+        0,0,14696,14684,1,0,0,0,14696,14690,1,0,0,0,14696,14691,1,0,0,0,
+        14697,14699,1,0,0,0,14698,14679,1,0,0,0,14698,14681,1,0,0,0,14699,
+        1537,1,0,0,0,14700,14701,5,42,0,0,14701,14702,5,2085,0,0,14702,14712,
+        3,2368,1184,0,14703,14705,3,1546,773,0,14704,14703,1,0,0,0,14705,
+        14706,1,0,0,0,14706,14704,1,0,0,0,14706,14707,1,0,0,0,14707,14709,
+        1,0,0,0,14708,14710,3,1540,770,0,14709,14708,1,0,0,0,14709,14710,
+        1,0,0,0,14710,14713,1,0,0,0,14711,14713,3,1540,770,0,14712,14704,
+        1,0,0,0,14712,14711,1,0,0,0,14713,1539,1,0,0,0,14714,14716,3,1542,
+        771,0,14715,14717,3,1544,772,0,14716,14715,1,0,0,0,14716,14717,1,
+        0,0,0,14717,14720,1,0,0,0,14718,14720,3,1544,772,0,14719,14714,1,
+        0,0,0,14719,14718,1,0,0,0,14720,1541,1,0,0,0,14721,14728,3,1548,
+        774,0,14722,14728,3,1722,861,0,14723,14728,3,1624,812,0,14724,14728,
+        3,1550,775,0,14725,14728,3,1612,806,0,14726,14728,3,1614,807,0,14727,
+        14721,1,0,0,0,14727,14722,1,0,0,0,14727,14723,1,0,0,0,14727,14724,
+        1,0,0,0,14727,14725,1,0,0,0,14727,14726,1,0,0,0,14728,1543,1,0,0,
+        0,14729,14738,3,1602,801,0,14730,14735,3,1320,660,0,14731,14732,
+        5,2085,0,0,14732,14736,5,882,0,0,14733,14734,5,38,0,0,14734,14736,
+        5,2158,0,0,14735,14731,1,0,0,0,14735,14733,1,0,0,0,14736,14738,1,
+        0,0,0,14737,14729,1,0,0,0,14737,14730,1,0,0,0,14738,14739,1,0,0,
+        0,14739,14737,1,0,0,0,14739,14740,1,0,0,0,14740,1545,1,0,0,0,14741,
+        14743,5,1139,0,0,14742,14741,1,0,0,0,14742,14743,1,0,0,0,14743,14744,
+        1,0,0,0,14744,14745,5,2410,0,0,14745,14746,5,621,0,0,14746,14747,
+        7,189,0,0,14747,1547,1,0,0,0,14748,14766,3,1580,790,0,14749,14750,
+        5,1561,0,0,14750,14751,5,2143,0,0,14751,14766,3,2368,1184,0,14752,
+        14766,3,1300,650,0,14753,14754,5,1507,0,0,14754,14766,5,1260,0,0,
+        14755,14756,5,1507,0,0,14756,14766,5,2315,0,0,14757,14758,5,1552,
+        0,0,14758,14766,5,2445,0,0,14759,14761,5,1139,0,0,14760,14759,1,
+        0,0,0,14760,14761,1,0,0,0,14761,14762,1,0,0,0,14762,14763,5,1608,
+        0,0,14763,14766,5,63,0,0,14764,14766,3,2270,1135,0,14765,14748,1,
+        0,0,0,14765,14749,1,0,0,0,14765,14752,1,0,0,0,14765,14753,1,0,0,
+        0,14765,14755,1,0,0,0,14765,14757,1,0,0,0,14765,14760,1,0,0,0,14765,
+        14764,1,0,0,0,14766,1549,1,0,0,0,14767,14779,3,1552,776,0,14768,
+        14779,3,1554,777,0,14769,14779,3,1556,778,0,14770,14779,3,1558,779,
+        0,14771,14779,3,1560,780,0,14772,14779,3,1562,781,0,14773,14779,
+        3,1564,782,0,14774,14779,3,1566,783,0,14775,14779,3,1568,784,0,14776,
+        14779,3,1570,785,0,14777,14779,3,1574,787,0,14778,14767,1,0,0,0,
+        14778,14768,1,0,0,0,14778,14769,1,0,0,0,14778,14770,1,0,0,0,14778,
+        14771,1,0,0,0,14778,14772,1,0,0,0,14778,14773,1,0,0,0,14778,14774,
+        1,0,0,0,14778,14775,1,0,0,0,14778,14776,1,0,0,0,14778,14777,1,0,
+        0,0,14779,1551,1,0,0,0,14780,14797,5,21,0,0,14781,14798,3,1152,576,
+        0,14782,14798,3,1154,577,0,14783,14785,5,1350,0,0,14784,14786,3,
+        1716,858,0,14785,14784,1,0,0,0,14785,14786,1,0,0,0,14786,14789,1,
+        0,0,0,14787,14788,5,2082,0,0,14788,14790,3,1676,838,0,14789,14787,
+        1,0,0,0,14789,14790,1,0,0,0,14790,14792,1,0,0,0,14791,14793,3,1620,
+        810,0,14792,14791,1,0,0,0,14792,14793,1,0,0,0,14793,14795,1,0,0,
+        0,14794,14796,5,2205,0,0,14795,14794,1,0,0,0,14795,14796,1,0,0,0,
+        14796,14798,1,0,0,0,14797,14781,1,0,0,0,14797,14782,1,0,0,0,14797,
+        14783,1,0,0,0,14798,1553,1,0,0,0,14799,14802,5,469,0,0,14800,14803,
+        3,1576,788,0,14801,14803,3,1578,789,0,14802,14800,1,0,0,0,14802,
+        14801,1,0,0,0,14803,14808,1,0,0,0,14804,14806,3,1590,795,0,14805,
+        14807,3,940,470,0,14806,14805,1,0,0,0,14806,14807,1,0,0,0,14807,
+        14809,1,0,0,0,14808,14804,1,0,0,0,14808,14809,1,0,0,0,14809,1555,
+        1,0,0,0,14810,14811,5,947,0,0,14811,14812,5,1350,0,0,14812,14813,
+        3,1716,858,0,14813,14814,5,49,0,0,14814,14815,3,1716,858,0,14815,
+        14816,5,780,0,0,14816,14817,5,1350,0,0,14817,14818,3,1716,858,0,
+        14818,1557,1,0,0,0,14819,14820,5,981,0,0,14820,14821,7,190,0,0,14821,
+        14824,3,1716,858,0,14822,14823,7,9,0,0,14823,14825,3,1180,590,0,
+        14824,14822,1,0,0,0,14824,14825,1,0,0,0,14825,14828,1,0,0,0,14826,
+        14827,5,21,0,0,14827,14829,3,1168,584,0,14828,14826,1,0,0,0,14828,
+        14829,1,0,0,0,14829,14836,1,0,0,0,14830,14832,5,1513,0,0,14831,14830,
+        1,0,0,0,14831,14832,1,0,0,0,14832,14833,1,0,0,0,14833,14834,5,2205,
+        0,0,14834,14835,5,874,0,0,14835,14837,5,715,0,0,14836,14831,1,0,
+        0,0,14836,14837,1,0,0,0,14837,14839,1,0,0,0,14838,14840,3,1300,650,
+        0,14839,14838,1,0,0,0,14839,14840,1,0,0,0,14840,1559,1,0,0,0,14841,
+        14842,5,1719,0,0,14842,14888,3,1576,788,0,14843,14844,5,82,0,0,14844,
+        14845,5,2449,0,0,14845,14850,3,2210,1105,0,14846,14847,5,2455,0,
+        0,14847,14849,3,2210,1105,0,14848,14846,1,0,0,0,14849,14852,1,0,
+        0,0,14850,14848,1,0,0,0,14850,14851,1,0,0,0,14851,14853,1,0,0,0,
+        14852,14850,1,0,0,0,14853,14854,5,2450,0,0,14854,14855,5,780,0,0,
+        14855,14856,5,2449,0,0,14856,14861,3,1152,576,0,14857,14858,5,2455,
+        0,0,14858,14860,3,1152,576,0,14859,14857,1,0,0,0,14860,14863,1,0,
+        0,0,14861,14859,1,0,0,0,14861,14862,1,0,0,0,14862,14864,1,0,0,0,
+        14863,14861,1,0,0,0,14864,14865,5,2450,0,0,14865,14889,1,0,0,0,14866,
+        14867,5,780,0,0,14867,14884,5,2449,0,0,14868,14873,3,1152,576,0,
+        14869,14870,5,2455,0,0,14870,14872,3,1152,576,0,14871,14869,1,0,
+        0,0,14872,14875,1,0,0,0,14873,14871,1,0,0,0,14873,14874,1,0,0,0,
+        14874,14885,1,0,0,0,14875,14873,1,0,0,0,14876,14881,3,1154,577,0,
+        14877,14878,5,2455,0,0,14878,14880,3,1154,577,0,14879,14877,1,0,
+        0,0,14880,14883,1,0,0,0,14881,14879,1,0,0,0,14881,14882,1,0,0,0,
+        14882,14885,1,0,0,0,14883,14881,1,0,0,0,14884,14868,1,0,0,0,14884,
+        14876,1,0,0,0,14885,14886,1,0,0,0,14886,14887,5,2450,0,0,14887,14889,
+        1,0,0,0,14888,14843,1,0,0,0,14888,14866,1,0,0,0,14889,14893,1,0,
+        0,0,14890,14894,3,1592,796,0,14891,14894,3,1590,795,0,14892,14894,
+        5,1258,0,0,14893,14890,1,0,0,0,14893,14891,1,0,0,0,14893,14892,1,
+        0,0,0,14893,14894,1,0,0,0,14894,1561,1,0,0,0,14895,14898,5,2161,
+        0,0,14896,14899,3,1576,788,0,14897,14899,3,1578,789,0,14898,14896,
+        1,0,0,0,14898,14897,1,0,0,0,14899,14908,1,0,0,0,14900,14902,5,469,
+        0,0,14901,14903,5,38,0,0,14902,14901,1,0,0,0,14902,14903,1,0,0,0,
+        14903,14906,1,0,0,0,14904,14906,5,1589,0,0,14905,14900,1,0,0,0,14905,
+        14904,1,0,0,0,14905,14906,1,0,0,0,14906,14907,1,0,0,0,14907,14909,
+        5,1764,0,0,14908,14905,1,0,0,0,14908,14909,1,0,0,0,14909,14911,1,
+        0,0,0,14910,14912,5,179,0,0,14911,14910,1,0,0,0,14911,14912,1,0,
+        0,0,14912,14917,1,0,0,0,14913,14915,3,1590,795,0,14914,14916,3,940,
+        470,0,14915,14914,1,0,0,0,14915,14916,1,0,0,0,14916,14918,1,0,0,
+        0,14917,14913,1,0,0,0,14917,14918,1,0,0,0,14918,1563,1,0,0,0,14919,
+        14920,5,538,0,0,14920,14921,5,1350,0,0,14921,14922,3,1716,858,0,
+        14922,14923,5,2310,0,0,14923,14924,5,2085,0,0,14924,14927,3,2368,
+        1184,0,14925,14926,7,110,0,0,14926,14928,5,715,0,0,14927,14925,1,
+        0,0,0,14927,14928,1,0,0,0,14928,14931,1,0,0,0,14929,14930,7,2,0,
+        0,14930,14932,5,2257,0,0,14931,14929,1,0,0,0,14931,14932,1,0,0,0,
+        14932,1565,1,0,0,0,14933,14934,5,228,0,0,14934,14936,5,1350,0,0,
+        14935,14937,3,940,470,0,14936,14935,1,0,0,0,14936,14937,1,0,0,0,
+        14937,14941,1,0,0,0,14938,14939,3,1322,661,0,14939,14940,5,224,0,
+        0,14940,14942,1,0,0,0,14941,14938,1,0,0,0,14941,14942,1,0,0,0,14942,
+        1567,1,0,0,0,14943,14944,5,1673,0,0,14944,14945,5,777,0,0,14945,
+        14948,5,2449,0,0,14946,14949,3,2420,1210,0,14947,14949,3,2100,1050,
+        0,14948,14946,1,0,0,0,14948,14947,1,0,0,0,14948,14949,1,0,0,0,14949,
+        14950,1,0,0,0,14950,14951,5,2450,0,0,14951,1569,1,0,0,0,14952,14967,
+        5,993,0,0,14953,14956,3,1576,788,0,14954,14955,5,912,0,0,14955,14957,
+        5,2085,0,0,14956,14954,1,0,0,0,14956,14957,1,0,0,0,14957,14958,1,
+        0,0,0,14958,14959,3,1182,591,0,14959,14968,1,0,0,0,14960,14962,3,
+        1578,789,0,14961,14963,3,1100,550,0,14962,14961,1,0,0,0,14962,14963,
+        1,0,0,0,14963,14965,1,0,0,0,14964,14966,3,1184,592,0,14965,14964,
+        1,0,0,0,14965,14966,1,0,0,0,14966,14968,1,0,0,0,14967,14953,1,0,
+        0,0,14967,14960,1,0,0,0,14968,14978,1,0,0,0,14969,14977,3,1572,786,
+        0,14970,14977,3,1590,795,0,14971,14977,3,940,470,0,14972,14973,3,
+        1322,661,0,14973,14974,5,224,0,0,14974,14977,1,0,0,0,14975,14977,
+        5,1258,0,0,14976,14969,1,0,0,0,14976,14970,1,0,0,0,14976,14971,1,
+        0,0,0,14976,14972,1,0,0,0,14976,14975,1,0,0,0,14977,14980,1,0,0,
+        0,14978,14976,1,0,0,0,14978,14979,1,0,0,0,14979,1571,1,0,0,0,14980,
+        14978,1,0,0,0,14981,14982,5,706,0,0,14982,14983,5,1609,0,0,14983,
+        14984,3,2298,1149,0,14984,1573,1,0,0,0,14985,14988,5,1561,0,0,14986,
+        14989,3,1576,788,0,14987,14989,3,1578,789,0,14988,14986,1,0,0,0,
+        14988,14987,1,0,0,0,14989,14990,1,0,0,0,14990,14991,5,2143,0,0,14991,
+        14992,3,1716,858,0,14992,1575,1,0,0,0,14993,15028,7,191,0,0,14994,
+        14999,3,1716,858,0,14995,14996,5,2455,0,0,14996,14998,3,1716,858,
+        0,14997,14995,1,0,0,0,14998,15001,1,0,0,0,14999,14997,1,0,0,0,14999,
+        15000,1,0,0,0,15000,15029,1,0,0,0,15001,14999,1,0,0,0,15002,15003,
+        5,2449,0,0,15003,15008,3,1716,858,0,15004,15005,5,2455,0,0,15005,
+        15007,3,1716,858,0,15006,15004,1,0,0,0,15007,15010,1,0,0,0,15008,
+        15006,1,0,0,0,15008,15009,1,0,0,0,15009,15011,1,0,0,0,15010,15008,
+        1,0,0,0,15011,15012,5,2450,0,0,15012,15029,1,0,0,0,15013,15015,5,
+        621,0,0,15014,15016,5,2449,0,0,15015,15014,1,0,0,0,15015,15016,1,
+        0,0,0,15016,15017,1,0,0,0,15017,15022,3,698,349,0,15018,15019,5,
+        2455,0,0,15019,15021,3,698,349,0,15020,15018,1,0,0,0,15021,15024,
+        1,0,0,0,15022,15020,1,0,0,0,15022,15023,1,0,0,0,15023,15026,1,0,
+        0,0,15024,15022,1,0,0,0,15025,15027,5,2450,0,0,15026,15025,1,0,0,
+        0,15026,15027,1,0,0,0,15027,15029,1,0,0,0,15028,14994,1,0,0,0,15028,
+        15002,1,0,0,0,15028,15013,1,0,0,0,15029,1577,1,0,0,0,15030,15062,
+        7,192,0,0,15031,15034,3,1716,858,0,15032,15033,5,2209,0,0,15033,
+        15035,5,715,0,0,15034,15032,1,0,0,0,15034,15035,1,0,0,0,15035,15063,
+        1,0,0,0,15036,15037,5,2449,0,0,15037,15042,3,1716,858,0,15038,15039,
+        5,2455,0,0,15039,15041,3,1716,858,0,15040,15038,1,0,0,0,15041,15044,
+        1,0,0,0,15042,15040,1,0,0,0,15042,15043,1,0,0,0,15043,15045,1,0,
+        0,0,15044,15042,1,0,0,0,15045,15046,5,2450,0,0,15046,15063,1,0,0,
+        0,15047,15049,5,621,0,0,15048,15050,5,2449,0,0,15049,15048,1,0,0,
+        0,15049,15050,1,0,0,0,15050,15051,1,0,0,0,15051,15056,3,700,350,
+        0,15052,15053,5,2455,0,0,15053,15055,3,700,350,0,15054,15052,1,0,
+        0,0,15055,15058,1,0,0,0,15056,15054,1,0,0,0,15056,15057,1,0,0,0,
+        15057,15060,1,0,0,0,15058,15056,1,0,0,0,15059,15061,5,2450,0,0,15060,
+        15059,1,0,0,0,15060,15061,1,0,0,0,15061,15063,1,0,0,0,15062,15031,
+        1,0,0,0,15062,15036,1,0,0,0,15062,15047,1,0,0,0,15063,1579,1,0,0,
+        0,15064,15084,3,1206,603,0,15065,15084,3,898,449,0,15066,15084,3,
+        1190,595,0,15067,15084,3,1192,596,0,15068,15084,3,1290,645,0,15069,
+        15084,3,1296,648,0,15070,15084,3,1298,649,0,15071,15084,7,109,0,
+        0,15072,15073,5,1581,0,0,15073,15074,5,2449,0,0,15074,15075,5,978,
+        0,0,15075,15076,7,24,0,0,15076,15084,5,2450,0,0,15077,15084,3,1304,
+        652,0,15078,15084,3,1302,651,0,15079,15084,3,940,470,0,15080,15084,
+        3,1284,642,0,15081,15084,3,1120,560,0,15082,15084,3,1286,643,0,15083,
+        15064,1,0,0,0,15083,15065,1,0,0,0,15083,15066,1,0,0,0,15083,15067,
+        1,0,0,0,15083,15068,1,0,0,0,15083,15069,1,0,0,0,15083,15070,1,0,
+        0,0,15083,15071,1,0,0,0,15083,15072,1,0,0,0,15083,15077,1,0,0,0,
+        15083,15078,1,0,0,0,15083,15079,1,0,0,0,15083,15080,1,0,0,0,15083,
+        15081,1,0,0,0,15083,15082,1,0,0,0,15084,15085,1,0,0,0,15085,15083,
+        1,0,0,0,15085,15086,1,0,0,0,15086,15088,1,0,0,0,15087,15089,3,1582,
+        791,0,15088,15087,1,0,0,0,15088,15089,1,0,0,0,15089,1581,1,0,0,0,
+        15090,15095,3,1616,808,0,15091,15095,3,1586,793,0,15092,15095,3,
+        1584,792,0,15093,15095,5,228,0,0,15094,15090,1,0,0,0,15094,15091,
+        1,0,0,0,15094,15092,1,0,0,0,15094,15093,1,0,0,0,15095,1583,1,0,0,
+        0,15096,15097,5,912,0,0,15097,15100,5,2085,0,0,15098,15101,3,1296,
+        648,0,15099,15101,3,1298,649,0,15100,15098,1,0,0,0,15100,15099,1,
+        0,0,0,15101,1585,1,0,0,0,15102,15113,3,1588,794,0,15103,15108,5,
+        1322,0,0,15104,15109,3,1212,606,0,15105,15109,3,1296,648,0,15106,
+        15109,3,1300,650,0,15107,15109,3,1298,649,0,15108,15104,1,0,0,0,
+        15108,15105,1,0,0,0,15108,15106,1,0,0,0,15108,15107,1,0,0,0,15109,
+        15110,1,0,0,0,15110,15108,1,0,0,0,15110,15111,1,0,0,0,15111,15113,
+        1,0,0,0,15112,15102,1,0,0,0,15112,15103,1,0,0,0,15113,1587,1,0,0,
+        0,15114,15115,5,21,0,0,15115,15117,5,1322,0,0,15116,15118,3,1212,
+        606,0,15117,15116,1,0,0,0,15117,15118,1,0,0,0,15118,15135,1,0,0,
+        0,15119,15120,5,2449,0,0,15120,15122,5,1350,0,0,15121,15123,3,1212,
+        606,0,15122,15121,1,0,0,0,15122,15123,1,0,0,0,15123,15131,1,0,0,
+        0,15124,15125,5,2455,0,0,15125,15127,5,1350,0,0,15126,15128,3,1212,
+        606,0,15127,15126,1,0,0,0,15127,15128,1,0,0,0,15128,15130,1,0,0,
+        0,15129,15124,1,0,0,0,15130,15133,1,0,0,0,15131,15129,1,0,0,0,15131,
+        15132,1,0,0,0,15132,15134,1,0,0,0,15133,15131,1,0,0,0,15134,15136,
+        5,2450,0,0,15135,15119,1,0,0,0,15135,15136,1,0,0,0,15136,1589,1,
+        0,0,0,15137,15140,3,1592,796,0,15138,15140,3,1594,797,0,15139,15137,
+        1,0,0,0,15139,15138,1,0,0,0,15140,1591,1,0,0,0,15141,15142,7,193,
+        0,0,15142,15143,5,643,0,0,15143,15144,5,715,0,0,15144,1593,1,0,0,
+        0,15145,15146,5,2209,0,0,15146,15151,5,715,0,0,15147,15148,5,2449,
+        0,0,15148,15149,3,1596,798,0,15149,15150,5,2450,0,0,15150,15152,
+        1,0,0,0,15151,15147,1,0,0,0,15151,15152,1,0,0,0,15152,1595,1,0,0,
+        0,15153,15154,3,2354,1177,0,15154,15157,5,2449,0,0,15155,15158,3,
+        1598,799,0,15156,15158,3,1600,800,0,15157,15155,1,0,0,0,15157,15156,
+        1,0,0,0,15158,15159,1,0,0,0,15159,15164,5,2450,0,0,15160,15161,5,
+        2455,0,0,15161,15163,3,1594,797,0,15162,15160,1,0,0,0,15163,15166,
+        1,0,0,0,15164,15162,1,0,0,0,15164,15165,1,0,0,0,15165,1597,1,0,0,
+        0,15166,15164,1,0,0,0,15167,15169,3,556,278,0,15168,15170,3,518,
+        259,0,15169,15168,1,0,0,0,15169,15170,1,0,0,0,15170,15175,1,0,0,
+        0,15171,15172,5,2455,0,0,15172,15174,3,1598,799,0,15173,15171,1,
+        0,0,0,15174,15177,1,0,0,0,15175,15173,1,0,0,0,15175,15176,1,0,0,
+        0,15176,1599,1,0,0,0,15177,15175,1,0,0,0,15178,15180,5,1777,0,0,
+        15179,15181,3,1166,583,0,15180,15179,1,0,0,0,15180,15181,1,0,0,0,
+        15181,15184,1,0,0,0,15182,15183,5,2082,0,0,15183,15185,3,1676,838,
+        0,15184,15182,1,0,0,0,15184,15185,1,0,0,0,15185,15190,1,0,0,0,15186,
+        15187,5,2455,0,0,15187,15189,3,1600,800,0,15188,15186,1,0,0,0,15189,
+        15192,1,0,0,0,15190,15188,1,0,0,0,15190,15191,1,0,0,0,15191,1601,
+        1,0,0,0,15192,15190,1,0,0,0,15193,15195,7,17,0,0,15194,15196,7,96,
+        0,0,15195,15194,1,0,0,0,15195,15196,1,0,0,0,15196,15213,1,0,0,0,
+        15197,15198,5,2185,0,0,15198,15199,5,2449,0,0,15199,15204,3,2366,
+        1183,0,15200,15201,5,2455,0,0,15201,15203,3,2366,1183,0,15202,15200,
+        1,0,0,0,15203,15206,1,0,0,0,15204,15202,1,0,0,0,15204,15205,1,0,
+        0,0,15205,15207,1,0,0,0,15206,15204,1,0,0,0,15207,15208,5,2450,0,
+        0,15208,15214,1,0,0,0,15209,15210,5,1453,0,0,15210,15214,5,817,0,
+        0,15211,15212,5,286,0,0,15212,15214,3,2336,1168,0,15213,15197,1,
+        0,0,0,15213,15209,1,0,0,0,15213,15211,1,0,0,0,15214,15216,1,0,0,
+        0,15215,15217,3,1604,802,0,15216,15215,1,0,0,0,15216,15217,1,0,0,
+        0,15217,15219,1,0,0,0,15218,15220,3,1610,805,0,15219,15218,1,0,0,
+        0,15219,15220,1,0,0,0,15220,15222,1,0,0,0,15221,15223,5,179,0,0,
+        15222,15221,1,0,0,0,15222,15223,1,0,0,0,15223,15226,1,0,0,0,15224,
+        15225,7,165,0,0,15225,15227,5,718,0,0,15226,15224,1,0,0,0,15226,
+        15227,1,0,0,0,15227,1603,1,0,0,0,15228,15229,5,2248,0,0,15229,15236,
+        5,718,0,0,15230,15237,3,2354,1177,0,15231,15232,5,2449,0,0,15232,
+        15233,3,474,237,0,15233,15234,5,2450,0,0,15234,15237,1,0,0,0,15235,
+        15237,3,486,243,0,15236,15230,1,0,0,0,15236,15231,1,0,0,0,15236,
+        15235,1,0,0,0,15237,1605,1,0,0,0,15238,15252,3,1206,603,0,15239,
+        15252,3,898,449,0,15240,15252,5,1258,0,0,15241,15244,5,2082,0,0,
+        15242,15245,3,1676,838,0,15243,15245,5,389,0,0,15244,15242,1,0,0,
+        0,15244,15243,1,0,0,0,15245,15252,1,0,0,0,15246,15252,3,1620,810,
+        0,15247,15252,3,1608,804,0,15248,15252,5,1590,0,0,15249,15252,3,
+        532,266,0,15250,15252,3,940,470,0,15251,15238,1,0,0,0,15251,15239,
+        1,0,0,0,15251,15240,1,0,0,0,15251,15241,1,0,0,0,15251,15246,1,0,
+        0,0,15251,15247,1,0,0,0,15251,15248,1,0,0,0,15251,15249,1,0,0,0,
+        15251,15250,1,0,0,0,15252,15253,1,0,0,0,15253,15251,1,0,0,0,15253,
+        15254,1,0,0,0,15254,1607,1,0,0,0,15255,15256,7,194,0,0,15256,1609,
+        1,0,0,0,15257,15258,5,537,0,0,15258,15259,5,780,0,0,15259,15260,
+        3,2368,1184,0,15260,1611,1,0,0,0,15261,15263,5,993,0,0,15262,15264,
+        5,1258,0,0,15263,15262,1,0,0,0,15263,15264,1,0,0,0,15264,15266,1,
+        0,0,0,15265,15267,3,1212,606,0,15266,15265,1,0,0,0,15266,15267,1,
+        0,0,0,15267,15269,1,0,0,0,15268,15270,3,1190,595,0,15269,15268,1,
+        0,0,0,15269,15270,1,0,0,0,15270,15272,1,0,0,0,15271,15273,3,1616,
+        808,0,15272,15271,1,0,0,0,15272,15273,1,0,0,0,15273,15278,1,0,0,
+        0,15274,15277,3,1660,830,0,15275,15277,3,1650,825,0,15276,15274,
+        1,0,0,0,15276,15275,1,0,0,0,15277,15280,1,0,0,0,15278,15276,1,0,
+        0,0,15278,15279,1,0,0,0,15279,15282,1,0,0,0,15280,15278,1,0,0,0,
+        15281,15283,3,940,470,0,15282,15281,1,0,0,0,15282,15283,1,0,0,0,
+        15283,1613,1,0,0,0,15284,15287,5,981,0,0,15285,15288,3,1126,563,
+        0,15286,15288,5,1135,0,0,15287,15285,1,0,0,0,15287,15286,1,0,0,0,
+        15288,15290,1,0,0,0,15289,15291,3,1572,786,0,15290,15289,1,0,0,0,
+        15290,15291,1,0,0,0,15291,15293,1,0,0,0,15292,15294,5,1258,0,0,15293,
+        15292,1,0,0,0,15293,15294,1,0,0,0,15294,15296,1,0,0,0,15295,15297,
+        3,1590,795,0,15296,15295,1,0,0,0,15296,15297,1,0,0,0,15297,1615,
+        1,0,0,0,15298,15303,3,1618,809,0,15299,15300,5,1373,0,0,15300,15303,
+        5,2443,0,0,15301,15303,3,1620,810,0,15302,15298,1,0,0,0,15302,15299,
+        1,0,0,0,15302,15301,1,0,0,0,15303,15304,1,0,0,0,15304,15302,1,0,
+        0,0,15304,15305,1,0,0,0,15305,15307,1,0,0,0,15306,15308,3,1622,811,
+        0,15307,15306,1,0,0,0,15307,15308,1,0,0,0,15308,15311,1,0,0,0,15309,
+        15311,3,1622,811,0,15310,15302,1,0,0,0,15310,15309,1,0,0,0,15311,
+        1617,1,0,0,0,15312,15313,5,912,0,0,15313,15316,5,2085,0,0,15314,
+        15316,5,1121,0,0,15315,15312,1,0,0,0,15315,15314,1,0,0,0,15316,1619,
+        1,0,0,0,15317,15321,5,1075,0,0,15318,15319,5,258,0,0,15319,15321,
+        5,2443,0,0,15320,15317,1,0,0,0,15320,15318,1,0,0,0,15321,1621,1,
+        0,0,0,15322,15323,5,706,0,0,15323,15325,3,2366,1183,0,15324,15322,
+        1,0,0,0,15324,15325,1,0,0,0,15325,15326,1,0,0,0,15326,15328,5,1322,
+        0,0,15327,15329,3,1212,606,0,15328,15327,1,0,0,0,15328,15329,1,0,
+        0,0,15329,1623,1,0,0,0,15330,15335,3,1636,818,0,15331,15335,3,1630,
+        815,0,15332,15335,3,1626,813,0,15333,15335,3,1662,831,0,15334,15330,
+        1,0,0,0,15334,15331,1,0,0,0,15334,15332,1,0,0,0,15334,15333,1,0,
+        0,0,15335,1625,1,0,0,0,15336,15337,5,981,0,0,15337,15338,5,1014,
+        0,0,15338,15339,5,2085,0,0,15339,15340,3,1628,814,0,15340,15341,
+        5,1588,0,0,15341,15342,5,69,0,0,15342,15343,7,195,0,0,15343,1627,
+        1,0,0,0,15344,15345,3,2368,1184,0,15345,1629,1,0,0,0,15346,15347,
+        5,1561,0,0,15347,15348,5,237,0,0,15348,15349,3,1632,816,0,15349,
+        15350,5,2143,0,0,15350,15351,3,1634,817,0,15351,1631,1,0,0,0,15352,
+        15353,3,2366,1183,0,15353,1633,1,0,0,0,15354,15355,3,2366,1183,0,
+        15355,1635,1,0,0,0,15356,15361,3,1722,861,0,15357,15361,3,1648,824,
+        0,15358,15361,3,1640,820,0,15359,15361,3,1638,819,0,15360,15356,
+        1,0,0,0,15360,15357,1,0,0,0,15360,15358,1,0,0,0,15360,15359,1,0,
+        0,0,15361,15362,1,0,0,0,15362,15360,1,0,0,0,15362,15363,1,0,0,0,
+        15363,1637,1,0,0,0,15364,15365,5,1673,0,0,15365,15379,5,2206,0,0,
+        15366,15367,5,237,0,0,15367,15380,3,2366,1183,0,15368,15369,5,2449,
+        0,0,15369,15374,3,2366,1183,0,15370,15371,5,2455,0,0,15371,15373,
+        3,2366,1183,0,15372,15370,1,0,0,0,15373,15376,1,0,0,0,15374,15372,
+        1,0,0,0,15374,15375,1,0,0,0,15375,15377,1,0,0,0,15376,15374,1,0,
+        0,0,15377,15378,5,2450,0,0,15378,15380,1,0,0,0,15379,15366,1,0,0,
+        0,15379,15368,1,0,0,0,15380,15386,1,0,0,0,15381,15382,5,179,0,0,
+        15382,15385,5,287,0,0,15383,15385,5,781,0,0,15384,15381,1,0,0,0,
+        15384,15383,1,0,0,0,15385,15388,1,0,0,0,15386,15384,1,0,0,0,15386,
+        15387,1,0,0,0,15387,15427,1,0,0,0,15388,15386,1,0,0,0,15389,15403,
+        5,469,0,0,15390,15391,5,237,0,0,15391,15404,3,2366,1183,0,15392,
+        15393,5,2449,0,0,15393,15398,3,2366,1183,0,15394,15395,5,2455,0,
+        0,15395,15397,3,2366,1183,0,15396,15394,1,0,0,0,15397,15400,1,0,
+        0,0,15398,15396,1,0,0,0,15398,15399,1,0,0,0,15399,15401,1,0,0,0,
+        15400,15398,1,0,0,0,15401,15402,5,2450,0,0,15402,15404,1,0,0,0,15403,
+        15390,1,0,0,0,15403,15392,1,0,0,0,15404,15410,1,0,0,0,15405,15406,
+        5,179,0,0,15406,15409,5,287,0,0,15407,15409,5,781,0,0,15408,15405,
+        1,0,0,0,15408,15407,1,0,0,0,15409,15412,1,0,0,0,15410,15408,1,0,
+        0,0,15410,15411,1,0,0,0,15411,15415,1,0,0,0,15412,15410,1,0,0,0,
+        15413,15414,5,201,0,0,15414,15416,5,2443,0,0,15415,15413,1,0,0,0,
+        15415,15416,1,0,0,0,15416,15427,1,0,0,0,15417,15422,5,469,0,0,15418,
+        15419,5,2206,0,0,15419,15423,5,238,0,0,15420,15421,5,238,0,0,15421,
+        15423,5,297,0,0,15422,15418,1,0,0,0,15422,15420,1,0,0,0,15423,15424,
+        1,0,0,0,15424,15425,5,201,0,0,15425,15427,5,2443,0,0,15426,15364,
+        1,0,0,0,15426,15389,1,0,0,0,15426,15417,1,0,0,0,15427,1639,1,0,0,
+        0,15428,15454,5,981,0,0,15429,15430,5,2449,0,0,15430,15435,3,1642,
+        821,0,15431,15432,5,2455,0,0,15432,15434,3,1642,821,0,15433,15431,
+        1,0,0,0,15434,15437,1,0,0,0,15435,15433,1,0,0,0,15435,15436,1,0,
+        0,0,15436,15438,1,0,0,0,15437,15435,1,0,0,0,15438,15439,5,2450,0,
+        0,15439,15455,1,0,0,0,15440,15441,5,2449,0,0,15441,15446,3,1644,
+        822,0,15442,15443,5,2455,0,0,15443,15445,3,1644,822,0,15444,15442,
+        1,0,0,0,15445,15448,1,0,0,0,15446,15444,1,0,0,0,15446,15447,1,0,
+        0,0,15447,15449,1,0,0,0,15448,15446,1,0,0,0,15449,15450,5,2450,0,
+        0,15450,15455,1,0,0,0,15451,15455,3,1642,821,0,15452,15455,3,1644,
+        822,0,15453,15455,3,1646,823,0,15454,15429,1,0,0,0,15454,15440,1,
+        0,0,0,15454,15451,1,0,0,0,15454,15452,1,0,0,0,15454,15453,1,0,0,
+        0,15455,1641,1,0,0,0,15456,15458,3,2366,1183,0,15457,15459,3,2402,
+        1201,0,15458,15457,1,0,0,0,15458,15459,1,0,0,0,15459,15469,1,0,0,
+        0,15460,15463,5,389,0,0,15461,15462,5,1261,0,0,15462,15464,5,1230,
+        0,0,15463,15461,1,0,0,0,15463,15464,1,0,0,0,15464,15465,1,0,0,0,
+        15465,15470,3,2100,1050,0,15466,15470,3,1694,847,0,15467,15468,5,
+        469,0,0,15468,15470,5,688,0,0,15469,15460,1,0,0,0,15469,15466,1,
+        0,0,0,15469,15467,1,0,0,0,15469,15470,1,0,0,0,15470,15474,1,0,0,
+        0,15471,15472,5,505,0,0,15472,15475,3,1674,837,0,15473,15475,5,387,
+        0,0,15474,15471,1,0,0,0,15474,15473,1,0,0,0,15474,15475,1,0,0,0,
+        15475,15479,1,0,0,0,15476,15478,3,858,429,0,15477,15476,1,0,0,0,
+        15478,15481,1,0,0,0,15479,15477,1,0,0,0,15479,15480,1,0,0,0,15480,
+        15483,1,0,0,0,15481,15479,1,0,0,0,15482,15484,3,1660,830,0,15483,
+        15482,1,0,0,0,15483,15484,1,0,0,0,15484,15486,1,0,0,0,15485,15487,
+        3,2270,1135,0,15486,15485,1,0,0,0,15486,15487,1,0,0,0,15487,1643,
+        1,0,0,0,15488,15489,3,2366,1183,0,15489,15490,7,70,0,0,15490,1645,
+        1,0,0,0,15491,15492,5,237,0,0,15492,15494,3,2366,1183,0,15493,15495,
+        5,1206,0,0,15494,15493,1,0,0,0,15494,15495,1,0,0,0,15495,15496,1,
+        0,0,0,15496,15497,5,1782,0,0,15497,15498,5,82,0,0,15498,15499,5,
+        38,0,0,15499,15501,5,849,0,0,15500,15502,5,617,0,0,15501,15500,1,
+        0,0,0,15501,15502,1,0,0,0,15502,1647,1,0,0,0,15503,15525,5,21,0,
+        0,15504,15507,5,2449,0,0,15505,15508,3,1690,845,0,15506,15508,3,
+        1700,850,0,15507,15505,1,0,0,0,15507,15506,1,0,0,0,15508,15516,1,
+        0,0,0,15509,15512,5,2455,0,0,15510,15513,3,1690,845,0,15511,15513,
+        3,1700,850,0,15512,15510,1,0,0,0,15512,15511,1,0,0,0,15513,15515,
+        1,0,0,0,15514,15509,1,0,0,0,15515,15518,1,0,0,0,15516,15514,1,0,
+        0,0,15516,15517,1,0,0,0,15517,15519,1,0,0,0,15518,15516,1,0,0,0,
+        15519,15520,5,2450,0,0,15520,15526,1,0,0,0,15521,15524,3,1690,845,
+        0,15522,15524,3,1700,850,0,15523,15521,1,0,0,0,15523,15522,1,0,0,
+        0,15524,15526,1,0,0,0,15525,15504,1,0,0,0,15525,15523,1,0,0,0,15526,
+        15528,1,0,0,0,15527,15529,3,1680,840,0,15528,15527,1,0,0,0,15528,
+        15529,1,0,0,0,15529,1649,1,0,0,0,15530,15531,5,2269,0,0,15531,15537,
+        3,1678,839,0,15532,15534,3,1714,857,0,15533,15532,1,0,0,0,15533,
+        15534,1,0,0,0,15534,15535,1,0,0,0,15535,15538,3,1652,826,0,15536,
+        15538,3,1714,857,0,15537,15533,1,0,0,0,15537,15536,1,0,0,0,15538,
+        1651,1,0,0,0,15539,15540,5,1765,0,0,15540,15542,5,69,0,0,15541,15543,
+        7,122,0,0,15542,15541,1,0,0,0,15542,15543,1,0,0,0,15543,15544,1,
+        0,0,0,15544,15553,5,869,0,0,15545,15547,3,1654,827,0,15546,15545,
+        1,0,0,0,15546,15547,1,0,0,0,15547,15548,1,0,0,0,15548,15549,5,2449,
+        0,0,15549,15550,3,1658,829,0,15550,15551,5,2450,0,0,15551,15554,
+        1,0,0,0,15552,15554,3,1654,827,0,15553,15546,1,0,0,0,15553,15552,
+        1,0,0,0,15553,15554,1,0,0,0,15554,1653,1,0,0,0,15555,15558,3,2436,
+        1218,0,15556,15558,5,2446,0,0,15557,15555,1,0,0,0,15557,15556,1,
+        0,0,0,15558,1655,1,0,0,0,15559,15563,3,2436,1218,0,15560,15563,3,
+        2426,1213,0,15561,15563,5,2446,0,0,15562,15559,1,0,0,0,15562,15560,
+        1,0,0,0,15562,15561,1,0,0,0,15563,1657,1,0,0,0,15564,15565,5,2082,
+        0,0,15565,15572,3,2430,1215,0,15566,15568,3,1666,833,0,15567,15569,
+        3,1208,604,0,15568,15567,1,0,0,0,15568,15569,1,0,0,0,15569,15572,
+        1,0,0,0,15570,15572,3,1208,604,0,15571,15564,1,0,0,0,15571,15566,
+        1,0,0,0,15571,15570,1,0,0,0,15572,1659,1,0,0,0,15573,15618,5,869,
+        0,0,15574,15575,5,2449,0,0,15575,15580,3,1656,828,0,15576,15577,
+        5,2455,0,0,15577,15579,3,1656,828,0,15578,15576,1,0,0,0,15579,15582,
+        1,0,0,0,15580,15578,1,0,0,0,15580,15581,1,0,0,0,15581,15583,1,0,
+        0,0,15582,15580,1,0,0,0,15583,15584,5,2450,0,0,15584,15585,5,1765,
+        0,0,15585,15595,5,69,0,0,15586,15596,7,122,0,0,15587,15591,5,2449,
+        0,0,15588,15590,3,1658,829,0,15589,15588,1,0,0,0,15590,15593,1,0,
+        0,0,15591,15589,1,0,0,0,15591,15592,1,0,0,0,15592,15594,1,0,0,0,
+        15593,15591,1,0,0,0,15594,15596,5,2450,0,0,15595,15586,1,0,0,0,15595,
+        15587,1,0,0,0,15596,15597,1,0,0,0,15597,15595,1,0,0,0,15597,15598,
+        1,0,0,0,15598,15619,1,0,0,0,15599,15600,5,2449,0,0,15600,15601,3,
+        1656,828,0,15601,15602,5,2450,0,0,15602,15603,5,1765,0,0,15603,15614,
+        5,69,0,0,15604,15615,7,122,0,0,15605,15615,3,1654,827,0,15606,15610,
+        5,2449,0,0,15607,15609,3,1658,829,0,15608,15607,1,0,0,0,15609,15612,
+        1,0,0,0,15610,15608,1,0,0,0,15610,15611,1,0,0,0,15611,15613,1,0,
+        0,0,15612,15610,1,0,0,0,15613,15615,5,2450,0,0,15614,15604,1,0,0,
+        0,15614,15605,1,0,0,0,15614,15606,1,0,0,0,15615,15616,1,0,0,0,15616,
+        15614,1,0,0,0,15616,15617,1,0,0,0,15617,15619,1,0,0,0,15618,15574,
+        1,0,0,0,15618,15599,1,0,0,0,15619,1661,1,0,0,0,15620,15621,5,981,
+        0,0,15621,15622,5,869,0,0,15622,15623,5,2449,0,0,15623,15624,3,1656,
+        828,0,15624,15625,5,2450,0,0,15625,15626,5,2449,0,0,15626,15627,
+        3,1664,832,0,15627,15628,5,2450,0,0,15628,1663,1,0,0,0,15629,15654,
+        3,1208,604,0,15630,15631,7,196,0,0,15631,15654,5,2443,0,0,15632,
+        15633,5,1513,0,0,15633,15654,5,627,0,0,15634,15654,3,1672,836,0,
+        15635,15654,3,1668,834,0,15636,15654,3,1670,835,0,15637,15638,5,
+        505,0,0,15638,15654,3,1674,837,0,15639,15654,5,387,0,0,15640,15654,
+        5,166,0,0,15641,15646,5,166,0,0,15642,15646,5,1067,0,0,15643,15644,
+        5,166,0,0,15644,15646,5,1508,0,0,15645,15641,1,0,0,0,15645,15642,
+        1,0,0,0,15645,15643,1,0,0,0,15646,15648,1,0,0,0,15647,15649,3,898,
+        449,0,15648,15647,1,0,0,0,15648,15649,1,0,0,0,15649,15654,1,0,0,
+        0,15650,15654,3,1296,648,0,15651,15654,3,1300,650,0,15652,15654,
+        3,1298,649,0,15653,15629,1,0,0,0,15653,15630,1,0,0,0,15653,15632,
+        1,0,0,0,15653,15634,1,0,0,0,15653,15635,1,0,0,0,15653,15636,1,0,
+        0,0,15653,15637,1,0,0,0,15653,15639,1,0,0,0,15653,15640,1,0,0,0,
+        15653,15645,1,0,0,0,15653,15650,1,0,0,0,15653,15651,1,0,0,0,15653,
+        15652,1,0,0,0,15654,15655,1,0,0,0,15655,15653,1,0,0,0,15655,15656,
+        1,0,0,0,15656,1665,1,0,0,0,15657,15658,7,17,0,0,15658,15659,5,1764,
+        0,0,15659,15660,5,739,0,0,15660,15662,5,1608,0,0,15661,15663,5,2443,
+        0,0,15662,15661,1,0,0,0,15662,15663,1,0,0,0,15663,15686,1,0,0,0,
+        15664,15665,5,205,0,0,15665,15686,5,2443,0,0,15666,15667,5,1375,
+        0,0,15667,15686,5,2443,0,0,15668,15669,5,627,0,0,15669,15686,5,2443,
+        0,0,15670,15686,3,1672,836,0,15671,15686,3,1668,834,0,15672,15686,
+        3,1670,835,0,15673,15674,5,505,0,0,15674,15686,3,1674,837,0,15675,
+        15686,5,387,0,0,15676,15681,5,166,0,0,15677,15681,5,1067,0,0,15678,
+        15679,5,166,0,0,15679,15681,5,1508,0,0,15680,15676,1,0,0,0,15680,
+        15677,1,0,0,0,15680,15678,1,0,0,0,15681,15683,1,0,0,0,15682,15684,
+        3,898,449,0,15683,15682,1,0,0,0,15683,15684,1,0,0,0,15684,15686,
+        1,0,0,0,15685,15657,1,0,0,0,15685,15664,1,0,0,0,15685,15666,1,0,
+        0,0,15685,15668,1,0,0,0,15685,15670,1,0,0,0,15685,15671,1,0,0,0,
+        15685,15672,1,0,0,0,15685,15673,1,0,0,0,15685,15675,1,0,0,0,15685,
+        15680,1,0,0,0,15686,15687,1,0,0,0,15687,15685,1,0,0,0,15687,15688,
+        1,0,0,0,15688,1667,1,0,0,0,15689,15690,7,197,0,0,15690,1669,1,0,
+        0,0,15691,15697,5,1075,0,0,15692,15694,5,258,0,0,15693,15695,7,198,
+        0,0,15694,15693,1,0,0,0,15694,15695,1,0,0,0,15695,15697,1,0,0,0,
+        15696,15691,1,0,0,0,15696,15692,1,0,0,0,15697,1671,1,0,0,0,15698,
+        15704,5,1585,0,0,15699,15705,5,2408,0,0,15700,15701,5,2411,0,0,15701,
+        15705,5,2443,0,0,15702,15705,5,91,0,0,15703,15705,5,1134,0,0,15704,
+        15699,1,0,0,0,15704,15700,1,0,0,0,15704,15702,1,0,0,0,15704,15703,
+        1,0,0,0,15704,15705,1,0,0,0,15705,1673,1,0,0,0,15706,15707,5,2248,
+        0,0,15707,15709,5,2445,0,0,15708,15706,1,0,0,0,15708,15709,1,0,0,
+        0,15709,15713,1,0,0,0,15710,15711,5,686,0,0,15711,15712,5,160,0,
+        0,15712,15714,5,2482,0,0,15713,15710,1,0,0,0,15713,15714,1,0,0,0,
+        15714,15716,1,0,0,0,15715,15717,5,2445,0,0,15716,15715,1,0,0,0,15716,
+        15717,1,0,0,0,15717,15722,1,0,0,0,15718,15720,5,1139,0,0,15719,15718,
+        1,0,0,0,15719,15720,1,0,0,0,15720,15721,1,0,0,0,15721,15723,5,1615,
+        0,0,15722,15719,1,0,0,0,15722,15723,1,0,0,0,15723,1675,1,0,0,0,15724,
+        15725,3,2430,1215,0,15725,1677,1,0,0,0,15726,15727,3,2430,1215,0,
+        15727,15728,5,2442,0,0,15728,15730,1,0,0,0,15729,15726,1,0,0,0,15729,
+        15730,1,0,0,0,15730,15734,1,0,0,0,15731,15732,3,2430,1215,0,15732,
+        15733,5,2442,0,0,15733,15735,1,0,0,0,15734,15731,1,0,0,0,15734,15735,
+        1,0,0,0,15735,15736,1,0,0,0,15736,15737,3,2430,1215,0,15737,1679,
+        1,0,0,0,15738,15759,3,1720,860,0,15739,15759,3,1710,855,0,15740,
+        15743,3,1650,825,0,15741,15743,3,1660,830,0,15742,15740,1,0,0,0,
+        15742,15741,1,0,0,0,15743,15755,1,0,0,0,15744,15745,5,2449,0,0,15745,
+        15750,3,1682,841,0,15746,15747,5,2455,0,0,15747,15749,3,1682,841,
+        0,15748,15746,1,0,0,0,15749,15752,1,0,0,0,15750,15748,1,0,0,0,15750,
+        15751,1,0,0,0,15751,15753,1,0,0,0,15752,15750,1,0,0,0,15753,15754,
+        5,2450,0,0,15754,15756,1,0,0,0,15755,15744,1,0,0,0,15755,15756,1,
+        0,0,0,15756,15759,1,0,0,0,15757,15759,3,1056,528,0,15758,15738,1,
+        0,0,0,15758,15739,1,0,0,0,15758,15742,1,0,0,0,15758,15757,1,0,0,
+        0,15759,15760,1,0,0,0,15760,15758,1,0,0,0,15760,15761,1,0,0,0,15761,
+        1681,1,0,0,0,15762,15795,5,869,0,0,15763,15764,5,2449,0,0,15764,
+        15765,3,1656,828,0,15765,15766,5,2455,0,0,15766,15767,3,1656,828,
+        0,15767,15768,1,0,0,0,15768,15769,5,2450,0,0,15769,15770,5,1765,
+        0,0,15770,15776,5,69,0,0,15771,15777,7,122,0,0,15772,15773,5,2449,
+        0,0,15773,15774,3,1658,829,0,15774,15775,5,2450,0,0,15775,15777,
+        1,0,0,0,15776,15771,1,0,0,0,15776,15772,1,0,0,0,15777,15778,1,0,
+        0,0,15778,15776,1,0,0,0,15778,15779,1,0,0,0,15779,15796,1,0,0,0,
+        15780,15781,5,2449,0,0,15781,15782,3,1656,828,0,15782,15783,5,2450,
+        0,0,15783,15784,5,1765,0,0,15784,15791,5,69,0,0,15785,15792,7,122,
+        0,0,15786,15792,3,1654,827,0,15787,15788,5,2449,0,0,15788,15789,
+        3,1658,829,0,15789,15790,5,2450,0,0,15790,15792,1,0,0,0,15791,15785,
+        1,0,0,0,15791,15786,1,0,0,0,15791,15787,1,0,0,0,15792,15793,1,0,
+        0,0,15793,15791,1,0,0,0,15793,15794,1,0,0,0,15794,15796,1,0,0,0,
+        15795,15763,1,0,0,0,15795,15780,1,0,0,0,15796,1683,1,0,0,0,15797,
+        15798,4,842,12,0,15798,15799,5,2442,0,0,15799,15800,5,621,0,0,15800,
+        15807,3,2366,1183,0,15801,15802,5,2449,0,0,15802,15803,3,1686,843,
+        0,15803,15804,5,2455,0,0,15804,15805,3,1688,844,0,15805,15806,5,
+        2450,0,0,15806,15808,1,0,0,0,15807,15801,1,0,0,0,15807,15808,1,0,
+        0,0,15808,1685,1,0,0,0,15809,15810,3,2366,1183,0,15810,1687,1,0,
+        0,0,15811,15812,3,2366,1183,0,15812,1689,1,0,0,0,15813,15822,3,2366,
+        1183,0,15814,15817,3,2402,1201,0,15815,15817,3,2340,1170,0,15816,
+        15814,1,0,0,0,15816,15815,1,0,0,0,15817,15820,1,0,0,0,15818,15819,
+        5,2374,0,0,15819,15821,3,1692,846,0,15820,15818,1,0,0,0,15820,15821,
+        1,0,0,0,15821,15823,1,0,0,0,15822,15816,1,0,0,0,15822,15823,1,0,
+        0,0,15823,15825,1,0,0,0,15824,15826,5,1711,0,0,15825,15824,1,0,0,
+        0,15825,15826,1,0,0,0,15826,15828,1,0,0,0,15827,15829,7,70,0,0,15828,
+        15827,1,0,0,0,15828,15829,1,0,0,0,15829,15837,1,0,0,0,15830,15833,
+        5,389,0,0,15831,15832,5,1261,0,0,15832,15834,5,1230,0,0,15833,15831,
+        1,0,0,0,15833,15834,1,0,0,0,15834,15835,1,0,0,0,15835,15838,3,2100,
+        1050,0,15836,15838,3,1694,847,0,15837,15830,1,0,0,0,15837,15836,
+        1,0,0,0,15837,15838,1,0,0,0,15838,15841,1,0,0,0,15839,15840,5,505,
+        0,0,15840,15842,3,1674,837,0,15841,15839,1,0,0,0,15841,15842,1,0,
+        0,0,15842,15849,1,0,0,0,15843,15845,3,858,429,0,15844,15843,1,0,
+        0,0,15845,15846,1,0,0,0,15846,15844,1,0,0,0,15846,15847,1,0,0,0,
+        15847,15850,1,0,0,0,15848,15850,3,860,430,0,15849,15844,1,0,0,0,
+        15849,15848,1,0,0,0,15849,15850,1,0,0,0,15850,15852,1,0,0,0,15851,
+        15853,3,2270,1135,0,15852,15851,1,0,0,0,15852,15853,1,0,0,0,15853,
+        1691,1,0,0,0,15854,15855,3,2430,1215,0,15855,1693,1,0,0,0,15856,
+        15864,5,641,0,0,15857,15865,5,44,0,0,15858,15859,5,160,0,0,15859,
+        15862,5,389,0,0,15860,15861,5,1261,0,0,15861,15863,5,1230,0,0,15862,
+        15860,1,0,0,0,15862,15863,1,0,0,0,15863,15865,1,0,0,0,15864,15857,
+        1,0,0,0,15864,15858,1,0,0,0,15864,15865,1,0,0,0,15865,15866,1,0,
+        0,0,15866,15867,5,69,0,0,15867,15869,5,688,0,0,15868,15870,3,1696,
+        848,0,15869,15868,1,0,0,0,15869,15870,1,0,0,0,15870,1695,1,0,0,0,
+        15871,15873,3,1698,849,0,15872,15871,1,0,0,0,15873,15874,1,0,0,0,
+        15874,15872,1,0,0,0,15874,15875,1,0,0,0,15875,15885,1,0,0,0,15876,
+        15878,5,2449,0,0,15877,15879,3,1698,849,0,15878,15877,1,0,0,0,15879,
+        15880,1,0,0,0,15880,15878,1,0,0,0,15880,15881,1,0,0,0,15881,15882,
+        1,0,0,0,15882,15883,5,2450,0,0,15883,15885,1,0,0,0,15884,15872,1,
+        0,0,0,15884,15876,1,0,0,0,15885,1697,1,0,0,0,15886,15887,5,1739,
+        0,0,15887,15891,5,2310,0,0,15888,15892,3,2422,1211,0,15889,15890,
+        5,859,0,0,15890,15892,5,2260,0,0,15891,15888,1,0,0,0,15891,15889,
+        1,0,0,0,15892,15915,1,0,0,0,15893,15894,5,708,0,0,15894,15895,5,
+        160,0,0,15895,15915,3,2422,1211,0,15896,15897,5,933,0,0,15897,15915,
+        3,2422,1211,0,15898,15915,5,1122,0,0,15899,15900,5,961,0,0,15900,
+        15915,3,2422,1211,0,15901,15915,5,1125,0,0,15902,15915,5,348,0,0,
+        15903,15915,5,1085,0,0,15904,15905,5,166,0,0,15905,15915,3,2422,
+        1211,0,15906,15915,5,1067,0,0,15907,15915,5,1305,0,0,15908,15915,
+        5,1142,0,0,15909,15910,5,1622,0,0,15910,15915,7,49,0,0,15911,15915,
+        5,1183,0,0,15912,15915,5,815,0,0,15913,15915,5,1115,0,0,15914,15886,
+        1,0,0,0,15914,15893,1,0,0,0,15914,15896,1,0,0,0,15914,15898,1,0,
+        0,0,15914,15899,1,0,0,0,15914,15901,1,0,0,0,15914,15902,1,0,0,0,
+        15914,15903,1,0,0,0,15914,15904,1,0,0,0,15914,15906,1,0,0,0,15914,
+        15907,1,0,0,0,15914,15908,1,0,0,0,15914,15909,1,0,0,0,15914,15911,
+        1,0,0,0,15914,15912,1,0,0,0,15914,15913,1,0,0,0,15915,1699,1,0,0,
+        0,15916,15922,3,2366,1183,0,15917,15920,3,2402,1201,0,15918,15919,
+        5,2374,0,0,15919,15921,3,1692,846,0,15920,15918,1,0,0,0,15920,15921,
+        1,0,0,0,15921,15923,1,0,0,0,15922,15917,1,0,0,0,15922,15923,1,0,
+        0,0,15923,15925,1,0,0,0,15924,15926,7,70,0,0,15925,15924,1,0,0,0,
+        15925,15926,1,0,0,0,15926,15928,1,0,0,0,15927,15929,3,1702,851,0,
+        15928,15927,1,0,0,0,15928,15929,1,0,0,0,15929,15931,1,0,0,0,15930,
+        15932,5,2290,0,0,15931,15930,1,0,0,0,15931,15932,1,0,0,0,15932,15934,
+        1,0,0,0,15933,15935,3,1708,854,0,15934,15933,1,0,0,0,15934,15935,
+        1,0,0,0,15935,15944,1,0,0,0,15936,15937,5,2205,0,0,15937,15942,5,
+        112,0,0,15938,15939,5,336,0,0,15939,15943,5,483,0,0,15940,15941,
+        5,483,0,0,15941,15943,3,1466,733,0,15942,15938,1,0,0,0,15942,15940,
+        1,0,0,0,15943,15945,1,0,0,0,15944,15936,1,0,0,0,15944,15945,1,0,
+        0,0,15945,15955,1,0,0,0,15946,15947,5,2205,0,0,15947,15948,5,114,
+        0,0,15948,15953,5,2310,0,0,15949,15950,7,199,0,0,15950,15954,5,483,
+        0,0,15951,15952,5,483,0,0,15952,15954,3,1466,733,0,15953,15949,1,
+        0,0,0,15953,15951,1,0,0,0,15954,15956,1,0,0,0,15955,15946,1,0,0,
+        0,15955,15956,1,0,0,0,15956,15960,1,0,0,0,15957,15959,3,858,429,
+        0,15958,15957,1,0,0,0,15959,15962,1,0,0,0,15960,15958,1,0,0,0,15960,
+        15961,1,0,0,0,15961,15964,1,0,0,0,15962,15960,1,0,0,0,15963,15965,
+        3,1706,853,0,15964,15963,1,0,0,0,15964,15965,1,0,0,0,15965,1701,
+        1,0,0,0,15966,15979,3,1704,852,0,15967,15969,5,641,0,0,15968,15970,
+        5,44,0,0,15969,15968,1,0,0,0,15969,15970,1,0,0,0,15970,15972,1,0,
+        0,0,15971,15967,1,0,0,0,15971,15972,1,0,0,0,15972,15973,1,0,0,0,
+        15973,15974,5,69,0,0,15974,15975,5,2449,0,0,15975,15976,3,2100,1050,
+        0,15976,15977,5,2450,0,0,15977,15979,1,0,0,0,15978,15966,1,0,0,0,
+        15978,15971,1,0,0,0,15979,1703,1,0,0,0,15980,15988,5,641,0,0,15981,
+        15989,5,44,0,0,15982,15983,5,160,0,0,15983,15986,5,389,0,0,15984,
+        15985,5,1261,0,0,15985,15987,5,1230,0,0,15986,15984,1,0,0,0,15986,
+        15987,1,0,0,0,15987,15989,1,0,0,0,15988,15981,1,0,0,0,15988,15982,
+        1,0,0,0,15988,15989,1,0,0,0,15989,15990,1,0,0,0,15990,15991,5,69,
+        0,0,15991,16001,5,688,0,0,15992,15997,5,2449,0,0,15993,15996,3,340,
+        170,0,15994,15996,3,338,169,0,15995,15993,1,0,0,0,15995,15994,1,
+        0,0,0,15996,15999,1,0,0,0,15997,15995,1,0,0,0,15997,15998,1,0,0,
+        0,15998,16000,1,0,0,0,15999,15997,1,0,0,0,16000,16002,5,2450,0,0,
+        16001,15992,1,0,0,0,16001,16002,1,0,0,0,16002,1705,1,0,0,0,16003,
+        16004,5,160,0,0,16004,16005,5,2239,0,0,16005,16006,5,621,0,0,16006,
+        16007,5,1748,0,0,16007,1707,1,0,0,0,16008,16009,5,530,0,0,16009,
+        16014,5,2248,0,0,16010,16011,7,199,0,0,16011,16015,5,483,0,0,16012,
+        16013,5,483,0,0,16013,16015,3,1466,733,0,16014,16010,1,0,0,0,16014,
+        16012,1,0,0,0,16015,1709,1,0,0,0,16016,16017,5,1014,0,0,16017,16020,
+        5,2085,0,0,16018,16021,3,1712,856,0,16019,16021,5,240,0,0,16020,
+        16018,1,0,0,0,16020,16019,1,0,0,0,16021,16023,1,0,0,0,16022,16024,
+        3,1714,857,0,16023,16022,1,0,0,0,16023,16024,1,0,0,0,16024,16026,
+        1,0,0,0,16025,16027,7,200,0,0,16026,16025,1,0,0,0,16026,16027,1,
+        0,0,0,16027,16028,1,0,0,0,16028,16029,5,1765,0,0,16029,16030,5,69,
+        0,0,16030,16044,3,2368,1184,0,16031,16038,5,2449,0,0,16032,16033,
+        5,2449,0,0,16033,16034,3,1070,535,0,16034,16035,5,2450,0,0,16035,
+        16039,1,0,0,0,16036,16039,3,1214,607,0,16037,16039,3,1680,840,0,
+        16038,16032,1,0,0,0,16038,16036,1,0,0,0,16038,16037,1,0,0,0,16039,
+        16040,1,0,0,0,16040,16038,1,0,0,0,16040,16041,1,0,0,0,16041,16042,
+        1,0,0,0,16042,16043,5,2450,0,0,16043,16045,1,0,0,0,16044,16031,1,
+        0,0,0,16044,16045,1,0,0,0,16045,16051,1,0,0,0,16046,16048,5,1588,
+        0,0,16047,16049,5,69,0,0,16048,16047,1,0,0,0,16048,16049,1,0,0,0,
+        16049,16050,1,0,0,0,16050,16052,7,195,0,0,16051,16046,1,0,0,0,16051,
+        16052,1,0,0,0,16052,1711,1,0,0,0,16053,16054,3,2436,1218,0,16054,
+        1713,1,0,0,0,16055,16057,5,486,0,0,16056,16055,1,0,0,0,16056,16057,
+        1,0,0,0,16057,16058,1,0,0,0,16058,16059,5,786,0,0,16059,16061,5,
+        1248,0,0,16060,16062,5,2168,0,0,16061,16060,1,0,0,0,16061,16062,
+        1,0,0,0,16062,16063,1,0,0,0,16063,16064,5,2449,0,0,16064,16065,3,
+        2340,1170,0,16065,16066,5,2450,0,0,16066,16075,1,0,0,0,16067,16069,
+        5,1206,0,0,16068,16067,1,0,0,0,16068,16069,1,0,0,0,16069,16070,1,
+        0,0,0,16070,16071,5,1782,0,0,16071,16072,5,82,0,0,16072,16073,5,
+        38,0,0,16073,16075,5,849,0,0,16074,16056,1,0,0,0,16074,16068,1,0,
+        0,0,16075,1715,1,0,0,0,16076,16079,3,2436,1218,0,16077,16079,5,2446,
+        0,0,16078,16076,1,0,0,0,16078,16077,1,0,0,0,16079,1717,1,0,0,0,16080,
+        16081,5,1791,0,0,16081,16084,5,889,0,0,16082,16085,3,1292,646,0,
+        16083,16085,3,1294,647,0,16084,16082,1,0,0,0,16084,16083,1,0,0,0,
+        16085,1719,1,0,0,0,16086,16087,5,237,0,0,16087,16088,3,2436,1218,
+        0,16088,16089,3,1714,857,0,16089,1721,1,0,0,0,16090,16091,5,21,0,
+        0,16091,16101,5,2449,0,0,16092,16097,3,864,432,0,16093,16094,5,2455,
+        0,0,16094,16096,3,864,432,0,16095,16093,1,0,0,0,16096,16099,1,0,
+        0,0,16097,16095,1,0,0,0,16097,16098,1,0,0,0,16098,16102,1,0,0,0,
+        16099,16097,1,0,0,0,16100,16102,3,862,431,0,16101,16092,1,0,0,0,
+        16101,16100,1,0,0,0,16102,16103,1,0,0,0,16103,16104,5,2450,0,0,16104,
+        16145,1,0,0,0,16105,16108,5,21,0,0,16106,16109,3,864,432,0,16107,
+        16109,3,862,431,0,16108,16106,1,0,0,0,16108,16107,1,0,0,0,16109,
+        16145,1,0,0,0,16110,16127,5,981,0,0,16111,16112,5,286,0,0,16112,
+        16128,3,2336,1168,0,16113,16114,5,1453,0,0,16114,16128,5,817,0,0,
+        16115,16116,5,2185,0,0,16116,16117,5,2449,0,0,16117,16122,3,2366,
+        1183,0,16118,16119,5,2455,0,0,16119,16121,3,2366,1183,0,16120,16118,
+        1,0,0,0,16121,16124,1,0,0,0,16122,16120,1,0,0,0,16122,16123,1,0,
+        0,0,16123,16125,1,0,0,0,16124,16122,1,0,0,0,16125,16126,5,2450,0,
+        0,16126,16128,1,0,0,0,16127,16111,1,0,0,0,16127,16113,1,0,0,0,16127,
+        16115,1,0,0,0,16128,16129,1,0,0,0,16129,16131,3,866,433,0,16130,
+        16132,5,179,0,0,16131,16130,1,0,0,0,16131,16132,1,0,0,0,16132,16145,
+        1,0,0,0,16133,16134,5,1561,0,0,16134,16135,5,286,0,0,16135,16136,
+        3,1724,862,0,16136,16137,5,2143,0,0,16137,16138,3,1726,863,0,16138,
+        16145,1,0,0,0,16139,16141,3,1728,864,0,16140,16139,1,0,0,0,16141,
+        16142,1,0,0,0,16142,16140,1,0,0,0,16142,16143,1,0,0,0,16143,16145,
+        1,0,0,0,16144,16090,1,0,0,0,16144,16105,1,0,0,0,16144,16110,1,0,
+        0,0,16144,16133,1,0,0,0,16144,16140,1,0,0,0,16145,1723,1,0,0,0,16146,
+        16147,3,2336,1168,0,16147,1725,1,0,0,0,16148,16149,3,2336,1168,0,
+        16149,1727,1,0,0,0,16150,16167,5,469,0,0,16151,16152,5,1453,0,0,
+        16152,16168,5,817,0,0,16153,16154,5,2185,0,0,16154,16155,5,2449,
+        0,0,16155,16160,3,2366,1183,0,16156,16157,5,2455,0,0,16157,16159,
+        3,2366,1183,0,16158,16156,1,0,0,0,16159,16162,1,0,0,0,16160,16158,
+        1,0,0,0,16160,16161,1,0,0,0,16161,16163,1,0,0,0,16162,16160,1,0,
+        0,0,16163,16164,5,2450,0,0,16164,16168,1,0,0,0,16165,16166,5,286,
+        0,0,16166,16168,3,2336,1168,0,16167,16151,1,0,0,0,16167,16153,1,
+        0,0,0,16167,16165,1,0,0,0,16168,16170,1,0,0,0,16169,16171,5,179,
+        0,0,16170,16169,1,0,0,0,16170,16171,1,0,0,0,16171,16174,1,0,0,0,
+        16172,16173,7,201,0,0,16173,16175,5,718,0,0,16174,16172,1,0,0,0,
+        16174,16175,1,0,0,0,16175,16177,1,0,0,0,16176,16178,5,1258,0,0,16177,
+        16176,1,0,0,0,16177,16178,1,0,0,0,16178,1729,1,0,0,0,16179,16180,
+        5,200,0,0,16180,16181,5,2449,0,0,16181,16182,3,2096,1048,0,16182,
+        16184,5,2450,0,0,16183,16185,5,429,0,0,16184,16183,1,0,0,0,16184,
+        16185,1,0,0,0,16185,1731,1,0,0,0,16186,16187,5,619,0,0,16187,16188,
+        5,817,0,0,16188,16189,3,2386,1193,0,16189,16191,3,1734,867,0,16190,
+        16192,3,1736,868,0,16191,16190,1,0,0,0,16191,16192,1,0,0,0,16192,
+        1733,1,0,0,0,16193,16194,5,1530,0,0,16194,16196,3,2368,1184,0,16195,
+        16197,3,2386,1193,0,16196,16195,1,0,0,0,16196,16197,1,0,0,0,16197,
+        16205,1,0,0,0,16198,16199,5,1261,0,0,16199,16203,5,403,0,0,16200,
+        16204,5,179,0,0,16201,16202,5,1673,0,0,16202,16204,5,1230,0,0,16203,
+        16200,1,0,0,0,16203,16201,1,0,0,0,16204,16206,1,0,0,0,16205,16198,
+        1,0,0,0,16205,16206,1,0,0,0,16206,1735,1,0,0,0,16207,16208,5,1261,
+        0,0,16208,16212,5,403,0,0,16209,16213,5,179,0,0,16210,16211,5,1673,
+        0,0,16211,16213,5,1230,0,0,16212,16209,1,0,0,0,16212,16210,1,0,0,
+        0,16213,1737,1,0,0,0,16214,16216,5,382,0,0,16215,16217,3,1760,880,
+        0,16216,16215,1,0,0,0,16216,16217,1,0,0,0,16217,16219,1,0,0,0,16218,
+        16214,1,0,0,0,16218,16219,1,0,0,0,16219,16220,1,0,0,0,16220,16221,
+        5,113,0,0,16221,16228,3,1790,895,0,16222,16224,5,535,0,0,16223,16225,
+        3,1842,921,0,16224,16223,1,0,0,0,16225,16226,1,0,0,0,16226,16224,
+        1,0,0,0,16226,16227,1,0,0,0,16227,16229,1,0,0,0,16228,16222,1,0,
+        0,0,16228,16229,1,0,0,0,16229,16230,1,0,0,0,16230,16231,5,508,0,
+        0,16231,1739,1,0,0,0,16232,16233,5,88,0,0,16233,16234,7,92,0,0,16234,
+        1741,1,0,0,0,16235,16238,3,1744,872,0,16236,16238,3,1746,873,0,16237,
+        16235,1,0,0,0,16237,16236,1,0,0,0,16238,1743,1,0,0,0,16239,16240,
+        5,824,0,0,16240,16241,5,793,0,0,16241,16242,5,998,0,0,16242,16243,
+        5,2445,0,0,16243,1745,1,0,0,0,16244,16245,5,824,0,0,16245,16248,
+        5,213,0,0,16246,16248,5,561,0,0,16247,16244,1,0,0,0,16247,16246,
+        1,0,0,0,16248,16260,1,0,0,0,16249,16250,5,998,0,0,16250,16251,3,
+        2430,1215,0,16251,16252,5,850,0,0,16252,16253,3,2428,1214,0,16253,
+        16261,1,0,0,0,16254,16255,5,850,0,0,16255,16258,3,2428,1214,0,16256,
+        16257,5,998,0,0,16257,16259,3,2430,1215,0,16258,16256,1,0,0,0,16258,
+        16259,1,0,0,0,16259,16261,1,0,0,0,16260,16249,1,0,0,0,16260,16254,
+        1,0,0,0,16261,16263,1,0,0,0,16262,16264,3,1748,874,0,16263,16262,
+        1,0,0,0,16263,16264,1,0,0,0,16264,16267,1,0,0,0,16265,16266,5,2310,
+        0,0,16266,16268,5,296,0,0,16267,16265,1,0,0,0,16267,16268,1,0,0,
+        0,16268,16270,1,0,0,0,16269,16271,3,1750,875,0,16270,16269,1,0,0,
+        0,16270,16271,1,0,0,0,16271,1747,1,0,0,0,16272,16273,5,34,0,0,16273,
+        16274,5,739,0,0,16274,16275,5,2449,0,0,16275,16276,3,2098,1049,0,
+        16276,16277,5,2450,0,0,16277,1749,1,0,0,0,16278,16279,5,1337,0,0,
+        16279,16280,5,2449,0,0,16280,16285,3,1752,876,0,16281,16282,5,2455,
+        0,0,16282,16284,3,1752,876,0,16283,16281,1,0,0,0,16284,16287,1,0,
+        0,0,16285,16283,1,0,0,0,16285,16286,1,0,0,0,16286,16288,1,0,0,0,
+        16287,16285,1,0,0,0,16288,16289,5,2450,0,0,16289,1751,1,0,0,0,16290,
+        16311,5,296,0,0,16291,16294,5,1650,0,0,16292,16295,5,2436,0,0,16293,
+        16295,3,1754,877,0,16294,16292,1,0,0,0,16294,16293,1,0,0,0,16294,
+        16295,1,0,0,0,16295,16311,1,0,0,0,16296,16299,3,2320,1160,0,16297,
+        16299,5,1588,0,0,16298,16296,1,0,0,0,16298,16297,1,0,0,0,16299,16301,
+        1,0,0,0,16300,16302,3,1754,877,0,16301,16300,1,0,0,0,16301,16302,
+        1,0,0,0,16302,16305,1,0,0,0,16303,16304,5,160,0,0,16304,16306,5,
+        1529,0,0,16305,16303,1,0,0,0,16305,16306,1,0,0,0,16306,16308,1,0,
+        0,0,16307,16309,3,2436,1218,0,16308,16307,1,0,0,0,16308,16309,1,
+        0,0,0,16309,16311,1,0,0,0,16310,16290,1,0,0,0,16310,16291,1,0,0,
+        0,16310,16298,1,0,0,0,16311,1753,1,0,0,0,16312,16314,5,734,0,0,16313,
+        16315,7,202,0,0,16314,16313,1,0,0,0,16314,16315,1,0,0,0,16315,16322,
+        1,0,0,0,16316,16322,5,845,0,0,16317,16322,5,2430,0,0,16318,16322,
+        5,2432,0,0,16319,16322,5,2428,0,0,16320,16322,5,2429,0,0,16321,16312,
+        1,0,0,0,16321,16316,1,0,0,0,16321,16317,1,0,0,0,16321,16318,1,0,
+        0,0,16321,16319,1,0,0,0,16321,16320,1,0,0,0,16322,1755,1,0,0,0,16323,
+        16327,3,2320,1160,0,16324,16326,7,203,0,0,16325,16324,1,0,0,0,16326,
+        16329,1,0,0,0,16327,16325,1,0,0,0,16327,16328,1,0,0,0,16328,16331,
+        1,0,0,0,16329,16327,1,0,0,0,16330,16332,3,2400,1200,0,16331,16330,
+        1,0,0,0,16331,16332,1,0,0,0,16332,16334,1,0,0,0,16333,16335,3,1758,
+        879,0,16334,16333,1,0,0,0,16334,16335,1,0,0,0,16335,1757,1,0,0,0,
+        16336,16337,7,204,0,0,16337,16338,3,2100,1050,0,16338,1759,1,0,0,
+        0,16339,16341,3,1762,881,0,16340,16339,1,0,0,0,16341,16342,1,0,0,
+        0,16342,16340,1,0,0,0,16342,16343,1,0,0,0,16343,1761,1,0,0,0,16344,
+        16356,3,1774,887,0,16345,16356,3,1772,886,0,16346,16356,3,168,84,
+        0,16347,16356,3,170,85,0,16348,16356,3,1764,882,0,16349,16356,3,
+        1766,883,0,16350,16356,3,1768,884,0,16351,16356,3,1782,891,0,16352,
+        16356,3,184,92,0,16353,16356,3,182,91,0,16354,16356,3,1834,917,0,
+        16355,16344,1,0,0,0,16355,16345,1,0,0,0,16355,16346,1,0,0,0,16355,
+        16347,1,0,0,0,16355,16348,1,0,0,0,16355,16349,1,0,0,0,16355,16350,
+        1,0,0,0,16355,16351,1,0,0,0,16355,16352,1,0,0,0,16355,16353,1,0,
+        0,0,16355,16354,1,0,0,0,16356,1763,1,0,0,0,16357,16359,3,2428,1214,
+        0,16358,16360,5,284,0,0,16359,16358,1,0,0,0,16359,16360,1,0,0,0,
+        16360,16361,1,0,0,0,16361,16366,3,2400,1200,0,16362,16364,5,1206,
+        0,0,16363,16362,1,0,0,0,16363,16364,1,0,0,0,16364,16365,1,0,0,0,
+        16365,16367,5,1230,0,0,16366,16363,1,0,0,0,16366,16367,1,0,0,0,16367,
+        16369,1,0,0,0,16368,16370,3,1758,879,0,16369,16368,1,0,0,0,16369,
+        16370,1,0,0,0,16370,16371,1,0,0,0,16371,16372,5,2472,0,0,16372,1765,
+        1,0,0,0,16373,16374,5,1787,0,0,16374,16375,3,2428,1214,0,16375,16376,
+        5,786,0,0,16376,16382,3,2400,1200,0,16377,16378,5,1497,0,0,16378,
+        16379,3,2100,1050,0,16379,16380,5,2441,0,0,16380,16381,3,2100,1050,
+        0,16381,16383,1,0,0,0,16382,16377,1,0,0,0,16382,16383,1,0,0,0,16383,
+        16386,1,0,0,0,16384,16385,5,1206,0,0,16385,16387,5,1230,0,0,16386,
+        16384,1,0,0,0,16386,16387,1,0,0,0,16387,16388,1,0,0,0,16388,16389,
+        5,2472,0,0,16389,1767,1,0,0,0,16390,16391,5,343,0,0,16391,16403,
+        3,2428,1214,0,16392,16393,5,2449,0,0,16393,16398,3,1770,885,0,16394,
+        16395,5,2455,0,0,16395,16397,3,1770,885,0,16396,16394,1,0,0,0,16397,
+        16400,1,0,0,0,16398,16396,1,0,0,0,16398,16399,1,0,0,0,16399,16401,
+        1,0,0,0,16400,16398,1,0,0,0,16401,16402,5,2450,0,0,16402,16404,1,
+        0,0,0,16403,16392,1,0,0,0,16403,16404,1,0,0,0,16404,16407,1,0,0,
+        0,16405,16406,5,1588,0,0,16406,16408,3,2400,1200,0,16407,16405,1,
+        0,0,0,16407,16408,1,0,0,0,16408,16411,1,0,0,0,16409,16410,5,786,
+        0,0,16410,16412,3,1890,945,0,16411,16409,1,0,0,0,16411,16412,1,0,
+        0,0,16412,16413,1,0,0,0,16413,16414,5,2472,0,0,16414,1769,1,0,0,
+        0,16415,16420,3,2320,1160,0,16416,16418,5,739,0,0,16417,16416,1,
+        0,0,0,16417,16418,1,0,0,0,16418,16419,1,0,0,0,16419,16421,3,2400,
+        1200,0,16420,16417,1,0,0,0,16420,16421,1,0,0,0,16421,16423,1,0,0,
+        0,16422,16424,3,1758,879,0,16423,16422,1,0,0,0,16423,16424,1,0,0,
+        0,16424,1771,1,0,0,0,16425,16426,3,2428,1214,0,16426,16427,5,535,
+        0,0,16427,16428,5,2472,0,0,16428,1773,1,0,0,0,16429,16470,5,1435,
+        0,0,16430,16471,5,1662,0,0,16431,16471,5,96,0,0,16432,16433,5,536,
+        0,0,16433,16434,5,2449,0,0,16434,16435,3,2344,1172,0,16435,16436,
+        5,2455,0,0,16436,16437,3,2424,1212,0,16437,16438,5,2450,0,0,16438,
+        16471,1,0,0,0,16439,16440,5,745,0,0,16440,16441,5,2449,0,0,16441,
+        16442,3,2428,1214,0,16442,16443,5,2455,0,0,16443,16444,3,2100,1050,
+        0,16444,16445,5,2450,0,0,16445,16471,1,0,0,0,16446,16447,5,1579,
+        0,0,16447,16450,5,2449,0,0,16448,16451,3,2428,1214,0,16449,16451,
+        5,389,0,0,16450,16448,1,0,0,0,16450,16449,1,0,0,0,16451,16454,1,
+        0,0,0,16452,16453,5,2455,0,0,16453,16455,3,2428,1214,0,16454,16452,
+        1,0,0,0,16455,16456,1,0,0,0,16456,16454,1,0,0,0,16456,16457,1,0,
+        0,0,16457,16458,1,0,0,0,16458,16459,5,2450,0,0,16459,16471,1,0,0,
+        0,16460,16461,5,409,0,0,16461,16462,5,2449,0,0,16462,16465,3,2428,
+        1214,0,16463,16464,5,2455,0,0,16464,16466,5,2445,0,0,16465,16463,
+        1,0,0,0,16465,16466,1,0,0,0,16466,16467,1,0,0,0,16467,16468,5,2450,
+        0,0,16468,16471,1,0,0,0,16469,16471,5,2173,0,0,16470,16430,1,0,0,
+        0,16470,16431,1,0,0,0,16470,16432,1,0,0,0,16470,16439,1,0,0,0,16470,
+        16446,1,0,0,0,16470,16460,1,0,0,0,16470,16469,1,0,0,0,16471,16472,
+        1,0,0,0,16472,16473,5,2472,0,0,16473,1775,1,0,0,0,16474,16475,5,
+        1514,0,0,16475,16476,5,2449,0,0,16476,16481,3,1778,889,0,16477,16478,
+        5,2455,0,0,16478,16480,3,1778,889,0,16479,16477,1,0,0,0,16480,16483,
+        1,0,0,0,16481,16479,1,0,0,0,16481,16482,1,0,0,0,16482,16484,1,0,
+        0,0,16483,16481,1,0,0,0,16484,16485,5,2450,0,0,16485,1777,1,0,0,
+        0,16486,16488,3,2366,1183,0,16487,16489,3,2400,1200,0,16488,16487,
+        1,0,0,0,16488,16489,1,0,0,0,16489,16492,1,0,0,0,16490,16491,5,1206,
+        0,0,16491,16493,5,1230,0,0,16492,16490,1,0,0,0,16492,16493,1,0,0,
+        0,16493,16495,1,0,0,0,16494,16496,3,1758,879,0,16495,16494,1,0,0,
+        0,16495,16496,1,0,0,0,16496,1779,1,0,0,0,16497,16498,5,1532,0,0,
+        16498,16501,5,343,0,0,16499,16500,5,1588,0,0,16500,16502,3,2400,
+        1200,0,16501,16499,1,0,0,0,16501,16502,1,0,0,0,16502,1781,1,0,0,
+        0,16503,16504,5,2168,0,0,16504,16505,3,2428,1214,0,16505,16510,5,
+        786,0,0,16506,16511,3,1784,892,0,16507,16511,3,1788,894,0,16508,
+        16511,3,1776,888,0,16509,16511,3,1780,890,0,16510,16506,1,0,0,0,
+        16510,16507,1,0,0,0,16510,16508,1,0,0,0,16510,16509,1,0,0,0,16511,
+        16512,1,0,0,0,16512,16513,5,2472,0,0,16513,1783,1,0,0,0,16514,16515,
+        5,2085,0,0,16515,16516,5,1248,0,0,16516,16519,3,2400,1200,0,16517,
+        16518,5,1206,0,0,16518,16520,5,1230,0,0,16519,16517,1,0,0,0,16519,
+        16520,1,0,0,0,16520,16522,1,0,0,0,16521,16523,3,1786,893,0,16522,
+        16521,1,0,0,0,16522,16523,1,0,0,0,16523,1785,1,0,0,0,16524,16527,
+        5,714,0,0,16525,16527,5,718,0,0,16526,16524,1,0,0,0,16526,16525,
+        1,0,0,0,16527,16528,1,0,0,0,16528,16529,5,160,0,0,16529,16530,3,
+        2400,1200,0,16530,1787,1,0,0,0,16531,16537,5,2269,0,0,16532,16534,
+        5,2271,0,0,16533,16532,1,0,0,0,16533,16534,1,0,0,0,16534,16535,1,
+        0,0,0,16535,16537,5,68,0,0,16536,16531,1,0,0,0,16536,16533,1,0,0,
+        0,16537,16538,1,0,0,0,16538,16539,5,2449,0,0,16539,16540,3,2100,
+        1050,0,16540,16541,5,2450,0,0,16541,16542,5,1248,0,0,16542,16545,
+        3,2400,1200,0,16543,16544,5,1206,0,0,16544,16546,5,1230,0,0,16545,
+        16543,1,0,0,0,16545,16546,1,0,0,0,16546,1789,1,0,0,0,16547,16549,
+        3,1774,887,0,16548,16547,1,0,0,0,16549,16552,1,0,0,0,16550,16548,
+        1,0,0,0,16550,16551,1,0,0,0,16551,16553,1,0,0,0,16552,16550,1,0,
+        0,0,16553,16554,3,1794,897,0,16554,16555,7,205,0,0,16555,16559,1,
+        0,0,0,16556,16559,3,1792,896,0,16557,16559,3,1834,917,0,16558,16550,
+        1,0,0,0,16558,16556,1,0,0,0,16558,16557,1,0,0,0,16559,16560,1,0,
+        0,0,16560,16558,1,0,0,0,16560,16561,1,0,0,0,16561,1791,1,0,0,0,16562,
+        16563,5,2470,0,0,16563,16564,5,2470,0,0,16564,16565,3,2338,1169,
+        0,16565,16566,5,2469,0,0,16566,16567,5,2469,0,0,16567,1793,1,0,0,
+        0,16568,16586,3,1840,920,0,16569,16586,3,1848,924,0,16570,16586,
+        3,1796,898,0,16571,16586,3,1798,899,0,16572,16586,3,1800,900,0,16573,
+        16586,3,1802,901,0,16574,16586,3,1804,902,0,16575,16586,3,1810,905,
+        0,16576,16586,3,1814,907,0,16577,16586,3,1824,912,0,16578,16586,
+        3,1826,913,0,16579,16586,3,1828,914,0,16580,16586,3,2146,1073,0,
+        16581,16586,3,1850,925,0,16582,16586,3,1830,915,0,16583,16586,3,
+        1832,916,0,16584,16586,3,776,388,0,16585,16568,1,0,0,0,16585,16569,
+        1,0,0,0,16585,16570,1,0,0,0,16585,16571,1,0,0,0,16585,16572,1,0,
+        0,0,16585,16573,1,0,0,0,16585,16574,1,0,0,0,16585,16575,1,0,0,0,
+        16585,16576,1,0,0,0,16585,16577,1,0,0,0,16585,16578,1,0,0,0,16585,
+        16579,1,0,0,0,16585,16580,1,0,0,0,16585,16581,1,0,0,0,16585,16582,
+        1,0,0,0,16585,16583,1,0,0,0,16585,16584,1,0,0,0,16586,1795,1,0,0,
+        0,16587,16590,3,2410,1205,0,16588,16590,3,2408,1204,0,16589,16587,
+        1,0,0,0,16589,16588,1,0,0,0,16590,16591,1,0,0,0,16591,16592,5,2459,
+        0,0,16592,16593,3,2100,1050,0,16593,1797,1,0,0,0,16594,16596,5,297,
+        0,0,16595,16597,3,2338,1169,0,16596,16595,1,0,0,0,16596,16597,1,
+        0,0,0,16597,16600,1,0,0,0,16598,16599,5,2302,0,0,16599,16601,3,2096,
+        1048,0,16600,16598,1,0,0,0,16600,16601,1,0,0,0,16601,1799,1,0,0,
+        0,16602,16604,5,548,0,0,16603,16605,3,2338,1169,0,16604,16603,1,
+        0,0,0,16604,16605,1,0,0,0,16605,16608,1,0,0,0,16606,16607,5,2302,
+        0,0,16607,16609,3,2096,1048,0,16608,16606,1,0,0,0,16608,16609,1,
+        0,0,0,16609,1801,1,0,0,0,16610,16611,5,647,0,0,16611,16612,3,2338,
+        1169,0,16612,1803,1,0,0,0,16613,16614,5,692,0,0,16614,16615,3,2096,
+        1048,0,16615,16616,5,2101,0,0,16616,16620,3,1790,895,0,16617,16619,
+        3,1806,903,0,16618,16617,1,0,0,0,16619,16622,1,0,0,0,16620,16618,
+        1,0,0,0,16620,16621,1,0,0,0,16621,16624,1,0,0,0,16622,16620,1,0,
+        0,0,16623,16625,3,1808,904,0,16624,16623,1,0,0,0,16624,16625,1,0,
+        0,0,16625,16626,1,0,0,0,16626,16627,5,508,0,0,16627,16628,5,692,
+        0,0,16628,1805,1,0,0,0,16629,16630,5,492,0,0,16630,16631,3,2096,
+        1048,0,16631,16632,5,2101,0,0,16632,16633,3,1790,895,0,16633,1807,
+        1,0,0,0,16634,16635,5,491,0,0,16635,16636,3,1790,895,0,16636,1809,
+        1,0,0,0,16637,16639,3,1792,896,0,16638,16637,1,0,0,0,16638,16639,
+        1,0,0,0,16639,16644,1,0,0,0,16640,16641,5,2304,0,0,16641,16645,3,
+        2096,1048,0,16642,16643,5,621,0,0,16643,16645,3,1812,906,0,16644,
+        16640,1,0,0,0,16644,16642,1,0,0,0,16644,16645,1,0,0,0,16645,16646,
+        1,0,0,0,16646,16647,5,895,0,0,16647,16648,3,1790,895,0,16648,16649,
+        5,508,0,0,16649,16651,5,895,0,0,16650,16652,3,2338,1169,0,16651,
+        16650,1,0,0,0,16651,16652,1,0,0,0,16652,1811,1,0,0,0,16653,16654,
+        3,2354,1177,0,16654,16656,5,739,0,0,16655,16657,5,1590,0,0,16656,
+        16655,1,0,0,0,16656,16657,1,0,0,0,16657,16658,1,0,0,0,16658,16659,
+        3,1820,910,0,16659,16660,5,2441,0,0,16660,16661,3,1822,911,0,16661,
+        16679,1,0,0,0,16662,16663,3,2358,1179,0,16663,16676,5,739,0,0,16664,
+        16670,3,2356,1178,0,16665,16667,5,2449,0,0,16666,16668,3,2098,1049,
+        0,16667,16666,1,0,0,0,16667,16668,1,0,0,0,16668,16669,1,0,0,0,16669,
+        16671,5,2450,0,0,16670,16665,1,0,0,0,16670,16671,1,0,0,0,16671,16677,
+        1,0,0,0,16672,16673,5,2449,0,0,16673,16674,3,1890,945,0,16674,16675,
+        5,2450,0,0,16675,16677,1,0,0,0,16676,16664,1,0,0,0,16676,16672,1,
+        0,0,0,16677,16679,1,0,0,0,16678,16653,1,0,0,0,16678,16662,1,0,0,
+        0,16679,1813,1,0,0,0,16680,16681,5,616,0,0,16681,16682,3,2354,1177,
+        0,16682,16683,5,739,0,0,16683,16686,3,1816,908,0,16684,16685,5,1619,
+        0,0,16685,16687,5,537,0,0,16686,16684,1,0,0,0,16686,16687,1,0,0,
+        0,16687,16690,1,0,0,0,16688,16691,3,1856,928,0,16689,16691,3,1852,
+        926,0,16690,16688,1,0,0,0,16690,16689,1,0,0,0,16691,1815,1,0,0,0,
+        16692,16693,3,1820,910,0,16693,16694,5,2441,0,0,16694,16695,3,1822,
+        911,0,16695,16706,1,0,0,0,16696,16697,5,735,0,0,16697,16698,5,1248,
+        0,0,16698,16700,3,2410,1205,0,16699,16701,3,1818,909,0,16700,16699,
+        1,0,0,0,16700,16701,1,0,0,0,16701,16706,1,0,0,0,16702,16703,5,2259,
+        0,0,16703,16704,5,1248,0,0,16704,16706,3,2354,1177,0,16705,16692,
+        1,0,0,0,16705,16696,1,0,0,0,16705,16702,1,0,0,0,16706,1817,1,0,0,
+        0,16707,16708,5,118,0,0,16708,16709,3,1820,910,0,16709,16710,5,49,
+        0,0,16710,16711,3,1822,911,0,16711,1819,1,0,0,0,16712,16713,3,2124,
+        1062,0,16713,1821,1,0,0,0,16714,16715,3,2124,1062,0,16715,1823,1,
+        0,0,0,16716,16717,5,1230,0,0,16717,1825,1,0,0,0,16718,16720,5,1494,
+        0,0,16719,16721,3,2344,1172,0,16720,16719,1,0,0,0,16720,16721,1,
+        0,0,0,16721,1827,1,0,0,0,16722,16724,5,1588,0,0,16723,16725,3,2100,
+        1050,0,16724,16723,1,0,0,0,16724,16725,1,0,0,0,16725,1829,1,0,0,
+        0,16726,16728,5,173,0,0,16727,16726,1,0,0,0,16727,16728,1,0,0,0,
+        16728,16729,1,0,0,0,16729,16731,3,2314,1157,0,16730,16732,3,2390,
+        1195,0,16731,16730,1,0,0,0,16731,16732,1,0,0,0,16732,16740,1,0,0,
+        0,16733,16734,5,2442,0,0,16734,16736,3,2314,1157,0,16735,16737,3,
+        2390,1195,0,16736,16735,1,0,0,0,16736,16737,1,0,0,0,16737,16739,
+        1,0,0,0,16738,16733,1,0,0,0,16739,16742,1,0,0,0,16740,16738,1,0,
+        0,0,16740,16741,1,0,0,0,16741,16745,1,0,0,0,16742,16740,1,0,0,0,
+        16743,16744,5,780,0,0,16744,16746,3,2408,1204,0,16745,16743,1,0,
+        0,0,16745,16746,1,0,0,0,16746,1831,1,0,0,0,16747,16748,5,1397,0,
+        0,16748,16749,5,1608,0,0,16749,16750,5,2449,0,0,16750,16751,3,2100,
+        1050,0,16751,16752,5,2450,0,0,16752,1833,1,0,0,0,16753,16754,5,460,
+        0,0,16754,16755,3,2096,1048,0,16755,16757,5,461,0,0,16756,16758,
+        3,1838,919,0,16757,16756,1,0,0,0,16757,16758,1,0,0,0,16758,16767,
+        1,0,0,0,16759,16760,5,457,0,0,16760,16761,3,2096,1048,0,16761,16763,
+        5,461,0,0,16762,16764,3,1838,919,0,16763,16762,1,0,0,0,16763,16764,
+        1,0,0,0,16764,16766,1,0,0,0,16765,16759,1,0,0,0,16766,16769,1,0,
+        0,0,16767,16765,1,0,0,0,16767,16768,1,0,0,0,16768,16774,1,0,0,0,
+        16769,16767,1,0,0,0,16770,16772,5,456,0,0,16771,16773,3,1838,919,
+        0,16772,16771,1,0,0,0,16772,16773,1,0,0,0,16773,16775,1,0,0,0,16774,
+        16770,1,0,0,0,16774,16775,1,0,0,0,16775,16776,1,0,0,0,16776,16777,
+        5,458,0,0,16777,1835,1,0,0,0,16778,16779,5,459,0,0,16779,16780,3,
+        2124,1062,0,16780,16781,5,458,0,0,16781,1837,1,0,0,0,16782,16784,
+        3,1774,887,0,16783,16782,1,0,0,0,16783,16784,1,0,0,0,16784,16785,
+        1,0,0,0,16785,16786,3,1794,897,0,16786,16787,5,2472,0,0,16787,16793,
+        1,0,0,0,16788,16793,3,1764,882,0,16789,16793,3,1836,918,0,16790,
+        16793,3,182,91,0,16791,16793,3,184,92,0,16792,16783,1,0,0,0,16792,
+        16788,1,0,0,0,16792,16789,1,0,0,0,16792,16790,1,0,0,0,16792,16791,
+        1,0,0,0,16793,16794,1,0,0,0,16794,16792,1,0,0,0,16794,16795,1,0,
+        0,0,16795,1839,1,0,0,0,16796,16797,5,113,0,0,16797,16804,3,1790,
+        895,0,16798,16800,5,535,0,0,16799,16801,3,1842,921,0,16800,16799,
+        1,0,0,0,16801,16802,1,0,0,0,16802,16800,1,0,0,0,16802,16803,1,0,
+        0,0,16803,16805,1,0,0,0,16804,16798,1,0,0,0,16804,16805,1,0,0,0,
+        16805,16806,1,0,0,0,16806,16808,5,508,0,0,16807,16809,3,2338,1169,
+        0,16808,16807,1,0,0,0,16808,16809,1,0,0,0,16809,1841,1,0,0,0,16810,
+        16811,5,2302,0,0,16811,16816,3,2344,1172,0,16812,16813,5,1309,0,
+        0,16813,16815,3,2344,1172,0,16814,16812,1,0,0,0,16815,16818,1,0,
+        0,0,16816,16814,1,0,0,0,16816,16817,1,0,0,0,16817,16819,1,0,0,0,
+        16818,16816,1,0,0,0,16819,16820,5,2101,0,0,16820,16821,3,1790,895,
+        0,16821,1843,1,0,0,0,16822,16826,5,382,0,0,16823,16825,3,1762,881,
+        0,16824,16823,1,0,0,0,16825,16828,1,0,0,0,16826,16824,1,0,0,0,16826,
+        16827,1,0,0,0,16827,16830,1,0,0,0,16828,16826,1,0,0,0,16829,16822,
+        1,0,0,0,16829,16830,1,0,0,0,16830,16831,1,0,0,0,16831,16832,3,1840,
+        920,0,16832,1845,1,0,0,0,16833,16835,3,1762,881,0,16834,16833,1,
+        0,0,0,16835,16838,1,0,0,0,16836,16834,1,0,0,0,16836,16837,1,0,0,
+        0,16837,16839,1,0,0,0,16838,16836,1,0,0,0,16839,16840,3,1840,920,
+        0,16840,1847,1,0,0,0,16841,16845,5,382,0,0,16842,16844,3,1762,881,
+        0,16843,16842,1,0,0,0,16844,16847,1,0,0,0,16845,16843,1,0,0,0,16845,
+        16846,1,0,0,0,16846,16849,1,0,0,0,16847,16845,1,0,0,0,16848,16841,
+        1,0,0,0,16848,16849,1,0,0,0,16849,16850,1,0,0,0,16850,16851,3,1840,
+        920,0,16851,1849,1,0,0,0,16852,16858,3,1852,926,0,16853,16858,3,
+        1856,928,0,16854,16858,3,1858,929,0,16855,16858,3,1870,935,0,16856,
+        16858,3,1884,942,0,16857,16852,1,0,0,0,16857,16853,1,0,0,0,16857,
+        16854,1,0,0,0,16857,16855,1,0,0,0,16857,16856,1,0,0,0,16858,1851,
+        1,0,0,0,16859,16860,5,543,0,0,16860,16861,5,699,0,0,16861,16871,
+        3,2100,1050,0,16862,16864,3,2300,1150,0,16863,16865,3,2234,1117,
+        0,16864,16863,1,0,0,0,16864,16865,1,0,0,0,16865,16872,1,0,0,0,16866,
+        16868,3,2234,1117,0,16867,16869,3,1854,927,0,16868,16867,1,0,0,0,
+        16868,16869,1,0,0,0,16869,16872,1,0,0,0,16870,16872,3,1854,927,0,
+        16871,16862,1,0,0,0,16871,16866,1,0,0,0,16871,16870,1,0,0,0,16871,
+        16872,1,0,0,0,16872,1853,1,0,0,0,16873,16874,7,206,0,0,16874,16875,
+        3,2300,1150,0,16875,1855,1,0,0,0,16876,16884,3,2056,1028,0,16877,
+        16884,3,2068,1034,0,16878,16884,3,1890,945,0,16879,16884,3,2030,
+        1015,0,16880,16884,3,2036,1018,0,16881,16884,3,2038,1019,0,16882,
+        16884,3,1886,943,0,16883,16876,1,0,0,0,16883,16877,1,0,0,0,16883,
+        16878,1,0,0,0,16883,16879,1,0,0,0,16883,16880,1,0,0,0,16883,16881,
+        1,0,0,0,16883,16882,1,0,0,0,16884,1857,1,0,0,0,16885,16890,3,1860,
+        930,0,16886,16890,3,1862,931,0,16887,16890,3,1864,932,0,16888,16890,
+        3,1868,934,0,16889,16885,1,0,0,0,16889,16886,1,0,0,0,16889,16887,
+        1,0,0,0,16889,16888,1,0,0,0,16890,1859,1,0,0,0,16891,16892,5,218,
+        0,0,16892,16893,3,2356,1178,0,16893,1861,1,0,0,0,16894,16895,5,1266,
+        0,0,16895,16901,3,2356,1178,0,16896,16898,5,2449,0,0,16897,16899,
+        3,2098,1049,0,16898,16897,1,0,0,0,16898,16899,1,0,0,0,16899,16900,
+        1,0,0,0,16900,16902,5,2450,0,0,16901,16896,1,0,0,0,16901,16902,1,
+        0,0,0,16902,1863,1,0,0,0,16903,16904,5,587,0,0,16904,16932,3,2356,
+        1178,0,16905,16906,5,780,0,0,16906,16911,3,1866,933,0,16907,16908,
+        5,2455,0,0,16908,16910,3,1866,933,0,16909,16907,1,0,0,0,16910,16913,
+        1,0,0,0,16911,16909,1,0,0,0,16911,16912,1,0,0,0,16912,16933,1,0,
+        0,0,16913,16911,1,0,0,0,16914,16915,5,159,0,0,16915,16916,5,233,
+        0,0,16916,16917,5,780,0,0,16917,16922,3,1866,933,0,16918,16919,5,
+        2455,0,0,16919,16921,3,1866,933,0,16920,16918,1,0,0,0,16921,16924,
+        1,0,0,0,16922,16920,1,0,0,0,16922,16923,1,0,0,0,16923,16930,1,0,
+        0,0,16924,16922,1,0,0,0,16925,16928,5,859,0,0,16926,16929,3,2422,
+        1211,0,16927,16929,3,1866,933,0,16928,16926,1,0,0,0,16928,16927,
+        1,0,0,0,16929,16931,1,0,0,0,16930,16925,1,0,0,0,16930,16931,1,0,
+        0,0,16931,16933,1,0,0,0,16932,16905,1,0,0,0,16932,16914,1,0,0,0,
+        16933,1865,1,0,0,0,16934,16937,3,2352,1176,0,16935,16937,3,2144,
+        1072,0,16936,16934,1,0,0,0,16936,16935,1,0,0,0,16937,1867,1,0,0,
+        0,16938,16939,5,1266,0,0,16939,16940,3,2352,1176,0,16940,16943,5,
+        621,0,0,16941,16944,3,1890,945,0,16942,16944,3,2100,1050,0,16943,
+        16941,1,0,0,0,16943,16942,1,0,0,0,16944,16946,1,0,0,0,16945,16947,
+        3,2234,1117,0,16946,16945,1,0,0,0,16946,16947,1,0,0,0,16947,1869,
+        1,0,0,0,16948,16954,3,1872,936,0,16949,16954,3,1874,937,0,16950,
+        16954,3,1876,938,0,16951,16954,3,1880,940,0,16952,16954,3,1882,941,
+        0,16953,16948,1,0,0,0,16953,16949,1,0,0,0,16953,16950,1,0,0,0,16953,
+        16951,1,0,0,0,16953,16952,1,0,0,0,16954,1871,1,0,0,0,16955,16956,
+        5,1673,0,0,16956,16970,5,2149,0,0,16957,16958,5,1507,0,0,16958,16971,
+        7,11,0,0,16959,16960,5,788,0,0,16960,16964,5,847,0,0,16961,16965,
+        5,1661,0,0,16962,16963,5,1507,0,0,16963,16965,5,243,0,0,16964,16961,
+        1,0,0,0,16964,16962,1,0,0,0,16965,16971,1,0,0,0,16966,16967,5,2243,
+        0,0,16967,16968,5,1598,0,0,16968,16969,5,1647,0,0,16969,16971,3,
+        2310,1155,0,16970,16957,1,0,0,0,16970,16959,1,0,0,0,16970,16966,
+        1,0,0,0,16970,16971,1,0,0,0,16971,16974,1,0,0,0,16972,16973,5,998,
+        0,0,16973,16975,3,2426,1213,0,16974,16972,1,0,0,0,16974,16975,1,
+        0,0,0,16975,1873,1,0,0,0,16976,16977,5,1673,0,0,16977,16987,7,95,
+        0,0,16978,16988,5,38,0,0,16979,16984,3,2336,1168,0,16980,16981,5,
+        2455,0,0,16981,16983,3,2336,1168,0,16982,16980,1,0,0,0,16983,16986,
+        1,0,0,0,16984,16982,1,0,0,0,16984,16985,1,0,0,0,16985,16988,1,0,
+        0,0,16986,16984,1,0,0,0,16987,16978,1,0,0,0,16987,16979,1,0,0,0,
+        16988,16989,1,0,0,0,16989,16990,7,69,0,0,16990,1875,1,0,0,0,16991,
+        16993,5,242,0,0,16992,16994,5,2311,0,0,16993,16992,1,0,0,0,16993,
+        16994,1,0,0,0,16994,16996,1,0,0,0,16995,16997,3,1878,939,0,16996,
+        16995,1,0,0,0,16996,16997,1,0,0,0,16997,17014,1,0,0,0,16998,16999,
+        5,241,0,0,16999,17001,5,2445,0,0,17000,17002,3,1878,939,0,17001,
+        17000,1,0,0,0,17001,17002,1,0,0,0,17002,17015,1,0,0,0,17003,17012,
+        5,617,0,0,17004,17007,5,2445,0,0,17005,17006,5,2455,0,0,17006,17008,
+        3,2422,1211,0,17007,17005,1,0,0,0,17007,17008,1,0,0,0,17008,17013,
+        1,0,0,0,17009,17010,5,308,0,0,17010,17013,5,2445,0,0,17011,17013,
+        5,307,0,0,17012,17004,1,0,0,0,17012,17009,1,0,0,0,17012,17011,1,
+        0,0,0,17013,17015,1,0,0,0,17014,16998,1,0,0,0,17014,17003,1,0,0,
+        0,17014,17015,1,0,0,0,17015,1877,1,0,0,0,17016,17021,5,2315,0,0,
+        17017,17020,7,207,0,0,17018,17020,7,0,0,0,17019,17017,1,0,0,0,17019,
+        17018,1,0,0,0,17020,17023,1,0,0,0,17021,17019,1,0,0,0,17021,17022,
+        1,0,0,0,17022,1879,1,0,0,0,17023,17021,1,0,0,0,17024,17026,5,1598,
+        0,0,17025,17027,5,2311,0,0,17026,17025,1,0,0,0,17026,17027,1,0,0,
+        0,17027,17035,1,0,0,0,17028,17030,5,2143,0,0,17029,17031,5,1618,
+        0,0,17030,17029,1,0,0,0,17030,17031,1,0,0,0,17031,17032,1,0,0,0,
+        17032,17036,3,2308,1154,0,17033,17034,5,617,0,0,17034,17036,3,2426,
+        1213,0,17035,17028,1,0,0,0,17035,17033,1,0,0,0,17035,17036,1,0,0,
+        0,17036,1881,1,0,0,0,17037,17038,5,1618,0,0,17038,17039,3,2308,1154,
+        0,17039,1883,1,0,0,0,17040,17041,3,2100,1050,0,17041,17063,5,2442,
+        0,0,17042,17054,7,208,0,0,17043,17044,5,2449,0,0,17044,17049,3,2100,
+        1050,0,17045,17046,5,2455,0,0,17046,17048,3,2100,1050,0,17047,17045,
+        1,0,0,0,17048,17051,1,0,0,0,17049,17047,1,0,0,0,17049,17050,1,0,
+        0,0,17050,17052,1,0,0,0,17051,17049,1,0,0,0,17052,17053,5,2450,0,
+        0,17053,17055,1,0,0,0,17054,17043,1,0,0,0,17054,17055,1,0,0,0,17055,
+        17064,1,0,0,0,17056,17061,5,2420,0,0,17057,17058,5,2449,0,0,17058,
+        17059,3,2100,1050,0,17059,17060,5,2450,0,0,17060,17062,1,0,0,0,17061,
+        17057,1,0,0,0,17061,17062,1,0,0,0,17062,17064,1,0,0,0,17063,17042,
+        1,0,0,0,17063,17056,1,0,0,0,17064,1885,1,0,0,0,17065,17066,5,553,
+        0,0,17066,17071,5,1403,0,0,17067,17068,5,1673,0,0,17068,17069,5,
+        1742,0,0,17069,17070,5,2474,0,0,17070,17072,3,2426,1213,0,17071,
+        17067,1,0,0,0,17071,17072,1,0,0,0,17072,17075,1,0,0,0,17073,17074,
+        5,780,0,0,17074,17076,3,2368,1184,0,17075,17073,1,0,0,0,17075,17076,
+        1,0,0,0,17076,17077,1,0,0,0,17077,17083,5,621,0,0,17078,17084,3,
+        1890,945,0,17079,17084,3,2030,1015,0,17080,17084,3,2036,1018,0,17081,
+        17084,3,2038,1019,0,17082,17084,3,2056,1028,0,17083,17078,1,0,0,
+        0,17083,17079,1,0,0,0,17083,17080,1,0,0,0,17083,17081,1,0,0,0,17083,
+        17082,1,0,0,0,17084,1887,1,0,0,0,17085,17086,3,1916,958,0,17086,
+        1889,1,0,0,0,17087,17094,3,1888,944,0,17088,17093,3,2024,1012,0,
+        17089,17093,3,2016,1008,0,17090,17093,3,2020,1010,0,17091,17093,
+        3,2022,1011,0,17092,17088,1,0,0,0,17092,17089,1,0,0,0,17092,17090,
+        1,0,0,0,17092,17091,1,0,0,0,17093,17096,1,0,0,0,17094,17092,1,0,
+        0,0,17094,17095,1,0,0,0,17095,1891,1,0,0,0,17096,17094,1,0,0,0,17097,
+        17102,5,2310,0,0,17098,17101,3,182,91,0,17099,17101,3,184,92,0,17100,
+        17098,1,0,0,0,17100,17099,1,0,0,0,17101,17104,1,0,0,0,17102,17100,
+        1,0,0,0,17102,17103,1,0,0,0,17103,17105,1,0,0,0,17104,17102,1,0,
+        0,0,17105,17110,3,1894,947,0,17106,17107,5,2455,0,0,17107,17109,
+        3,1894,947,0,17108,17106,1,0,0,0,17109,17112,1,0,0,0,17110,17108,
+        1,0,0,0,17110,17111,1,0,0,0,17111,17131,1,0,0,0,17112,17110,1,0,
+        0,0,17113,17116,5,2310,0,0,17114,17117,3,182,91,0,17115,17117,3,
+        184,92,0,17116,17114,1,0,0,0,17116,17115,1,0,0,0,17117,17118,1,0,
+        0,0,17118,17116,1,0,0,0,17118,17119,1,0,0,0,17119,17128,1,0,0,0,
+        17120,17125,3,1894,947,0,17121,17122,5,2455,0,0,17122,17124,3,1894,
+        947,0,17123,17121,1,0,0,0,17124,17127,1,0,0,0,17125,17123,1,0,0,
+        0,17125,17126,1,0,0,0,17126,17129,1,0,0,0,17127,17125,1,0,0,0,17128,
+        17120,1,0,0,0,17128,17129,1,0,0,0,17129,17131,1,0,0,0,17130,17097,
+        1,0,0,0,17130,17113,1,0,0,0,17131,1893,1,0,0,0,17132,17135,3,1896,
+        948,0,17133,17135,3,1902,951,0,17134,17132,1,0,0,0,17134,17133,1,
+        0,0,0,17135,1895,1,0,0,0,17136,17138,3,2330,1165,0,17137,17139,3,
+        2386,1193,0,17138,17137,1,0,0,0,17138,17139,1,0,0,0,17139,17140,
+        1,0,0,0,17140,17141,5,69,0,0,17141,17142,5,2449,0,0,17142,17144,
+        3,1918,959,0,17143,17145,3,2016,1008,0,17144,17143,1,0,0,0,17144,
+        17145,1,0,0,0,17145,17146,1,0,0,0,17146,17148,5,2450,0,0,17147,17149,
+        3,1898,949,0,17148,17147,1,0,0,0,17148,17149,1,0,0,0,17149,17151,
+        1,0,0,0,17150,17152,3,1900,950,0,17151,17150,1,0,0,0,17151,17152,
+        1,0,0,0,17152,1897,1,0,0,0,17153,17154,5,1637,0,0,17154,17155,7,
+        209,0,0,17155,17156,5,599,0,0,17156,17157,5,160,0,0,17157,17159,
+        3,2366,1183,0,17158,17160,5,70,0,0,17159,17158,1,0,0,0,17159,17160,
+        1,0,0,0,17160,17162,1,0,0,0,17161,17163,5,414,0,0,17162,17161,1,
+        0,0,0,17162,17163,1,0,0,0,17163,17166,1,0,0,0,17164,17165,5,1231,
+        0,0,17165,17167,5,599,0,0,17166,17164,1,0,0,0,17166,17167,1,0,0,
+        0,17167,17170,1,0,0,0,17168,17169,5,1231,0,0,17169,17171,5,826,0,
+        0,17170,17168,1,0,0,0,17170,17171,1,0,0,0,17171,17190,1,0,0,0,17172,
+        17173,5,2455,0,0,17173,17175,3,2366,1183,0,17174,17176,5,70,0,0,
+        17175,17174,1,0,0,0,17175,17176,1,0,0,0,17176,17178,1,0,0,0,17177,
+        17179,5,414,0,0,17178,17177,1,0,0,0,17178,17179,1,0,0,0,17179,17182,
+        1,0,0,0,17180,17181,5,1231,0,0,17181,17183,5,599,0,0,17182,17180,
+        1,0,0,0,17182,17183,1,0,0,0,17183,17186,1,0,0,0,17184,17185,5,1231,
+        0,0,17185,17187,5,826,0,0,17186,17184,1,0,0,0,17186,17187,1,0,0,
+        0,17187,17189,1,0,0,0,17188,17172,1,0,0,0,17189,17192,1,0,0,0,17190,
+        17188,1,0,0,0,17190,17191,1,0,0,0,17191,17193,1,0,0,0,17192,17190,
+        1,0,0,0,17193,17194,5,1673,0,0,17194,17195,3,2366,1183,0,17195,1899,
+        1,0,0,0,17196,17197,5,348,0,0,17197,17198,3,2384,1192,0,17198,17199,
+        5,1673,0,0,17199,17200,3,2366,1183,0,17200,17201,5,2143,0,0,17201,
+        17202,3,2100,1050,0,17202,17203,5,389,0,0,17203,17204,3,2100,1050,
+        0,17204,1901,1,0,0,0,17205,17206,3,2430,1215,0,17206,17207,5,45,
+        0,0,17207,17208,5,2288,0,0,17208,17209,5,69,0,0,17209,17210,5,2449,
+        0,0,17210,17211,3,1904,952,0,17211,17212,5,2450,0,0,17212,1903,1,
+        0,0,0,17213,17214,5,2248,0,0,17214,17216,3,752,376,0,17215,17217,
+        3,1906,953,0,17216,17215,1,0,0,0,17216,17217,1,0,0,0,17217,17219,
+        1,0,0,0,17218,17220,3,1908,954,0,17219,17218,1,0,0,0,17219,17220,
+        1,0,0,0,17220,17222,1,0,0,0,17221,17223,3,1912,956,0,17222,17221,
+        1,0,0,0,17222,17223,1,0,0,0,17223,1905,1,0,0,0,17224,17225,5,674,
+        0,0,17225,17226,5,2449,0,0,17226,17231,3,752,376,0,17227,17228,5,
+        2455,0,0,17228,17230,3,752,376,0,17229,17227,1,0,0,0,17230,17233,
+        1,0,0,0,17231,17229,1,0,0,0,17231,17232,1,0,0,0,17232,17234,1,0,
+        0,0,17233,17231,1,0,0,0,17234,17235,5,2450,0,0,17235,1907,1,0,0,
+        0,17236,17237,5,595,0,0,17237,17238,5,568,0,0,17238,17239,5,2449,
+        0,0,17239,17244,3,1910,955,0,17240,17241,5,2455,0,0,17241,17243,
+        3,1910,955,0,17242,17240,1,0,0,0,17243,17246,1,0,0,0,17244,17242,
+        1,0,0,0,17244,17245,1,0,0,0,17245,17247,1,0,0,0,17246,17244,1,0,
+        0,0,17247,17248,5,2450,0,0,17248,1909,1,0,0,0,17249,17252,5,935,
+        0,0,17250,17252,3,752,376,0,17251,17249,1,0,0,0,17251,17250,1,0,
+        0,0,17252,17253,1,0,0,0,17253,17254,5,2143,0,0,17254,17255,3,2096,
+        1048,0,17255,1911,1,0,0,0,17256,17257,5,21,0,0,17257,17258,5,935,
+        0,0,17258,17259,5,2449,0,0,17259,17264,3,1914,957,0,17260,17261,
+        5,2455,0,0,17261,17263,3,1914,957,0,17262,17260,1,0,0,0,17263,17266,
+        1,0,0,0,17264,17262,1,0,0,0,17264,17265,1,0,0,0,17265,17267,1,0,
+        0,0,17266,17264,1,0,0,0,17267,17268,5,2450,0,0,17268,1913,1,0,0,
+        0,17269,17270,3,2430,1215,0,17270,17271,5,69,0,0,17271,17272,5,2449,
+        0,0,17272,17273,3,2100,1050,0,17273,17274,5,2450,0,0,17274,1915,
+        1,0,0,0,17275,17277,3,1892,946,0,17276,17275,1,0,0,0,17276,17277,
+        1,0,0,0,17277,17278,1,0,0,0,17278,17282,3,1920,960,0,17279,17281,
+        3,1922,961,0,17280,17279,1,0,0,0,17281,17284,1,0,0,0,17282,17280,
+        1,0,0,0,17282,17283,1,0,0,0,17283,1917,1,0,0,0,17284,17282,1,0,0,
+        0,17285,17289,3,1920,960,0,17286,17288,3,1922,961,0,17287,17286,
+        1,0,0,0,17288,17291,1,0,0,0,17289,17287,1,0,0,0,17289,17290,1,0,
+        0,0,17290,1919,1,0,0,0,17291,17289,1,0,0,0,17292,17298,3,1924,962,
+        0,17293,17294,5,2449,0,0,17294,17295,3,1918,959,0,17295,17296,5,
+        2450,0,0,17296,17298,1,0,0,0,17297,17292,1,0,0,0,17297,17293,1,0,
+        0,0,17298,1921,1,0,0,0,17299,17301,5,2183,0,0,17300,17302,5,38,0,
+        0,17301,17300,1,0,0,0,17301,17302,1,0,0,0,17302,17306,1,0,0,0,17303,
+        17306,5,776,0,0,17304,17306,5,957,0,0,17305,17299,1,0,0,0,17305,
+        17303,1,0,0,0,17305,17304,1,0,0,0,17306,17307,1,0,0,0,17307,17308,
+        3,1920,960,0,17308,1923,1,0,0,0,17309,17311,5,1649,0,0,17310,17312,
+        7,210,0,0,17311,17310,1,0,0,0,17311,17312,1,0,0,0,17312,17313,1,
+        0,0,0,17313,17315,3,1926,963,0,17314,17316,3,2300,1150,0,17315,17314,
+        1,0,0,0,17315,17316,1,0,0,0,17316,17318,1,0,0,0,17317,17319,3,1928,
+        964,0,17318,17317,1,0,0,0,17318,17319,1,0,0,0,17319,17321,1,0,0,
+        0,17320,17322,3,2298,1149,0,17321,17320,1,0,0,0,17321,17322,1,0,
+        0,0,17322,17327,1,0,0,0,17323,17326,3,1970,985,0,17324,17326,3,1974,
+        987,0,17325,17323,1,0,0,0,17325,17324,1,0,0,0,17326,17329,1,0,0,
+        0,17327,17325,1,0,0,0,17327,17328,1,0,0,0,17328,17331,1,0,0,0,17329,
+        17327,1,0,0,0,17330,17332,3,1986,993,0,17331,17330,1,0,0,0,17331,
+        17332,1,0,0,0,17332,17334,1,0,0,0,17333,17335,3,2016,1008,0,17334,
+        17333,1,0,0,0,17334,17335,1,0,0,0,17335,17337,1,0,0,0,17336,17338,
+        3,2020,1010,0,17337,17336,1,0,0,0,17337,17338,1,0,0,0,17338,17340,
+        1,0,0,0,17339,17341,3,2022,1011,0,17340,17339,1,0,0,0,17340,17341,
+        1,0,0,0,17341,1925,1,0,0,0,17342,17352,5,2452,0,0,17343,17348,3,
+        1930,965,0,17344,17345,5,2455,0,0,17345,17347,3,1930,965,0,17346,
+        17344,1,0,0,0,17347,17350,1,0,0,0,17348,17346,1,0,0,0,17348,17349,
+        1,0,0,0,17349,17352,1,0,0,0,17350,17348,1,0,0,0,17351,17342,1,0,
+        0,0,17351,17343,1,0,0,0,17352,1927,1,0,0,0,17353,17354,5,629,0,0,
+        17354,17355,3,1932,966,0,17355,1929,1,0,0,0,17356,17357,3,2368,1184,
+        0,17357,17358,5,2442,0,0,17358,17359,5,2452,0,0,17359,17365,1,0,
+        0,0,17360,17362,3,2100,1050,0,17361,17363,3,2294,1147,0,17362,17361,
+        1,0,0,0,17362,17363,1,0,0,0,17363,17365,1,0,0,0,17364,17356,1,0,
+        0,0,17364,17360,1,0,0,0,17365,1931,1,0,0,0,17366,17371,3,1934,967,
+        0,17367,17368,5,2455,0,0,17368,17370,3,1934,967,0,17369,17367,1,
+        0,0,0,17370,17373,1,0,0,0,17371,17369,1,0,0,0,17371,17372,1,0,0,
+        0,17372,1933,1,0,0,0,17373,17371,1,0,0,0,17374,17378,3,1936,968,
+        0,17375,17377,3,1940,970,0,17376,17375,1,0,0,0,17377,17380,1,0,0,
+        0,17378,17376,1,0,0,0,17378,17379,1,0,0,0,17379,17383,1,0,0,0,17380,
+        17378,1,0,0,0,17381,17384,3,1952,976,0,17382,17384,3,1964,982,0,
+        17383,17381,1,0,0,0,17383,17382,1,0,0,0,17383,17384,1,0,0,0,17384,
+        1935,1,0,0,0,17385,17389,3,1938,969,0,17386,17388,3,1950,975,0,17387,
+        17386,1,0,0,0,17388,17391,1,0,0,0,17389,17387,1,0,0,0,17389,17390,
+        1,0,0,0,17390,17394,1,0,0,0,17391,17389,1,0,0,0,17392,17393,4,968,
+        13,0,17393,17395,3,2296,1148,0,17394,17392,1,0,0,0,17394,17395,1,
+        0,0,0,17395,1937,1,0,0,0,17396,17399,3,2086,1043,0,17397,17400,3,
+        1952,976,0,17398,17400,3,1964,982,0,17399,17397,1,0,0,0,17399,17398,
+        1,0,0,0,17399,17400,1,0,0,0,17400,17420,1,0,0,0,17401,17402,5,2449,
+        0,0,17402,17406,3,1934,967,0,17403,17405,3,1922,961,0,17404,17403,
+        1,0,0,0,17405,17408,1,0,0,0,17406,17404,1,0,0,0,17406,17407,1,0,
+        0,0,17407,17409,1,0,0,0,17408,17406,1,0,0,0,17409,17412,5,2450,0,
+        0,17410,17413,3,1952,976,0,17411,17413,3,1964,982,0,17412,17410,
+        1,0,0,0,17412,17411,1,0,0,0,17412,17413,1,0,0,0,17413,17420,1,0,
+        0,0,17414,17415,5,1260,0,0,17415,17416,5,2449,0,0,17416,17417,3,
+        2086,1043,0,17417,17418,5,2450,0,0,17418,17420,1,0,0,0,17419,17396,
+        1,0,0,0,17419,17401,1,0,0,0,17419,17414,1,0,0,0,17420,1939,1,0,0,
+        0,17421,17423,3,1948,974,0,17422,17421,1,0,0,0,17422,17423,1,0,0,
+        0,17423,17425,1,0,0,0,17424,17426,7,211,0,0,17425,17424,1,0,0,0,
+        17425,17426,1,0,0,0,17426,17429,1,0,0,0,17427,17430,5,750,0,0,17428,
+        17430,3,1946,973,0,17429,17427,1,0,0,0,17429,17428,1,0,0,0,17429,
+        17430,1,0,0,0,17430,17431,1,0,0,0,17431,17432,5,795,0,0,17432,17434,
+        3,1936,968,0,17433,17435,3,1948,974,0,17434,17433,1,0,0,0,17434,
+        17435,1,0,0,0,17435,17440,1,0,0,0,17436,17439,3,1942,971,0,17437,
+        17439,3,1944,972,0,17438,17436,1,0,0,0,17438,17437,1,0,0,0,17439,
+        17442,1,0,0,0,17440,17438,1,0,0,0,17440,17441,1,0,0,0,17441,17447,
+        1,0,0,0,17442,17440,1,0,0,0,17443,17444,7,212,0,0,17444,17445,5,
+        61,0,0,17445,17447,3,1936,968,0,17446,17422,1,0,0,0,17446,17443,
+        1,0,0,0,17447,1941,1,0,0,0,17448,17449,5,1261,0,0,17449,17450,3,
+        2096,1048,0,17450,1943,1,0,0,0,17451,17452,5,2248,0,0,17452,17453,
+        3,2386,1193,0,17453,1945,1,0,0,0,17454,17456,7,213,0,0,17455,17457,
+        5,1315,0,0,17456,17455,1,0,0,0,17456,17457,1,0,0,0,17457,1947,1,
+        0,0,0,17458,17459,5,1350,0,0,17459,17467,5,160,0,0,17460,17463,5,
+        2449,0,0,17461,17464,3,1916,958,0,17462,17464,3,2098,1049,0,17463,
+        17461,1,0,0,0,17463,17462,1,0,0,0,17463,17464,1,0,0,0,17464,17465,
+        1,0,0,0,17465,17468,5,2450,0,0,17466,17468,3,2098,1049,0,17467,17460,
+        1,0,0,0,17467,17466,1,0,0,0,17468,1949,1,0,0,0,17469,17477,5,2285,
+        0,0,17470,17471,5,1388,0,0,17471,17472,5,621,0,0,17472,17473,3,2366,
+        1183,0,17473,17474,5,118,0,0,17474,17478,1,0,0,0,17475,17476,5,118,
+        0,0,17476,17478,7,83,0,0,17477,17470,1,0,0,0,17477,17475,1,0,0,0,
+        17478,17479,1,0,0,0,17479,17480,3,2100,1050,0,17480,17481,5,49,0,
+        0,17481,17482,3,2100,1050,0,17482,17495,1,0,0,0,17483,17484,5,69,
+        0,0,17484,17492,5,1248,0,0,17485,17486,7,214,0,0,17486,17493,3,2100,
+        1050,0,17487,17488,5,1388,0,0,17488,17489,5,621,0,0,17489,17490,
+        3,2366,1183,0,17490,17491,3,2100,1050,0,17491,17493,1,0,0,0,17492,
+        17485,1,0,0,0,17492,17487,1,0,0,0,17493,17495,1,0,0,0,17494,17469,
+        1,0,0,0,17494,17483,1,0,0,0,17495,1951,1,0,0,0,17496,17498,5,1399,
+        0,0,17497,17499,5,2354,0,0,17498,17497,1,0,0,0,17498,17499,1,0,0,
+        0,17499,17500,1,0,0,0,17500,17501,5,2449,0,0,17501,17506,3,1954,
+        977,0,17502,17503,5,2455,0,0,17503,17505,3,1954,977,0,17504,17502,
+        1,0,0,0,17505,17508,1,0,0,0,17506,17504,1,0,0,0,17506,17507,1,0,
+        0,0,17507,17509,1,0,0,0,17508,17506,1,0,0,0,17509,17510,3,1956,978,
+        0,17510,17511,3,1958,979,0,17511,17513,5,2450,0,0,17512,17514,3,
+        2296,1148,0,17513,17512,1,0,0,0,17513,17514,1,0,0,0,17514,1953,1,
+        0,0,0,17515,17522,3,2214,1107,0,17516,17517,3,2328,1164,0,17517,
+        17518,5,2449,0,0,17518,17519,3,2100,1050,0,17519,17520,5,2450,0,
+        0,17520,17522,1,0,0,0,17521,17515,1,0,0,0,17521,17516,1,0,0,0,17522,
+        17524,1,0,0,0,17523,17525,3,2294,1147,0,17524,17523,1,0,0,0,17524,
+        17525,1,0,0,0,17525,1955,1,0,0,0,17526,17529,5,621,0,0,17527,17530,
+        3,2366,1183,0,17528,17530,3,2386,1193,0,17529,17527,1,0,0,0,17529,
+        17528,1,0,0,0,17530,1957,1,0,0,0,17531,17532,5,739,0,0,17532,17550,
+        5,2449,0,0,17533,17551,3,1916,958,0,17534,17539,5,55,0,0,17535,17536,
+        5,2455,0,0,17536,17538,5,55,0,0,17537,17535,1,0,0,0,17538,17541,
+        1,0,0,0,17539,17537,1,0,0,0,17539,17540,1,0,0,0,17540,17551,1,0,
+        0,0,17541,17539,1,0,0,0,17542,17547,3,1960,980,0,17543,17544,5,2455,
+        0,0,17544,17546,3,1960,980,0,17545,17543,1,0,0,0,17546,17549,1,0,
+        0,0,17547,17545,1,0,0,0,17547,17548,1,0,0,0,17548,17551,1,0,0,0,
+        17549,17547,1,0,0,0,17550,17533,1,0,0,0,17550,17534,1,0,0,0,17550,
+        17542,1,0,0,0,17551,17552,1,0,0,0,17552,17553,5,2450,0,0,17553,1959,
+        1,0,0,0,17554,17556,3,1962,981,0,17555,17557,3,2294,1147,0,17556,
+        17555,1,0,0,0,17556,17557,1,0,0,0,17557,1961,1,0,0,0,17558,17565,
+        3,2100,1050,0,17559,17561,5,2449,0,0,17560,17562,3,2098,1049,0,17561,
+        17560,1,0,0,0,17561,17562,1,0,0,0,17562,17563,1,0,0,0,17563,17565,
+        5,2450,0,0,17564,17558,1,0,0,0,17564,17559,1,0,0,0,17565,1963,1,
+        0,0,0,17566,17569,5,2196,0,0,17567,17568,7,215,0,0,17568,17570,5,
+        1231,0,0,17569,17567,1,0,0,0,17569,17570,1,0,0,0,17570,17571,1,0,
+        0,0,17571,17574,5,2449,0,0,17572,17575,3,2366,1183,0,17573,17575,
+        3,2386,1193,0,17574,17572,1,0,0,0,17574,17573,1,0,0,0,17575,17576,
+        1,0,0,0,17576,17577,3,1956,978,0,17577,17578,3,1966,983,0,17578,
+        17580,5,2450,0,0,17579,17581,3,2296,1148,0,17580,17579,1,0,0,0,17580,
+        17581,1,0,0,0,17581,1965,1,0,0,0,17582,17583,5,739,0,0,17583,17584,
+        5,2449,0,0,17584,17589,3,1968,984,0,17585,17586,5,2455,0,0,17586,
+        17588,3,1968,984,0,17587,17585,1,0,0,0,17588,17591,1,0,0,0,17589,
+        17587,1,0,0,0,17589,17590,1,0,0,0,17590,17592,1,0,0,0,17591,17589,
+        1,0,0,0,17592,17593,5,2450,0,0,17593,1967,1,0,0,0,17594,17597,3,
+        2366,1183,0,17595,17597,3,2386,1193,0,17596,17594,1,0,0,0,17596,
+        17595,1,0,0,0,17597,17613,1,0,0,0,17598,17611,5,69,0,0,17599,17612,
+        3,2420,1210,0,17600,17601,5,2449,0,0,17601,17606,3,2420,1210,0,17602,
+        17603,5,2455,0,0,17603,17605,3,2420,1210,0,17604,17602,1,0,0,0,17605,
+        17608,1,0,0,0,17606,17604,1,0,0,0,17606,17607,1,0,0,0,17607,17609,
+        1,0,0,0,17608,17606,1,0,0,0,17609,17610,5,2450,0,0,17610,17612,1,
+        0,0,0,17611,17599,1,0,0,0,17611,17600,1,0,0,0,17612,17614,1,0,0,
+        0,17613,17598,1,0,0,0,17613,17614,1,0,0,0,17614,1969,1,0,0,0,17615,
+        17616,5,280,0,0,17616,17618,5,160,0,0,17617,17619,5,1085,0,0,17618,
+        17617,1,0,0,0,17618,17619,1,0,0,0,17619,17620,1,0,0,0,17620,17622,
+        3,2096,1048,0,17621,17623,3,1972,986,0,17622,17621,1,0,0,0,17622,
+        17623,1,0,0,0,17623,17633,1,0,0,0,17624,17625,3,1972,986,0,17625,
+        17626,5,280,0,0,17626,17628,5,160,0,0,17627,17629,5,1085,0,0,17628,
+        17627,1,0,0,0,17628,17629,1,0,0,0,17629,17630,1,0,0,0,17630,17631,
+        3,2096,1048,0,17631,17633,1,0,0,0,17632,17615,1,0,0,0,17632,17624,
+        1,0,0,0,17633,1971,1,0,0,0,17634,17635,5,1739,0,0,17635,17636,5,
+        2310,0,0,17636,17637,3,2096,1048,0,17637,1973,1,0,0,0,17638,17639,
+        5,650,0,0,17639,17640,5,160,0,0,17640,17645,3,1976,988,0,17641,17642,
+        5,2455,0,0,17642,17644,3,1976,988,0,17643,17641,1,0,0,0,17644,17647,
+        1,0,0,0,17645,17643,1,0,0,0,17645,17646,1,0,0,0,17646,17649,1,0,
+        0,0,17647,17645,1,0,0,0,17648,17650,3,1984,992,0,17649,17648,1,0,
+        0,0,17649,17650,1,0,0,0,17650,17665,1,0,0,0,17651,17662,3,1984,992,
+        0,17652,17653,5,650,0,0,17653,17654,5,160,0,0,17654,17659,3,1976,
+        988,0,17655,17656,5,2455,0,0,17656,17658,3,1976,988,0,17657,17655,
+        1,0,0,0,17658,17661,1,0,0,0,17659,17657,1,0,0,0,17659,17660,1,0,
+        0,0,17660,17663,1,0,0,0,17661,17659,1,0,0,0,17662,17652,1,0,0,0,
+        17662,17663,1,0,0,0,17663,17665,1,0,0,0,17664,17638,1,0,0,0,17664,
+        17651,1,0,0,0,17665,1975,1,0,0,0,17666,17670,3,1980,990,0,17667,
+        17670,3,1978,989,0,17668,17670,3,2100,1050,0,17669,17666,1,0,0,0,
+        17669,17667,1,0,0,0,17669,17668,1,0,0,0,17670,1977,1,0,0,0,17671,
+        17672,7,216,0,0,17672,17673,5,2449,0,0,17673,17678,3,1982,991,0,
+        17674,17675,5,2455,0,0,17675,17677,3,1982,991,0,17676,17674,1,0,
+        0,0,17677,17680,1,0,0,0,17678,17676,1,0,0,0,17678,17679,1,0,0,0,
+        17679,17681,1,0,0,0,17680,17678,1,0,0,0,17681,17682,5,2450,0,0,17682,
+        1979,1,0,0,0,17683,17684,5,652,0,0,17684,17685,5,1674,0,0,17685,
+        17686,5,2449,0,0,17686,17691,3,1982,991,0,17687,17688,5,2455,0,0,
+        17688,17690,3,1982,991,0,17689,17687,1,0,0,0,17690,17693,1,0,0,0,
+        17691,17689,1,0,0,0,17691,17692,1,0,0,0,17692,17694,1,0,0,0,17693,
+        17691,1,0,0,0,17694,17695,5,2450,0,0,17695,1981,1,0,0,0,17696,17704,
+        3,1978,989,0,17697,17699,5,2449,0,0,17698,17700,3,2098,1049,0,17699,
+        17698,1,0,0,0,17699,17700,1,0,0,0,17700,17701,1,0,0,0,17701,17704,
+        5,2450,0,0,17702,17704,3,2100,1050,0,17703,17696,1,0,0,0,17703,17697,
+        1,0,0,0,17703,17702,1,0,0,0,17704,1983,1,0,0,0,17705,17706,5,664,
+        0,0,17706,17707,3,2096,1048,0,17707,1985,1,0,0,0,17708,17712,5,972,
+        0,0,17709,17711,3,1988,994,0,17710,17709,1,0,0,0,17711,17714,1,0,
+        0,0,17712,17710,1,0,0,0,17712,17713,1,0,0,0,17713,17716,1,0,0,0,
+        17714,17712,1,0,0,0,17715,17717,3,1990,995,0,17716,17715,1,0,0,0,
+        17716,17717,1,0,0,0,17717,17721,1,0,0,0,17718,17720,3,1992,996,0,
+        17719,17718,1,0,0,0,17720,17723,1,0,0,0,17721,17719,1,0,0,0,17721,
+        17722,1,0,0,0,17722,17724,1,0,0,0,17723,17721,1,0,0,0,17724,17725,
+        3,1994,997,0,17725,1987,1,0,0,0,17726,17727,7,217,0,0,17727,17735,
+        5,1007,0,0,17728,17732,5,2185,0,0,17729,17733,5,422,0,0,17730,17731,
+        5,1697,0,0,17731,17733,5,1529,0,0,17732,17729,1,0,0,0,17732,17730,
+        1,0,0,0,17733,17735,1,0,0,0,17734,17726,1,0,0,0,17734,17728,1,0,
+        0,0,17735,1989,1,0,0,0,17736,17737,5,1588,0,0,17737,17738,7,218,
+        0,0,17738,17739,5,1609,0,0,17739,1991,1,0,0,0,17740,17741,5,1529,
+        0,0,17741,17742,3,2322,1161,0,17742,17743,5,1261,0,0,17743,17744,
+        5,2449,0,0,17744,17745,3,1916,958,0,17745,17746,5,2450,0,0,17746,
+        17750,3,1996,998,0,17747,17749,3,1988,994,0,17748,17747,1,0,0,0,
+        17749,17752,1,0,0,0,17750,17748,1,0,0,0,17750,17751,1,0,0,0,17751,
+        1993,1,0,0,0,17752,17750,1,0,0,0,17753,17754,5,903,0,0,17754,17756,
+        3,2324,1162,0,17755,17753,1,0,0,0,17755,17756,1,0,0,0,17756,17757,
+        1,0,0,0,17757,17761,3,1996,998,0,17758,17760,3,1988,994,0,17759,
+        17758,1,0,0,0,17760,17763,1,0,0,0,17761,17759,1,0,0,0,17761,17762,
+        1,0,0,0,17762,17764,1,0,0,0,17763,17761,1,0,0,0,17764,17765,3,2004,
+        1002,0,17765,1995,1,0,0,0,17766,17768,3,1998,999,0,17767,17766,1,
+        0,0,0,17767,17768,1,0,0,0,17768,17769,1,0,0,0,17769,17770,5,422,
+        0,0,17770,17771,5,160,0,0,17771,17772,3,2000,1000,0,17772,17773,
+        5,935,0,0,17773,17774,3,2000,1000,0,17774,1997,1,0,0,0,17775,17776,
+        5,1350,0,0,17776,17777,5,160,0,0,17777,17778,3,2000,1000,0,17778,
+        1999,1,0,0,0,17779,17780,5,2449,0,0,17780,17785,3,2002,1001,0,17781,
+        17782,5,2455,0,0,17782,17784,3,2002,1001,0,17783,17781,1,0,0,0,17784,
+        17787,1,0,0,0,17785,17783,1,0,0,0,17785,17786,1,0,0,0,17786,17788,
+        1,0,0,0,17787,17785,1,0,0,0,17788,17789,5,2450,0,0,17789,2001,1,
+        0,0,0,17790,17793,3,2100,1050,0,17791,17793,3,1924,962,0,17792,17790,
+        1,0,0,0,17792,17791,1,0,0,0,17793,17795,1,0,0,0,17794,17796,3,2294,
+        1147,0,17795,17794,1,0,0,0,17795,17796,1,0,0,0,17796,2003,1,0,0,
+        0,17797,17799,3,2006,1003,0,17798,17797,1,0,0,0,17798,17799,1,0,
+        0,0,17799,17800,1,0,0,0,17800,17809,5,2449,0,0,17801,17806,3,2008,
+        1004,0,17802,17803,5,2455,0,0,17803,17805,3,2008,1004,0,17804,17802,
+        1,0,0,0,17805,17808,1,0,0,0,17806,17804,1,0,0,0,17806,17807,1,0,
+        0,0,17807,17810,1,0,0,0,17808,17806,1,0,0,0,17809,17801,1,0,0,0,
+        17809,17810,1,0,0,0,17810,17811,1,0,0,0,17811,17812,5,2450,0,0,17812,
+        2005,1,0,0,0,17813,17819,5,1613,0,0,17814,17820,5,2209,0,0,17815,
+        17817,5,2215,0,0,17816,17818,5,38,0,0,17817,17816,1,0,0,0,17817,
+        17818,1,0,0,0,17818,17820,1,0,0,0,17819,17814,1,0,0,0,17819,17815,
+        1,0,0,0,17819,17820,1,0,0,0,17820,17823,1,0,0,0,17821,17822,7,219,
+        0,0,17822,17824,5,1305,0,0,17823,17821,1,0,0,0,17823,17824,1,0,0,
+        0,17824,17826,1,0,0,0,17825,17827,3,2012,1006,0,17826,17825,1,0,
+        0,0,17826,17827,1,0,0,0,17827,2007,1,0,0,0,17828,17834,5,2209,0,
+        0,17829,17831,5,2215,0,0,17830,17832,5,38,0,0,17831,17830,1,0,0,
+        0,17831,17832,1,0,0,0,17832,17834,1,0,0,0,17833,17828,1,0,0,0,17833,
+        17829,1,0,0,0,17833,17834,1,0,0,0,17834,17835,1,0,0,0,17835,17837,
+        3,2010,1005,0,17836,17838,3,2016,1008,0,17837,17836,1,0,0,0,17837,
+        17838,1,0,0,0,17838,17839,1,0,0,0,17839,17840,5,2474,0,0,17840,17841,
+        3,2100,1050,0,17841,2009,1,0,0,0,17842,17843,3,2128,1064,0,17843,
+        2011,1,0,0,0,17844,17845,5,791,0,0,17845,17846,5,2449,0,0,17846,
+        17847,3,2100,1050,0,17847,17849,5,2450,0,0,17848,17850,3,2014,1007,
+        0,17849,17848,1,0,0,0,17849,17850,1,0,0,0,17850,2013,1,0,0,0,17851,
+        17852,5,2204,0,0,17852,17853,5,2449,0,0,17853,17854,3,2096,1048,
+        0,17854,17855,5,2450,0,0,17855,2015,1,0,0,0,17856,17858,5,1305,0,
+        0,17857,17859,5,1688,0,0,17858,17857,1,0,0,0,17858,17859,1,0,0,0,
+        17859,17860,1,0,0,0,17860,17861,5,160,0,0,17861,17866,3,2018,1009,
+        0,17862,17863,5,2455,0,0,17863,17865,3,2018,1009,0,17864,17862,1,
+        0,0,0,17865,17868,1,0,0,0,17866,17864,1,0,0,0,17866,17867,1,0,0,
+        0,17867,2017,1,0,0,0,17868,17866,1,0,0,0,17869,17871,3,2100,1050,
+        0,17870,17872,7,55,0,0,17871,17870,1,0,0,0,17871,17872,1,0,0,0,17872,
+        17875,1,0,0,0,17873,17874,5,1231,0,0,17874,17876,7,56,0,0,17875,
+        17873,1,0,0,0,17875,17876,1,0,0,0,17876,2019,1,0,0,0,17877,17878,
+        5,1247,0,0,17878,17879,3,2100,1050,0,17879,17880,7,220,0,0,17880,
+        2021,1,0,0,0,17881,17882,5,587,0,0,17882,17887,7,221,0,0,17883,17885,
+        3,2100,1050,0,17884,17886,5,1380,0,0,17885,17884,1,0,0,0,17885,17886,
+        1,0,0,0,17886,17888,1,0,0,0,17887,17883,1,0,0,0,17887,17888,1,0,
+        0,0,17888,17889,1,0,0,0,17889,17893,7,220,0,0,17890,17894,5,1260,
+        0,0,17891,17892,5,2310,0,0,17892,17894,5,2107,0,0,17893,17890,1,
+        0,0,0,17893,17891,1,0,0,0,17894,2023,1,0,0,0,17895,17896,5,621,0,
+        0,17896,17898,5,2209,0,0,17897,17899,3,2026,1013,0,17898,17897,1,
+        0,0,0,17898,17899,1,0,0,0,17899,17901,1,0,0,0,17900,17902,3,2028,
+        1014,0,17901,17900,1,0,0,0,17901,17902,1,0,0,0,17902,2025,1,0,0,
+        0,17903,17904,5,1248,0,0,17904,17905,3,2384,1192,0,17905,2027,1,
+        0,0,0,17906,17907,5,1704,0,0,17907,17912,5,880,0,0,17908,17912,5,
+        1221,0,0,17909,17910,5,2295,0,0,17910,17912,3,2100,1050,0,17911,
+        17906,1,0,0,0,17911,17908,1,0,0,0,17911,17909,1,0,0,0,17912,2029,
+        1,0,0,0,17913,17914,5,2209,0,0,17914,17915,3,2076,1038,0,17915,17917,
+        3,2032,1016,0,17916,17918,3,2298,1149,0,17917,17916,1,0,0,0,17917,
+        17918,1,0,0,0,17918,17920,1,0,0,0,17919,17921,3,2078,1039,0,17920,
+        17919,1,0,0,0,17920,17921,1,0,0,0,17921,17923,1,0,0,0,17922,17924,
+        3,2080,1040,0,17923,17922,1,0,0,0,17923,17924,1,0,0,0,17924,2031,
+        1,0,0,0,17925,17941,5,1673,0,0,17926,17931,3,2034,1017,0,17927,17928,
+        5,2455,0,0,17928,17930,3,2034,1017,0,17929,17927,1,0,0,0,17930,17933,
+        1,0,0,0,17931,17929,1,0,0,0,17931,17932,1,0,0,0,17932,17942,1,0,
+        0,0,17933,17931,1,0,0,0,17934,17935,5,2260,0,0,17935,17936,5,2449,
+        0,0,17936,17937,3,2428,1214,0,17937,17938,5,2450,0,0,17938,17939,
+        5,2474,0,0,17939,17940,3,2100,1050,0,17940,17942,1,0,0,0,17941,17926,
+        1,0,0,0,17941,17934,1,0,0,0,17942,2033,1,0,0,0,17943,17944,3,2366,
+        1183,0,17944,17945,5,2474,0,0,17945,17946,3,2100,1050,0,17946,17952,
+        1,0,0,0,17947,17948,3,2386,1193,0,17948,17949,5,2474,0,0,17949,17950,
+        3,1916,958,0,17950,17952,1,0,0,0,17951,17943,1,0,0,0,17951,17947,
+        1,0,0,0,17952,2035,1,0,0,0,17953,17955,5,403,0,0,17954,17956,5,629,
+        0,0,17955,17954,1,0,0,0,17955,17956,1,0,0,0,17956,17957,1,0,0,0,
+        17957,17959,3,2076,1038,0,17958,17960,3,2298,1149,0,17959,17958,
+        1,0,0,0,17959,17960,1,0,0,0,17960,17962,1,0,0,0,17961,17963,3,2078,
+        1039,0,17962,17961,1,0,0,0,17962,17963,1,0,0,0,17963,17965,1,0,0,
+        0,17964,17966,3,2080,1040,0,17965,17964,1,0,0,0,17965,17966,1,0,
+        0,0,17966,2037,1,0,0,0,17967,17970,5,757,0,0,17968,17971,3,2040,
+        1020,0,17969,17971,3,2042,1021,0,17970,17968,1,0,0,0,17970,17969,
+        1,0,0,0,17971,2039,1,0,0,0,17972,17978,3,2052,1026,0,17973,17975,
+        3,2054,1027,0,17974,17976,3,2078,1039,0,17975,17974,1,0,0,0,17975,
+        17976,1,0,0,0,17976,17979,1,0,0,0,17977,17979,3,1890,945,0,17978,
+        17973,1,0,0,0,17978,17977,1,0,0,0,17979,17981,1,0,0,0,17980,17982,
+        3,2080,1040,0,17981,17980,1,0,0,0,17981,17982,1,0,0,0,17982,2041,
+        1,0,0,0,17983,17985,5,38,0,0,17984,17986,3,2044,1022,0,17985,17984,
+        1,0,0,0,17986,17987,1,0,0,0,17987,17985,1,0,0,0,17987,17988,1,0,
+        0,0,17988,17991,1,0,0,0,17989,17991,3,2046,1023,0,17990,17983,1,
+        0,0,0,17990,17989,1,0,0,0,17991,17992,1,0,0,0,17992,17993,3,1890,
+        945,0,17993,2043,1,0,0,0,17994,17996,3,2052,1026,0,17995,17997,3,
+        2054,1027,0,17996,17995,1,0,0,0,17996,17997,1,0,0,0,17997,17999,
+        1,0,0,0,17998,18000,3,2080,1040,0,17999,17998,1,0,0,0,17999,18000,
+        1,0,0,0,18000,2045,1,0,0,0,18001,18003,7,222,0,0,18002,18001,1,0,
+        0,0,18002,18003,1,0,0,0,18003,18005,1,0,0,0,18004,18006,3,2048,1024,
+        0,18005,18004,1,0,0,0,18006,18007,1,0,0,0,18007,18005,1,0,0,0,18007,
+        18008,1,0,0,0,18008,18010,1,0,0,0,18009,18011,3,2050,1025,0,18010,
+        18009,1,0,0,0,18010,18011,1,0,0,0,18011,2047,1,0,0,0,18012,18013,
+        5,2302,0,0,18013,18014,3,2096,1048,0,18014,18016,5,2101,0,0,18015,
+        18017,3,2044,1022,0,18016,18015,1,0,0,0,18017,18018,1,0,0,0,18018,
+        18016,1,0,0,0,18018,18019,1,0,0,0,18019,2049,1,0,0,0,18020,18022,
+        5,491,0,0,18021,18023,3,2044,1022,0,18022,18021,1,0,0,0,18023,18024,
+        1,0,0,0,18024,18022,1,0,0,0,18024,18025,1,0,0,0,18025,2051,1,0,0,
+        0,18026,18027,5,780,0,0,18027,18029,3,2076,1038,0,18028,18030,5,
+        589,0,0,18029,18028,1,0,0,0,18029,18030,1,0,0,0,18030,18032,1,0,
+        0,0,18031,18033,3,2386,1193,0,18032,18031,1,0,0,0,18032,18033,1,
+        0,0,0,18033,2053,1,0,0,0,18034,18050,5,2259,0,0,18035,18051,5,2482,
+        0,0,18036,18037,5,2449,0,0,18037,18038,3,2098,1049,0,18038,18046,
+        5,2450,0,0,18039,18040,5,2455,0,0,18040,18041,5,2449,0,0,18041,18042,
+        3,2098,1049,0,18042,18043,5,2450,0,0,18043,18045,1,0,0,0,18044,18039,
+        1,0,0,0,18045,18048,1,0,0,0,18046,18044,1,0,0,0,18046,18047,1,0,
+        0,0,18047,18051,1,0,0,0,18048,18046,1,0,0,0,18049,18051,3,2144,1072,
+        0,18050,18035,1,0,0,0,18050,18036,1,0,0,0,18050,18049,1,0,0,0,18051,
+        2055,1,0,0,0,18052,18053,5,947,0,0,18053,18054,5,780,0,0,18054,18055,
+        3,2066,1033,0,18055,18056,5,2248,0,0,18056,18057,3,2066,1033,0,18057,
+        18058,5,1261,0,0,18058,18059,5,2449,0,0,18059,18060,3,2096,1048,
+        0,18060,18069,5,2450,0,0,18061,18063,3,2058,1029,0,18062,18064,3,
+        2064,1032,0,18063,18062,1,0,0,0,18063,18064,1,0,0,0,18064,18070,
+        1,0,0,0,18065,18067,3,2064,1032,0,18066,18068,3,2058,1029,0,18067,
+        18066,1,0,0,0,18067,18068,1,0,0,0,18068,18070,1,0,0,0,18069,18061,
+        1,0,0,0,18069,18065,1,0,0,0,18070,18072,1,0,0,0,18071,18073,3,2080,
+        1040,0,18072,18071,1,0,0,0,18072,18073,1,0,0,0,18073,18075,1,0,0,
+        0,18074,18076,3,2078,1039,0,18075,18074,1,0,0,0,18075,18076,1,0,
+        0,0,18076,2057,1,0,0,0,18077,18078,5,2302,0,0,18078,18079,5,915,
+        0,0,18079,18080,5,2101,0,0,18080,18081,5,2209,0,0,18081,18082,5,
+        1673,0,0,18082,18087,3,2060,1030,0,18083,18084,5,2455,0,0,18084,
+        18086,3,2060,1030,0,18085,18083,1,0,0,0,18086,18089,1,0,0,0,18087,
+        18085,1,0,0,0,18087,18088,1,0,0,0,18088,18091,1,0,0,0,18089,18087,
+        1,0,0,0,18090,18092,3,2298,1149,0,18091,18090,1,0,0,0,18091,18092,
+        1,0,0,0,18092,18094,1,0,0,0,18093,18095,3,2062,1031,0,18094,18093,
+        1,0,0,0,18094,18095,1,0,0,0,18095,2059,1,0,0,0,18096,18097,3,2366,
+        1183,0,18097,18098,5,2474,0,0,18098,18099,3,2100,1050,0,18099,2061,
+        1,0,0,0,18100,18101,5,403,0,0,18101,18102,3,2298,1149,0,18102,2063,
+        1,0,0,0,18103,18104,5,2302,0,0,18104,18105,5,1206,0,0,18105,18106,
+        5,915,0,0,18106,18107,5,2101,0,0,18107,18109,5,757,0,0,18108,18110,
+        3,2386,1193,0,18109,18108,1,0,0,0,18109,18110,1,0,0,0,18110,18111,
+        1,0,0,0,18111,18113,3,2054,1027,0,18112,18114,3,2298,1149,0,18113,
+        18112,1,0,0,0,18113,18114,1,0,0,0,18114,2065,1,0,0,0,18115,18126,
+        3,2368,1184,0,18116,18117,5,2449,0,0,18117,18118,3,1890,945,0,18118,
+        18119,5,2450,0,0,18119,18126,1,0,0,0,18120,18126,3,2088,1044,0,18121,
+        18122,5,2449,0,0,18122,18123,3,2088,1044,0,18123,18124,5,2450,0,
+        0,18124,18126,1,0,0,0,18125,18115,1,0,0,0,18125,18116,1,0,0,0,18125,
+        18120,1,0,0,0,18125,18121,1,0,0,0,18126,18128,1,0,0,0,18127,18129,
+        3,2296,1148,0,18128,18127,1,0,0,0,18128,18129,1,0,0,0,18129,2067,
+        1,0,0,0,18130,18131,5,882,0,0,18131,18132,5,2085,0,0,18132,18137,
+        3,2072,1036,0,18133,18134,5,2455,0,0,18134,18136,3,2072,1036,0,18135,
+        18133,1,0,0,0,18136,18139,1,0,0,0,18137,18135,1,0,0,0,18137,18138,
+        1,0,0,0,18138,18140,1,0,0,0,18139,18137,1,0,0,0,18140,18141,5,739,
+        0,0,18141,18142,3,2074,1037,0,18142,18144,5,978,0,0,18143,18145,
+        3,2070,1035,0,18144,18143,1,0,0,0,18144,18145,1,0,0,0,18145,2069,
+        1,0,0,0,18146,18147,5,2295,0,0,18147,18150,3,2100,1050,0,18148,18150,
+        5,1221,0,0,18149,18146,1,0,0,0,18149,18148,1,0,0,0,18150,2071,1,
+        0,0,0,18151,18153,3,2368,1184,0,18152,18154,3,2292,1146,0,18153,
+        18152,1,0,0,0,18153,18154,1,0,0,0,18154,2073,1,0,0,0,18155,18156,
+        5,1608,0,0,18156,18168,5,1682,0,0,18157,18158,5,1608,0,0,18158,18168,
+        5,541,0,0,18159,18161,5,1682,0,0,18160,18162,5,2209,0,0,18161,18160,
+        1,0,0,0,18161,18162,1,0,0,0,18162,18168,1,0,0,0,18163,18164,5,1682,
+        0,0,18164,18165,5,1608,0,0,18165,18168,5,541,0,0,18166,18168,5,541,
+        0,0,18167,18155,1,0,0,0,18167,18157,1,0,0,0,18167,18159,1,0,0,0,
+        18167,18163,1,0,0,0,18167,18166,1,0,0,0,18168,2075,1,0,0,0,18169,
+        18176,3,2086,1043,0,18170,18171,5,1260,0,0,18171,18172,5,2449,0,
+        0,18172,18173,3,2086,1043,0,18173,18174,5,2450,0,0,18174,18176,1,
+        0,0,0,18175,18169,1,0,0,0,18175,18170,1,0,0,0,18176,18178,1,0,0,
+        0,18177,18179,3,2296,1148,0,18178,18177,1,0,0,0,18178,18179,1,0,
+        0,0,18179,2077,1,0,0,0,18180,18181,7,206,0,0,18181,18182,3,2098,
+        1049,0,18182,18183,3,2300,1150,0,18183,2079,1,0,0,0,18184,18185,
+        5,889,0,0,18185,18187,5,522,0,0,18186,18188,3,2082,1041,0,18187,
+        18186,1,0,0,0,18187,18188,1,0,0,0,18188,18190,1,0,0,0,18189,18191,
+        3,2100,1050,0,18190,18189,1,0,0,0,18190,18191,1,0,0,0,18191,18193,
+        1,0,0,0,18192,18194,3,2084,1042,0,18193,18192,1,0,0,0,18193,18194,
+        1,0,0,0,18194,2081,1,0,0,0,18195,18196,5,780,0,0,18196,18197,3,2368,
+        1184,0,18197,2083,1,0,0,0,18198,18199,5,1551,0,0,18199,18202,5,859,
+        0,0,18200,18203,5,2187,0,0,18201,18203,3,2100,1050,0,18202,18200,
+        1,0,0,0,18202,18201,1,0,0,0,18203,2085,1,0,0,0,18204,18241,3,2088,
+        1044,0,18205,18206,5,2449,0,0,18206,18208,3,1890,945,0,18207,18209,
+        3,2090,1045,0,18208,18207,1,0,0,0,18208,18209,1,0,0,0,18209,18210,
+        1,0,0,0,18210,18211,5,2450,0,0,18211,18241,1,0,0,0,18212,18214,3,
+        2368,1184,0,18213,18215,3,1906,953,0,18214,18213,1,0,0,0,18214,18215,
+        1,0,0,0,18215,18217,1,0,0,0,18216,18218,3,2092,1046,0,18217,18216,
+        1,0,0,0,18217,18218,1,0,0,0,18218,18241,1,0,0,0,18219,18222,3,2180,
+        1090,0,18220,18221,5,69,0,0,18221,18223,3,2428,1214,0,18222,18220,
+        1,0,0,0,18222,18223,1,0,0,0,18223,18241,1,0,0,0,18224,18225,5,828,
+        0,0,18225,18226,5,2449,0,0,18226,18228,3,1916,958,0,18227,18229,
+        3,2090,1045,0,18228,18227,1,0,0,0,18228,18229,1,0,0,0,18229,18230,
+        1,0,0,0,18230,18231,5,2450,0,0,18231,18241,1,0,0,0,18232,18233,4,
+        1043,14,0,18233,18234,5,1553,0,0,18234,18235,5,2449,0,0,18235,18236,
+        3,2368,1184,0,18236,18237,5,1206,0,0,18237,18238,5,2353,0,0,18238,
+        18239,5,2450,0,0,18239,18241,1,0,0,0,18240,18204,1,0,0,0,18240,18205,
+        1,0,0,0,18240,18212,1,0,0,0,18240,18219,1,0,0,0,18240,18224,1,0,
+        0,0,18240,18232,1,0,0,0,18241,2087,1,0,0,0,18242,18253,7,223,0,0,
+        18243,18244,5,2449,0,0,18244,18245,3,1916,958,0,18245,18246,5,2450,
+        0,0,18246,18254,1,0,0,0,18247,18248,5,2449,0,0,18248,18249,3,2100,
+        1050,0,18249,18251,5,2450,0,0,18250,18252,3,2434,1217,0,18251,18250,
+        1,0,0,0,18251,18252,1,0,0,0,18252,18254,1,0,0,0,18253,18243,1,0,
+        0,0,18253,18247,1,0,0,0,18254,2089,1,0,0,0,18255,18264,5,2310,0,
+        0,18256,18257,5,1507,0,0,18257,18265,5,1260,0,0,18258,18259,5,200,
+        0,0,18259,18262,5,1274,0,0,18260,18261,5,286,0,0,18261,18263,3,2336,
+        1168,0,18262,18260,1,0,0,0,18262,18263,1,0,0,0,18263,18265,1,0,0,
+        0,18264,18256,1,0,0,0,18264,18258,1,0,0,0,18265,2091,1,0,0,0,18266,
+        18268,5,1616,0,0,18267,18269,5,143,0,0,18268,18267,1,0,0,0,18268,
+        18269,1,0,0,0,18269,18270,1,0,0,0,18270,18271,5,2449,0,0,18271,18274,
+        3,2100,1050,0,18272,18273,5,2455,0,0,18273,18275,3,2100,1050,0,18274,
+        18272,1,0,0,0,18274,18275,1,0,0,0,18275,18276,1,0,0,0,18276,18278,
+        5,2450,0,0,18277,18279,3,2094,1047,0,18278,18277,1,0,0,0,18278,18279,
+        1,0,0,0,18279,2093,1,0,0,0,18280,18281,5,1644,0,0,18281,18282,5,
+        2449,0,0,18282,18283,3,2100,1050,0,18283,18284,5,2450,0,0,18284,
+        2095,1,0,0,0,18285,18292,3,2100,1050,0,18286,18287,5,798,0,0,18287,
+        18288,5,2449,0,0,18288,18289,3,2098,1049,0,18289,18290,5,2450,0,
+        0,18290,18292,1,0,0,0,18291,18285,1,0,0,0,18291,18286,1,0,0,0,18292,
+        2097,1,0,0,0,18293,18298,3,2100,1050,0,18294,18295,5,2455,0,0,18295,
+        18297,3,2100,1050,0,18296,18294,1,0,0,0,18297,18300,1,0,0,0,18298,
+        18296,1,0,0,0,18298,18299,1,0,0,0,18299,2099,1,0,0,0,18300,18298,
+        1,0,0,0,18301,18304,3,2102,1051,0,18302,18304,3,2104,1052,0,18303,
+        18301,1,0,0,0,18303,18302,1,0,0,0,18304,2101,1,0,0,0,18305,18306,
+        5,343,0,0,18306,18307,5,2449,0,0,18307,18308,3,1916,958,0,18308,
+        18309,5,2450,0,0,18309,2103,1,0,0,0,18310,18311,6,1052,-1,0,18311,
+        18312,3,2106,1053,0,18312,18321,1,0,0,0,18313,18314,10,2,0,0,18314,
+        18315,5,49,0,0,18315,18320,3,2104,1052,3,18316,18317,10,1,0,0,18317,
+        18318,5,1309,0,0,18318,18320,3,2104,1052,2,18319,18313,1,0,0,0,18319,
+        18316,1,0,0,0,18320,18323,1,0,0,0,18321,18319,1,0,0,0,18321,18322,
+        1,0,0,0,18322,2105,1,0,0,0,18323,18321,1,0,0,0,18324,18326,5,1206,
+        0,0,18325,18324,1,0,0,0,18325,18326,1,0,0,0,18326,18327,1,0,0,0,
+        18327,18329,3,2112,1056,0,18328,18330,3,2108,1054,0,18329,18328,
+        1,0,0,0,18329,18330,1,0,0,0,18330,2107,1,0,0,0,18331,18333,5,786,
+        0,0,18332,18334,5,1206,0,0,18333,18332,1,0,0,0,18333,18334,1,0,0,
+        0,18334,18335,1,0,0,0,18335,18336,3,2110,1055,0,18336,2109,1,0,0,
+        0,18337,18376,5,1230,0,0,18338,18376,5,1000,0,0,18339,18376,5,1446,
+        0,0,18340,18376,5,736,0,0,18341,18342,5,36,0,0,18342,18376,5,1673,
+        0,0,18343,18376,5,497,0,0,18344,18346,5,1248,0,0,18345,18347,5,2168,
+        0,0,18346,18345,1,0,0,0,18346,18347,1,0,0,0,18347,18348,1,0,0,0,
+        18348,18350,5,2449,0,0,18349,18351,5,1260,0,0,18350,18349,1,0,0,
+        0,18350,18351,1,0,0,0,18351,18352,1,0,0,0,18352,18357,3,2400,1200,
+        0,18353,18354,5,2455,0,0,18354,18356,3,2400,1200,0,18355,18353,1,
+        0,0,0,18356,18359,1,0,0,0,18357,18355,1,0,0,0,18357,18358,1,0,0,
+        0,18358,18360,1,0,0,0,18359,18357,1,0,0,0,18360,18361,5,2450,0,0,
+        18361,18376,1,0,0,0,18362,18365,5,802,0,0,18363,18364,5,622,0,0,
+        18364,18366,5,802,0,0,18365,18363,1,0,0,0,18365,18366,1,0,0,0,18366,
+        18368,1,0,0,0,18367,18369,7,224,0,0,18368,18367,1,0,0,0,18368,18369,
+        1,0,0,0,18369,18373,1,0,0,0,18370,18371,7,2,0,0,18371,18372,5,2185,
+        0,0,18372,18374,5,820,0,0,18373,18370,1,0,0,0,18373,18374,1,0,0,
+        0,18374,18376,1,0,0,0,18375,18337,1,0,0,0,18375,18338,1,0,0,0,18375,
+        18339,1,0,0,0,18375,18340,1,0,0,0,18375,18341,1,0,0,0,18375,18343,
+        1,0,0,0,18375,18344,1,0,0,0,18375,18362,1,0,0,0,18376,2111,1,0,0,
+        0,18377,18378,6,1056,-1,0,18378,18387,3,2114,1057,0,18379,18381,
+        5,1206,0,0,18380,18379,1,0,0,0,18380,18381,1,0,0,0,18381,18382,1,
+        0,0,0,18382,18384,7,225,0,0,18383,18385,5,1248,0,0,18384,18383,1,
+        0,0,0,18384,18385,1,0,0,0,18385,18386,1,0,0,0,18386,18388,3,2124,
+        1062,0,18387,18380,1,0,0,0,18387,18388,1,0,0,0,18388,18398,1,0,0,
+        0,18389,18390,10,1,0,0,18390,18391,5,995,0,0,18391,18393,7,226,0,
+        0,18392,18394,7,227,0,0,18393,18392,1,0,0,0,18393,18394,1,0,0,0,
+        18394,18395,1,0,0,0,18395,18397,3,2114,1057,0,18396,18389,1,0,0,
+        0,18397,18400,1,0,0,0,18398,18396,1,0,0,0,18398,18399,1,0,0,0,18399,
+        2113,1,0,0,0,18400,18398,1,0,0,0,18401,18402,6,1057,-1,0,18402,18403,
+        3,2116,1058,0,18403,18416,1,0,0,0,18404,18405,10,3,0,0,18405,18406,
+        3,2118,1059,0,18406,18407,3,2114,1057,4,18407,18415,1,0,0,0,18408,
+        18410,10,2,0,0,18409,18411,5,1206,0,0,18410,18409,1,0,0,0,18410,
+        18411,1,0,0,0,18411,18412,1,0,0,0,18412,18413,5,739,0,0,18413,18415,
+        3,2120,1060,0,18414,18404,1,0,0,0,18414,18408,1,0,0,0,18415,18418,
+        1,0,0,0,18416,18414,1,0,0,0,18416,18417,1,0,0,0,18417,2115,1,0,0,
+        0,18418,18416,1,0,0,0,18419,18435,3,2124,1062,0,18420,18422,5,1206,
+        0,0,18421,18420,1,0,0,0,18421,18422,1,0,0,0,18422,18433,1,0,0,0,
+        18423,18424,5,739,0,0,18424,18434,3,2120,1060,0,18425,18426,5,118,
+        0,0,18426,18434,3,2122,1061,0,18427,18428,7,228,0,0,18428,18431,
+        3,2124,1062,0,18429,18430,5,525,0,0,18430,18432,3,2124,1062,0,18431,
+        18429,1,0,0,0,18431,18432,1,0,0,0,18432,18434,1,0,0,0,18433,18423,
+        1,0,0,0,18433,18425,1,0,0,0,18433,18427,1,0,0,0,18434,18436,1,0,
+        0,0,18435,18421,1,0,0,0,18435,18436,1,0,0,0,18436,2117,1,0,0,0,18437,
+        18452,5,2474,0,0,18438,18446,5,2465,0,0,18439,18440,5,2470,0,0,18440,
+        18446,5,2469,0,0,18441,18442,5,2468,0,0,18442,18446,5,2474,0,0,18443,
+        18444,5,2466,0,0,18444,18446,5,2474,0,0,18445,18438,1,0,0,0,18445,
+        18439,1,0,0,0,18445,18441,1,0,0,0,18445,18443,1,0,0,0,18446,18452,
+        1,0,0,0,18447,18449,7,229,0,0,18448,18450,5,2474,0,0,18449,18448,
+        1,0,0,0,18449,18450,1,0,0,0,18450,18452,1,0,0,0,18451,18437,1,0,
+        0,0,18451,18445,1,0,0,0,18451,18447,1,0,0,0,18452,2119,1,0,0,0,18453,
+        18454,5,2449,0,0,18454,18455,3,1916,958,0,18455,18456,5,2450,0,0,
+        18456,18472,1,0,0,0,18457,18458,5,2449,0,0,18458,18463,3,2124,1062,
+        0,18459,18460,5,2455,0,0,18460,18462,3,2124,1062,0,18461,18459,1,
+        0,0,0,18462,18465,1,0,0,0,18463,18461,1,0,0,0,18463,18464,1,0,0,
+        0,18464,18466,1,0,0,0,18465,18463,1,0,0,0,18466,18467,5,2450,0,0,
+        18467,18472,1,0,0,0,18468,18472,3,2420,1210,0,18469,18472,3,2408,
+        1204,0,18470,18472,3,2410,1205,0,18471,18453,1,0,0,0,18471,18457,
+        1,0,0,0,18471,18468,1,0,0,0,18471,18469,1,0,0,0,18471,18470,1,0,
+        0,0,18472,2121,1,0,0,0,18473,18474,3,2124,1062,0,18474,18475,5,49,
+        0,0,18475,18476,3,2124,1062,0,18476,2123,1,0,0,0,18477,18478,6,1062,
+        -1,0,18478,18487,3,2128,1064,0,18479,18484,5,82,0,0,18480,18485,
+        5,874,0,0,18481,18482,5,2114,0,0,18482,18483,5,2365,0,0,18483,18485,
+        3,2124,1062,0,18484,18480,1,0,0,0,18484,18481,1,0,0,0,18485,18488,
+        1,0,0,0,18486,18488,3,2126,1063,0,18487,18479,1,0,0,0,18487,18486,
+        1,0,0,0,18487,18488,1,0,0,0,18488,18492,1,0,0,0,18489,18490,5,1261,
+        0,0,18490,18491,5,1322,0,0,18491,18493,7,230,0,0,18492,18489,1,0,
+        0,0,18492,18493,1,0,0,0,18493,18512,1,0,0,0,18494,18495,10,5,0,0,
+        18495,18496,5,2451,0,0,18496,18511,3,2124,1062,6,18497,18498,10,
+        4,0,0,18498,18499,7,231,0,0,18499,18511,3,2124,1062,5,18500,18501,
+        10,3,0,0,18501,18502,7,143,0,0,18502,18511,3,2124,1062,4,18503,18504,
+        10,2,0,0,18504,18505,5,2473,0,0,18505,18506,5,2473,0,0,18506,18511,
+        3,2124,1062,3,18507,18508,10,1,0,0,18508,18509,5,2374,0,0,18509,
+        18511,3,1692,846,0,18510,18494,1,0,0,0,18510,18497,1,0,0,0,18510,
+        18500,1,0,0,0,18510,18503,1,0,0,0,18510,18507,1,0,0,0,18511,18514,
+        1,0,0,0,18512,18510,1,0,0,0,18512,18513,1,0,0,0,18513,2125,1,0,0,
+        0,18514,18512,1,0,0,0,18515,18520,5,365,0,0,18516,18517,5,2449,0,
+        0,18517,18518,3,2124,1062,0,18518,18519,5,2450,0,0,18519,18521,1,
+        0,0,0,18520,18516,1,0,0,0,18520,18521,1,0,0,0,18521,18522,1,0,0,
+        0,18522,18523,5,2143,0,0,18523,18528,5,1638,0,0,18524,18525,5,2449,
+        0,0,18525,18526,3,2124,1062,0,18526,18527,5,2450,0,0,18527,18529,
+        1,0,0,0,18528,18524,1,0,0,0,18528,18529,1,0,0,0,18529,18540,1,0,
+        0,0,18530,18535,5,2360,0,0,18531,18532,5,2449,0,0,18532,18533,3,
+        2124,1062,0,18533,18534,5,2450,0,0,18534,18536,1,0,0,0,18535,18531,
+        1,0,0,0,18535,18536,1,0,0,0,18536,18537,1,0,0,0,18537,18538,5,2143,
+        0,0,18538,18540,5,986,0,0,18539,18515,1,0,0,0,18539,18530,1,0,0,
+        0,18540,2127,1,0,0,0,18541,18543,7,143,0,0,18542,18541,1,0,0,0,18542,
+        18543,1,0,0,0,18543,18544,1,0,0,0,18544,18549,3,2136,1068,0,18545,
+        18546,5,2475,0,0,18546,18547,3,2130,1065,0,18547,18548,5,2476,0,
+        0,18548,18550,1,0,0,0,18549,18545,1,0,0,0,18549,18550,1,0,0,0,18550,
+        2129,1,0,0,0,18551,18554,5,55,0,0,18552,18554,3,2100,1050,0,18553,
+        18551,1,0,0,0,18553,18552,1,0,0,0,18554,18562,1,0,0,0,18555,18558,
+        5,2455,0,0,18556,18559,5,55,0,0,18557,18559,3,2100,1050,0,18558,
+        18556,1,0,0,0,18558,18557,1,0,0,0,18559,18561,1,0,0,0,18560,18555,
+        1,0,0,0,18561,18564,1,0,0,0,18562,18560,1,0,0,0,18562,18563,1,0,
+        0,0,18563,18575,1,0,0,0,18564,18562,1,0,0,0,18565,18570,3,2132,1066,
+        0,18566,18567,5,2455,0,0,18567,18569,3,2132,1066,0,18568,18566,1,
+        0,0,0,18569,18572,1,0,0,0,18570,18568,1,0,0,0,18570,18571,1,0,0,
+        0,18571,18575,1,0,0,0,18572,18570,1,0,0,0,18573,18575,3,2134,1067,
+        0,18574,18553,1,0,0,0,18574,18565,1,0,0,0,18574,18573,1,0,0,0,18575,
+        2131,1,0,0,0,18576,18577,5,621,0,0,18577,18595,3,2366,1183,0,18578,
+        18579,5,739,0,0,18579,18581,5,2449,0,0,18580,18582,3,2098,1049,0,
+        18581,18580,1,0,0,0,18581,18582,1,0,0,0,18582,18583,1,0,0,0,18583,
+        18596,5,2450,0,0,18584,18585,5,858,0,0,18585,18587,3,2100,1050,0,
+        18586,18584,1,0,0,0,18586,18587,1,0,0,0,18587,18588,1,0,0,0,18588,
+        18589,5,629,0,0,18589,18590,3,2100,1050,0,18590,18591,5,2143,0,0,
+        18591,18592,3,2100,1050,0,18592,18593,7,232,0,0,18593,18594,3,2100,
+        1050,0,18594,18596,1,0,0,0,18595,18578,1,0,0,0,18595,18586,1,0,0,
+        0,18596,2133,1,0,0,0,18597,18598,5,621,0,0,18598,18599,3,2386,1193,
+        0,18599,18600,5,739,0,0,18600,18607,5,2449,0,0,18601,18608,3,1916,
+        958,0,18602,18604,5,2449,0,0,18603,18605,3,2098,1049,0,18604,18603,
+        1,0,0,0,18604,18605,1,0,0,0,18605,18606,1,0,0,0,18606,18608,5,2450,
+        0,0,18607,18601,1,0,0,0,18607,18602,1,0,0,0,18608,18609,1,0,0,0,
+        18609,18610,5,2450,0,0,18610,2135,1,0,0,0,18611,18612,5,1456,0,0,
+        18612,18632,3,2138,1069,0,18613,18614,5,279,0,0,18614,18632,3,2138,
+        1069,0,18615,18616,5,1022,0,0,18616,18632,3,2138,1069,0,18617,18618,
+        5,1252,0,0,18618,18632,3,2138,1069,0,18619,18629,3,2138,1069,0,18620,
+        18627,5,2442,0,0,18621,18628,7,233,0,0,18622,18623,7,234,0,0,18623,
+        18624,5,2449,0,0,18624,18625,3,2100,1050,0,18625,18626,5,2450,0,
+        0,18626,18628,1,0,0,0,18627,18621,1,0,0,0,18627,18622,1,0,0,0,18628,
+        18630,1,0,0,0,18629,18620,1,0,0,0,18629,18630,1,0,0,0,18630,18632,
+        1,0,0,0,18631,18611,1,0,0,0,18631,18613,1,0,0,0,18631,18615,1,0,
+        0,0,18631,18617,1,0,0,0,18631,18619,1,0,0,0,18632,2137,1,0,0,0,18633,
+        18641,3,2156,1078,0,18634,18641,3,2168,1084,0,18635,18641,3,2172,
+        1086,0,18636,18637,4,1069,25,0,18637,18641,3,2166,1083,0,18638,18641,
+        3,2142,1071,0,18639,18641,3,2140,1070,0,18640,18633,1,0,0,0,18640,
+        18634,1,0,0,0,18640,18635,1,0,0,0,18640,18636,1,0,0,0,18640,18638,
+        1,0,0,0,18640,18639,1,0,0,0,18641,2139,1,0,0,0,18642,18643,5,460,
+        0,0,18643,18644,3,2096,1048,0,18644,18645,5,461,0,0,18645,18653,
+        3,2100,1050,0,18646,18647,5,457,0,0,18647,18648,3,2096,1048,0,18648,
+        18649,5,461,0,0,18649,18650,3,2100,1050,0,18650,18652,1,0,0,0,18651,
+        18646,1,0,0,0,18652,18655,1,0,0,0,18653,18651,1,0,0,0,18653,18654,
+        1,0,0,0,18654,18658,1,0,0,0,18655,18653,1,0,0,0,18656,18657,5,456,
+        0,0,18657,18659,3,2100,1050,0,18658,18656,1,0,0,0,18658,18659,1,
+        0,0,0,18659,18660,1,0,0,0,18660,18661,5,458,0,0,18661,2141,1,0,0,
+        0,18662,18679,5,1724,0,0,18663,18664,5,1386,0,0,18664,18665,5,2449,
+        0,0,18665,18666,3,2100,1050,0,18666,18667,5,2450,0,0,18667,18680,
+        1,0,0,0,18668,18677,5,1385,0,0,18669,18670,5,2442,0,0,18670,18678,
+        5,313,0,0,18671,18672,5,2449,0,0,18672,18673,3,2100,1050,0,18673,
+        18674,5,2450,0,0,18674,18675,5,2442,0,0,18675,18676,7,235,0,0,18676,
+        18678,1,0,0,0,18677,18669,1,0,0,0,18677,18671,1,0,0,0,18678,18680,
+        1,0,0,0,18679,18663,1,0,0,0,18679,18668,1,0,0,0,18680,2143,1,0,0,
+        0,18681,18682,3,1094,547,0,18682,18683,5,2449,0,0,18683,18684,3,
+        2100,1050,0,18684,18689,5,2450,0,0,18685,18686,5,2442,0,0,18686,
+        18688,3,2412,1206,0,18687,18685,1,0,0,0,18688,18691,1,0,0,0,18689,
+        18687,1,0,0,0,18689,18690,1,0,0,0,18690,2145,1,0,0,0,18691,18689,
+        1,0,0,0,18692,18695,3,2150,1075,0,18693,18695,3,2148,1074,0,18694,
+        18692,1,0,0,0,18694,18693,1,0,0,0,18695,2147,1,0,0,0,18696,18698,
+        3,1792,896,0,18697,18696,1,0,0,0,18697,18698,1,0,0,0,18698,18699,
+        1,0,0,0,18699,18700,5,180,0,0,18700,18702,3,2100,1050,0,18701,18703,
+        3,2152,1076,0,18702,18701,1,0,0,0,18703,18704,1,0,0,0,18704,18702,
+        1,0,0,0,18704,18705,1,0,0,0,18705,18707,1,0,0,0,18706,18708,3,2154,
+        1077,0,18707,18706,1,0,0,0,18707,18708,1,0,0,0,18708,18709,1,0,0,
+        0,18709,18711,5,508,0,0,18710,18712,5,180,0,0,18711,18710,1,0,0,
+        0,18711,18712,1,0,0,0,18712,18714,1,0,0,0,18713,18715,3,2338,1169,
+        0,18714,18713,1,0,0,0,18714,18715,1,0,0,0,18715,2149,1,0,0,0,18716,
+        18718,3,1792,896,0,18717,18716,1,0,0,0,18717,18718,1,0,0,0,18718,
+        18719,1,0,0,0,18719,18721,5,180,0,0,18720,18722,3,2152,1076,0,18721,
+        18720,1,0,0,0,18722,18723,1,0,0,0,18723,18721,1,0,0,0,18723,18724,
+        1,0,0,0,18724,18726,1,0,0,0,18725,18727,3,2154,1077,0,18726,18725,
+        1,0,0,0,18726,18727,1,0,0,0,18727,18728,1,0,0,0,18728,18730,5,508,
+        0,0,18729,18731,5,180,0,0,18730,18729,1,0,0,0,18730,18731,1,0,0,
+        0,18731,18733,1,0,0,0,18732,18734,3,2338,1169,0,18733,18732,1,0,
+        0,0,18733,18734,1,0,0,0,18734,2151,1,0,0,0,18735,18736,5,2302,0,
+        0,18736,18737,3,2100,1050,0,18737,18738,5,2101,0,0,18738,18739,3,
+        1790,895,0,18739,2153,1,0,0,0,18740,18741,5,491,0,0,18741,18742,
+        3,1790,895,0,18742,2155,1,0,0,0,18743,18746,3,2160,1080,0,18744,
+        18746,3,2158,1079,0,18745,18743,1,0,0,0,18745,18744,1,0,0,0,18746,
+        2157,1,0,0,0,18747,18748,5,180,0,0,18748,18750,3,2100,1050,0,18749,
+        18751,3,2162,1081,0,18750,18749,1,0,0,0,18751,18752,1,0,0,0,18752,
+        18750,1,0,0,0,18752,18753,1,0,0,0,18753,18755,1,0,0,0,18754,18756,
+        3,2164,1082,0,18755,18754,1,0,0,0,18755,18756,1,0,0,0,18756,18757,
+        1,0,0,0,18757,18759,5,508,0,0,18758,18760,5,180,0,0,18759,18758,
+        1,0,0,0,18759,18760,1,0,0,0,18760,2159,1,0,0,0,18761,18763,5,180,
+        0,0,18762,18764,3,2162,1081,0,18763,18762,1,0,0,0,18764,18765,1,
+        0,0,0,18765,18763,1,0,0,0,18765,18766,1,0,0,0,18766,18768,1,0,0,
+        0,18767,18769,3,2164,1082,0,18768,18767,1,0,0,0,18768,18769,1,0,
+        0,0,18769,18770,1,0,0,0,18770,18772,5,508,0,0,18771,18773,5,180,
+        0,0,18772,18771,1,0,0,0,18772,18773,1,0,0,0,18773,2161,1,0,0,0,18774,
+        18775,5,2302,0,0,18775,18776,3,2100,1050,0,18776,18777,5,2101,0,
+        0,18777,18778,3,2100,1050,0,18778,2163,1,0,0,0,18779,18780,5,491,
+        0,0,18780,18781,3,2100,1050,0,18781,2165,1,0,0,0,18782,18813,3,2408,
+        1204,0,18783,18813,3,2420,1210,0,18784,18813,3,2432,1216,0,18785,
+        18787,3,2410,1205,0,18786,18788,3,2434,1217,0,18787,18786,1,0,0,
+        0,18787,18788,1,0,0,0,18788,18813,1,0,0,0,18789,18790,5,2449,0,0,
+        18790,18791,3,1916,958,0,18791,18795,5,2450,0,0,18792,18794,3,1922,
+        961,0,18793,18792,1,0,0,0,18794,18797,1,0,0,0,18795,18793,1,0,0,
+        0,18795,18796,1,0,0,0,18796,18813,1,0,0,0,18797,18795,1,0,0,0,18798,
+        18799,5,2449,0,0,18799,18800,3,2100,1050,0,18800,18805,5,2450,0,
+        0,18801,18802,5,2442,0,0,18802,18804,3,2412,1206,0,18803,18801,1,
+        0,0,0,18804,18807,1,0,0,0,18805,18803,1,0,0,0,18805,18806,1,0,0,
+        0,18806,18813,1,0,0,0,18807,18805,1,0,0,0,18808,18809,5,2449,0,0,
+        18809,18810,3,2098,1049,0,18810,18811,5,2450,0,0,18811,18813,1,0,
+        0,0,18812,18782,1,0,0,0,18812,18783,1,0,0,0,18812,18784,1,0,0,0,
+        18812,18785,1,0,0,0,18812,18789,1,0,0,0,18812,18798,1,0,0,0,18812,
+        18808,1,0,0,0,18813,2167,1,0,0,0,18814,18830,7,236,0,0,18815,18816,
+        5,2449,0,0,18816,18817,3,1888,944,0,18817,18818,5,2450,0,0,18818,
+        18831,1,0,0,0,18819,18820,5,2449,0,0,18820,18825,3,2100,1050,0,18821,
+        18822,5,2455,0,0,18822,18824,3,2100,1050,0,18823,18821,1,0,0,0,18824,
+        18827,1,0,0,0,18825,18823,1,0,0,0,18825,18826,1,0,0,0,18826,18828,
+        1,0,0,0,18827,18825,1,0,0,0,18828,18829,5,2450,0,0,18829,18831,1,
+        0,0,0,18830,18815,1,0,0,0,18830,18819,1,0,0,0,18831,2169,1,0,0,0,
+        18832,18833,5,2418,0,0,18833,18834,5,2449,0,0,18834,18835,3,2100,
+        1050,0,18835,18836,5,2455,0,0,18836,18839,3,2100,1050,0,18837,18838,
+        5,2455,0,0,18838,18840,3,2100,1050,0,18839,18837,1,0,0,0,18839,18840,
+        1,0,0,0,18840,18841,1,0,0,0,18841,18842,5,2450,0,0,18842,18919,1,
+        0,0,0,18843,18844,5,2419,0,0,18844,18848,5,2449,0,0,18845,18849,
+        3,2414,1207,0,18846,18849,3,2172,1086,0,18847,18849,3,2100,1050,
+        0,18848,18845,1,0,0,0,18848,18846,1,0,0,0,18848,18847,1,0,0,0,18849,
+        18852,1,0,0,0,18850,18851,5,2455,0,0,18851,18853,3,2426,1213,0,18852,
+        18850,1,0,0,0,18852,18853,1,0,0,0,18853,18856,1,0,0,0,18854,18855,
+        5,2455,0,0,18855,18857,3,2426,1213,0,18856,18854,1,0,0,0,18856,18857,
+        1,0,0,0,18857,18858,1,0,0,0,18858,18859,5,2450,0,0,18859,18919,1,
+        0,0,0,18860,18861,5,2403,0,0,18861,18862,5,2449,0,0,18862,18863,
+        3,2098,1049,0,18863,18864,5,2450,0,0,18864,18919,1,0,0,0,18865,18866,
+        5,204,0,0,18866,18867,5,2449,0,0,18867,18868,3,2124,1062,0,18868,
+        18869,5,2248,0,0,18869,18870,5,1008,0,0,18870,18871,5,2450,0,0,18871,
+        18919,1,0,0,0,18872,18873,5,2413,0,0,18873,18874,5,2449,0,0,18874,
+        18875,3,2100,1050,0,18875,18876,5,2455,0,0,18876,18877,3,2100,1050,
+        0,18877,18878,5,2450,0,0,18878,18919,1,0,0,0,18879,18880,5,2420,
+        0,0,18880,18888,5,2449,0,0,18881,18883,7,237,0,0,18882,18881,1,0,
+        0,0,18882,18883,1,0,0,0,18883,18885,1,0,0,0,18884,18886,3,2100,1050,
+        0,18885,18884,1,0,0,0,18885,18886,1,0,0,0,18886,18887,1,0,0,0,18887,
+        18889,5,629,0,0,18888,18882,1,0,0,0,18888,18889,1,0,0,0,18889,18890,
+        1,0,0,0,18890,18891,3,2124,1062,0,18891,18892,5,2450,0,0,18892,18919,
+        1,0,0,0,18893,18894,5,2427,0,0,18894,18898,5,2449,0,0,18895,18899,
+        3,2414,1207,0,18896,18899,3,2172,1086,0,18897,18899,3,2100,1050,
+        0,18898,18895,1,0,0,0,18898,18896,1,0,0,0,18898,18897,1,0,0,0,18899,
+        18906,1,0,0,0,18900,18901,5,389,0,0,18901,18902,3,2124,1062,0,18902,
+        18903,5,1261,0,0,18903,18904,5,301,0,0,18904,18905,5,520,0,0,18905,
+        18907,1,0,0,0,18906,18900,1,0,0,0,18906,18907,1,0,0,0,18907,18914,
+        1,0,0,0,18908,18909,5,2455,0,0,18909,18912,3,2426,1213,0,18910,18911,
+        5,2455,0,0,18911,18913,3,2426,1213,0,18912,18910,1,0,0,0,18912,18913,
+        1,0,0,0,18913,18915,1,0,0,0,18914,18908,1,0,0,0,18914,18915,1,0,
+        0,0,18915,18916,1,0,0,0,18916,18917,5,2450,0,0,18917,18919,1,0,0,
+        0,18918,18832,1,0,0,0,18918,18843,1,0,0,0,18918,18860,1,0,0,0,18918,
+        18865,1,0,0,0,18918,18872,1,0,0,0,18918,18879,1,0,0,0,18918,18893,
+        1,0,0,0,18919,2171,1,0,0,0,18920,18926,3,2170,1085,0,18921,18926,
+        3,2212,1106,0,18922,18926,3,2174,1087,0,18923,18924,4,1086,26,0,
+        18924,18926,3,2218,1109,0,18925,18920,1,0,0,0,18925,18921,1,0,0,
+        0,18925,18922,1,0,0,0,18925,18923,1,0,0,0,18926,2173,1,0,0,0,18927,
+        18928,5,797,0,0,18928,18929,5,2449,0,0,18929,18934,3,2182,1091,0,
+        18930,18931,5,2455,0,0,18931,18933,3,2182,1091,0,18932,18930,1,0,
+        0,0,18933,18936,1,0,0,0,18934,18932,1,0,0,0,18934,18935,1,0,0,0,
+        18935,18938,1,0,0,0,18936,18934,1,0,0,0,18937,18939,3,2184,1092,
+        0,18938,18937,1,0,0,0,18938,18939,1,0,0,0,18939,18941,1,0,0,0,18940,
+        18942,3,2186,1093,0,18941,18940,1,0,0,0,18941,18942,1,0,0,0,18942,
+        18944,1,0,0,0,18943,18945,5,1768,0,0,18944,18943,1,0,0,0,18944,18945,
+        1,0,0,0,18945,18946,1,0,0,0,18946,18947,5,2450,0,0,18947,19116,1,
+        0,0,0,18948,18949,5,796,0,0,18949,18950,5,2449,0,0,18950,18953,3,
+        2100,1050,0,18951,18952,5,622,0,0,18952,18954,5,802,0,0,18953,18951,
+        1,0,0,0,18953,18954,1,0,0,0,18954,18956,1,0,0,0,18955,18957,3,2016,
+        1008,0,18956,18955,1,0,0,0,18956,18957,1,0,0,0,18957,18959,1,0,0,
+        0,18958,18960,3,2184,1092,0,18959,18958,1,0,0,0,18959,18960,1,0,
+        0,0,18960,18962,1,0,0,0,18961,18963,3,2186,1093,0,18962,18961,1,
+        0,0,0,18962,18963,1,0,0,0,18963,18965,1,0,0,0,18964,18966,5,1768,
+        0,0,18965,18964,1,0,0,0,18965,18966,1,0,0,0,18966,18967,1,0,0,0,
+        18967,18968,5,2450,0,0,18968,19116,1,0,0,0,18969,18970,5,804,0,0,
+        18970,18971,5,2449,0,0,18971,18972,3,2176,1088,0,18972,18973,5,2450,
+        0,0,18973,19116,1,0,0,0,18974,18975,5,803,0,0,18975,18977,5,2449,
+        0,0,18976,18978,5,817,0,0,18977,18976,1,0,0,0,18977,18978,1,0,0,
+        0,18978,18979,1,0,0,0,18979,18980,3,2100,1050,0,18980,18981,5,2260,
+        0,0,18981,18985,3,2100,1050,0,18982,18983,7,238,0,0,18983,18984,
+        5,1261,0,0,18984,18986,5,1230,0,0,18985,18982,1,0,0,0,18985,18986,
+        1,0,0,0,18986,19001,1,0,0,0,18987,18999,5,1587,0,0,18988,18995,5,
+        2261,0,0,18989,18990,5,2449,0,0,18990,18992,5,2443,0,0,18991,18993,
+        7,239,0,0,18992,18991,1,0,0,0,18992,18993,1,0,0,0,18993,18994,1,
+        0,0,0,18994,18996,5,2450,0,0,18995,18989,1,0,0,0,18995,18996,1,0,
+        0,0,18996,19000,1,0,0,0,18997,19000,5,215,0,0,18998,19000,5,142,
+        0,0,18999,18988,1,0,0,0,18999,18997,1,0,0,0,18999,18998,1,0,0,0,
+        19000,19002,1,0,0,0,19001,18987,1,0,0,0,19001,19002,1,0,0,0,19002,
+        19004,1,0,0,0,19003,19005,5,1768,0,0,19004,19003,1,0,0,0,19004,19005,
+        1,0,0,0,19005,19009,1,0,0,0,19006,19007,5,2310,0,0,19007,19008,5,
+        2185,0,0,19008,19010,5,820,0,0,19009,19006,1,0,0,0,19009,19010,1,
+        0,0,0,19010,19011,1,0,0,0,19011,19012,5,2450,0,0,19012,19116,1,0,
+        0,0,19013,19014,5,806,0,0,19014,19015,5,2449,0,0,19015,19018,3,2100,
+        1050,0,19016,19017,5,622,0,0,19017,19019,5,802,0,0,19018,19016,1,
+        0,0,0,19018,19019,1,0,0,0,19019,19020,1,0,0,0,19020,19021,5,2455,
+        0,0,19021,19022,5,2445,0,0,19022,19024,3,2194,1097,0,19023,19025,
+        3,2198,1099,0,19024,19023,1,0,0,0,19024,19025,1,0,0,0,19025,19027,
+        1,0,0,0,19026,19028,3,2200,1100,0,19027,19026,1,0,0,0,19027,19028,
+        1,0,0,0,19028,19030,1,0,0,0,19029,19031,3,2202,1101,0,19030,19029,
+        1,0,0,0,19030,19031,1,0,0,0,19031,19032,1,0,0,0,19032,19033,5,2450,
+        0,0,19033,19116,1,0,0,0,19034,19035,5,807,0,0,19035,19036,5,2449,
+        0,0,19036,19039,5,2445,0,0,19037,19038,5,1587,0,0,19038,19040,3,
+        2196,1098,0,19039,19037,1,0,0,0,19039,19040,1,0,0,0,19040,19042,
+        1,0,0,0,19041,19043,5,1450,0,0,19042,19041,1,0,0,0,19042,19043,1,
+        0,0,0,19043,19045,1,0,0,0,19044,19046,5,71,0,0,19045,19044,1,0,0,
+        0,19045,19046,1,0,0,0,19046,19048,1,0,0,0,19047,19049,5,2161,0,0,
+        19048,19047,1,0,0,0,19048,19049,1,0,0,0,19049,19058,1,0,0,0,19050,
+        19055,5,1230,0,0,19051,19055,5,520,0,0,19052,19053,5,497,0,0,19053,
+        19055,7,240,0,0,19054,19050,1,0,0,0,19054,19051,1,0,0,0,19054,19052,
+        1,0,0,0,19055,19056,1,0,0,0,19056,19057,5,1261,0,0,19057,19059,5,
+        520,0,0,19058,19054,1,0,0,0,19058,19059,1,0,0,0,19059,19060,1,0,
+        0,0,19060,19116,5,2450,0,0,19061,19062,5,811,0,0,19062,19063,5,2449,
+        0,0,19063,19064,3,2100,1050,0,19064,19065,5,2455,0,0,19065,19070,
+        3,2188,1094,0,19066,19067,5,2455,0,0,19067,19069,3,2188,1094,0,19068,
+        19066,1,0,0,0,19069,19072,1,0,0,0,19070,19068,1,0,0,0,19070,19071,
+        1,0,0,0,19071,19073,1,0,0,0,19072,19070,1,0,0,0,19073,19074,5,2450,
+        0,0,19074,19116,1,0,0,0,19075,19076,5,812,0,0,19076,19077,5,2449,
+        0,0,19077,19080,3,2100,1050,0,19078,19079,5,622,0,0,19079,19081,
+        5,802,0,0,19080,19078,1,0,0,0,19080,19081,1,0,0,0,19081,19113,1,
+        0,0,0,19082,19084,5,2455,0,0,19083,19085,5,2445,0,0,19084,19083,
+        1,0,0,0,19084,19085,1,0,0,0,19085,19087,1,0,0,0,19086,19088,3,2204,
+        1102,0,19087,19086,1,0,0,0,19087,19088,1,0,0,0,19088,19097,1,0,0,
+        0,19089,19094,5,520,0,0,19090,19094,5,1230,0,0,19091,19092,5,389,
+        0,0,19092,19094,3,2210,1105,0,19093,19089,1,0,0,0,19093,19090,1,
+        0,0,0,19093,19091,1,0,0,0,19093,19094,1,0,0,0,19094,19095,1,0,0,
+        0,19095,19096,5,1261,0,0,19096,19098,5,520,0,0,19097,19093,1,0,0,
+        0,19097,19098,1,0,0,0,19098,19107,1,0,0,0,19099,19104,5,520,0,0,
+        19100,19104,5,1230,0,0,19101,19102,5,389,0,0,19102,19104,3,2210,
+        1105,0,19103,19099,1,0,0,0,19103,19100,1,0,0,0,19103,19101,1,0,0,
+        0,19103,19104,1,0,0,0,19104,19105,1,0,0,0,19105,19106,5,1261,0,0,
+        19106,19108,5,497,0,0,19107,19103,1,0,0,0,19107,19108,1,0,0,0,19108,
+        19110,1,0,0,0,19109,19111,3,2208,1104,0,19110,19109,1,0,0,0,19110,
+        19111,1,0,0,0,19111,19112,1,0,0,0,19112,19114,5,2450,0,0,19113,19082,
+        1,0,0,0,19113,19114,1,0,0,0,19114,19116,1,0,0,0,19115,18927,1,0,
+        0,0,19115,18948,1,0,0,0,19115,18969,1,0,0,0,19115,18974,1,0,0,0,
+        19115,19013,1,0,0,0,19115,19034,1,0,0,0,19115,19061,1,0,0,0,19115,
+        19075,1,0,0,0,19116,2175,1,0,0,0,19117,19122,3,2178,1089,0,19118,
+        19119,5,2455,0,0,19119,19121,3,2178,1089,0,19120,19118,1,0,0,0,19121,
+        19124,1,0,0,0,19122,19120,1,0,0,0,19122,19123,1,0,0,0,19123,19127,
+        1,0,0,0,19124,19122,1,0,0,0,19125,19127,5,2452,0,0,19126,19117,1,
+        0,0,0,19126,19125,1,0,0,0,19127,19129,1,0,0,0,19128,19130,3,2184,
+        1092,0,19129,19128,1,0,0,0,19129,19130,1,0,0,0,19130,19132,1,0,0,
+        0,19131,19133,3,2186,1093,0,19132,19131,1,0,0,0,19132,19133,1,0,
+        0,0,19133,19135,1,0,0,0,19134,19136,5,1768,0,0,19135,19134,1,0,0,
+        0,19135,19136,1,0,0,0,19136,19140,1,0,0,0,19137,19138,5,2310,0,0,
+        19138,19139,5,2185,0,0,19139,19141,5,820,0,0,19140,19137,1,0,0,0,
+        19140,19141,1,0,0,0,19141,2177,1,0,0,0,19142,19144,5,817,0,0,19143,
+        19142,1,0,0,0,19143,19144,1,0,0,0,19144,19145,1,0,0,0,19145,19147,
+        3,2100,1050,0,19146,19148,7,241,0,0,19147,19146,1,0,0,0,19147,19148,
+        1,0,0,0,19148,19149,1,0,0,0,19149,19150,3,2100,1050,0,19150,19157,
+        1,0,0,0,19151,19152,3,2100,1050,0,19152,19153,5,2471,0,0,19153,19154,
+        3,2100,1050,0,19154,19157,1,0,0,0,19155,19157,3,2428,1214,0,19156,
+        19143,1,0,0,0,19156,19151,1,0,0,0,19156,19155,1,0,0,0,19157,19160,
+        1,0,0,0,19158,19159,5,622,0,0,19159,19161,5,802,0,0,19160,19158,
+        1,0,0,0,19160,19161,1,0,0,0,19161,2179,1,0,0,0,19162,19163,5,808,
+        0,0,19163,19164,5,2449,0,0,19164,19167,3,2100,1050,0,19165,19166,
+        5,622,0,0,19166,19168,5,802,0,0,19167,19165,1,0,0,0,19167,19168,
+        1,0,0,0,19168,19171,1,0,0,0,19169,19170,5,2455,0,0,19170,19172,5,
+        2445,0,0,19171,19169,1,0,0,0,19171,19172,1,0,0,0,19172,19176,1,0,
+        0,0,19173,19174,7,242,0,0,19174,19175,5,1261,0,0,19175,19177,5,520,
+        0,0,19176,19173,1,0,0,0,19176,19177,1,0,0,0,19177,19181,1,0,0,0,
+        19178,19179,7,243,0,0,19179,19180,5,1261,0,0,19180,19182,5,497,0,
+        0,19181,19178,1,0,0,0,19181,19182,1,0,0,0,19182,19184,1,0,0,0,19183,
+        19185,3,2190,1095,0,19184,19183,1,0,0,0,19184,19185,1,0,0,0,19185,
+        19186,1,0,0,0,19186,19187,5,2450,0,0,19187,2181,1,0,0,0,19188,19194,
+        3,2100,1050,0,19189,19194,5,2445,0,0,19190,19194,5,1230,0,0,19191,
+        19194,5,2443,0,0,19192,19194,3,2174,1087,0,19193,19188,1,0,0,0,19193,
+        19189,1,0,0,0,19193,19190,1,0,0,0,19193,19191,1,0,0,0,19193,19192,
+        1,0,0,0,19194,19197,1,0,0,0,19195,19196,5,622,0,0,19196,19198,5,
+        802,0,0,19197,19195,1,0,0,0,19197,19198,1,0,0,0,19198,2183,1,0,0,
+        0,19199,19200,7,238,0,0,19200,19201,5,1261,0,0,19201,19202,5,1230,
+        0,0,19202,2185,1,0,0,0,19203,19215,5,1587,0,0,19204,19211,5,2261,
+        0,0,19205,19206,5,2449,0,0,19206,19208,5,2443,0,0,19207,19209,7,
+        239,0,0,19208,19207,1,0,0,0,19208,19209,1,0,0,0,19209,19210,1,0,
+        0,0,19210,19212,5,2450,0,0,19211,19205,1,0,0,0,19211,19212,1,0,0,
+        0,19212,19216,1,0,0,0,19213,19216,5,215,0,0,19214,19216,5,142,0,
+        0,19215,19204,1,0,0,0,19215,19213,1,0,0,0,19215,19214,1,0,0,0,19216,
+        2187,1,0,0,0,19217,19218,5,1560,0,0,19218,19224,5,2445,0,0,19219,
+        19221,7,244,0,0,19220,19219,1,0,0,0,19220,19221,1,0,0,0,19221,19222,
+        1,0,0,0,19222,19223,5,1261,0,0,19223,19225,5,965,0,0,19224,19220,
+        1,0,0,0,19224,19225,1,0,0,0,19225,19305,1,0,0,0,19226,19227,5,757,
+        0,0,19227,19228,5,2445,0,0,19228,19229,5,2474,0,0,19229,19233,5,
+        2445,0,0,19230,19231,7,245,0,0,19231,19232,5,1261,0,0,19232,19234,
+        5,545,0,0,19233,19230,1,0,0,0,19233,19234,1,0,0,0,19234,19240,1,
+        0,0,0,19235,19237,7,246,0,0,19236,19235,1,0,0,0,19236,19237,1,0,
+        0,0,19237,19238,1,0,0,0,19238,19239,5,1261,0,0,19239,19241,5,1230,
+        0,0,19240,19236,1,0,0,0,19240,19241,1,0,0,0,19241,19305,1,0,0,0,
+        19242,19243,5,1564,0,0,19243,19244,5,2445,0,0,19244,19245,5,2474,
+        0,0,19245,19249,5,2445,0,0,19246,19247,7,247,0,0,19247,19248,5,1261,
+        0,0,19248,19250,5,965,0,0,19249,19246,1,0,0,0,19249,19250,1,0,0,
+        0,19250,19256,1,0,0,0,19251,19253,7,248,0,0,19252,19251,1,0,0,0,
+        19252,19253,1,0,0,0,19253,19254,1,0,0,0,19254,19255,5,1261,0,0,19255,
+        19257,5,1230,0,0,19256,19252,1,0,0,0,19256,19257,1,0,0,0,19257,19305,
+        1,0,0,0,19258,19261,3,2100,1050,0,19259,19260,5,622,0,0,19260,19262,
+        5,802,0,0,19261,19259,1,0,0,0,19261,19262,1,0,0,0,19262,19305,1,
+        0,0,0,19263,19264,5,57,0,0,19264,19265,5,2445,0,0,19265,19266,5,
+        2474,0,0,19266,19270,5,2445,0,0,19267,19268,7,247,0,0,19268,19269,
+        5,1261,0,0,19269,19271,5,965,0,0,19270,19267,1,0,0,0,19270,19271,
+        1,0,0,0,19271,19277,1,0,0,0,19272,19274,7,248,0,0,19273,19272,1,
+        0,0,0,19273,19274,1,0,0,0,19274,19275,1,0,0,0,19275,19276,5,1261,
+        0,0,19276,19278,5,1230,0,0,19277,19273,1,0,0,0,19277,19278,1,0,0,
+        0,19278,19305,1,0,0,0,19279,19280,5,1673,0,0,19280,19281,5,2445,
+        0,0,19281,19282,5,2474,0,0,19282,19285,3,2100,1050,0,19283,19284,
+        5,622,0,0,19284,19286,5,802,0,0,19285,19283,1,0,0,0,19285,19286,
+        1,0,0,0,19286,19290,1,0,0,0,19287,19288,7,245,0,0,19288,19289,5,
+        1261,0,0,19289,19291,5,545,0,0,19290,19287,1,0,0,0,19290,19291,1,
+        0,0,0,19291,19295,1,0,0,0,19292,19293,7,247,0,0,19293,19294,5,1261,
+        0,0,19294,19296,5,965,0,0,19295,19292,1,0,0,0,19295,19296,1,0,0,
+        0,19296,19302,1,0,0,0,19297,19299,7,248,0,0,19298,19297,1,0,0,0,
+        19298,19299,1,0,0,0,19299,19300,1,0,0,0,19300,19301,5,1261,0,0,19301,
+        19303,5,1230,0,0,19302,19298,1,0,0,0,19302,19303,1,0,0,0,19303,19305,
+        1,0,0,0,19304,19217,1,0,0,0,19304,19226,1,0,0,0,19304,19242,1,0,
+        0,0,19304,19258,1,0,0,0,19304,19263,1,0,0,0,19304,19279,1,0,0,0,
+        19305,2189,1,0,0,0,19306,19307,5,238,0,0,19307,19308,5,2449,0,0,
+        19308,19313,3,2192,1096,0,19309,19310,5,2455,0,0,19310,19312,3,2192,
+        1096,0,19311,19309,1,0,0,0,19312,19315,1,0,0,0,19313,19311,1,0,0,
+        0,19313,19314,1,0,0,0,19314,19316,1,0,0,0,19315,19313,1,0,0,0,19316,
+        19317,5,2450,0,0,19317,2191,1,0,0,0,19318,19320,3,2100,1050,0,19319,
+        19321,3,2206,1103,0,19320,19319,1,0,0,0,19320,19321,1,0,0,0,19321,
+        19332,1,0,0,0,19322,19324,5,546,0,0,19323,19322,1,0,0,0,19323,19324,
+        1,0,0,0,19324,19325,1,0,0,0,19325,19326,5,1365,0,0,19326,19333,5,
+        2445,0,0,19327,19330,5,2161,0,0,19328,19329,5,1365,0,0,19329,19331,
+        5,2445,0,0,19330,19328,1,0,0,0,19330,19331,1,0,0,0,19331,19333,1,
+        0,0,0,19332,19323,1,0,0,0,19332,19327,1,0,0,0,19332,19333,1,0,0,
+        0,19333,19335,1,0,0,0,19334,19336,3,2200,1100,0,19335,19334,1,0,
+        0,0,19335,19336,1,0,0,0,19336,19338,1,0,0,0,19337,19339,3,2202,1101,
+        0,19338,19337,1,0,0,0,19338,19339,1,0,0,0,19339,19372,1,0,0,0,19340,
+        19342,3,2100,1050,0,19341,19343,3,2196,1098,0,19342,19341,1,0,0,
+        0,19342,19343,1,0,0,0,19343,19345,1,0,0,0,19344,19346,5,2161,0,0,
+        19345,19344,1,0,0,0,19345,19346,1,0,0,0,19346,19347,1,0,0,0,19347,
+        19348,5,622,0,0,19348,19350,5,802,0,0,19349,19351,3,2198,1099,0,
+        19350,19349,1,0,0,0,19350,19351,1,0,0,0,19351,19352,1,0,0,0,19352,
+        19353,5,1365,0,0,19353,19354,5,2445,0,0,19354,19372,1,0,0,0,19355,
+        19357,5,1014,0,0,19356,19358,5,1365,0,0,19357,19356,1,0,0,0,19357,
+        19358,1,0,0,0,19358,19359,1,0,0,0,19359,19363,3,2100,1050,0,19360,
+        19361,5,2475,0,0,19361,19362,5,2452,0,0,19362,19364,5,2476,0,0,19363,
+        19360,1,0,0,0,19363,19364,1,0,0,0,19364,19365,1,0,0,0,19365,19366,
+        3,2190,1095,0,19366,19372,1,0,0,0,19367,19368,3,2100,1050,0,19368,
+        19369,5,621,0,0,19369,19370,5,1306,0,0,19370,19372,1,0,0,0,19371,
+        19318,1,0,0,0,19371,19340,1,0,0,0,19371,19355,1,0,0,0,19371,19367,
+        1,0,0,0,19372,2193,1,0,0,0,19373,19374,5,1587,0,0,19374,19376,3,
+        2196,1098,0,19375,19373,1,0,0,0,19375,19376,1,0,0,0,19376,19378,
+        1,0,0,0,19377,19379,5,1450,0,0,19378,19377,1,0,0,0,19378,19379,1,
+        0,0,0,19379,19381,1,0,0,0,19380,19382,5,71,0,0,19381,19380,1,0,0,
+        0,19381,19382,1,0,0,0,19382,2195,1,0,0,0,19383,19390,5,2261,0,0,
+        19384,19385,5,2449,0,0,19385,19387,5,2443,0,0,19386,19388,7,239,
+        0,0,19387,19386,1,0,0,0,19387,19388,1,0,0,0,19388,19389,1,0,0,0,
+        19389,19391,5,2450,0,0,19390,19384,1,0,0,0,19390,19391,1,0,0,0,19391,
+        19395,1,0,0,0,19392,19395,5,215,0,0,19393,19395,5,142,0,0,19394,
+        19383,1,0,0,0,19394,19392,1,0,0,0,19394,19393,1,0,0,0,19395,2197,
+        1,0,0,0,19396,19398,5,2308,0,0,19397,19399,5,68,0,0,19398,19397,
+        1,0,0,0,19398,19399,1,0,0,0,19399,19400,1,0,0,0,19400,19410,5,2314,
+        0,0,19401,19403,5,2310,0,0,19402,19404,7,249,0,0,19403,19402,1,0,
+        0,0,19403,19404,1,0,0,0,19404,19406,1,0,0,0,19405,19407,5,68,0,0,
+        19406,19405,1,0,0,0,19406,19407,1,0,0,0,19407,19408,1,0,0,0,19408,
+        19410,5,2314,0,0,19409,19396,1,0,0,0,19409,19401,1,0,0,0,19410,2199,
+        1,0,0,0,19411,19419,5,520,0,0,19412,19419,5,1230,0,0,19413,19419,
+        5,497,0,0,19414,19415,5,497,0,0,19415,19419,5,68,0,0,19416,19417,
+        5,497,0,0,19417,19419,5,1240,0,0,19418,19411,1,0,0,0,19418,19412,
+        1,0,0,0,19418,19413,1,0,0,0,19418,19414,1,0,0,0,19418,19416,1,0,
+        0,0,19418,19419,1,0,0,0,19419,19420,1,0,0,0,19420,19421,5,1261,0,
+        0,19421,19422,5,520,0,0,19422,2201,1,0,0,0,19423,19431,5,520,0,0,
+        19424,19431,5,1230,0,0,19425,19431,5,497,0,0,19426,19427,5,497,0,
+        0,19427,19431,5,68,0,0,19428,19429,5,497,0,0,19429,19431,5,1240,
+        0,0,19430,19423,1,0,0,0,19430,19424,1,0,0,0,19430,19425,1,0,0,0,
+        19430,19426,1,0,0,0,19430,19428,1,0,0,0,19430,19431,1,0,0,0,19431,
+        19432,1,0,0,0,19432,19433,5,1261,0,0,19433,19434,5,497,0,0,19434,
+        2203,1,0,0,0,19435,19437,5,1587,0,0,19436,19438,3,2206,1103,0,19437,
+        19436,1,0,0,0,19437,19438,1,0,0,0,19438,19440,1,0,0,0,19439,19441,
+        5,71,0,0,19440,19439,1,0,0,0,19440,19441,1,0,0,0,19441,2205,1,0,
+        0,0,19442,19449,5,2261,0,0,19443,19444,5,2449,0,0,19444,19446,5,
+        2443,0,0,19445,19447,7,239,0,0,19446,19445,1,0,0,0,19446,19447,1,
+        0,0,0,19447,19448,1,0,0,0,19448,19450,5,2450,0,0,19449,19443,1,0,
+        0,0,19449,19450,1,0,0,0,19450,19452,1,0,0,0,19451,19453,5,2161,0,
+        0,19452,19451,1,0,0,0,19452,19453,1,0,0,0,19453,19480,1,0,0,0,19454,
+        19480,5,215,0,0,19455,19480,5,361,0,0,19456,19464,5,1232,0,0,19457,
+        19458,5,2449,0,0,19458,19461,5,770,0,0,19459,19460,5,2455,0,0,19460,
+        19462,5,770,0,0,19461,19459,1,0,0,0,19461,19462,1,0,0,0,19462,19463,
+        1,0,0,0,19463,19465,5,2450,0,0,19464,19457,1,0,0,0,19464,19465,1,
+        0,0,0,19465,19480,1,0,0,0,19466,19470,5,2110,0,0,19467,19468,5,2310,
+        0,0,19468,19469,5,2114,0,0,19469,19471,5,2365,0,0,19470,19467,1,
+        0,0,0,19470,19471,1,0,0,0,19471,19480,1,0,0,0,19472,19480,5,1635,
+        0,0,19473,19477,3,2100,1050,0,19474,19475,5,2248,0,0,19475,19476,
+        5,182,0,0,19476,19478,5,912,0,0,19477,19474,1,0,0,0,19477,19478,
+        1,0,0,0,19478,19480,1,0,0,0,19479,19442,1,0,0,0,19479,19454,1,0,
+        0,0,19479,19455,1,0,0,0,19479,19456,1,0,0,0,19479,19466,1,0,0,0,
+        19479,19472,1,0,0,0,19479,19473,1,0,0,0,19480,2207,1,0,0,0,19481,
+        19482,7,248,0,0,19482,19483,5,1261,0,0,19483,19492,5,966,0,0,19484,
+        19485,5,2449,0,0,19485,19486,5,965,0,0,19486,19493,5,351,0,0,19487,
+        19488,5,566,0,0,19488,19493,5,351,0,0,19489,19490,5,2168,0,0,19490,
+        19491,5,520,0,0,19491,19493,5,2450,0,0,19492,19484,1,0,0,0,19492,
+        19487,1,0,0,0,19492,19489,1,0,0,0,19492,19493,1,0,0,0,19493,2209,
+        1,0,0,0,19494,19500,5,2445,0,0,19495,19500,3,2170,1085,0,19496,19500,
+        3,2422,1211,0,19497,19500,3,2424,1212,0,19498,19500,5,933,0,0,19499,
+        19494,1,0,0,0,19499,19495,1,0,0,0,19499,19496,1,0,0,0,19499,19497,
+        1,0,0,0,19499,19498,1,0,0,0,19500,2211,1,0,0,0,19501,19504,3,2214,
+        1107,0,19502,19505,3,2132,1066,0,19503,19505,3,2134,1067,0,19504,
+        19502,1,0,0,0,19504,19503,1,0,0,0,19504,19505,1,0,0,0,19505,2213,
+        1,0,0,0,19506,19507,5,2421,0,0,19507,19509,5,2449,0,0,19508,19510,
+        7,227,0,0,19509,19508,1,0,0,0,19509,19510,1,0,0,0,19510,19511,1,
+        0,0,0,19511,19512,3,2100,1050,0,19512,19515,5,2450,0,0,19513,19516,
+        3,2226,1113,0,19514,19516,3,2388,1194,0,19515,19513,1,0,0,0,19515,
+        19514,1,0,0,0,19515,19516,1,0,0,0,19516,19589,1,0,0,0,19517,19518,
+        5,313,0,0,19518,19526,5,2449,0,0,19519,19527,5,2452,0,0,19520,19522,
+        7,210,0,0,19521,19520,1,0,0,0,19521,19522,1,0,0,0,19522,19523,1,
+        0,0,0,19523,19525,3,2124,1062,0,19524,19521,1,0,0,0,19524,19525,
+        1,0,0,0,19525,19527,1,0,0,0,19526,19519,1,0,0,0,19526,19524,1,0,
+        0,0,19527,19528,1,0,0,0,19528,19531,5,2450,0,0,19529,19532,3,2226,
+        1113,0,19530,19532,3,2388,1194,0,19531,19529,1,0,0,0,19531,19530,
+        1,0,0,0,19531,19532,1,0,0,0,19532,19589,1,0,0,0,19533,19534,5,2416,
+        0,0,19534,19535,5,2449,0,0,19535,19541,3,2100,1050,0,19536,19539,
+        5,2455,0,0,19537,19540,5,2443,0,0,19538,19540,3,2100,1050,0,19539,
+        19537,1,0,0,0,19539,19538,1,0,0,0,19540,19542,1,0,0,0,19541,19536,
+        1,0,0,0,19541,19542,1,0,0,0,19542,19543,1,0,0,0,19543,19544,5,2450,
+        0,0,19544,19589,1,0,0,0,19545,19546,5,2400,0,0,19546,19548,5,2449,
+        0,0,19547,19549,7,227,0,0,19548,19547,1,0,0,0,19548,19549,1,0,0,
+        0,19549,19550,1,0,0,0,19550,19551,3,2100,1050,0,19551,19554,5,2450,
+        0,0,19552,19555,3,2226,1113,0,19553,19555,3,2388,1194,0,19554,19552,
+        1,0,0,0,19554,19553,1,0,0,0,19554,19555,1,0,0,0,19555,19589,1,0,
+        0,0,19556,19557,5,2411,0,0,19557,19559,5,2449,0,0,19558,19560,7,
+        227,0,0,19559,19558,1,0,0,0,19559,19560,1,0,0,0,19560,19561,1,0,
+        0,0,19561,19562,3,2100,1050,0,19562,19565,5,2450,0,0,19563,19566,
+        3,2226,1113,0,19564,19566,3,2388,1194,0,19565,19563,1,0,0,0,19565,
+        19564,1,0,0,0,19565,19566,1,0,0,0,19566,19589,1,0,0,0,19567,19568,
+        5,2408,0,0,19568,19570,5,2449,0,0,19569,19571,7,227,0,0,19570,19569,
+        1,0,0,0,19570,19571,1,0,0,0,19571,19572,1,0,0,0,19572,19573,3,2100,
+        1050,0,19573,19576,5,2450,0,0,19574,19577,3,2226,1113,0,19575,19577,
+        3,2388,1194,0,19576,19574,1,0,0,0,19576,19575,1,0,0,0,19576,19577,
+        1,0,0,0,19577,19589,1,0,0,0,19578,19579,5,2425,0,0,19579,19580,5,
+        2449,0,0,19580,19581,3,2098,1049,0,19581,19582,5,2450,0,0,19582,
+        19589,1,0,0,0,19583,19584,5,2426,0,0,19584,19585,5,2449,0,0,19585,
+        19586,3,2098,1049,0,19586,19587,5,2450,0,0,19587,19589,1,0,0,0,19588,
+        19506,1,0,0,0,19588,19517,1,0,0,0,19588,19533,1,0,0,0,19588,19545,
+        1,0,0,0,19588,19556,1,0,0,0,19588,19567,1,0,0,0,19588,19578,1,0,
+        0,0,19588,19583,1,0,0,0,19589,2215,1,0,0,0,19590,19591,5,1261,0,
+        0,19591,19592,5,1322,0,0,19592,19594,7,230,0,0,19593,19595,5,2445,
+        0,0,19594,19593,1,0,0,0,19594,19595,1,0,0,0,19595,19598,1,0,0,0,
+        19596,19597,7,2,0,0,19597,19599,5,313,0,0,19598,19596,1,0,0,0,19598,
+        19599,1,0,0,0,19599,2217,1,0,0,0,19600,19601,3,2220,1110,0,19601,
+        19603,3,2392,1196,0,19602,19604,3,2226,1113,0,19603,19602,1,0,0,
+        0,19603,19604,1,0,0,0,19604,20022,1,0,0,0,19605,19606,3,2436,1218,
+        0,19606,19608,3,2394,1197,0,19607,19609,3,2234,1117,0,19608,19607,
+        1,0,0,0,19608,19609,1,0,0,0,19609,20022,1,0,0,0,19610,19611,5,313,
+        0,0,19611,19617,5,2449,0,0,19612,19618,5,2452,0,0,19613,19615,7,
+        210,0,0,19614,19613,1,0,0,0,19614,19615,1,0,0,0,19615,19616,1,0,
+        0,0,19616,19618,3,2124,1062,0,19617,19612,1,0,0,0,19617,19614,1,
+        0,0,0,19618,19619,1,0,0,0,19619,19621,5,2450,0,0,19620,19622,3,2226,
+        1113,0,19621,19620,1,0,0,0,19621,19622,1,0,0,0,19622,20022,1,0,0,
+        0,19623,19624,7,250,0,0,19624,19631,5,2449,0,0,19625,19626,5,995,
+        0,0,19626,19627,5,2449,0,0,19627,19628,3,1916,958,0,19628,19629,
+        5,2450,0,0,19629,19632,1,0,0,0,19630,19632,3,2124,1062,0,19631,19625,
+        1,0,0,0,19631,19630,1,0,0,0,19632,19633,1,0,0,0,19633,19634,5,69,
+        0,0,19634,19641,3,2400,1200,0,19635,19636,5,389,0,0,19636,19637,
+        3,2124,1062,0,19637,19638,5,1261,0,0,19638,19639,5,301,0,0,19639,
+        19640,5,520,0,0,19640,19642,1,0,0,0,19641,19635,1,0,0,0,19641,19642,
+        1,0,0,0,19642,19649,1,0,0,0,19643,19644,5,2455,0,0,19644,19647,3,
+        2426,1213,0,19645,19646,5,2455,0,0,19646,19648,3,2426,1213,0,19647,
+        19645,1,0,0,0,19647,19648,1,0,0,0,19648,19650,1,0,0,0,19649,19643,
+        1,0,0,0,19649,19650,1,0,0,0,19650,19651,1,0,0,0,19651,19652,5,2450,
+        0,0,19652,20022,1,0,0,0,19653,19654,5,228,0,0,19654,19655,5,2449,
+        0,0,19655,19661,3,2414,1207,0,19656,19659,5,2455,0,0,19657,19660,
+        3,2422,1211,0,19658,19660,3,2426,1213,0,19659,19657,1,0,0,0,19659,
+        19658,1,0,0,0,19660,19662,1,0,0,0,19661,19656,1,0,0,0,19661,19662,
+        1,0,0,0,19662,19663,1,0,0,0,19663,19664,5,2450,0,0,19664,20022,1,
+        0,0,0,19665,19666,5,233,0,0,19666,19668,5,2449,0,0,19667,19669,7,
+        251,0,0,19668,19667,1,0,0,0,19668,19669,1,0,0,0,19669,19670,1,0,
+        0,0,19670,19672,3,2124,1062,0,19671,19673,3,2240,1120,0,19672,19671,
+        1,0,0,0,19672,19673,1,0,0,0,19673,19674,1,0,0,0,19674,19675,5,2450,
+        0,0,19675,20022,1,0,0,0,19676,19677,3,2222,1111,0,19677,19679,3,
+        2390,1195,0,19678,19680,3,2242,1121,0,19679,19678,1,0,0,0,19680,
+        19681,1,0,0,0,19681,19679,1,0,0,0,19681,19682,1,0,0,0,19682,20022,
+        1,0,0,0,19683,19684,5,2395,0,0,19684,19686,5,2449,0,0,19685,19687,
+        7,210,0,0,19686,19685,1,0,0,0,19686,19687,1,0,0,0,19687,19688,1,
+        0,0,0,19688,19691,3,2398,1199,0,19689,19690,5,2455,0,0,19690,19692,
+        3,2100,1050,0,19691,19689,1,0,0,0,19691,19692,1,0,0,0,19692,19694,
+        1,0,0,0,19693,19695,3,2216,1108,0,19694,19693,1,0,0,0,19694,19695,
+        1,0,0,0,19695,19696,1,0,0,0,19696,19703,5,2450,0,0,19697,19698,5,
+        2307,0,0,19698,19699,5,650,0,0,19699,19700,5,2449,0,0,19700,19701,
+        3,2016,1008,0,19701,19702,5,2450,0,0,19702,19704,1,0,0,0,19703,19697,
+        1,0,0,0,19703,19704,1,0,0,0,19704,19706,1,0,0,0,19705,19707,3,2226,
+        1113,0,19706,19705,1,0,0,0,19706,19707,1,0,0,0,19707,20022,1,0,0,
+        0,19708,19709,3,2356,1178,0,19709,19710,7,252,0,0,19710,20022,1,
+        0,0,0,19711,19712,5,383,0,0,19712,19713,5,2449,0,0,19713,19715,3,
+        2124,1062,0,19714,19716,7,253,0,0,19715,19714,1,0,0,0,19715,19716,
+        1,0,0,0,19716,19717,1,0,0,0,19717,19718,5,2450,0,0,19718,20022,1,
+        0,0,0,19719,19720,5,564,0,0,19720,19721,5,2449,0,0,19721,19722,3,
+        2436,1218,0,19722,19723,5,629,0,0,19723,19724,3,2124,1062,0,19724,
+        19725,5,2450,0,0,19725,20022,1,0,0,0,19726,19727,7,254,0,0,19727,
+        19729,3,2392,1196,0,19728,19730,3,2396,1198,0,19729,19728,1,0,0,
+        0,19729,19730,1,0,0,0,19730,19731,1,0,0,0,19731,19732,3,2226,1113,
+        0,19732,20022,1,0,0,0,19733,19734,7,255,0,0,19734,19736,3,2392,1196,
+        0,19735,19737,3,2396,1198,0,19736,19735,1,0,0,0,19736,19737,1,0,
+        0,0,19737,19738,1,0,0,0,19738,19739,3,2226,1113,0,19739,20022,1,
+        0,0,0,19740,19741,3,2224,1112,0,19741,19742,5,2449,0,0,19742,19744,
+        3,2098,1049,0,19743,19745,3,2246,1123,0,19744,19743,1,0,0,0,19744,
+        19745,1,0,0,0,19745,19747,1,0,0,0,19746,19748,3,2234,1117,0,19747,
+        19746,1,0,0,0,19747,19748,1,0,0,0,19748,19749,1,0,0,0,19749,19750,
+        5,2450,0,0,19750,20022,1,0,0,0,19751,19752,7,256,0,0,19752,19753,
+        5,2449,0,0,19753,19760,3,2124,1062,0,19754,19755,5,389,0,0,19755,
+        19756,3,2124,1062,0,19756,19757,5,1261,0,0,19757,19758,5,301,0,0,
+        19758,19759,5,520,0,0,19759,19761,1,0,0,0,19760,19754,1,0,0,0,19760,
+        19761,1,0,0,0,19761,19768,1,0,0,0,19762,19763,5,2455,0,0,19763,19766,
+        3,2426,1213,0,19764,19765,5,2455,0,0,19765,19767,3,2426,1213,0,19766,
+        19764,1,0,0,0,19766,19767,1,0,0,0,19767,19769,1,0,0,0,19768,19762,
+        1,0,0,0,19768,19769,1,0,0,0,19769,19770,1,0,0,0,19770,19771,5,2450,
+        0,0,19771,20022,1,0,0,0,19772,19773,7,257,0,0,19773,19774,5,2449,
+        0,0,19774,19781,3,2124,1062,0,19775,19776,5,389,0,0,19776,19777,
+        3,2124,1062,0,19777,19778,5,1261,0,0,19778,19779,5,301,0,0,19779,
+        19780,5,520,0,0,19780,19782,1,0,0,0,19781,19775,1,0,0,0,19781,19782,
+        1,0,0,0,19782,19783,1,0,0,0,19783,19784,5,2450,0,0,19784,20022,1,
+        0,0,0,19785,19786,5,2155,0,0,19786,19787,5,2449,0,0,19787,19790,
+        3,2100,1050,0,19788,19789,5,2248,0,0,19789,19791,7,258,0,0,19790,
+        19788,1,0,0,0,19790,19791,1,0,0,0,19791,19796,1,0,0,0,19792,19793,
+        5,2455,0,0,19793,19795,3,2100,1050,0,19794,19792,1,0,0,0,19795,19798,
+        1,0,0,0,19796,19794,1,0,0,0,19796,19797,1,0,0,0,19797,19799,1,0,
+        0,0,19798,19796,1,0,0,0,19799,19800,5,2450,0,0,19800,20022,1,0,0,
+        0,19801,19802,5,2157,0,0,19802,19803,5,2449,0,0,19803,19804,3,2100,
+        1050,0,19804,19806,5,69,0,0,19805,19807,5,1532,0,0,19806,19805,1,
+        0,0,0,19806,19807,1,0,0,0,19807,19808,1,0,0,0,19808,19809,3,2400,
+        1200,0,19809,19814,5,2450,0,0,19810,19811,5,2442,0,0,19811,19813,
+        3,2412,1206,0,19812,19810,1,0,0,0,19813,19816,1,0,0,0,19814,19812,
+        1,0,0,0,19814,19815,1,0,0,0,19815,20022,1,0,0,0,19816,19814,1,0,
+        0,0,19817,19818,5,2420,0,0,19818,19826,5,2449,0,0,19819,19821,7,
+        237,0,0,19820,19819,1,0,0,0,19820,19821,1,0,0,0,19821,19823,1,0,
+        0,0,19822,19824,3,2426,1213,0,19823,19822,1,0,0,0,19823,19824,1,
+        0,0,0,19824,19825,1,0,0,0,19825,19827,5,629,0,0,19826,19820,1,0,
+        0,0,19826,19827,1,0,0,0,19827,19828,1,0,0,0,19828,19829,3,2124,1062,
+        0,19829,19830,5,2450,0,0,19830,20022,1,0,0,0,19831,19832,5,2256,
+        0,0,19832,19833,5,2449,0,0,19833,19834,3,2124,1062,0,19834,19835,
+        5,69,0,0,19835,19842,3,2400,1200,0,19836,19837,5,2455,0,0,19837,
+        19840,3,2426,1213,0,19838,19839,5,2455,0,0,19839,19841,3,2426,1213,
+        0,19840,19838,1,0,0,0,19840,19841,1,0,0,0,19841,19843,1,0,0,0,19842,
+        19836,1,0,0,0,19842,19843,1,0,0,0,19843,19844,1,0,0,0,19844,19845,
+        5,2450,0,0,19845,20022,1,0,0,0,19846,19847,5,2321,0,0,19847,19848,
+        5,2449,0,0,19848,19850,3,2100,1050,0,19849,19851,3,2016,1008,0,19850,
+        19849,1,0,0,0,19850,19851,1,0,0,0,19851,19852,1,0,0,0,19852,19857,
+        5,2450,0,0,19853,19854,5,2442,0,0,19854,19856,3,2412,1206,0,19855,
+        19853,1,0,0,0,19856,19859,1,0,0,0,19857,19855,1,0,0,0,19857,19858,
+        1,0,0,0,19858,20022,1,0,0,0,19859,19857,1,0,0,0,19860,19861,7,259,
+        0,0,19861,19862,5,2449,0,0,19862,19867,3,2258,1129,0,19863,19864,
+        5,2455,0,0,19864,19866,3,2258,1129,0,19865,19863,1,0,0,0,19866,19869,
+        1,0,0,0,19867,19865,1,0,0,0,19867,19868,1,0,0,0,19868,19870,1,0,
+        0,0,19869,19867,1,0,0,0,19870,19875,5,2450,0,0,19871,19872,5,2442,
+        0,0,19872,19874,3,2412,1206,0,19873,19871,1,0,0,0,19874,19877,1,
+        0,0,0,19875,19873,1,0,0,0,19875,19876,1,0,0,0,19876,20022,1,0,0,
+        0,19877,19875,1,0,0,0,19878,19879,5,2330,0,0,19879,19881,5,2449,
+        0,0,19880,19882,7,260,0,0,19881,19880,1,0,0,0,19881,19882,1,0,0,
+        0,19882,19884,1,0,0,0,19883,19885,7,261,0,0,19884,19883,1,0,0,0,
+        19884,19885,1,0,0,0,19885,19886,1,0,0,0,19886,19889,3,2100,1050,
+        0,19887,19888,5,2455,0,0,19888,19890,3,2250,1125,0,19889,19887,1,
+        0,0,0,19889,19890,1,0,0,0,19890,19898,1,0,0,0,19891,19892,5,2455,
+        0,0,19892,19894,3,2100,1050,0,19893,19895,3,2294,1147,0,19894,19893,
+        1,0,0,0,19894,19895,1,0,0,0,19895,19897,1,0,0,0,19896,19891,1,0,
+        0,0,19897,19900,1,0,0,0,19898,19896,1,0,0,0,19898,19899,1,0,0,0,
+        19899,19901,1,0,0,0,19900,19898,1,0,0,0,19901,19906,5,2450,0,0,19902,
+        19903,5,2442,0,0,19903,19905,3,2412,1206,0,19904,19902,1,0,0,0,19905,
+        19908,1,0,0,0,19906,19904,1,0,0,0,19906,19907,1,0,0,0,19907,20022,
+        1,0,0,0,19908,19906,1,0,0,0,19909,19910,5,2332,0,0,19910,19911,5,
+        2449,0,0,19911,19913,3,2100,1050,0,19912,19914,3,2248,1124,0,19913,
+        19912,1,0,0,0,19913,19914,1,0,0,0,19914,19915,1,0,0,0,19915,19916,
+        5,2450,0,0,19916,20022,1,0,0,0,19917,19918,5,2341,0,0,19918,19919,
+        5,2449,0,0,19919,19920,7,262,0,0,19920,19922,3,2124,1062,0,19921,
+        19923,5,2300,0,0,19922,19921,1,0,0,0,19922,19923,1,0,0,0,19923,19924,
+        1,0,0,0,19924,19929,5,2450,0,0,19925,19926,5,2442,0,0,19926,19928,
+        3,2412,1206,0,19927,19925,1,0,0,0,19928,19931,1,0,0,0,19929,19927,
+        1,0,0,0,19929,19930,1,0,0,0,19930,20022,1,0,0,0,19931,19929,1,0,
+        0,0,19932,19933,5,2343,0,0,19933,19938,5,2449,0,0,19934,19935,5,
+        998,0,0,19935,19939,3,2428,1214,0,19936,19937,5,529,0,0,19937,19939,
+        3,2124,1062,0,19938,19934,1,0,0,0,19938,19936,1,0,0,0,19939,19942,
+        1,0,0,0,19940,19941,5,2455,0,0,19941,19943,3,2124,1062,0,19942,19940,
+        1,0,0,0,19942,19943,1,0,0,0,19943,19944,1,0,0,0,19944,19949,5,2450,
+        0,0,19945,19946,5,2442,0,0,19946,19948,3,2412,1206,0,19947,19945,
+        1,0,0,0,19948,19951,1,0,0,0,19949,19947,1,0,0,0,19949,19950,1,0,
+        0,0,19950,20022,1,0,0,0,19951,19949,1,0,0,0,19952,19953,5,2345,0,
+        0,19953,19954,5,2449,0,0,19954,19956,3,2124,1062,0,19955,19957,3,
+        2248,1124,0,19956,19955,1,0,0,0,19956,19957,1,0,0,0,19957,19958,
+        1,0,0,0,19958,19959,5,1587,0,0,19959,19963,5,294,0,0,19960,19961,
+        5,1230,0,0,19961,19962,5,1261,0,0,19962,19964,5,497,0,0,19963,19960,
+        1,0,0,0,19963,19964,1,0,0,0,19964,19965,1,0,0,0,19965,19970,5,2450,
+        0,0,19966,19967,5,2442,0,0,19967,19969,3,2412,1206,0,19968,19966,
+        1,0,0,0,19969,19972,1,0,0,0,19970,19968,1,0,0,0,19970,19971,1,0,
+        0,0,19971,20022,1,0,0,0,19972,19970,1,0,0,0,19973,19974,5,2346,0,
+        0,19974,19975,5,2449,0,0,19975,19978,3,2124,1062,0,19976,19977,5,
+        2455,0,0,19977,19979,3,2260,1130,0,19978,19976,1,0,0,0,19978,19979,
+        1,0,0,0,19979,19982,1,0,0,0,19980,19981,5,2455,0,0,19981,19983,3,
+        2262,1131,0,19982,19980,1,0,0,0,19982,19983,1,0,0,0,19983,19984,
+        1,0,0,0,19984,19989,5,2450,0,0,19985,19986,5,2442,0,0,19986,19988,
+        3,2412,1206,0,19987,19985,1,0,0,0,19988,19991,1,0,0,0,19989,19987,
+        1,0,0,0,19989,19990,1,0,0,0,19990,20022,1,0,0,0,19991,19989,1,0,
+        0,0,19992,19993,5,2348,0,0,19993,19994,5,2449,0,0,19994,19995,7,
+        262,0,0,19995,19998,3,2124,1062,0,19996,19997,5,69,0,0,19997,19999,
+        3,2400,1200,0,19998,19996,1,0,0,0,19998,19999,1,0,0,0,19999,20001,
+        1,0,0,0,20000,20002,3,2264,1132,0,20001,20000,1,0,0,0,20001,20002,
+        1,0,0,0,20002,20004,1,0,0,0,20003,20005,3,2266,1133,0,20004,20003,
+        1,0,0,0,20004,20005,1,0,0,0,20005,20007,1,0,0,0,20006,20008,3,2268,
+        1134,0,20007,20006,1,0,0,0,20007,20008,1,0,0,0,20008,20011,1,0,0,
+        0,20009,20010,7,263,0,0,20010,20012,5,391,0,0,20011,20009,1,0,0,
+        0,20011,20012,1,0,0,0,20012,20013,1,0,0,0,20013,20016,5,2450,0,0,
+        20014,20015,5,2442,0,0,20015,20017,3,2412,1206,0,20016,20014,1,0,
+        0,0,20016,20017,1,0,0,0,20017,20022,1,0,0,0,20018,20019,5,2114,0,
+        0,20019,20022,5,2445,0,0,20020,20022,3,2370,1185,0,20021,19600,1,
+        0,0,0,20021,19605,1,0,0,0,20021,19610,1,0,0,0,20021,19623,1,0,0,
+        0,20021,19653,1,0,0,0,20021,19665,1,0,0,0,20021,19676,1,0,0,0,20021,
+        19683,1,0,0,0,20021,19708,1,0,0,0,20021,19711,1,0,0,0,20021,19719,
+        1,0,0,0,20021,19726,1,0,0,0,20021,19733,1,0,0,0,20021,19740,1,0,
+        0,0,20021,19751,1,0,0,0,20021,19772,1,0,0,0,20021,19785,1,0,0,0,
+        20021,19801,1,0,0,0,20021,19817,1,0,0,0,20021,19831,1,0,0,0,20021,
+        19846,1,0,0,0,20021,19860,1,0,0,0,20021,19878,1,0,0,0,20021,19909,
+        1,0,0,0,20021,19917,1,0,0,0,20021,19932,1,0,0,0,20021,19952,1,0,
+        0,0,20021,19973,1,0,0,0,20021,19992,1,0,0,0,20021,20018,1,0,0,0,
+        20021,20020,1,0,0,0,20022,2219,1,0,0,0,20023,20024,7,264,0,0,20024,
+        2221,1,0,0,0,20025,20026,7,265,0,0,20026,2223,1,0,0,0,20027,20028,
+        7,266,0,0,20028,2225,1,0,0,0,20029,20030,5,1324,0,0,20030,20051,
+        5,2449,0,0,20031,20033,3,1948,974,0,20032,20031,1,0,0,0,20032,20033,
+        1,0,0,0,20033,20038,1,0,0,0,20034,20036,3,2016,1008,0,20035,20037,
+        3,2228,1114,0,20036,20035,1,0,0,0,20036,20037,1,0,0,0,20037,20039,
+        1,0,0,0,20038,20034,1,0,0,0,20038,20039,1,0,0,0,20039,20052,1,0,
+        0,0,20040,20041,5,675,0,0,20041,20042,3,2430,1215,0,20042,20043,
+        5,1247,0,0,20043,20049,3,2422,1211,0,20044,20045,5,10,0,0,20045,
+        20046,5,47,0,0,20046,20047,5,82,0,0,20047,20048,5,847,0,0,20048,
+        20050,3,2430,1215,0,20049,20044,1,0,0,0,20049,20050,1,0,0,0,20050,
+        20052,1,0,0,0,20051,20032,1,0,0,0,20051,20040,1,0,0,0,20052,20053,
+        1,0,0,0,20053,20054,5,2450,0,0,20054,2227,1,0,0,0,20055,20062,3,
+        2230,1115,0,20056,20057,5,118,0,0,20057,20058,3,2232,1116,0,20058,
+        20059,5,49,0,0,20059,20060,3,2232,1116,0,20060,20063,1,0,0,0,20061,
+        20063,3,2232,1116,0,20062,20056,1,0,0,0,20062,20061,1,0,0,0,20063,
+        2229,1,0,0,0,20064,20065,7,267,0,0,20065,2231,1,0,0,0,20066,20067,
+        5,2176,0,0,20067,20074,5,1438,0,0,20068,20069,5,336,0,0,20069,20074,
+        5,1608,0,0,20070,20071,3,2124,1062,0,20071,20072,7,268,0,0,20072,
+        20074,1,0,0,0,20073,20066,1,0,0,0,20073,20068,1,0,0,0,20073,20070,
+        1,0,0,0,20074,2233,1,0,0,0,20075,20085,5,2248,0,0,20076,20086,5,
+        2452,0,0,20077,20082,3,2236,1118,0,20078,20079,5,2455,0,0,20079,
+        20081,3,2236,1118,0,20080,20078,1,0,0,0,20081,20084,1,0,0,0,20082,
+        20080,1,0,0,0,20082,20083,1,0,0,0,20083,20086,1,0,0,0,20084,20082,
+        1,0,0,0,20085,20076,1,0,0,0,20085,20077,1,0,0,0,20086,2235,1,0,0,
+        0,20087,20088,5,739,0,0,20088,20096,3,2100,1050,0,20089,20090,5,
+        739,0,0,20090,20091,5,1320,0,0,20091,20096,3,2238,1119,0,20092,20093,
+        5,1320,0,0,20093,20096,3,2238,1119,0,20094,20096,3,2100,1050,0,20095,
+        20087,1,0,0,0,20095,20089,1,0,0,0,20095,20092,1,0,0,0,20095,20094,
+        1,0,0,0,20096,2237,1,0,0,0,20097,20100,3,2410,1205,0,20098,20100,
+        3,2408,1204,0,20099,20097,1,0,0,0,20099,20098,1,0,0,0,20100,2239,
+        1,0,0,0,20101,20102,5,1305,0,0,20102,20103,5,160,0,0,20103,20108,
+        3,2124,1062,0,20104,20105,5,2455,0,0,20105,20107,3,2124,1062,0,20106,
+        20104,1,0,0,0,20107,20110,1,0,0,0,20108,20106,1,0,0,0,20108,20109,
+        1,0,0,0,20109,2241,1,0,0,0,20110,20108,1,0,0,0,20111,20112,5,2307,
+        0,0,20112,20113,5,650,0,0,20113,20114,5,2449,0,0,20114,20115,3,2016,
+        1008,0,20115,20116,5,2450,0,0,20116,20119,1,0,0,0,20117,20119,3,
+        2226,1113,0,20118,20111,1,0,0,0,20118,20117,1,0,0,0,20119,2243,1,
+        0,0,0,20120,20121,6,1122,-1,0,20121,20129,5,2445,0,0,20122,20129,
+        3,2170,1085,0,20123,20124,5,2449,0,0,20124,20125,3,2244,1122,0,20125,
+        20126,5,2450,0,0,20126,20129,1,0,0,0,20127,20129,3,2430,1215,0,20128,
+        20120,1,0,0,0,20128,20122,1,0,0,0,20128,20123,1,0,0,0,20128,20127,
+        1,0,0,0,20129,20136,1,0,0,0,20130,20131,10,3,0,0,20131,20132,5,2473,
+        0,0,20132,20133,5,2473,0,0,20133,20135,3,2244,1122,4,20134,20130,
+        1,0,0,0,20135,20138,1,0,0,0,20136,20134,1,0,0,0,20136,20137,1,0,
+        0,0,20137,2245,1,0,0,0,20138,20136,1,0,0,0,20139,20161,5,311,0,0,
+        20140,20142,5,972,0,0,20141,20143,5,91,0,0,20142,20141,1,0,0,0,20142,
+        20143,1,0,0,0,20143,20162,1,0,0,0,20144,20145,5,2449,0,0,20145,20150,
+        3,2304,1152,0,20146,20147,5,2455,0,0,20147,20149,3,2304,1152,0,20148,
+        20146,1,0,0,0,20149,20152,1,0,0,0,20150,20148,1,0,0,0,20150,20151,
+        1,0,0,0,20151,20153,1,0,0,0,20152,20150,1,0,0,0,20153,20154,5,2450,
+        0,0,20154,20155,5,2259,0,0,20155,20157,5,2449,0,0,20156,20158,3,
+        2098,1049,0,20157,20156,1,0,0,0,20157,20158,1,0,0,0,20158,20159,
+        1,0,0,0,20159,20160,5,2450,0,0,20160,20162,1,0,0,0,20161,20140,1,
+        0,0,0,20161,20144,1,0,0,0,20162,2247,1,0,0,0,20163,20166,5,1354,
+        0,0,20164,20165,5,160,0,0,20165,20167,5,2260,0,0,20166,20164,1,0,
+        0,0,20166,20167,1,0,0,0,20167,20168,1,0,0,0,20168,20170,3,2100,1050,
+        0,20169,20171,3,2294,1147,0,20170,20169,1,0,0,0,20170,20171,1,0,
+        0,0,20171,20179,1,0,0,0,20172,20173,5,2455,0,0,20173,20175,3,2100,
+        1050,0,20174,20176,3,2294,1147,0,20175,20174,1,0,0,0,20175,20176,
+        1,0,0,0,20176,20178,1,0,0,0,20177,20172,1,0,0,0,20178,20181,1,0,
+        0,0,20179,20177,1,0,0,0,20179,20180,1,0,0,0,20180,2249,1,0,0,0,20181,
+        20179,1,0,0,0,20182,20183,5,2322,0,0,20183,20185,5,2449,0,0,20184,
+        20186,7,260,0,0,20185,20184,1,0,0,0,20185,20186,1,0,0,0,20186,20188,
+        1,0,0,0,20187,20189,7,269,0,0,20188,20187,1,0,0,0,20188,20189,1,
+        0,0,0,20189,20190,1,0,0,0,20190,20195,3,2258,1129,0,20191,20192,
+        5,2455,0,0,20192,20194,3,2258,1129,0,20193,20191,1,0,0,0,20194,20197,
+        1,0,0,0,20195,20193,1,0,0,0,20195,20196,1,0,0,0,20196,20198,1,0,
+        0,0,20197,20195,1,0,0,0,20198,20199,5,2450,0,0,20199,2251,1,0,0,
+        0,20200,20201,5,2340,0,0,20201,20205,5,2449,0,0,20202,20203,3,2124,
+        1062,0,20203,20204,3,2294,1147,0,20204,20206,1,0,0,0,20205,20202,
+        1,0,0,0,20205,20206,1,0,0,0,20206,20213,1,0,0,0,20207,20208,5,2455,
+        0,0,20208,20209,3,2124,1062,0,20209,20210,3,2294,1147,0,20210,20212,
+        1,0,0,0,20211,20207,1,0,0,0,20212,20215,1,0,0,0,20213,20211,1,0,
+        0,0,20213,20214,1,0,0,0,20214,20217,1,0,0,0,20215,20213,1,0,0,0,
+        20216,20218,3,2256,1128,0,20217,20216,1,0,0,0,20217,20218,1,0,0,
+        0,20218,20219,1,0,0,0,20219,20220,5,2450,0,0,20220,2253,1,0,0,0,
+        20221,20232,3,2302,1151,0,20222,20223,5,621,0,0,20223,20233,5,1306,
+        0,0,20224,20227,3,2400,1200,0,20225,20226,5,1365,0,0,20226,20228,
+        3,2124,1062,0,20227,20225,1,0,0,0,20227,20228,1,0,0,0,20228,20230,
+        1,0,0,0,20229,20231,3,2256,1128,0,20230,20229,1,0,0,0,20230,20231,
+        1,0,0,0,20231,20233,1,0,0,0,20232,20222,1,0,0,0,20232,20224,1,0,
+        0,0,20233,2255,1,0,0,0,20234,20235,5,389,0,0,20235,20236,3,2124,
+        1062,0,20236,2257,1,0,0,0,20237,20245,3,2100,1050,0,20238,20240,
+        5,69,0,0,20239,20238,1,0,0,0,20239,20240,1,0,0,0,20240,20241,1,0,
+        0,0,20241,20246,3,2430,1215,0,20242,20243,5,69,0,0,20243,20244,5,
+        529,0,0,20244,20246,3,2100,1050,0,20245,20239,1,0,0,0,20245,20242,
+        1,0,0,0,20245,20246,1,0,0,0,20246,2259,1,0,0,0,20247,20251,5,2287,
+        0,0,20248,20249,5,1139,0,0,20249,20252,5,2260,0,0,20250,20252,3,
+        2100,1050,0,20251,20248,1,0,0,0,20251,20250,1,0,0,0,20252,2261,1,
+        0,0,0,20253,20259,5,1731,0,0,20254,20260,5,2362,0,0,20255,20257,
+        5,1139,0,0,20256,20258,5,2260,0,0,20257,20256,1,0,0,0,20257,20258,
+        1,0,0,0,20258,20260,1,0,0,0,20259,20254,1,0,0,0,20259,20255,1,0,
+        0,0,20260,2263,1,0,0,0,20261,20262,5,504,0,0,20262,20263,3,2124,
+        1062,0,20263,2265,1,0,0,0,20264,20265,5,2287,0,0,20265,20266,3,2124,
+        1062,0,20266,2267,1,0,0,0,20267,20268,5,1139,0,0,20268,20276,5,710,
+        0,0,20269,20273,5,710,0,0,20270,20271,5,1701,0,0,20271,20272,5,2474,
+        0,0,20272,20274,3,2124,1062,0,20273,20270,1,0,0,0,20273,20274,1,
+        0,0,0,20274,20276,1,0,0,0,20275,20267,1,0,0,0,20275,20269,1,0,0,
+        0,20276,2269,1,0,0,0,20277,20278,5,51,0,0,20278,20279,5,2449,0,0,
+        20279,20280,3,2272,1136,0,20280,20281,5,2450,0,0,20281,2271,1,0,
+        0,0,20282,20288,5,21,0,0,20283,20284,5,692,0,0,20284,20285,5,1206,
+        0,0,20285,20289,5,546,0,0,20286,20287,5,1309,0,0,20287,20289,5,1564,
+        0,0,20288,20283,1,0,0,0,20288,20286,1,0,0,0,20288,20289,1,0,0,0,
+        20289,20297,1,0,0,0,20290,20293,5,469,0,0,20291,20292,5,692,0,0,
+        20292,20294,5,546,0,0,20293,20291,1,0,0,0,20293,20294,1,0,0,0,20294,
+        20297,1,0,0,0,20295,20297,5,1564,0,0,20296,20282,1,0,0,0,20296,20290,
+        1,0,0,0,20296,20295,1,0,0,0,20296,20297,1,0,0,0,20297,20298,1,0,
+        0,0,20298,20303,3,2274,1137,0,20299,20300,5,2455,0,0,20300,20302,
+        3,2272,1136,0,20301,20299,1,0,0,0,20302,20305,1,0,0,0,20303,20301,
+        1,0,0,0,20303,20304,1,0,0,0,20304,2273,1,0,0,0,20305,20303,1,0,0,
+        0,20306,20308,3,2428,1214,0,20307,20309,5,2445,0,0,20308,20307,1,
+        0,0,0,20308,20309,1,0,0,0,20309,2275,1,0,0,0,20310,20321,5,548,0,
+        0,20311,20321,5,2481,0,0,20312,20313,5,1685,0,0,20313,20321,7,270,
+        0,0,20314,20321,3,2284,1142,0,20315,20321,3,2288,1144,0,20316,20321,
+        3,2280,1140,0,20317,20321,3,2286,1143,0,20318,20321,3,2290,1145,
+        0,20319,20321,3,2278,1139,0,20320,20310,1,0,0,0,20320,20311,1,0,
+        0,0,20320,20312,1,0,0,0,20320,20314,1,0,0,0,20320,20315,1,0,0,0,
+        20320,20316,1,0,0,0,20320,20317,1,0,0,0,20320,20318,1,0,0,0,20320,
+        20319,1,0,0,0,20321,2277,1,0,0,0,20322,20323,4,1139,28,0,20323,20324,
+        7,271,0,0,20324,20325,3,1794,897,0,20325,2279,1,0,0,0,20326,20332,
+        5,1739,0,0,20327,20329,5,2458,0,0,20328,20330,5,2458,0,0,20329,20328,
+        1,0,0,0,20329,20330,1,0,0,0,20330,20332,1,0,0,0,20331,20326,1,0,
+        0,0,20331,20327,1,0,0,0,20332,20333,1,0,0,0,20333,20334,3,2282,1141,
+        0,20334,2281,1,0,0,0,20335,20336,3,2430,1215,0,20336,20337,5,2471,
+        0,0,20337,20339,1,0,0,0,20338,20335,1,0,0,0,20338,20339,1,0,0,0,
+        20339,20341,1,0,0,0,20340,20342,7,272,0,0,20341,20340,1,0,0,0,20341,
+        20342,1,0,0,0,20342,20348,1,0,0,0,20343,20344,3,2430,1215,0,20344,
+        20345,7,272,0,0,20345,20347,1,0,0,0,20346,20343,1,0,0,0,20347,20350,
+        1,0,0,0,20348,20346,1,0,0,0,20348,20349,1,0,0,0,20349,20351,1,0,
+        0,0,20350,20348,1,0,0,0,20351,20352,3,2430,1215,0,20352,20353,5,
+        2442,0,0,20353,20354,7,273,0,0,20354,2283,1,0,0,0,20355,20356,5,
+        2301,0,0,20356,20372,7,274,0,0,20357,20363,5,548,0,0,20358,20364,
+        5,1789,0,0,20359,20364,5,575,0,0,20360,20364,5,2297,0,0,20361,20364,
+        3,2352,1176,0,20362,20364,3,2422,1211,0,20363,20358,1,0,0,0,20363,
+        20359,1,0,0,0,20363,20360,1,0,0,0,20363,20361,1,0,0,0,20363,20362,
+        1,0,0,0,20364,20366,1,0,0,0,20365,20367,7,275,0,0,20366,20365,1,
+        0,0,0,20366,20367,1,0,0,0,20367,20373,1,0,0,0,20368,20370,5,297,
+        0,0,20369,20371,7,276,0,0,20370,20369,1,0,0,0,20370,20371,1,0,0,
+        0,20371,20373,1,0,0,0,20372,20357,1,0,0,0,20372,20368,1,0,0,0,20373,
+        2285,1,0,0,0,20374,20390,5,1673,0,0,20375,20376,3,2436,1218,0,20376,
+        20377,7,100,0,0,20377,20379,1,0,0,0,20378,20375,1,0,0,0,20379,20380,
+        1,0,0,0,20380,20378,1,0,0,0,20380,20381,1,0,0,0,20381,20391,1,0,
+        0,0,20382,20388,3,2436,1218,0,20383,20389,5,2445,0,0,20384,20389,
+        5,1261,0,0,20385,20389,5,1246,0,0,20386,20389,3,2422,1211,0,20387,
+        20389,3,2436,1218,0,20388,20383,1,0,0,0,20388,20384,1,0,0,0,20388,
+        20385,1,0,0,0,20388,20386,1,0,0,0,20388,20387,1,0,0,0,20389,20391,
+        1,0,0,0,20390,20378,1,0,0,0,20390,20382,1,0,0,0,20391,2287,1,0,0,
+        0,20392,20402,5,2122,0,0,20393,20397,5,1739,0,0,20394,20396,3,2430,
+        1215,0,20395,20394,1,0,0,0,20396,20399,1,0,0,0,20397,20395,1,0,0,
+        0,20397,20398,1,0,0,0,20398,20403,1,0,0,0,20399,20397,1,0,0,0,20400,
+        20403,5,1685,0,0,20401,20403,5,1763,0,0,20402,20393,1,0,0,0,20402,
+        20400,1,0,0,0,20402,20401,1,0,0,0,20402,20403,1,0,0,0,20403,2289,
+        1,0,0,0,20404,20406,5,212,0,0,20405,20407,5,237,0,0,20406,20405,
+        1,0,0,0,20406,20407,1,0,0,0,20407,20408,1,0,0,0,20408,20411,3,2436,
+        1218,0,20409,20411,5,38,0,0,20410,20404,1,0,0,0,20410,20409,1,0,
+        0,0,20411,2291,1,0,0,0,20412,20414,7,190,0,0,20413,20415,5,621,0,
+        0,20414,20413,1,0,0,0,20414,20415,1,0,0,0,20415,20416,1,0,0,0,20416,
+        20418,5,2449,0,0,20417,20419,3,2098,1049,0,20418,20417,1,0,0,0,20418,
+        20419,1,0,0,0,20419,20420,1,0,0,0,20420,20421,5,2450,0,0,20421,2293,
+        1,0,0,0,20422,20424,5,69,0,0,20423,20422,1,0,0,0,20423,20424,1,0,
+        0,0,20424,20427,1,0,0,0,20425,20428,3,2428,1214,0,20426,20428,3,
+        2426,1213,0,20427,20425,1,0,0,0,20427,20426,1,0,0,0,20428,20431,
+        1,0,0,0,20429,20431,5,69,0,0,20430,20423,1,0,0,0,20430,20429,1,0,
+        0,0,20431,2295,1,0,0,0,20432,20435,3,2428,1214,0,20433,20435,3,2426,
+        1213,0,20434,20432,1,0,0,0,20434,20433,1,0,0,0,20435,2297,1,0,0,
+        0,20436,20441,5,2303,0,0,20437,20438,5,336,0,0,20438,20439,5,1248,
+        0,0,20439,20442,3,2356,1178,0,20440,20442,3,2096,1048,0,20441,20437,
+        1,0,0,0,20441,20440,1,0,0,0,20442,2299,1,0,0,0,20443,20444,5,159,
+        0,0,20444,20446,5,233,0,0,20445,20443,1,0,0,0,20445,20446,1,0,0,
+        0,20446,20447,1,0,0,0,20447,20450,5,780,0,0,20448,20451,3,2410,1205,
+        0,20449,20451,3,2408,1204,0,20450,20448,1,0,0,0,20450,20449,1,0,
+        0,0,20451,20459,1,0,0,0,20452,20455,5,2455,0,0,20453,20456,3,2410,
+        1205,0,20454,20456,3,2408,1204,0,20455,20453,1,0,0,0,20455,20454,
+        1,0,0,0,20456,20458,1,0,0,0,20457,20452,1,0,0,0,20458,20461,1,0,
+        0,0,20459,20457,1,0,0,0,20459,20460,1,0,0,0,20460,2301,1,0,0,0,20461,
+        20459,1,0,0,0,20462,20465,3,2428,1214,0,20463,20465,3,2426,1213,
+        0,20464,20462,1,0,0,0,20464,20463,1,0,0,0,20465,2303,1,0,0,0,20466,
+        20467,3,2428,1214,0,20467,2305,1,0,0,0,20468,20469,3,2428,1214,0,
+        20469,2307,1,0,0,0,20470,20471,3,2428,1214,0,20471,2309,1,0,0,0,
+        20472,20473,3,2428,1214,0,20473,2311,1,0,0,0,20474,20475,3,2428,
+        1214,0,20475,2313,1,0,0,0,20476,20481,3,2428,1214,0,20477,20478,
+        5,2442,0,0,20478,20480,3,2430,1215,0,20479,20477,1,0,0,0,20480,20483,
+        1,0,0,0,20481,20479,1,0,0,0,20481,20482,1,0,0,0,20482,20486,1,0,
+        0,0,20483,20481,1,0,0,0,20484,20485,5,2458,0,0,20485,20487,3,2360,
+        1180,0,20486,20484,1,0,0,0,20486,20487,1,0,0,0,20487,2315,1,0,0,
+        0,20488,20489,3,2428,1214,0,20489,2317,1,0,0,0,20490,20493,3,2428,
+        1214,0,20491,20492,5,2442,0,0,20492,20494,3,2430,1215,0,20493,20491,
+        1,0,0,0,20493,20494,1,0,0,0,20494,2319,1,0,0,0,20495,20496,3,2428,
+        1214,0,20496,2321,1,0,0,0,20497,20498,3,2428,1214,0,20498,2323,1,
+        0,0,0,20499,20500,3,2428,1214,0,20500,2325,1,0,0,0,20501,20504,3,
+        2428,1214,0,20502,20503,5,2442,0,0,20503,20505,3,2430,1215,0,20504,
+        20502,1,0,0,0,20504,20505,1,0,0,0,20505,2327,1,0,0,0,20506,20511,
+        3,2428,1214,0,20507,20508,5,2442,0,0,20508,20510,3,2430,1215,0,20509,
+        20507,1,0,0,0,20510,20513,1,0,0,0,20511,20509,1,0,0,0,20511,20512,
+        1,0,0,0,20512,2329,1,0,0,0,20513,20511,1,0,0,0,20514,20515,3,2428,
+        1214,0,20515,2331,1,0,0,0,20516,20518,3,2430,1215,0,20517,20519,
+        3,576,288,0,20518,20517,1,0,0,0,20518,20519,1,0,0,0,20519,2333,1,
+        0,0,0,20520,20523,3,2430,1215,0,20521,20523,5,280,0,0,20522,20520,
+        1,0,0,0,20522,20521,1,0,0,0,20523,2335,1,0,0,0,20524,20529,3,2428,
+        1214,0,20525,20526,5,2442,0,0,20526,20528,3,2430,1215,0,20527,20525,
+        1,0,0,0,20528,20531,1,0,0,0,20529,20527,1,0,0,0,20529,20530,1,0,
+        0,0,20530,20534,1,0,0,0,20531,20529,1,0,0,0,20532,20533,5,2458,0,
+        0,20533,20535,3,2360,1180,0,20534,20532,1,0,0,0,20534,20535,1,0,
+        0,0,20535,2337,1,0,0,0,20536,20537,3,2430,1215,0,20537,2339,1,0,
+        0,0,20538,20543,3,2430,1215,0,20539,20540,5,2442,0,0,20540,20542,
+        3,2430,1215,0,20541,20539,1,0,0,0,20542,20545,1,0,0,0,20543,20541,
+        1,0,0,0,20543,20544,1,0,0,0,20544,2341,1,0,0,0,20545,20543,1,0,0,
+        0,20546,20551,3,2430,1215,0,20547,20548,5,2442,0,0,20548,20550,3,
+        2430,1215,0,20549,20547,1,0,0,0,20550,20553,1,0,0,0,20551,20549,
+        1,0,0,0,20551,20552,1,0,0,0,20552,2343,1,0,0,0,20553,20551,1,0,0,
+        0,20554,20559,3,2428,1214,0,20555,20556,5,2442,0,0,20556,20558,3,
+        2430,1215,0,20557,20555,1,0,0,0,20558,20561,1,0,0,0,20559,20557,
+        1,0,0,0,20559,20560,1,0,0,0,20560,2345,1,0,0,0,20561,20559,1,0,0,
+        0,20562,20565,3,2428,1214,0,20563,20564,5,2442,0,0,20564,20566,3,
+        2430,1215,0,20565,20563,1,0,0,0,20565,20566,1,0,0,0,20566,2347,1,
+        0,0,0,20567,20570,3,2428,1214,0,20568,20569,5,2442,0,0,20569,20571,
+        3,2430,1215,0,20570,20568,1,0,0,0,20570,20571,1,0,0,0,20571,2349,
+        1,0,0,0,20572,20575,3,2428,1214,0,20573,20574,5,2442,0,0,20574,20576,
+        3,2430,1215,0,20575,20573,1,0,0,0,20575,20576,1,0,0,0,20576,2351,
+        1,0,0,0,20577,20578,5,2477,0,0,20578,20580,3,2372,1186,0,20579,20577,
+        1,0,0,0,20579,20580,1,0,0,0,20580,20581,1,0,0,0,20581,20584,3,2430,
+        1215,0,20582,20583,5,2442,0,0,20583,20585,3,2430,1215,0,20584,20582,
+        1,0,0,0,20584,20585,1,0,0,0,20585,20588,1,0,0,0,20586,20588,3,2408,
+        1204,0,20587,20579,1,0,0,0,20587,20586,1,0,0,0,20588,2353,1,0,0,
+        0,20589,20592,3,2428,1214,0,20590,20591,5,2442,0,0,20591,20593,3,
+        2430,1215,0,20592,20590,1,0,0,0,20592,20593,1,0,0,0,20593,2355,1,
+        0,0,0,20594,20597,3,2410,1205,0,20595,20597,3,2408,1204,0,20596,
+        20594,1,0,0,0,20596,20595,1,0,0,0,20597,2357,1,0,0,0,20598,20601,
+        3,2428,1214,0,20599,20601,3,2408,1204,0,20600,20598,1,0,0,0,20600,
+        20599,1,0,0,0,20601,2359,1,0,0,0,20602,20607,3,1464,732,0,20603,
+        20604,5,2442,0,0,20604,20606,3,1462,731,0,20605,20603,1,0,0,0,20606,
+        20609,1,0,0,0,20607,20605,1,0,0,0,20607,20608,1,0,0,0,20608,20612,
+        1,0,0,0,20609,20607,1,0,0,0,20610,20611,5,2458,0,0,20611,20613,3,
+        2364,1182,0,20612,20610,1,0,0,0,20612,20613,1,0,0,0,20613,2361,1,
+        0,0,0,20614,20615,3,2428,1214,0,20615,2363,1,0,0,0,20616,20617,3,
+        2428,1214,0,20617,2365,1,0,0,0,20618,20623,3,2428,1214,0,20619,20620,
+        5,2442,0,0,20620,20622,3,2430,1215,0,20621,20619,1,0,0,0,20622,20625,
+        1,0,0,0,20623,20621,1,0,0,0,20623,20624,1,0,0,0,20624,2367,1,0,0,
+        0,20625,20623,1,0,0,0,20626,20629,3,2428,1214,0,20627,20628,5,2442,
+        0,0,20628,20630,3,2430,1215,0,20629,20627,1,0,0,0,20629,20630,1,
+        0,0,0,20630,20634,1,0,0,0,20631,20632,5,2458,0,0,20632,20635,3,2360,
+        1180,0,20633,20635,3,2292,1146,0,20634,20631,1,0,0,0,20634,20633,
+        1,0,0,0,20634,20635,1,0,0,0,20635,20641,1,0,0,0,20636,20638,3,2370,
+        1185,0,20637,20639,3,2434,1217,0,20638,20637,1,0,0,0,20638,20639,
+        1,0,0,0,20639,20641,1,0,0,0,20640,20626,1,0,0,0,20640,20636,1,0,
+        0,0,20641,2369,1,0,0,0,20642,20643,5,2349,0,0,20643,20647,5,2449,
+        0,0,20644,20645,3,2252,1126,0,20645,20646,5,2455,0,0,20646,20648,
+        1,0,0,0,20647,20644,1,0,0,0,20647,20648,1,0,0,0,20648,20649,1,0,
+        0,0,20649,20651,3,2124,1062,0,20650,20652,3,2248,1124,0,20651,20650,
+        1,0,0,0,20651,20652,1,0,0,0,20652,20657,1,0,0,0,20653,20654,5,1587,
+        0,0,20654,20655,5,1655,0,0,20655,20656,5,160,0,0,20656,20658,5,1532,
+        0,0,20657,20653,1,0,0,0,20657,20658,1,0,0,0,20658,20668,1,0,0,0,
+        20659,20660,5,238,0,0,20660,20665,3,2254,1127,0,20661,20662,5,2455,
+        0,0,20662,20664,3,2254,1127,0,20663,20661,1,0,0,0,20664,20667,1,
+        0,0,0,20665,20663,1,0,0,0,20665,20666,1,0,0,0,20666,20669,1,0,0,
+        0,20667,20665,1,0,0,0,20668,20659,1,0,0,0,20668,20669,1,0,0,0,20669,
+        20670,1,0,0,0,20670,20673,5,2450,0,0,20671,20672,5,2442,0,0,20672,
+        20674,3,2412,1206,0,20673,20671,1,0,0,0,20673,20674,1,0,0,0,20674,
+        2371,1,0,0,0,20675,20680,3,2430,1215,0,20676,20677,5,2442,0,0,20677,
+        20679,3,2430,1215,0,20678,20676,1,0,0,0,20679,20682,1,0,0,0,20680,
+        20678,1,0,0,0,20680,20681,1,0,0,0,20681,2373,1,0,0,0,20682,20680,
+        1,0,0,0,20683,20684,3,2428,1214,0,20684,2375,1,0,0,0,20685,20686,
+        3,2430,1215,0,20686,2377,1,0,0,0,20687,20688,3,2430,1215,0,20688,
+        2379,1,0,0,0,20689,20690,3,2430,1215,0,20690,2381,1,0,0,0,20691,
+        20716,3,2368,1184,0,20692,20693,5,2239,0,0,20693,20698,3,2380,1190,
+        0,20694,20695,5,2455,0,0,20695,20697,3,2380,1190,0,20696,20694,1,
+        0,0,0,20697,20700,1,0,0,0,20698,20696,1,0,0,0,20698,20699,1,0,0,
+        0,20699,20716,1,0,0,0,20700,20698,1,0,0,0,20701,20702,5,426,0,0,
+        20702,20716,3,2378,1189,0,20703,20704,5,483,0,0,20704,20716,3,2376,
+        1188,0,20705,20706,5,956,0,0,20706,20707,5,972,0,0,20707,20716,3,
+        2376,1188,0,20708,20709,5,793,0,0,20709,20710,7,86,0,0,20710,20716,
+        3,2376,1188,0,20711,20712,5,1724,0,0,20712,20713,5,2156,0,0,20713,
+        20714,5,1465,0,0,20714,20716,3,2376,1188,0,20715,20691,1,0,0,0,20715,
+        20692,1,0,0,0,20715,20701,1,0,0,0,20715,20703,1,0,0,0,20715,20705,
+        1,0,0,0,20715,20708,1,0,0,0,20715,20711,1,0,0,0,20716,2383,1,0,0,
+        0,20717,20722,3,2366,1183,0,20718,20719,5,2455,0,0,20719,20721,3,
+        2366,1183,0,20720,20718,1,0,0,0,20721,20724,1,0,0,0,20722,20720,
+        1,0,0,0,20722,20723,1,0,0,0,20723,2385,1,0,0,0,20724,20722,1,0,0,
+        0,20725,20726,5,2449,0,0,20726,20727,3,2384,1192,0,20727,20728,5,
+        2450,0,0,20728,2387,1,0,0,0,20729,20730,5,815,0,0,20730,20731,5,
+        2449,0,0,20731,20732,5,2394,0,0,20732,20735,7,56,0,0,20733,20736,
+        3,1948,974,0,20734,20736,3,2016,1008,0,20735,20733,1,0,0,0,20735,
+        20734,1,0,0,0,20736,20737,1,0,0,0,20737,20739,5,2450,0,0,20738,20740,
+        3,2226,1113,0,20739,20738,1,0,0,0,20739,20740,1,0,0,0,20740,2389,
+        1,0,0,0,20741,20750,5,2449,0,0,20742,20747,3,2398,1199,0,20743,20744,
+        5,2455,0,0,20744,20746,3,2398,1199,0,20745,20743,1,0,0,0,20746,20749,
+        1,0,0,0,20747,20745,1,0,0,0,20747,20748,1,0,0,0,20748,20751,1,0,
+        0,0,20749,20747,1,0,0,0,20750,20742,1,0,0,0,20750,20751,1,0,0,0,
+        20751,20752,1,0,0,0,20752,20754,5,2450,0,0,20753,20755,3,2388,1194,
+        0,20754,20753,1,0,0,0,20754,20755,1,0,0,0,20755,2391,1,0,0,0,20756,
+        20771,5,2449,0,0,20757,20759,3,2398,1199,0,20758,20760,3,2396,1198,
+        0,20759,20758,1,0,0,0,20759,20760,1,0,0,0,20760,20768,1,0,0,0,20761,
+        20762,5,2455,0,0,20762,20764,3,2398,1199,0,20763,20765,3,2396,1198,
+        0,20764,20763,1,0,0,0,20764,20765,1,0,0,0,20765,20767,1,0,0,0,20766,
+        20761,1,0,0,0,20767,20770,1,0,0,0,20768,20766,1,0,0,0,20768,20769,
+        1,0,0,0,20769,20772,1,0,0,0,20770,20768,1,0,0,0,20771,20757,1,0,
+        0,0,20771,20772,1,0,0,0,20772,20773,1,0,0,0,20773,20775,5,2450,0,
+        0,20774,20776,3,2388,1194,0,20775,20774,1,0,0,0,20775,20776,1,0,
+        0,0,20776,2393,1,0,0,0,20777,20778,5,2449,0,0,20778,20791,3,2366,
+        1183,0,20779,20782,5,2455,0,0,20780,20783,3,2422,1211,0,20781,20783,
+        5,1230,0,0,20782,20780,1,0,0,0,20782,20781,1,0,0,0,20783,20789,1,
+        0,0,0,20784,20787,5,2455,0,0,20785,20788,3,2422,1211,0,20786,20788,
+        5,1230,0,0,20787,20785,1,0,0,0,20787,20786,1,0,0,0,20788,20790,1,
+        0,0,0,20789,20784,1,0,0,0,20789,20790,1,0,0,0,20790,20792,1,0,0,
+        0,20791,20779,1,0,0,0,20791,20792,1,0,0,0,20792,20793,1,0,0,0,20793,
+        20813,5,2248,0,0,20794,20795,3,2368,1184,0,20795,20796,5,2442,0,
+        0,20796,20797,5,2452,0,0,20797,20814,1,0,0,0,20798,20814,5,2452,
+        0,0,20799,20801,3,2100,1050,0,20800,20802,3,2294,1147,0,20801,20800,
+        1,0,0,0,20801,20802,1,0,0,0,20802,20810,1,0,0,0,20803,20804,5,2455,
+        0,0,20804,20806,3,2100,1050,0,20805,20807,3,2294,1147,0,20806,20805,
+        1,0,0,0,20806,20807,1,0,0,0,20807,20809,1,0,0,0,20808,20803,1,0,
+        0,0,20809,20812,1,0,0,0,20810,20808,1,0,0,0,20810,20811,1,0,0,0,
+        20811,20814,1,0,0,0,20812,20810,1,0,0,0,20813,20794,1,0,0,0,20813,
+        20798,1,0,0,0,20813,20799,1,0,0,0,20814,20815,1,0,0,0,20815,20817,
+        5,2450,0,0,20816,20818,3,2388,1194,0,20817,20816,1,0,0,0,20817,20818,
+        1,0,0,0,20818,2395,1,0,0,0,20819,20820,7,277,0,0,20820,20821,5,1231,
+        0,0,20821,2397,1,0,0,0,20822,20823,3,2428,1214,0,20823,20824,5,2474,
+        0,0,20824,20825,5,2469,0,0,20825,20827,1,0,0,0,20826,20822,1,0,0,
+        0,20826,20827,1,0,0,0,20827,20828,1,0,0,0,20828,20829,3,2100,1050,
+        0,20829,2399,1,0,0,0,20830,20839,3,2402,1201,0,20831,20833,5,1532,
+        0,0,20832,20831,1,0,0,0,20832,20833,1,0,0,0,20833,20834,1,0,0,0,
+        20834,20836,3,2340,1170,0,20835,20837,7,278,0,0,20836,20835,1,0,
+        0,0,20836,20837,1,0,0,0,20837,20839,1,0,0,0,20838,20830,1,0,0,0,
+        20838,20832,1,0,0,0,20839,2401,1,0,0,0,20840,20842,3,2406,1203,0,
+        20841,20843,3,2404,1202,0,20842,20841,1,0,0,0,20842,20843,1,0,0,
+        0,20843,20853,1,0,0,0,20844,20846,5,2310,0,0,20845,20847,5,874,0,
+        0,20846,20845,1,0,0,0,20846,20847,1,0,0,0,20847,20848,1,0,0,0,20848,
+        20849,5,2114,0,0,20849,20854,5,2365,0,0,20850,20851,5,193,0,0,20851,
+        20852,5,1673,0,0,20852,20854,3,2372,1186,0,20853,20844,1,0,0,0,20853,
+        20850,1,0,0,0,20853,20854,1,0,0,0,20854,20872,1,0,0,0,20855,20856,
+        5,777,0,0,20856,20861,7,279,0,0,20857,20858,5,2449,0,0,20858,20859,
+        3,2100,1050,0,20859,20860,5,2450,0,0,20860,20862,1,0,0,0,20861,20857,
+        1,0,0,0,20861,20862,1,0,0,0,20862,20863,1,0,0,0,20863,20864,5,2143,
+        0,0,20864,20869,7,280,0,0,20865,20866,5,2449,0,0,20866,20867,3,2100,
+        1050,0,20867,20868,5,2450,0,0,20868,20870,1,0,0,0,20869,20865,1,
+        0,0,0,20869,20870,1,0,0,0,20870,20872,1,0,0,0,20871,20840,1,0,0,
+        0,20871,20855,1,0,0,0,20872,2403,1,0,0,0,20873,20876,5,2449,0,0,
+        20874,20877,3,2422,1211,0,20875,20877,5,2452,0,0,20876,20874,1,0,
+        0,0,20876,20875,1,0,0,0,20877,20883,1,0,0,0,20878,20881,5,2455,0,
+        0,20879,20882,3,2422,1211,0,20880,20882,3,2424,1212,0,20881,20879,
+        1,0,0,0,20881,20880,1,0,0,0,20882,20884,1,0,0,0,20883,20878,1,0,
+        0,0,20883,20884,1,0,0,0,20884,20886,1,0,0,0,20885,20887,7,239,0,
+        0,20886,20885,1,0,0,0,20886,20887,1,0,0,0,20887,20888,1,0,0,0,20888,
+        20889,5,2450,0,0,20889,2405,1,0,0,0,20890,20956,5,131,0,0,20891,
+        20956,5,1405,0,0,20892,20956,5,1005,0,0,20893,20956,5,128,0,0,20894,
+        20956,5,125,0,0,20895,20956,5,1006,0,0,20896,20956,5,1422,0,0,20897,
+        20956,5,1421,0,0,20898,20956,5,1694,0,0,20899,20956,5,1695,0,0,20900,
+        20956,5,1237,0,0,20901,20956,5,380,0,0,20902,20956,5,770,0,0,20903,
+        20956,5,778,0,0,20904,20956,5,1233,0,0,20905,20956,5,1708,0,0,20906,
+        20956,5,1232,0,0,20907,20956,5,381,0,0,20908,20910,5,465,0,0,20909,
+        20911,5,1439,0,0,20910,20909,1,0,0,0,20910,20911,1,0,0,0,20911,20956,
+        1,0,0,0,20912,20956,5,608,0,0,20913,20956,5,1511,0,0,20914,20956,
+        5,1009,0,0,20915,20917,5,894,0,0,20916,20918,5,1500,0,0,20917,20916,
+        1,0,0,0,20917,20918,1,0,0,0,20918,20956,1,0,0,0,20919,20956,5,196,
+        0,0,20920,20922,5,193,0,0,20921,20923,5,2271,0,0,20922,20921,1,0,
+        0,0,20922,20923,1,0,0,0,20923,20956,1,0,0,0,20924,20956,5,2261,0,
+        0,20925,20956,5,2262,0,0,20926,20956,5,1769,0,0,20927,20956,5,1500,
+        0,0,20928,20956,5,148,0,0,20929,20956,5,361,0,0,20930,20956,5,1603,
+        0,0,20931,20956,5,2216,0,0,20932,20956,5,2360,0,0,20933,20956,5,
+        986,0,0,20934,20956,5,365,0,0,20935,20956,5,680,0,0,20936,20956,
+        5,959,0,0,20937,20956,5,1638,0,0,20938,20956,5,1635,0,0,20939,20956,
+        5,2117,0,0,20940,20956,5,2118,0,0,20941,20956,5,2120,0,0,20942,20956,
+        5,2116,0,0,20943,20956,5,2110,0,0,20944,20956,5,2112,0,0,20945,20956,
+        5,2111,0,0,20946,20956,5,2109,0,0,20947,20956,5,2363,0,0,20948,20956,
+        5,471,0,0,20949,20956,5,119,0,0,20950,20956,5,142,0,0,20951,20956,
+        5,215,0,0,20952,20956,5,1011,0,0,20953,20956,5,967,0,0,20954,20956,
+        5,2353,0,0,20955,20890,1,0,0,0,20955,20891,1,0,0,0,20955,20892,1,
+        0,0,0,20955,20893,1,0,0,0,20955,20894,1,0,0,0,20955,20895,1,0,0,
+        0,20955,20896,1,0,0,0,20955,20897,1,0,0,0,20955,20898,1,0,0,0,20955,
+        20899,1,0,0,0,20955,20900,1,0,0,0,20955,20901,1,0,0,0,20955,20902,
+        1,0,0,0,20955,20903,1,0,0,0,20955,20904,1,0,0,0,20955,20905,1,0,
+        0,0,20955,20906,1,0,0,0,20955,20907,1,0,0,0,20955,20908,1,0,0,0,
+        20955,20912,1,0,0,0,20955,20913,1,0,0,0,20955,20914,1,0,0,0,20955,
+        20915,1,0,0,0,20955,20919,1,0,0,0,20955,20920,1,0,0,0,20955,20924,
+        1,0,0,0,20955,20925,1,0,0,0,20955,20926,1,0,0,0,20955,20927,1,0,
+        0,0,20955,20928,1,0,0,0,20955,20929,1,0,0,0,20955,20930,1,0,0,0,
+        20955,20931,1,0,0,0,20955,20932,1,0,0,0,20955,20933,1,0,0,0,20955,
+        20934,1,0,0,0,20955,20935,1,0,0,0,20955,20936,1,0,0,0,20955,20937,
+        1,0,0,0,20955,20938,1,0,0,0,20955,20939,1,0,0,0,20955,20940,1,0,
+        0,0,20955,20941,1,0,0,0,20955,20942,1,0,0,0,20955,20943,1,0,0,0,
+        20955,20944,1,0,0,0,20955,20945,1,0,0,0,20955,20946,1,0,0,0,20955,
+        20947,1,0,0,0,20955,20948,1,0,0,0,20955,20949,1,0,0,0,20955,20950,
+        1,0,0,0,20955,20951,1,0,0,0,20955,20952,1,0,0,0,20955,20953,1,0,
+        0,0,20955,20954,1,0,0,0,20956,2407,1,0,0,0,20957,20961,5,2464,0,
+        0,20958,20959,5,2471,0,0,20959,20961,5,2443,0,0,20960,20957,1,0,
+        0,0,20960,20958,1,0,0,0,20961,20970,1,0,0,0,20962,20964,5,734,0,
+        0,20963,20962,1,0,0,0,20963,20964,1,0,0,0,20964,20968,1,0,0,0,20965,
+        20969,5,2464,0,0,20966,20967,5,2471,0,0,20967,20969,5,2443,0,0,20968,
+        20965,1,0,0,0,20968,20966,1,0,0,0,20969,20971,1,0,0,0,20970,20963,
+        1,0,0,0,20970,20971,1,0,0,0,20971,20976,1,0,0,0,20972,20973,5,2442,
+        0,0,20973,20975,3,2412,1206,0,20974,20972,1,0,0,0,20975,20978,1,
+        0,0,0,20976,20974,1,0,0,0,20976,20977,1,0,0,0,20977,2409,1,0,0,0,
+        20978,20976,1,0,0,0,20979,20980,6,1205,-1,0,20980,20986,3,2412,1206,
+        0,20981,20982,5,2449,0,0,20982,20983,3,2410,1205,0,20983,20984,5,
+        2450,0,0,20984,20986,1,0,0,0,20985,20979,1,0,0,0,20985,20981,1,0,
+        0,0,20986,20996,1,0,0,0,20987,20990,10,2,0,0,20988,20989,5,2442,
+        0,0,20989,20991,3,2412,1206,0,20990,20988,1,0,0,0,20991,20992,1,
+        0,0,0,20992,20990,1,0,0,0,20992,20993,1,0,0,0,20993,20995,1,0,0,
+        0,20994,20987,1,0,0,0,20995,20998,1,0,0,0,20996,20994,1,0,0,0,20996,
+        20997,1,0,0,0,20997,2411,1,0,0,0,20998,20996,1,0,0,0,20999,21000,
+        5,2477,0,0,21000,21002,3,2372,1186,0,21001,20999,1,0,0,0,21001,21002,
+        1,0,0,0,21002,21003,1,0,0,0,21003,21006,3,2430,1215,0,21004,21005,
+        5,2458,0,0,21005,21007,3,2360,1180,0,21006,21004,1,0,0,0,21006,21007,
+        1,0,0,0,21007,21011,1,0,0,0,21008,21010,3,2390,1195,0,21009,21008,
+        1,0,0,0,21010,21013,1,0,0,0,21011,21009,1,0,0,0,21011,21012,1,0,
+        0,0,21012,2413,1,0,0,0,21013,21011,1,0,0,0,21014,21015,5,2477,0,
+        0,21015,21017,3,2372,1186,0,21016,21014,1,0,0,0,21016,21017,1,0,
+        0,0,21017,21018,1,0,0,0,21018,21023,3,2430,1215,0,21019,21020,5,
+        2442,0,0,21020,21022,3,2430,1215,0,21021,21019,1,0,0,0,21022,21025,
+        1,0,0,0,21023,21021,1,0,0,0,21023,21024,1,0,0,0,21024,2415,1,0,0,
+        0,21025,21023,1,0,0,0,21026,21028,5,38,0,0,21027,21029,5,1461,0,
+        0,21028,21027,1,0,0,0,21028,21029,1,0,0,0,21029,21063,1,0,0,0,21030,
+        21063,5,42,0,0,21031,21063,5,378,0,0,21032,21063,5,403,0,0,21033,
+        21063,5,543,0,0,21034,21063,5,606,0,0,21035,21036,5,606,0,0,21036,
+        21063,5,64,0,0,21037,21063,5,718,0,0,21038,21039,5,738,0,0,21039,
+        21063,5,1461,0,0,21040,21041,5,738,0,0,21041,21042,5,1558,0,0,21042,
+        21063,5,1461,0,0,21043,21063,5,757,0,0,21044,21045,5,815,0,0,21045,
+        21063,5,1655,0,0,21046,21047,5,947,0,0,21047,21063,5,2288,0,0,21048,
+        21049,5,1261,0,0,21049,21050,5,242,0,0,21050,21063,5,1533,0,0,21051,
+        21052,5,1486,0,0,21052,21063,5,1593,0,0,21053,21063,5,1507,0,0,21054,
+        21063,5,1530,0,0,21055,21063,5,1649,0,0,21056,21057,5,2155,0,0,21057,
+        21063,5,1724,0,0,21058,21063,5,2179,0,0,21059,21063,5,2209,0,0,21060,
+        21063,5,2243,0,0,21061,21063,5,2315,0,0,21062,21026,1,0,0,0,21062,
+        21030,1,0,0,0,21062,21031,1,0,0,0,21062,21032,1,0,0,0,21062,21033,
+        1,0,0,0,21062,21034,1,0,0,0,21062,21035,1,0,0,0,21062,21037,1,0,
+        0,0,21062,21038,1,0,0,0,21062,21040,1,0,0,0,21062,21043,1,0,0,0,
+        21062,21044,1,0,0,0,21062,21046,1,0,0,0,21062,21048,1,0,0,0,21062,
+        21051,1,0,0,0,21062,21053,1,0,0,0,21062,21054,1,0,0,0,21062,21055,
+        1,0,0,0,21062,21056,1,0,0,0,21062,21058,1,0,0,0,21062,21059,1,0,
+        0,0,21062,21060,1,0,0,0,21062,21061,1,0,0,0,21063,2417,1,0,0,0,21064,
+        21065,5,38,0,0,21065,21391,5,1461,0,0,21066,21391,5,31,0,0,21067,
+        21069,5,27,0,0,21068,21070,5,55,0,0,21069,21068,1,0,0,0,21069,21070,
+        1,0,0,0,21070,21071,1,0,0,0,21071,21072,5,1724,0,0,21072,21073,5,
+        2165,0,0,21073,21391,5,1673,0,0,21074,21075,7,59,0,0,21075,21076,
+        5,55,0,0,21076,21077,5,1724,0,0,21077,21391,5,1465,0,0,21078,21079,
+        5,27,0,0,21079,21080,5,1724,0,0,21080,21081,5,907,0,0,21081,21391,
+        5,1240,0,0,21082,21084,5,321,0,0,21083,21085,5,55,0,0,21084,21083,
+        1,0,0,0,21084,21085,1,0,0,0,21085,21086,1,0,0,0,21086,21391,5,220,
+        0,0,21087,21088,7,281,0,0,21088,21089,5,55,0,0,21089,21391,5,220,
+        0,0,21090,21091,7,282,0,0,21091,21092,5,55,0,0,21092,21391,5,296,
+        0,0,21093,21094,5,544,0,0,21094,21095,5,1522,0,0,21095,21391,5,1414,
+        0,0,21096,21097,5,42,0,0,21097,21391,5,350,0,0,21098,21100,7,283,
+        0,0,21099,21101,5,1475,0,0,21100,21099,1,0,0,0,21100,21101,1,0,0,
+        0,21101,21102,1,0,0,0,21102,21103,5,350,0,0,21103,21391,5,862,0,
+        0,21104,21105,5,469,0,0,21105,21106,5,1475,0,0,21106,21107,5,350,
+        0,0,21107,21391,5,862,0,0,21108,21109,5,378,0,0,21109,21110,5,280,
+        0,0,21110,21391,5,1669,0,0,21111,21112,5,378,0,0,21112,21113,5,55,
+        0,0,21113,21391,5,1463,0,0,21114,21115,5,46,0,0,21115,21116,5,55,
+        0,0,21116,21391,5,421,0,0,21117,21119,5,321,0,0,21118,21120,5,55,
+        0,0,21119,21118,1,0,0,0,21119,21120,1,0,0,0,21120,21121,1,0,0,0,
+        21121,21391,5,422,0,0,21122,21123,7,281,0,0,21123,21124,5,55,0,0,
+        21124,21391,5,422,0,0,21125,21126,7,282,0,0,21126,21127,5,55,0,0,
+        21127,21391,5,426,0,0,21128,21129,7,282,0,0,21129,21130,5,55,0,0,
+        21130,21391,5,483,0,0,21131,21136,5,606,0,0,21132,21133,5,64,0,0,
+        21133,21137,5,27,0,0,21134,21135,5,55,0,0,21135,21137,5,2085,0,0,
+        21136,21132,1,0,0,0,21136,21134,1,0,0,0,21137,21391,1,0,0,0,21138,
+        21139,7,59,0,0,21139,21140,5,55,0,0,21140,21391,5,718,0,0,21141,
+        21143,5,321,0,0,21142,21144,5,55,0,0,21143,21142,1,0,0,0,21143,21144,
+        1,0,0,0,21144,21145,1,0,0,0,21145,21391,5,732,0,0,21146,21147,7,
+        284,0,0,21147,21148,5,55,0,0,21148,21391,5,732,0,0,21149,21151,5,
+        321,0,0,21150,21152,7,285,0,0,21151,21150,1,0,0,0,21151,21152,1,
+        0,0,0,21152,21153,1,0,0,0,21153,21391,5,794,0,0,21154,21155,5,543,
+        0,0,21155,21156,5,55,0,0,21156,21391,7,286,0,0,21157,21158,5,906,
+        0,0,21158,21391,5,1625,0,0,21159,21160,5,27,0,0,21160,21161,5,817,
+        0,0,21161,21391,5,907,0,0,21162,21164,5,321,0,0,21163,21165,5,55,
+        0,0,21164,21163,1,0,0,0,21164,21165,1,0,0,0,21165,21166,1,0,0,0,
+        21166,21391,5,850,0,0,21167,21168,7,284,0,0,21168,21169,5,55,0,0,
+        21169,21391,5,850,0,0,21170,21391,5,890,0,0,21171,21173,5,321,0,
+        0,21172,21174,5,55,0,0,21173,21172,1,0,0,0,21173,21174,1,0,0,0,21174,
+        21175,1,0,0,0,21175,21176,5,920,0,0,21176,21391,5,2288,0,0,21177,
+        21178,7,281,0,0,21178,21179,5,55,0,0,21179,21180,5,920,0,0,21180,
+        21391,5,2288,0,0,21181,21183,5,643,0,0,21182,21181,1,0,0,0,21182,
+        21183,1,0,0,0,21183,21184,1,0,0,0,21184,21185,5,1486,0,0,21185,21391,
+        5,1593,0,0,21186,21187,5,1261,0,0,21187,21188,5,242,0,0,21188,21391,
+        5,1533,0,0,21189,21191,5,321,0,0,21190,21192,5,55,0,0,21191,21190,
+        1,0,0,0,21191,21192,1,0,0,0,21192,21193,1,0,0,0,21193,21194,5,956,
+        0,0,21194,21391,5,972,0,0,21195,21196,7,287,0,0,21196,21197,5,55,
+        0,0,21197,21198,5,956,0,0,21198,21391,5,972,0,0,21199,21201,5,321,
+        0,0,21200,21202,5,55,0,0,21201,21200,1,0,0,0,21201,21202,1,0,0,0,
+        21202,21203,1,0,0,0,21203,21391,5,332,0,0,21204,21205,7,288,0,0,
+        21205,21206,5,55,0,0,21206,21391,5,332,0,0,21207,21209,5,321,0,0,
+        21208,21210,5,55,0,0,21209,21208,1,0,0,0,21209,21210,1,0,0,0,21210,
+        21211,1,0,0,0,21211,21212,5,934,0,0,21212,21391,5,613,0,0,21213,
+        21214,7,289,0,0,21214,21215,5,55,0,0,21215,21216,5,934,0,0,21216,
+        21391,5,613,0,0,21217,21219,5,321,0,0,21218,21220,5,55,0,0,21219,
+        21218,1,0,0,0,21219,21220,1,0,0,0,21220,21221,1,0,0,0,21221,21222,
+        5,332,0,0,21222,21391,5,422,0,0,21223,21224,7,290,0,0,21224,21225,
+        5,55,0,0,21225,21226,5,332,0,0,21226,21391,5,422,0,0,21227,21229,
+        5,321,0,0,21228,21230,5,55,0,0,21229,21228,1,0,0,0,21229,21230,1,
+        0,0,0,21230,21231,1,0,0,0,21231,21232,5,332,0,0,21232,21233,5,158,
+        0,0,21233,21391,5,1464,0,0,21234,21235,7,291,0,0,21235,21236,5,55,
+        0,0,21236,21237,5,332,0,0,21237,21238,5,158,0,0,21238,21391,5,1464,
+        0,0,21239,21241,5,321,0,0,21240,21242,5,55,0,0,21241,21240,1,0,0,
+        0,21241,21242,1,0,0,0,21242,21243,1,0,0,0,21243,21391,5,1268,0,0,
+        21244,21245,7,284,0,0,21245,21246,5,55,0,0,21246,21391,5,1268,0,
+        0,21247,21248,7,59,0,0,21248,21249,5,55,0,0,21249,21391,5,1317,0,
+        0,21250,21251,5,321,0,0,21251,21252,5,1411,0,0,21252,21391,5,350,
+        0,0,21253,21254,5,1673,0,0,21254,21391,5,289,0,0,21255,21257,5,321,
+        0,0,21256,21258,5,55,0,0,21257,21256,1,0,0,0,21257,21258,1,0,0,0,
+        21258,21259,1,0,0,0,21259,21391,5,1463,0,0,21260,21261,7,284,0,0,
+        21261,21262,5,55,0,0,21262,21391,5,1463,0,0,21263,21264,7,59,0,0,
+        21264,21391,5,1465,0,0,21265,21266,5,321,0,0,21266,21391,5,1595,
+        0,0,21267,21268,7,292,0,0,21268,21269,5,55,0,0,21269,21391,5,1595,
+        0,0,21270,21271,7,59,0,0,21271,21272,5,1598,0,0,21272,21391,5,1647,
+        0,0,21273,21275,5,321,0,0,21274,21276,5,55,0,0,21275,21274,1,0,0,
+        0,21275,21276,1,0,0,0,21276,21277,1,0,0,0,21277,21391,5,1655,0,0,
+        21278,21279,7,293,0,0,21279,21280,5,55,0,0,21280,21391,5,1655,0,
+        0,21281,21282,7,294,0,0,21282,21391,5,1669,0,0,21283,21284,5,42,
+        0,0,21284,21285,5,1572,0,0,21285,21391,5,311,0,0,21286,21288,5,321,
+        0,0,21287,21289,5,55,0,0,21288,21287,1,0,0,0,21288,21289,1,0,0,0,
+        21289,21290,1,0,0,0,21290,21291,5,1724,0,0,21291,21292,5,2156,0,
+        0,21292,21391,5,1465,0,0,21293,21294,7,295,0,0,21294,21295,5,55,
+        0,0,21295,21296,5,1724,0,0,21296,21297,5,2156,0,0,21297,21391,5,
+        1465,0,0,21298,21299,5,2155,0,0,21299,21300,5,55,0,0,21300,21391,
+        5,1724,0,0,21301,21303,5,321,0,0,21302,21304,5,55,0,0,21303,21302,
+        1,0,0,0,21303,21304,1,0,0,0,21304,21305,1,0,0,0,21305,21391,5,1798,
+        0,0,21306,21307,5,469,0,0,21307,21308,5,55,0,0,21308,21391,5,1798,
+        0,0,21309,21310,7,282,0,0,21310,21311,5,1475,0,0,21311,21391,5,1798,
+        0,0,21312,21314,5,321,0,0,21313,21315,5,55,0,0,21314,21313,1,0,0,
+        0,21314,21315,1,0,0,0,21315,21316,1,0,0,0,21316,21391,5,2085,0,0,
+        21317,21318,7,296,0,0,21318,21319,5,55,0,0,21319,21391,5,2085,0,
+        0,21320,21321,7,297,0,0,21321,21391,5,2082,0,0,21322,21324,5,321,
+        0,0,21323,21325,5,55,0,0,21324,21323,1,0,0,0,21324,21325,1,0,0,0,
+        21325,21326,1,0,0,0,21326,21391,5,2159,0,0,21327,21328,7,281,0,0,
+        21328,21329,5,55,0,0,21329,21391,5,2159,0,0,21330,21331,5,27,0,0,
+        21331,21332,5,350,0,0,21332,21391,5,2159,0,0,21333,21335,5,321,0,
+        0,21334,21336,5,55,0,0,21335,21334,1,0,0,0,21335,21336,1,0,0,0,21336,
+        21337,1,0,0,0,21337,21391,5,2168,0,0,21338,21339,7,298,0,0,21339,
+        21340,5,55,0,0,21340,21391,5,2168,0,0,21341,21342,7,59,0,0,21342,
+        21391,5,2239,0,0,21343,21345,5,321,0,0,21344,21346,5,55,0,0,21345,
+        21344,1,0,0,0,21345,21346,1,0,0,0,21346,21347,1,0,0,0,21347,21391,
+        5,2288,0,0,21348,21349,7,299,0,0,21349,21350,5,55,0,0,21350,21391,
+        5,2288,0,0,21351,21352,7,300,0,0,21352,21391,5,55,0,0,21353,21354,
+        5,111,0,0,21354,21391,5,2239,0,0,21355,21356,5,190,0,0,21356,21391,
+        5,1204,0,0,21357,21358,5,544,0,0,21358,21359,5,4,0,0,21359,21391,
+        5,1414,0,0,21360,21362,5,617,0,0,21361,21363,5,55,0,0,21362,21361,
+        1,0,0,0,21362,21363,1,0,0,0,21363,21364,1,0,0,0,21364,21391,5,2149,
+        0,0,21365,21366,5,648,0,0,21366,21368,5,55,0,0,21367,21369,5,1240,
+        0,0,21368,21367,1,0,0,0,21368,21369,1,0,0,0,21369,21370,1,0,0,0,
+        21370,21391,5,1460,0,0,21371,21372,5,738,0,0,21372,21373,5,55,0,
+        0,21373,21391,5,1461,0,0,21374,21375,5,815,0,0,21375,21376,5,361,
+        0,0,21376,21391,5,2114,0,0,21377,21378,5,815,0,0,21378,21391,5,1834,
+        0,0,21379,21380,5,1477,0,0,21380,21391,5,369,0,0,21381,21391,5,1583,
+        0,0,21382,21383,5,1649,0,0,21383,21384,5,55,0,0,21384,21391,7,301,
+        0,0,21385,21391,5,1803,0,0,21386,21391,5,1809,0,0,21387,21391,5,
+        1811,0,0,21388,21391,5,1835,0,0,21389,21391,5,1870,0,0,21390,21064,
+        1,0,0,0,21390,21066,1,0,0,0,21390,21067,1,0,0,0,21390,21074,1,0,
+        0,0,21390,21078,1,0,0,0,21390,21082,1,0,0,0,21390,21087,1,0,0,0,
+        21390,21090,1,0,0,0,21390,21093,1,0,0,0,21390,21096,1,0,0,0,21390,
+        21098,1,0,0,0,21390,21104,1,0,0,0,21390,21108,1,0,0,0,21390,21111,
+        1,0,0,0,21390,21114,1,0,0,0,21390,21117,1,0,0,0,21390,21122,1,0,
+        0,0,21390,21125,1,0,0,0,21390,21128,1,0,0,0,21390,21131,1,0,0,0,
+        21390,21138,1,0,0,0,21390,21141,1,0,0,0,21390,21146,1,0,0,0,21390,
+        21149,1,0,0,0,21390,21154,1,0,0,0,21390,21157,1,0,0,0,21390,21159,
+        1,0,0,0,21390,21162,1,0,0,0,21390,21167,1,0,0,0,21390,21170,1,0,
+        0,0,21390,21171,1,0,0,0,21390,21177,1,0,0,0,21390,21182,1,0,0,0,
+        21390,21186,1,0,0,0,21390,21189,1,0,0,0,21390,21195,1,0,0,0,21390,
+        21199,1,0,0,0,21390,21204,1,0,0,0,21390,21207,1,0,0,0,21390,21213,
+        1,0,0,0,21390,21217,1,0,0,0,21390,21223,1,0,0,0,21390,21227,1,0,
+        0,0,21390,21234,1,0,0,0,21390,21239,1,0,0,0,21390,21244,1,0,0,0,
+        21390,21247,1,0,0,0,21390,21250,1,0,0,0,21390,21253,1,0,0,0,21390,
+        21255,1,0,0,0,21390,21260,1,0,0,0,21390,21263,1,0,0,0,21390,21265,
+        1,0,0,0,21390,21267,1,0,0,0,21390,21270,1,0,0,0,21390,21273,1,0,
+        0,0,21390,21278,1,0,0,0,21390,21281,1,0,0,0,21390,21283,1,0,0,0,
+        21390,21286,1,0,0,0,21390,21293,1,0,0,0,21390,21298,1,0,0,0,21390,
+        21301,1,0,0,0,21390,21306,1,0,0,0,21390,21309,1,0,0,0,21390,21312,
+        1,0,0,0,21390,21317,1,0,0,0,21390,21320,1,0,0,0,21390,21322,1,0,
+        0,0,21390,21327,1,0,0,0,21390,21330,1,0,0,0,21390,21333,1,0,0,0,
+        21390,21338,1,0,0,0,21390,21341,1,0,0,0,21390,21343,1,0,0,0,21390,
+        21348,1,0,0,0,21390,21351,1,0,0,0,21390,21353,1,0,0,0,21390,21355,
+        1,0,0,0,21390,21357,1,0,0,0,21390,21360,1,0,0,0,21390,21365,1,0,
+        0,0,21390,21371,1,0,0,0,21390,21374,1,0,0,0,21390,21377,1,0,0,0,
+        21390,21379,1,0,0,0,21390,21381,1,0,0,0,21390,21382,1,0,0,0,21390,
+        21385,1,0,0,0,21390,21386,1,0,0,0,21390,21387,1,0,0,0,21390,21388,
+        1,0,0,0,21390,21389,1,0,0,0,21391,2419,1,0,0,0,21392,21395,5,2110,
+        0,0,21393,21396,3,2426,1213,0,21394,21396,3,2408,1204,0,21395,21393,
+        1,0,0,0,21395,21394,1,0,0,0,21396,21401,1,0,0,0,21397,21398,5,82,
+        0,0,21398,21399,5,2114,0,0,21399,21400,5,2365,0,0,21400,21402,3,
+        2426,1213,0,21401,21397,1,0,0,0,21401,21402,1,0,0,0,21402,21456,
+        1,0,0,0,21403,21407,5,777,0,0,21404,21408,3,2426,1213,0,21405,21408,
+        3,2408,1204,0,21406,21408,3,2412,1206,0,21407,21404,1,0,0,0,21407,
+        21405,1,0,0,0,21407,21406,1,0,0,0,21408,21409,1,0,0,0,21409,21423,
+        7,302,0,0,21410,21413,5,2449,0,0,21411,21414,5,2443,0,0,21412,21414,
+        3,2408,1204,0,21413,21411,1,0,0,0,21413,21412,1,0,0,0,21414,21420,
+        1,0,0,0,21415,21418,5,2455,0,0,21416,21419,5,2443,0,0,21417,21419,
+        3,2408,1204,0,21418,21416,1,0,0,0,21418,21417,1,0,0,0,21419,21421,
+        1,0,0,0,21420,21415,1,0,0,0,21420,21421,1,0,0,0,21421,21422,1,0,
+        0,0,21422,21424,5,2450,0,0,21423,21410,1,0,0,0,21423,21424,1,0,0,
+        0,21424,21441,1,0,0,0,21425,21439,5,2143,0,0,21426,21440,5,986,0,
+        0,21427,21440,5,365,0,0,21428,21440,5,680,0,0,21429,21440,5,959,
+        0,0,21430,21437,5,1638,0,0,21431,21434,5,2449,0,0,21432,21435,5,
+        2443,0,0,21433,21435,3,2408,1204,0,21434,21432,1,0,0,0,21434,21433,
+        1,0,0,0,21435,21436,1,0,0,0,21436,21438,5,2450,0,0,21437,21431,1,
+        0,0,0,21437,21438,1,0,0,0,21438,21440,1,0,0,0,21439,21426,1,0,0,
+        0,21439,21427,1,0,0,0,21439,21428,1,0,0,0,21439,21429,1,0,0,0,21439,
+        21430,1,0,0,0,21440,21442,1,0,0,0,21441,21425,1,0,0,0,21441,21442,
+        1,0,0,0,21442,21456,1,0,0,0,21443,21456,3,2422,1211,0,21444,21445,
+        5,361,0,0,21445,21456,3,2426,1213,0,21446,21456,3,2426,1213,0,21447,
+        21456,5,1230,0,0,21448,21456,5,2160,0,0,21449,21456,5,576,0,0,21450,
+        21456,5,373,0,0,21451,21456,5,1671,0,0,21452,21456,5,961,0,0,21453,
+        21456,5,933,0,0,21454,21456,5,389,0,0,21455,21392,1,0,0,0,21455,
+        21403,1,0,0,0,21455,21443,1,0,0,0,21455,21444,1,0,0,0,21455,21446,
+        1,0,0,0,21455,21447,1,0,0,0,21455,21448,1,0,0,0,21455,21449,1,0,
+        0,0,21455,21450,1,0,0,0,21455,21451,1,0,0,0,21455,21452,1,0,0,0,
+        21455,21453,1,0,0,0,21455,21454,1,0,0,0,21456,2421,1,0,0,0,21457,
+        21459,5,2443,0,0,21458,21460,5,2442,0,0,21459,21458,1,0,0,0,21459,
+        21460,1,0,0,0,21460,21463,1,0,0,0,21461,21463,5,2444,0,0,21462,21457,
+        1,0,0,0,21462,21461,1,0,0,0,21463,2423,1,0,0,0,21464,21465,5,2454,
+        0,0,21465,21466,3,2422,1211,0,21466,2425,1,0,0,0,21467,21468,7,303,
+        0,0,21468,2427,1,0,0,0,21469,21470,5,2477,0,0,21470,21472,3,2372,
+        1186,0,21471,21469,1,0,0,0,21471,21472,1,0,0,0,21472,21473,1,0,0,
+        0,21473,21474,3,2430,1215,0,21474,2429,1,0,0,0,21475,21478,3,2436,
+        1218,0,21476,21478,5,2446,0,0,21477,21475,1,0,0,0,21477,21476,1,
+        0,0,0,21478,2431,1,0,0,0,21479,21480,5,2483,0,0,21480,2433,1,0,0,
+        0,21481,21482,5,2449,0,0,21482,21483,5,2453,0,0,21483,21484,5,2450,
+        0,0,21484,2435,1,0,0,0,21485,21617,3,2442,1221,0,21486,21617,3,2440,
+        1220,0,21487,21617,3,2438,1219,0,21488,21617,5,2482,0,0,21489,21617,
+        5,85,0,0,21490,21617,5,790,0,0,21491,21617,5,164,0,0,21492,21617,
+        5,861,0,0,21493,21617,5,1515,0,0,21494,21617,5,1023,0,0,21495,21617,
+        5,588,0,0,21496,21617,5,913,0,0,21497,21617,5,3,0,0,21498,21617,
+        5,36,0,0,21499,21617,5,34,0,0,21500,21617,5,35,0,0,21501,21617,5,
+        46,0,0,21502,21617,5,96,0,0,21503,21617,5,101,0,0,21504,21617,5,
+        108,0,0,21505,21617,5,131,0,0,21506,21617,5,148,0,0,21507,21617,
+        5,213,0,0,21508,21617,5,196,0,0,21509,21617,5,2428,0,0,21510,21617,
+        5,2429,0,0,21511,21617,5,220,0,0,21512,21617,5,288,0,0,21513,21617,
+        5,346,0,0,21514,21617,5,182,0,0,21515,21617,5,314,0,0,21516,21617,
+        5,361,0,0,21517,21617,5,381,0,0,21518,21617,5,403,0,0,21519,21617,
+        5,409,0,0,21520,21617,5,418,0,0,21521,21617,5,420,0,0,21522,21617,
+        5,430,0,0,21523,21617,5,471,0,0,21524,21617,5,2430,0,0,21525,21617,
+        5,480,0,0,21526,21617,5,500,0,0,21527,21617,5,503,0,0,21528,21617,
+        5,523,0,0,21529,21617,5,524,0,0,21530,21617,5,518,0,0,21531,21617,
+        5,535,0,0,21532,21617,5,536,0,0,21533,21617,5,537,0,0,21534,21617,
+        5,546,0,0,21535,21617,5,542,0,0,21536,21617,5,548,0,0,21537,21617,
+        5,2431,0,0,21538,21617,5,589,0,0,21539,21617,5,1725,0,0,21540,21617,
+        5,593,0,0,21541,21617,5,608,0,0,21542,21617,5,616,0,0,21543,21617,
+        5,636,0,0,21544,21617,5,735,0,0,21545,21617,5,751,0,0,21546,21617,
+        5,770,0,0,21547,21617,5,779,0,0,21548,21617,5,811,0,0,21549,21617,
+        5,813,0,0,21550,21617,5,824,0,0,21551,21617,5,894,0,0,21552,21617,
+        5,895,0,0,21553,21617,5,2432,0,0,21554,21617,5,991,0,0,21555,21617,
+        5,902,0,0,21556,21617,5,965,0,0,21557,21617,5,966,0,0,21558,21617,
+        5,1232,0,0,21559,21617,5,1281,0,0,21560,21617,5,1282,0,0,21561,21617,
+        5,1311,0,0,21562,21617,5,1320,0,0,21563,21617,5,1326,0,0,21564,21617,
+        5,1330,0,0,21565,21617,5,1333,0,0,21566,21617,5,1396,0,0,21567,21617,
+        5,1405,0,0,21568,21617,5,1412,0,0,21569,21617,5,1422,0,0,21570,21617,
+        5,1421,0,0,21571,21617,5,1435,0,0,21572,21617,5,1475,0,0,21573,21617,
+        5,1494,0,0,21574,21617,5,1500,0,0,21575,21617,5,1514,0,0,21576,21617,
+        5,1532,0,0,21577,21617,5,1561,0,0,21578,21617,5,1579,0,0,21579,21617,
+        5,1582,0,0,21580,21617,5,1635,0,0,21581,21617,5,1650,0,0,21582,21617,
+        5,1662,0,0,21583,21617,5,1673,0,0,21584,21617,5,1658,0,0,21585,21617,
+        5,1679,0,0,21586,21617,5,1694,0,0,21587,21617,5,1695,0,0,21588,21617,
+        5,1708,0,0,21589,21617,5,2435,0,0,21590,21617,5,1721,0,0,21591,21617,
+        5,1722,0,0,21592,21617,5,1787,0,0,21593,21617,5,2079,0,0,21594,21617,
+        5,2436,0,0,21595,21617,5,2109,0,0,21596,21617,5,2111,0,0,21597,21617,
+        5,2112,0,0,21598,21617,5,2115,0,0,21599,21617,5,2159,0,0,21600,21617,
+        5,2173,0,0,21601,21617,5,2262,0,0,21602,21617,5,2261,0,0,21603,21617,
+        5,2264,0,0,21604,21617,5,2297,0,0,21605,21617,5,2304,0,0,21606,21617,
+        5,2437,0,0,21607,21617,5,2321,0,0,21608,21617,5,2363,0,0,21609,21617,
+        5,2415,0,0,21610,21617,5,2423,0,0,21611,21617,5,2260,0,0,21612,21617,
+        5,2402,0,0,21613,21617,5,363,0,0,21614,21617,5,330,0,0,21615,21617,
+        5,195,0,0,21616,21485,1,0,0,0,21616,21486,1,0,0,0,21616,21487,1,
+        0,0,0,21616,21488,1,0,0,0,21616,21489,1,0,0,0,21616,21490,1,0,0,
+        0,21616,21491,1,0,0,0,21616,21492,1,0,0,0,21616,21493,1,0,0,0,21616,
+        21494,1,0,0,0,21616,21495,1,0,0,0,21616,21496,1,0,0,0,21616,21497,
+        1,0,0,0,21616,21498,1,0,0,0,21616,21499,1,0,0,0,21616,21500,1,0,
+        0,0,21616,21501,1,0,0,0,21616,21502,1,0,0,0,21616,21503,1,0,0,0,
+        21616,21504,1,0,0,0,21616,21505,1,0,0,0,21616,21506,1,0,0,0,21616,
+        21507,1,0,0,0,21616,21508,1,0,0,0,21616,21509,1,0,0,0,21616,21510,
+        1,0,0,0,21616,21511,1,0,0,0,21616,21512,1,0,0,0,21616,21513,1,0,
+        0,0,21616,21514,1,0,0,0,21616,21515,1,0,0,0,21616,21516,1,0,0,0,
+        21616,21517,1,0,0,0,21616,21518,1,0,0,0,21616,21519,1,0,0,0,21616,
+        21520,1,0,0,0,21616,21521,1,0,0,0,21616,21522,1,0,0,0,21616,21523,
+        1,0,0,0,21616,21524,1,0,0,0,21616,21525,1,0,0,0,21616,21526,1,0,
+        0,0,21616,21527,1,0,0,0,21616,21528,1,0,0,0,21616,21529,1,0,0,0,
+        21616,21530,1,0,0,0,21616,21531,1,0,0,0,21616,21532,1,0,0,0,21616,
+        21533,1,0,0,0,21616,21534,1,0,0,0,21616,21535,1,0,0,0,21616,21536,
+        1,0,0,0,21616,21537,1,0,0,0,21616,21538,1,0,0,0,21616,21539,1,0,
+        0,0,21616,21540,1,0,0,0,21616,21541,1,0,0,0,21616,21542,1,0,0,0,
+        21616,21543,1,0,0,0,21616,21544,1,0,0,0,21616,21545,1,0,0,0,21616,
+        21546,1,0,0,0,21616,21547,1,0,0,0,21616,21548,1,0,0,0,21616,21549,
+        1,0,0,0,21616,21550,1,0,0,0,21616,21551,1,0,0,0,21616,21552,1,0,
+        0,0,21616,21553,1,0,0,0,21616,21554,1,0,0,0,21616,21555,1,0,0,0,
+        21616,21556,1,0,0,0,21616,21557,1,0,0,0,21616,21558,1,0,0,0,21616,
+        21559,1,0,0,0,21616,21560,1,0,0,0,21616,21561,1,0,0,0,21616,21562,
+        1,0,0,0,21616,21563,1,0,0,0,21616,21564,1,0,0,0,21616,21565,1,0,
+        0,0,21616,21566,1,0,0,0,21616,21567,1,0,0,0,21616,21568,1,0,0,0,
+        21616,21569,1,0,0,0,21616,21570,1,0,0,0,21616,21571,1,0,0,0,21616,
+        21572,1,0,0,0,21616,21573,1,0,0,0,21616,21574,1,0,0,0,21616,21575,
+        1,0,0,0,21616,21576,1,0,0,0,21616,21577,1,0,0,0,21616,21578,1,0,
+        0,0,21616,21579,1,0,0,0,21616,21580,1,0,0,0,21616,21581,1,0,0,0,
+        21616,21582,1,0,0,0,21616,21583,1,0,0,0,21616,21584,1,0,0,0,21616,
+        21585,1,0,0,0,21616,21586,1,0,0,0,21616,21587,1,0,0,0,21616,21588,
+        1,0,0,0,21616,21589,1,0,0,0,21616,21590,1,0,0,0,21616,21591,1,0,
+        0,0,21616,21592,1,0,0,0,21616,21593,1,0,0,0,21616,21594,1,0,0,0,
+        21616,21595,1,0,0,0,21616,21596,1,0,0,0,21616,21597,1,0,0,0,21616,
+        21598,1,0,0,0,21616,21599,1,0,0,0,21616,21600,1,0,0,0,21616,21601,
+        1,0,0,0,21616,21602,1,0,0,0,21616,21603,1,0,0,0,21616,21604,1,0,
+        0,0,21616,21605,1,0,0,0,21616,21606,1,0,0,0,21616,21607,1,0,0,0,
+        21616,21608,1,0,0,0,21616,21609,1,0,0,0,21616,21610,1,0,0,0,21616,
+        21611,1,0,0,0,21616,21612,1,0,0,0,21616,21613,1,0,0,0,21616,21614,
+        1,0,0,0,21616,21615,1,0,0,0,21617,2437,1,0,0,0,21618,21619,7,304,
+        0,0,21619,2439,1,0,0,0,21620,21621,7,305,0,0,21621,2441,1,0,0,0,
+        21622,21623,7,306,0,0,21623,2443,1,0,0,0,3042,2446,2450,2459,2463,
+        2465,2478,2486,2495,2632,2639,2641,2644,2647,2669,2671,2678,2682,
+        2687,2689,2694,2697,2701,2709,2714,2718,2723,2728,2732,2738,2743,
+        2748,2752,2755,2761,2769,2776,2780,2785,2788,2804,2809,2813,2821,
+        2827,2835,2838,2840,2843,2847,2850,2854,2862,2868,2876,2879,2882,
+        2894,2896,2902,2907,2909,2915,2918,2930,2940,2943,2948,2951,2968,
+        2975,2980,2984,2999,3002,3017,3027,3041,3044,3057,3065,3071,3075,
+        3082,3086,3101,3119,3132,3138,3147,3157,3161,3174,3177,3186,3194,
+        3198,3208,3222,3232,3240,3243,3247,3250,3253,3256,3266,3285,3295,
+        3303,3308,3314,3335,3344,3347,3351,3353,3362,3366,3382,3396,3398,
+        3401,3405,3412,3419,3428,3433,3438,3440,3448,3456,3460,3466,3470,
+        3475,3482,3485,3495,3500,3507,3516,3518,3523,3526,3530,3535,3547,
+        3556,3559,3565,3571,3581,3597,3612,3625,3631,3643,3652,3657,3673,
+        3675,3691,3693,3714,3716,3736,3738,3753,3762,3764,3775,3782,3795,
+        3800,3809,3812,3817,3822,3827,3830,3836,3840,3846,3851,3856,3859,
+        3866,3873,3882,3884,3886,3890,3900,3910,3915,3920,3922,3927,3939,
+        3944,3953,3955,3960,3975,3987,3991,3994,3997,4004,4008,4011,4022,
+        4027,4032,4042,4047,4057,4059,4064,4067,4071,4076,4088,4093,4098,
+        4100,4105,4108,4113,4120,4123,4133,4138,4141,4146,4151,4154,4159,
+        4168,4184,4186,4196,4214,4221,4226,4232,4240,4242,4258,4263,4268,
+        4270,4275,4278,4285,4288,4291,4294,4304,4316,4320,4323,4332,4340,
+        4348,4351,4357,4362,4367,4371,4409,4437,4444,4449,4456,4466,4471,
+        4480,4484,4496,4499,4503,4506,4511,4516,4520,4530,4540,4546,4552,
+        4563,4568,4579,4584,4586,4594,4602,4607,4610,4612,4615,4623,4628,
+        4631,4639,4642,4650,4653,4656,4659,4663,4666,4674,4679,4684,4691,
+        4701,4717,4724,4731,4736,4746,4751,4756,4759,4764,4774,4779,4786,
+        4789,4794,4797,4800,4812,4819,4822,4825,4834,4837,4842,4845,4852,
+        4855,4862,4867,4871,4876,4881,4889,4899,4904,4911,4914,4918,4921,
+        4924,4927,4937,4942,4947,4950,4955,4965,4970,4974,4984,4989,4996,
+        5002,5006,5009,5012,5024,5031,5034,5037,5045,5059,5066,5078,5083,
+        5095,5115,5122,5124,5128,5136,5147,5158,5160,5167,5173,5179,5202,
+        5207,5212,5221,5224,5232,5237,5241,5244,5247,5250,5253,5256,5259,
+        5262,5266,5269,5272,5277,5281,5284,5289,5291,5303,5307,5311,5317,
+        5321,5324,5327,5337,5346,5354,5361,5366,5374,5377,5381,5389,5395,
+        5404,5412,5416,5419,5424,5428,5431,5434,5443,5451,5456,5482,5494,
+        5503,5506,5515,5525,5530,5541,5544,5546,5552,5557,5562,5565,5571,
+        5576,5579,5586,5592,5597,5603,5610,5613,5621,5627,5633,5637,5640,
+        5643,5656,5662,5669,5680,5688,5692,5695,5700,5710,5715,5720,5725,
+        5730,5735,5740,5745,5750,5755,5758,5767,5772,5782,5787,5794,5798,
+        5807,5814,5818,5825,5828,5831,5839,5843,5846,5854,5860,5862,5870,
+        5879,5884,5891,5896,5899,5903,5905,5916,5927,5941,5946,5956,5962,
+        5965,5970,5979,5982,5987,5991,6015,6017,6021,6024,6029,6032,6037,
+        6046,6057,6060,6063,6066,6070,6078,6083,6095,6098,6103,6107,6110,
+        6119,6125,6131,6134,6138,6153,6156,6159,6165,6171,6176,6182,6188,
+        6196,6200,6214,6221,6228,6234,6237,6241,6246,6251,6257,6262,6267,
+        6271,6276,6282,6286,6291,6295,6299,6312,6317,6320,6324,6329,6331,
+        6337,6339,6343,6346,6353,6364,6374,6378,6383,6387,6391,6394,6405,
+        6410,6422,6432,6444,6450,6452,6456,6465,6472,6482,6485,6492,6500,
+        6511,6518,6522,6524,6528,6538,6549,6554,6558,6562,6565,6568,6578,
+        6583,6591,6598,6602,6604,6608,6611,6621,6632,6637,6641,6645,6648,
+        6651,6658,6667,6675,6677,6700,6713,6727,6729,6740,6748,6754,6757,
+        6762,6766,6769,6772,6777,6785,6797,6805,6812,6831,6842,6845,6851,
+        6853,6860,6863,6865,6872,6887,6895,6909,6920,6922,6938,6940,6947,
+        6952,6959,6962,6967,6977,6986,6999,7009,7014,7017,7023,7041,7044,
+        7047,7055,7068,7070,7074,7082,7084,7086,7088,7096,7107,7118,7120,
+        7129,7140,7146,7153,7163,7167,7176,7179,7185,7188,7193,7199,7207,
+        7213,7219,7231,7239,7242,7253,7257,7268,7272,7283,7287,7293,7296,
+        7299,7302,7305,7309,7312,7316,7322,7325,7328,7331,7334,7338,7341,
+        7349,7354,7357,7361,7369,7373,7377,7386,7397,7404,7406,7410,7419,
+        7423,7427,7434,7440,7444,7451,7460,7472,7486,7490,7492,7495,7502,
+        7516,7525,7528,7531,7534,7542,7546,7555,7559,7574,7582,7594,7611,
+        7614,7619,7625,7629,7634,7640,7644,7647,7661,7666,7680,7685,7687,
+        7696,7704,7707,7710,7713,7716,7718,7722,7726,7733,7738,7743,7748,
+        7752,7755,7760,7768,7773,7776,7782,7787,7792,7799,7802,7815,7826,
+        7835,7844,7853,7862,7865,7871,7876,7878,7885,7927,7930,7934,7937,
+        7948,7957,7960,7962,7972,7977,7981,7985,7988,7991,8005,8007,8013,
+        8015,8019,8025,8031,8035,8038,8046,8056,8060,8079,8084,8091,8098,
+        8172,8179,8188,8197,8205,8212,8219,8224,8231,8238,8243,8250,8257,
+        8262,8269,8276,8281,8288,8295,8300,8303,8306,8313,8317,8326,8337,
+        8346,8350,8357,8359,8366,8374,8379,8383,8388,8395,8397,8401,8404,
+        8407,8416,8422,8424,8428,8432,8437,8442,8446,8452,8457,8462,8465,
+        8474,8477,8480,8486,8493,8498,8502,8508,8510,8516,8518,8522,8531,
+        8537,8546,8558,8566,8575,8578,8585,8589,8597,8604,8614,8619,8621,
+        8626,8633,8649,8656,8666,8675,8684,8693,8698,8703,8706,8714,8725,
+        8729,8732,8740,8746,8748,8753,8756,8763,8767,8772,8775,8788,8792,
+        8797,8800,8810,8814,8818,8823,8839,8844,8856,8860,8866,8881,8884,
+        8886,8888,8892,8895,8915,8920,8925,8936,8939,8951,8960,8971,8980,
+        8985,9009,9014,9020,9022,9030,9033,9036,9039,9045,9051,9057,9061,
+        9063,9066,9071,9075,9080,9083,9088,9091,9096,9100,9106,9110,9114,
+        9122,9135,9139,9145,9148,9152,9157,9161,9167,9172,9175,9183,9186,
+        9195,9199,9201,9220,9226,9231,9236,9238,9242,9251,9264,9275,9278,
+        9281,9284,9293,9295,9300,9312,9317,9321,9329,9336,9341,9346,9357,
+        9360,9372,9387,9392,9398,9402,9408,9412,9421,9430,9435,9439,9443,
+        9449,9456,9462,9471,9476,9483,9486,9503,9505,9520,9522,9535,9538,
+        9541,9544,9552,9555,9558,9561,9573,9584,9587,9592,9596,9604,9617,
+        9621,9625,9629,9632,9635,9638,9641,9651,9654,9663,9667,9675,9688,
+        9691,9693,9697,9701,9707,9712,9716,9719,9722,9731,9736,9740,9744,
+        9747,9754,9757,9759,9764,9773,9779,9782,9784,9801,9809,9818,9821,
+        9826,9829,9838,9858,9864,9869,9871,9881,9890,9902,9905,9908,9918,
+        9927,9935,9940,9948,9953,9956,9969,9971,9973,9976,9980,9990,9994,
+        9999,10004,10008,10011,10014,10018,10028,10038,10041,10044,10048,
+        10052,10065,10074,10085,10087,10098,10100,10105,10110,10117,10135,
+        10141,10146,10156,10162,10170,10176,10180,10183,10195,10202,10212,
+        10227,10232,10245,10250,10258,10263,10268,10273,10277,10282,10290,
+        10293,10296,10299,10302,10304,10311,10313,10317,10323,10326,10329,
+        10335,10338,10343,10346,10360,10366,10370,10374,10385,10392,10397,
+        10402,10407,10412,10414,10416,10422,10428,10435,10443,10451,10459,
+        10467,10475,10482,10493,10499,10503,10515,10522,10524,10526,10530,
+        10533,10536,10540,10547,10549,10552,10560,10562,10568,10574,10579,
+        10581,10589,10600,10603,10607,10611,10614,10619,10623,10627,10636,
+        10642,10648,10654,10657,10665,10669,10675,10681,10687,10691,10693,
+        10698,10701,10705,10709,10717,10721,10724,10727,10733,10736,10739,
+        10742,10745,10764,10771,10775,10778,10785,10790,10797,10803,10805,
+        10811,10815,10819,10826,10833,10837,10845,10850,10856,10859,10862,
+        10865,10868,10874,10880,10882,10893,10897,10901,10908,10912,10917,
+        10920,10933,10938,10941,10946,10959,10963,10967,10976,10981,10989,
+        10991,11004,11009,11017,11019,11055,11059,11069,11073,11077,11080,
+        11085,11088,11093,11101,11108,11120,11132,11137,11145,11159,11164,
+        11175,11179,11183,11185,11195,11205,11216,11232,11237,11239,11244,
+        11251,11258,11278,11283,11285,11290,11297,11304,11309,11320,11326,
+        11331,11334,11339,11342,11346,11361,11366,11370,11381,11386,11399,
+        11415,11420,11422,11427,11435,11449,11457,11470,11476,11480,11494,
+        11499,11503,11517,11520,11524,11527,11536,11544,11552,11555,11560,
+        11562,11566,11569,11578,11586,11594,11597,11602,11604,11614,11622,
+        11630,11633,11638,11651,11656,11665,11676,11690,11695,11698,11704,
+        11708,11712,11716,11720,11723,11735,11740,11754,11764,11767,11776,
+        11786,11790,11795,11798,11801,11804,11807,11811,11814,11817,11821,
+        11823,11828,11830,11838,11849,11854,11856,11865,11873,11880,11884,
+        11892,11898,11900,11906,11914,11916,11919,11924,11927,11932,11936,
+        11940,11945,11948,11954,11956,11963,11965,11969,11981,11983,11991,
+        11993,11997,12001,12005,12009,12025,12027,12049,12058,12060,12072,
+        12075,12079,12081,12091,12096,12099,12103,12111,12121,12126,12138,
+        12143,12155,12164,12170,12174,12179,12182,12190,12194,12201,12208,
+        12211,12219,12222,12225,12230,12235,12241,12243,12246,12253,12264,
+        12271,12273,12282,12287,12301,12310,12321,12330,12340,12348,12352,
+        12356,12359,12366,12374,12376,12380,12384,12387,12390,12395,12398,
+        12403,12407,12410,12413,12420,12427,12430,12432,12437,12441,12444,
+        12447,12452,12455,12458,12463,12467,12472,12475,12478,12481,12487,
+        12491,12498,12504,12507,12514,12516,12518,12523,12529,12533,12539,
+        12550,12556,12563,12577,12581,12585,12592,12596,12598,12603,12609,
+        12611,12637,12650,12655,12658,12662,12667,12670,12673,12680,12687,
+        12695,12701,12708,12711,12714,12717,12720,12727,12733,12736,12744,
+        12778,12785,12797,12806,12813,12828,12842,12851,12867,12870,12872,
+        12875,12883,12899,12910,12915,12923,12927,12932,12935,12943,12948,
+        12952,12959,12966,12970,12979,12987,12991,12994,13002,13008,13012,
+        13017,13022,13029,13033,13037,13051,13053,13056,13062,13067,13070,
+        13073,13076,13082,13096,13098,13102,13105,13108,13111,13118,13122,
+        13126,13129,13133,13136,13143,13147,13149,13152,13159,13165,13169,
+        13176,13180,13195,13201,13209,13218,13223,13228,13234,13241,13248,
+        13251,13253,13257,13263,13267,13273,13279,13283,13286,13313,13322,
+        13331,13341,13349,13354,13363,13373,13383,13394,13401,13408,13411,
+        13414,13417,13421,13423,13426,13429,13432,13435,13439,13441,13449,
+        13451,13462,13464,13467,13475,13485,13506,13508,13522,13526,13529,
+        13535,13542,13565,13568,13572,13577,13582,13585,13588,13593,13604,
+        13610,13614,13620,13627,13629,13631,13635,13638,13641,13651,13659,
+        13661,13663,13671,13680,13682,13686,13696,13705,13707,13710,13715,
+        13729,13738,13740,13744,13752,13754,13765,13775,13781,13786,13790,
+        13795,13800,13805,13809,13816,13823,13828,13833,13837,13848,13854,
+        13859,13863,13868,13871,13874,13878,13881,13884,13896,13905,13913,
+        13921,13926,13932,13936,13943,13948,13953,13958,13962,13971,13974,
+        13978,13984,13992,14001,14004,14019,14036,14042,14046,14053,14060,
+        14063,14065,14071,14073,14076,14085,14088,14092,14098,14110,14120,
+        14124,14127,14130,14135,14139,14143,14146,14153,14156,14163,14169,
+        14197,14207,14217,14219,14227,14258,14263,14277,14301,14304,14316,
+        14319,14325,14341,14343,14359,14372,14383,14387,14389,14397,14406,
+        14410,14418,14426,14432,14439,14443,14447,14449,14452,14462,14468,
+        14473,14479,14481,14492,14495,14498,14508,14517,14520,14523,14526,
+        14537,14540,14546,14549,14553,14556,14569,14571,14574,14576,14581,
+        14585,14608,14624,14629,14633,14637,14641,14644,14649,14651,14665,
+        14670,14677,14688,14694,14696,14698,14706,14709,14712,14716,14719,
+        14727,14735,14737,14739,14742,14760,14765,14778,14785,14789,14792,
+        14795,14797,14802,14806,14808,14824,14828,14831,14836,14839,14850,
+        14861,14873,14881,14884,14888,14893,14898,14902,14905,14908,14911,
+        14915,14917,14927,14931,14936,14941,14948,14956,14962,14965,14967,
+        14976,14978,14988,14999,15008,15015,15022,15026,15028,15034,15042,
+        15049,15056,15060,15062,15083,15085,15088,15094,15100,15108,15110,
+        15112,15117,15122,15127,15131,15135,15139,15151,15157,15164,15169,
+        15175,15180,15184,15190,15195,15204,15213,15216,15219,15222,15226,
+        15236,15244,15251,15253,15263,15266,15269,15272,15276,15278,15282,
+        15287,15290,15293,15296,15302,15304,15307,15310,15315,15320,15324,
+        15328,15334,15360,15362,15374,15379,15384,15386,15398,15403,15408,
+        15410,15415,15422,15426,15435,15446,15454,15458,15463,15469,15474,
+        15479,15483,15486,15494,15501,15507,15512,15516,15523,15525,15528,
+        15533,15537,15542,15546,15553,15557,15562,15568,15571,15580,15591,
+        15595,15597,15610,15614,15616,15618,15645,15648,15653,15655,15662,
+        15680,15683,15685,15687,15694,15696,15704,15708,15713,15716,15719,
+        15722,15729,15734,15742,15750,15755,15758,15760,15776,15778,15791,
+        15793,15795,15807,15816,15820,15822,15825,15828,15833,15837,15841,
+        15846,15849,15852,15862,15864,15869,15874,15880,15884,15891,15914,
+        15920,15922,15925,15928,15931,15934,15942,15944,15953,15955,15960,
+        15964,15969,15971,15978,15986,15988,15995,15997,16001,16014,16020,
+        16023,16026,16038,16040,16044,16048,16051,16056,16061,16068,16074,
+        16078,16084,16097,16101,16108,16122,16127,16131,16142,16144,16160,
+        16167,16170,16174,16177,16184,16191,16196,16203,16205,16212,16216,
+        16218,16226,16228,16237,16247,16258,16260,16263,16267,16270,16285,
+        16294,16298,16301,16305,16308,16310,16314,16321,16327,16331,16334,
+        16342,16355,16359,16363,16366,16369,16382,16386,16398,16403,16407,
+        16411,16417,16420,16423,16450,16456,16465,16470,16481,16488,16492,
+        16495,16501,16510,16519,16522,16526,16533,16536,16545,16550,16558,
+        16560,16585,16589,16596,16600,16604,16608,16620,16624,16638,16644,
+        16651,16656,16667,16670,16676,16678,16686,16690,16700,16705,16720,
+        16724,16727,16731,16736,16740,16745,16757,16763,16767,16772,16774,
+        16783,16792,16794,16802,16804,16808,16816,16826,16829,16836,16845,
+        16848,16857,16864,16868,16871,16883,16889,16898,16901,16911,16922,
+        16928,16930,16932,16936,16943,16946,16953,16964,16970,16974,16984,
+        16987,16993,16996,17001,17007,17012,17014,17019,17021,17026,17030,
+        17035,17049,17054,17061,17063,17071,17075,17083,17092,17094,17100,
+        17102,17110,17116,17118,17125,17128,17130,17134,17138,17144,17148,
+        17151,17159,17162,17166,17170,17175,17178,17182,17186,17190,17216,
+        17219,17222,17231,17244,17251,17264,17276,17282,17289,17297,17301,
+        17305,17311,17315,17318,17321,17325,17327,17331,17334,17337,17340,
+        17348,17351,17362,17364,17371,17378,17383,17389,17394,17399,17406,
+        17412,17419,17422,17425,17429,17434,17438,17440,17446,17456,17463,
+        17467,17477,17492,17494,17498,17506,17513,17521,17524,17529,17539,
+        17547,17550,17556,17561,17564,17569,17574,17580,17589,17596,17606,
+        17611,17613,17618,17622,17628,17632,17645,17649,17659,17662,17664,
+        17669,17678,17691,17699,17703,17712,17716,17721,17732,17734,17750,
+        17755,17761,17767,17785,17792,17795,17798,17806,17809,17817,17819,
+        17823,17826,17831,17833,17837,17849,17858,17866,17871,17875,17885,
+        17887,17893,17898,17901,17911,17917,17920,17923,17931,17941,17951,
+        17955,17959,17962,17965,17970,17975,17978,17981,17987,17990,17996,
+        17999,18002,18007,18010,18018,18024,18029,18032,18046,18050,18063,
+        18067,18069,18072,18075,18087,18091,18094,18109,18113,18125,18128,
+        18137,18144,18149,18153,18161,18167,18175,18178,18187,18190,18193,
+        18202,18208,18214,18217,18222,18228,18240,18251,18253,18262,18264,
+        18268,18274,18278,18291,18298,18303,18319,18321,18325,18329,18333,
+        18346,18350,18357,18365,18368,18373,18375,18380,18384,18387,18393,
+        18398,18410,18414,18416,18421,18431,18433,18435,18445,18449,18451,
+        18463,18471,18484,18487,18492,18510,18512,18520,18528,18535,18539,
+        18542,18549,18553,18558,18562,18570,18574,18581,18586,18595,18604,
+        18607,18627,18629,18631,18640,18653,18658,18677,18679,18689,18694,
+        18697,18704,18707,18711,18714,18717,18723,18726,18730,18733,18745,
+        18752,18755,18759,18765,18768,18772,18787,18795,18805,18812,18825,
+        18830,18839,18848,18852,18856,18882,18885,18888,18898,18906,18912,
+        18914,18918,18925,18934,18938,18941,18944,18953,18956,18959,18962,
+        18965,18977,18985,18992,18995,18999,19001,19004,19009,19018,19024,
+        19027,19030,19039,19042,19045,19048,19054,19058,19070,19080,19084,
+        19087,19093,19097,19103,19107,19110,19113,19115,19122,19126,19129,
+        19132,19135,19140,19143,19147,19156,19160,19167,19171,19176,19181,
+        19184,19193,19197,19208,19211,19215,19220,19224,19233,19236,19240,
+        19249,19252,19256,19261,19270,19273,19277,19285,19290,19295,19298,
+        19302,19304,19313,19320,19323,19330,19332,19335,19338,19342,19345,
+        19350,19357,19363,19371,19375,19378,19381,19387,19390,19394,19398,
+        19403,19406,19409,19418,19430,19437,19440,19446,19449,19452,19461,
+        19464,19470,19477,19479,19492,19499,19504,19509,19515,19521,19524,
+        19526,19531,19539,19541,19548,19554,19559,19565,19570,19576,19588,
+        19594,19598,19603,19608,19614,19617,19621,19631,19641,19647,19649,
+        19659,19661,19668,19672,19681,19686,19691,19694,19703,19706,19715,
+        19729,19736,19744,19747,19760,19766,19768,19781,19790,19796,19806,
+        19814,19820,19823,19826,19840,19842,19850,19857,19867,19875,19881,
+        19884,19889,19894,19898,19906,19913,19922,19929,19938,19942,19949,
+        19956,19963,19970,19978,19982,19989,19998,20001,20004,20007,20011,
+        20016,20021,20032,20036,20038,20049,20051,20062,20073,20082,20085,
+        20095,20099,20108,20118,20128,20136,20142,20150,20157,20161,20166,
+        20170,20175,20179,20185,20188,20195,20205,20213,20217,20227,20230,
+        20232,20239,20245,20251,20257,20259,20273,20275,20288,20293,20296,
+        20303,20308,20320,20329,20331,20338,20341,20348,20363,20366,20370,
+        20372,20380,20388,20390,20397,20402,20406,20410,20414,20418,20423,
+        20427,20430,20434,20441,20445,20450,20455,20459,20464,20481,20486,
+        20493,20504,20511,20518,20522,20529,20534,20543,20551,20559,20565,
+        20570,20575,20579,20584,20587,20592,20596,20600,20607,20612,20623,
+        20629,20634,20638,20640,20647,20651,20657,20665,20668,20673,20680,
+        20698,20715,20722,20735,20739,20747,20750,20754,20759,20764,20768,
+        20771,20775,20782,20787,20789,20791,20801,20806,20810,20813,20817,
+        20826,20832,20836,20838,20842,20846,20853,20861,20869,20871,20876,
+        20881,20883,20886,20910,20917,20922,20955,20960,20963,20968,20970,
+        20976,20985,20992,20996,21001,21006,21011,21016,21023,21028,21062,
+        21069,21084,21100,21119,21136,21143,21151,21164,21173,21182,21191,
+        21201,21209,21219,21229,21241,21257,21275,21288,21303,21314,21324,
+        21335,21345,21362,21368,21390,21395,21401,21407,21413,21418,21420,
+        21423,21434,21437,21439,21441,21455,21459,21462,21471,21477,21616
+    ];
+
+    private static __ATN: antlr.ATN;
+    public static get _ATN(): antlr.ATN {
+        if (!PlSqlParser.__ATN) {
+            PlSqlParser.__ATN = new antlr.ATNDeserializer().deserialize(PlSqlParser._serializedATN);
+        }
+
+        return PlSqlParser.__ATN;
+    }
+
+
+    private static readonly vocabulary = new antlr.Vocabulary(PlSqlParser.literalNames, PlSqlParser.symbolicNames, []);
+
+    public override get vocabulary(): antlr.Vocabulary {
+        return PlSqlParser.vocabulary;
+    }
+
+    private static readonly decisionsToDFA = PlSqlParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
+}
+
+export class Sql_scriptContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EOF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EOF, 0)!;
+    }
+    public sql_plus_command(): Sql_plus_commandContext[];
+    public sql_plus_command(i: number): Sql_plus_commandContext | null;
+    public sql_plus_command(i?: number): Sql_plus_commandContext[] | Sql_plus_commandContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sql_plus_commandContext);
+        }
+
+        return this.getRuleContext(i, Sql_plus_commandContext);
+    }
+    public script_unit(): Script_unitContext[];
+    public script_unit(i: number): Script_unitContext | null;
+    public script_unit(i?: number): Script_unitContext[] | Script_unitContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Script_unitContext);
+        }
+
+        return this.getRuleContext(i, Script_unitContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode[];
+    public SEMICOLON(i: number): antlr.TerminalNode | null;
+    public SEMICOLON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SEMICOLON);
+    	} else {
+    		return this.getToken(PlSqlParser.SEMICOLON, i);
+    	}
+    }
+    public terminator(): TerminatorContext[];
+    public terminator(i: number): TerminatorContext | null;
+    public terminator(i?: number): TerminatorContext[] | TerminatorContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TerminatorContext);
+        }
+
+        return this.getRuleContext(i, TerminatorContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_script;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_script) {
+             listener.enterSql_script(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_script) {
+             listener.exitSql_script(this);
+        }
+    }
+}
+
+
+export class Script_unitContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public plsql_unit(): Plsql_unitContext | null {
+        return this.getRuleContext(0, Plsql_unitContext);
+    }
+    public sql_unit(): Sql_unitContext | null {
+        return this.getRuleContext(0, Sql_unitContext);
+    }
+    public sql_plus_command(): Sql_plus_commandContext | null {
+        return this.getRuleContext(0, Sql_plus_commandContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_script_unit;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterScript_unit) {
+             listener.enterScript_unit(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitScript_unit) {
+             listener.exitScript_unit(this);
+        }
+    }
+}
+
+
+export class TerminatorContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SEMICOLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMICOLON, 0);
+    }
+    public SOLIDUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOLIDUS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_terminator;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTerminator) {
+             listener.enterTerminator(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTerminator) {
+             listener.exitTerminator(this);
+        }
+    }
+}
+
+
+export class Plsql_unitContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public anonymous_block(): Anonymous_blockContext | null {
+        return this.getRuleContext(0, Anonymous_blockContext);
+    }
+    public create_function_body(): Create_function_bodyContext | null {
+        return this.getRuleContext(0, Create_function_bodyContext);
+    }
+    public create_procedure_body(): Create_procedure_bodyContext | null {
+        return this.getRuleContext(0, Create_procedure_bodyContext);
+    }
+    public create_package(): Create_packageContext | null {
+        return this.getRuleContext(0, Create_packageContext);
+    }
+    public create_package_body(): Create_package_bodyContext | null {
+        return this.getRuleContext(0, Create_package_bodyContext);
+    }
+    public create_trigger(): Create_triggerContext | null {
+        return this.getRuleContext(0, Create_triggerContext);
+    }
+    public create_type_body(): Create_type_bodyContext | null {
+        return this.getRuleContext(0, Create_type_bodyContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_plsql_unit;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPlsql_unit) {
+             listener.enterPlsql_unit(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPlsql_unit) {
+             listener.exitPlsql_unit(this);
+        }
+    }
+}
+
+
+export class Sql_unitContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public alter_analytic_view(): Alter_analytic_viewContext | null {
+        return this.getRuleContext(0, Alter_analytic_viewContext);
+    }
+    public alter_attribute_dimension(): Alter_attribute_dimensionContext | null {
+        return this.getRuleContext(0, Alter_attribute_dimensionContext);
+    }
+    public alter_audit_policy(): Alter_audit_policyContext | null {
+        return this.getRuleContext(0, Alter_audit_policyContext);
+    }
+    public alter_cluster(): Alter_clusterContext | null {
+        return this.getRuleContext(0, Alter_clusterContext);
+    }
+    public alter_database(): Alter_databaseContext | null {
+        return this.getRuleContext(0, Alter_databaseContext);
+    }
+    public alter_database_link(): Alter_database_linkContext | null {
+        return this.getRuleContext(0, Alter_database_linkContext);
+    }
+    public alter_dimension(): Alter_dimensionContext | null {
+        return this.getRuleContext(0, Alter_dimensionContext);
+    }
+    public alter_diskgroup(): Alter_diskgroupContext | null {
+        return this.getRuleContext(0, Alter_diskgroupContext);
+    }
+    public alter_flashback_archive(): Alter_flashback_archiveContext | null {
+        return this.getRuleContext(0, Alter_flashback_archiveContext);
+    }
+    public alter_function(): Alter_functionContext | null {
+        return this.getRuleContext(0, Alter_functionContext);
+    }
+    public alter_hierarchy(): Alter_hierarchyContext | null {
+        return this.getRuleContext(0, Alter_hierarchyContext);
+    }
+    public alter_index(): Alter_indexContext | null {
+        return this.getRuleContext(0, Alter_indexContext);
+    }
+    public alter_inmemory_join_group(): Alter_inmemory_join_groupContext | null {
+        return this.getRuleContext(0, Alter_inmemory_join_groupContext);
+    }
+    public alter_java(): Alter_javaContext | null {
+        return this.getRuleContext(0, Alter_javaContext);
+    }
+    public alter_library(): Alter_libraryContext | null {
+        return this.getRuleContext(0, Alter_libraryContext);
+    }
+    public alter_lockdown_profile(): Alter_lockdown_profileContext | null {
+        return this.getRuleContext(0, Alter_lockdown_profileContext);
+    }
+    public alter_materialized_view(): Alter_materialized_viewContext | null {
+        return this.getRuleContext(0, Alter_materialized_viewContext);
+    }
+    public alter_materialized_view_log(): Alter_materialized_view_logContext | null {
+        return this.getRuleContext(0, Alter_materialized_view_logContext);
+    }
+    public alter_materialized_zonemap(): Alter_materialized_zonemapContext | null {
+        return this.getRuleContext(0, Alter_materialized_zonemapContext);
+    }
+    public alter_operator(): Alter_operatorContext | null {
+        return this.getRuleContext(0, Alter_operatorContext);
+    }
+    public alter_outline(): Alter_outlineContext | null {
+        return this.getRuleContext(0, Alter_outlineContext);
+    }
+    public alter_package(): Alter_packageContext | null {
+        return this.getRuleContext(0, Alter_packageContext);
+    }
+    public alter_pmem_filestore(): Alter_pmem_filestoreContext | null {
+        return this.getRuleContext(0, Alter_pmem_filestoreContext);
+    }
+    public alter_procedure(): Alter_procedureContext | null {
+        return this.getRuleContext(0, Alter_procedureContext);
+    }
+    public alter_resource_cost(): Alter_resource_costContext | null {
+        return this.getRuleContext(0, Alter_resource_costContext);
+    }
+    public alter_role(): Alter_roleContext | null {
+        return this.getRuleContext(0, Alter_roleContext);
+    }
+    public alter_rollback_segment(): Alter_rollback_segmentContext | null {
+        return this.getRuleContext(0, Alter_rollback_segmentContext);
+    }
+    public alter_sequence(): Alter_sequenceContext | null {
+        return this.getRuleContext(0, Alter_sequenceContext);
+    }
+    public alter_session(): Alter_sessionContext | null {
+        return this.getRuleContext(0, Alter_sessionContext);
+    }
+    public alter_synonym(): Alter_synonymContext | null {
+        return this.getRuleContext(0, Alter_synonymContext);
+    }
+    public alter_table(): Alter_tableContext | null {
+        return this.getRuleContext(0, Alter_tableContext);
+    }
+    public alter_tablespace(): Alter_tablespaceContext | null {
+        return this.getRuleContext(0, Alter_tablespaceContext);
+    }
+    public alter_tablespace_set(): Alter_tablespace_setContext | null {
+        return this.getRuleContext(0, Alter_tablespace_setContext);
+    }
+    public alter_trigger(): Alter_triggerContext | null {
+        return this.getRuleContext(0, Alter_triggerContext);
+    }
+    public alter_type(): Alter_typeContext | null {
+        return this.getRuleContext(0, Alter_typeContext);
+    }
+    public alter_user(): Alter_userContext | null {
+        return this.getRuleContext(0, Alter_userContext);
+    }
+    public alter_view(): Alter_viewContext | null {
+        return this.getRuleContext(0, Alter_viewContext);
+    }
+    public call_statement(): Call_statementContext | null {
+        return this.getRuleContext(0, Call_statementContext);
+    }
+    public create_analytic_view(): Create_analytic_viewContext | null {
+        return this.getRuleContext(0, Create_analytic_viewContext);
+    }
+    public create_attribute_dimension(): Create_attribute_dimensionContext | null {
+        return this.getRuleContext(0, Create_attribute_dimensionContext);
+    }
+    public create_audit_policy(): Create_audit_policyContext | null {
+        return this.getRuleContext(0, Create_audit_policyContext);
+    }
+    public create_cluster(): Create_clusterContext | null {
+        return this.getRuleContext(0, Create_clusterContext);
+    }
+    public create_context(): Create_contextContext | null {
+        return this.getRuleContext(0, Create_contextContext);
+    }
+    public create_controlfile(): Create_controlfileContext | null {
+        return this.getRuleContext(0, Create_controlfileContext);
+    }
+    public create_schema(): Create_schemaContext | null {
+        return this.getRuleContext(0, Create_schemaContext);
+    }
+    public create_database(): Create_databaseContext | null {
+        return this.getRuleContext(0, Create_databaseContext);
+    }
+    public create_database_link(): Create_database_linkContext | null {
+        return this.getRuleContext(0, Create_database_linkContext);
+    }
+    public create_dimension(): Create_dimensionContext | null {
+        return this.getRuleContext(0, Create_dimensionContext);
+    }
+    public create_directory(): Create_directoryContext | null {
+        return this.getRuleContext(0, Create_directoryContext);
+    }
+    public create_diskgroup(): Create_diskgroupContext | null {
+        return this.getRuleContext(0, Create_diskgroupContext);
+    }
+    public create_edition(): Create_editionContext | null {
+        return this.getRuleContext(0, Create_editionContext);
+    }
+    public create_flashback_archive(): Create_flashback_archiveContext | null {
+        return this.getRuleContext(0, Create_flashback_archiveContext);
+    }
+    public create_hierarchy(): Create_hierarchyContext | null {
+        return this.getRuleContext(0, Create_hierarchyContext);
+    }
+    public create_index(): Create_indexContext | null {
+        return this.getRuleContext(0, Create_indexContext);
+    }
+    public create_inmemory_join_group(): Create_inmemory_join_groupContext | null {
+        return this.getRuleContext(0, Create_inmemory_join_groupContext);
+    }
+    public create_java(): Create_javaContext | null {
+        return this.getRuleContext(0, Create_javaContext);
+    }
+    public create_library(): Create_libraryContext | null {
+        return this.getRuleContext(0, Create_libraryContext);
+    }
+    public create_lockdown_profile(): Create_lockdown_profileContext | null {
+        return this.getRuleContext(0, Create_lockdown_profileContext);
+    }
+    public create_materialized_view(): Create_materialized_viewContext | null {
+        return this.getRuleContext(0, Create_materialized_viewContext);
+    }
+    public create_materialized_view_log(): Create_materialized_view_logContext | null {
+        return this.getRuleContext(0, Create_materialized_view_logContext);
+    }
+    public create_materialized_zonemap(): Create_materialized_zonemapContext | null {
+        return this.getRuleContext(0, Create_materialized_zonemapContext);
+    }
+    public create_operator(): Create_operatorContext | null {
+        return this.getRuleContext(0, Create_operatorContext);
+    }
+    public create_outline(): Create_outlineContext | null {
+        return this.getRuleContext(0, Create_outlineContext);
+    }
+    public create_pmem_filestore(): Create_pmem_filestoreContext | null {
+        return this.getRuleContext(0, Create_pmem_filestoreContext);
+    }
+    public create_profile(): Create_profileContext | null {
+        return this.getRuleContext(0, Create_profileContext);
+    }
+    public create_restore_point(): Create_restore_pointContext | null {
+        return this.getRuleContext(0, Create_restore_pointContext);
+    }
+    public create_role(): Create_roleContext | null {
+        return this.getRuleContext(0, Create_roleContext);
+    }
+    public create_rollback_segment(): Create_rollback_segmentContext | null {
+        return this.getRuleContext(0, Create_rollback_segmentContext);
+    }
+    public create_sequence(): Create_sequenceContext | null {
+        return this.getRuleContext(0, Create_sequenceContext);
+    }
+    public create_spfile(): Create_spfileContext | null {
+        return this.getRuleContext(0, Create_spfileContext);
+    }
+    public create_synonym(): Create_synonymContext | null {
+        return this.getRuleContext(0, Create_synonymContext);
+    }
+    public create_table(): Create_tableContext | null {
+        return this.getRuleContext(0, Create_tableContext);
+    }
+    public create_tablespace(): Create_tablespaceContext | null {
+        return this.getRuleContext(0, Create_tablespaceContext);
+    }
+    public create_tablespace_set(): Create_tablespace_setContext | null {
+        return this.getRuleContext(0, Create_tablespace_setContext);
+    }
+    public create_type_spec(): Create_type_specContext | null {
+        return this.getRuleContext(0, Create_type_specContext);
+    }
+    public create_user(): Create_userContext | null {
+        return this.getRuleContext(0, Create_userContext);
+    }
+    public create_view(): Create_viewContext | null {
+        return this.getRuleContext(0, Create_viewContext);
+    }
+    public drop_analytic_view(): Drop_analytic_viewContext | null {
+        return this.getRuleContext(0, Drop_analytic_viewContext);
+    }
+    public drop_attribute_dimension(): Drop_attribute_dimensionContext | null {
+        return this.getRuleContext(0, Drop_attribute_dimensionContext);
+    }
+    public drop_audit_policy(): Drop_audit_policyContext | null {
+        return this.getRuleContext(0, Drop_audit_policyContext);
+    }
+    public drop_cluster(): Drop_clusterContext | null {
+        return this.getRuleContext(0, Drop_clusterContext);
+    }
+    public drop_context(): Drop_contextContext | null {
+        return this.getRuleContext(0, Drop_contextContext);
+    }
+    public drop_database(): Drop_databaseContext | null {
+        return this.getRuleContext(0, Drop_databaseContext);
+    }
+    public drop_database_link(): Drop_database_linkContext | null {
+        return this.getRuleContext(0, Drop_database_linkContext);
+    }
+    public drop_directory(): Drop_directoryContext | null {
+        return this.getRuleContext(0, Drop_directoryContext);
+    }
+    public drop_diskgroup(): Drop_diskgroupContext | null {
+        return this.getRuleContext(0, Drop_diskgroupContext);
+    }
+    public drop_edition(): Drop_editionContext | null {
+        return this.getRuleContext(0, Drop_editionContext);
+    }
+    public drop_flashback_archive(): Drop_flashback_archiveContext | null {
+        return this.getRuleContext(0, Drop_flashback_archiveContext);
+    }
+    public drop_function(): Drop_functionContext | null {
+        return this.getRuleContext(0, Drop_functionContext);
+    }
+    public drop_hierarchy(): Drop_hierarchyContext | null {
+        return this.getRuleContext(0, Drop_hierarchyContext);
+    }
+    public drop_index(): Drop_indexContext | null {
+        return this.getRuleContext(0, Drop_indexContext);
+    }
+    public drop_indextype(): Drop_indextypeContext | null {
+        return this.getRuleContext(0, Drop_indextypeContext);
+    }
+    public drop_inmemory_join_group(): Drop_inmemory_join_groupContext | null {
+        return this.getRuleContext(0, Drop_inmemory_join_groupContext);
+    }
+    public drop_java(): Drop_javaContext | null {
+        return this.getRuleContext(0, Drop_javaContext);
+    }
+    public drop_library(): Drop_libraryContext | null {
+        return this.getRuleContext(0, Drop_libraryContext);
+    }
+    public drop_lockdown_profile(): Drop_lockdown_profileContext | null {
+        return this.getRuleContext(0, Drop_lockdown_profileContext);
+    }
+    public drop_materialized_view(): Drop_materialized_viewContext | null {
+        return this.getRuleContext(0, Drop_materialized_viewContext);
+    }
+    public drop_materialized_view_log(): Drop_materialized_view_logContext | null {
+        return this.getRuleContext(0, Drop_materialized_view_logContext);
+    }
+    public drop_materialized_zonemap(): Drop_materialized_zonemapContext | null {
+        return this.getRuleContext(0, Drop_materialized_zonemapContext);
+    }
+    public drop_operator(): Drop_operatorContext | null {
+        return this.getRuleContext(0, Drop_operatorContext);
+    }
+    public drop_outline(): Drop_outlineContext | null {
+        return this.getRuleContext(0, Drop_outlineContext);
+    }
+    public drop_package(): Drop_packageContext | null {
+        return this.getRuleContext(0, Drop_packageContext);
+    }
+    public drop_pmem_filestore(): Drop_pmem_filestoreContext | null {
+        return this.getRuleContext(0, Drop_pmem_filestoreContext);
+    }
+    public drop_procedure(): Drop_procedureContext | null {
+        return this.getRuleContext(0, Drop_procedureContext);
+    }
+    public drop_restore_point(): Drop_restore_pointContext | null {
+        return this.getRuleContext(0, Drop_restore_pointContext);
+    }
+    public drop_role(): Drop_roleContext | null {
+        return this.getRuleContext(0, Drop_roleContext);
+    }
+    public drop_rollback_segment(): Drop_rollback_segmentContext | null {
+        return this.getRuleContext(0, Drop_rollback_segmentContext);
+    }
+    public drop_sequence(): Drop_sequenceContext | null {
+        return this.getRuleContext(0, Drop_sequenceContext);
+    }
+    public drop_synonym(): Drop_synonymContext | null {
+        return this.getRuleContext(0, Drop_synonymContext);
+    }
+    public drop_table(): Drop_tableContext | null {
+        return this.getRuleContext(0, Drop_tableContext);
+    }
+    public drop_tablespace(): Drop_tablespaceContext | null {
+        return this.getRuleContext(0, Drop_tablespaceContext);
+    }
+    public drop_tablespace_set(): Drop_tablespace_setContext | null {
+        return this.getRuleContext(0, Drop_tablespace_setContext);
+    }
+    public drop_trigger(): Drop_triggerContext | null {
+        return this.getRuleContext(0, Drop_triggerContext);
+    }
+    public drop_type(): Drop_typeContext | null {
+        return this.getRuleContext(0, Drop_typeContext);
+    }
+    public drop_user(): Drop_userContext | null {
+        return this.getRuleContext(0, Drop_userContext);
+    }
+    public drop_view(): Drop_viewContext | null {
+        return this.getRuleContext(0, Drop_viewContext);
+    }
+    public administer_key_management(): Administer_key_managementContext | null {
+        return this.getRuleContext(0, Administer_key_managementContext);
+    }
+    public analyze(): AnalyzeContext | null {
+        return this.getRuleContext(0, AnalyzeContext);
+    }
+    public associate_statistics(): Associate_statisticsContext | null {
+        return this.getRuleContext(0, Associate_statisticsContext);
+    }
+    public audit_traditional(): Audit_traditionalContext | null {
+        return this.getRuleContext(0, Audit_traditionalContext);
+    }
+    public comment_on_column(): Comment_on_columnContext | null {
+        return this.getRuleContext(0, Comment_on_columnContext);
+    }
+    public comment_on_materialized(): Comment_on_materializedContext | null {
+        return this.getRuleContext(0, Comment_on_materializedContext);
+    }
+    public comment_on_table(): Comment_on_tableContext | null {
+        return this.getRuleContext(0, Comment_on_tableContext);
+    }
+    public data_manipulation_language_statements(): Data_manipulation_language_statementsContext | null {
+        return this.getRuleContext(0, Data_manipulation_language_statementsContext);
+    }
+    public disassociate_statistics(): Disassociate_statisticsContext | null {
+        return this.getRuleContext(0, Disassociate_statisticsContext);
+    }
+    public flashback_table(): Flashback_tableContext | null {
+        return this.getRuleContext(0, Flashback_tableContext);
+    }
+    public grant_statement(): Grant_statementContext | null {
+        return this.getRuleContext(0, Grant_statementContext);
+    }
+    public noaudit_statement(): Noaudit_statementContext | null {
+        return this.getRuleContext(0, Noaudit_statementContext);
+    }
+    public purge_statement(): Purge_statementContext | null {
+        return this.getRuleContext(0, Purge_statementContext);
+    }
+    public rename_object(): Rename_objectContext | null {
+        return this.getRuleContext(0, Rename_objectContext);
+    }
+    public revoke_statement(): Revoke_statementContext | null {
+        return this.getRuleContext(0, Revoke_statementContext);
+    }
+    public transaction_control_statements(): Transaction_control_statementsContext | null {
+        return this.getRuleContext(0, Transaction_control_statementsContext);
+    }
+    public truncate_cluster(): Truncate_clusterContext | null {
+        return this.getRuleContext(0, Truncate_clusterContext);
+    }
+    public truncate_table(): Truncate_tableContext | null {
+        return this.getRuleContext(0, Truncate_tableContext);
+    }
+    public unified_auditing(): Unified_auditingContext | null {
+        return this.getRuleContext(0, Unified_auditingContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_unit;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_unit) {
+             listener.enterSql_unit(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_unit) {
+             listener.exitSql_unit(this);
+        }
+    }
+}
+
+
+export class Alter_diskgroupContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public DISKGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISKGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public undrop_disk_clause(): Undrop_disk_clauseContext | null {
+        return this.getRuleContext(0, Undrop_disk_clauseContext);
+    }
+    public diskgroup_availability(): Diskgroup_availabilityContext | null {
+        return this.getRuleContext(0, Diskgroup_availabilityContext);
+    }
+    public enable_disable_volume(): Enable_disable_volumeContext | null {
+        return this.getRuleContext(0, Enable_disable_volumeContext);
+    }
+    public resize_disk_clause(): Resize_disk_clauseContext | null {
+        return this.getRuleContext(0, Resize_disk_clauseContext);
+    }
+    public replace_disk_clause(): Replace_disk_clauseContext | null {
+        return this.getRuleContext(0, Replace_disk_clauseContext);
+    }
+    public rename_disk_clause(): Rename_disk_clauseContext | null {
+        return this.getRuleContext(0, Rename_disk_clauseContext);
+    }
+    public disk_online_clause(): Disk_online_clauseContext | null {
+        return this.getRuleContext(0, Disk_online_clauseContext);
+    }
+    public disk_offline_clause(): Disk_offline_clauseContext | null {
+        return this.getRuleContext(0, Disk_offline_clauseContext);
+    }
+    public rebalance_diskgroup_clause(): Rebalance_diskgroup_clauseContext | null {
+        return this.getRuleContext(0, Rebalance_diskgroup_clauseContext);
+    }
+    public check_diskgroup_clause(): Check_diskgroup_clauseContext | null {
+        return this.getRuleContext(0, Check_diskgroup_clauseContext);
+    }
+    public diskgroup_template_clauses(): Diskgroup_template_clausesContext | null {
+        return this.getRuleContext(0, Diskgroup_template_clausesContext);
+    }
+    public diskgroup_directory_clauses(): Diskgroup_directory_clausesContext | null {
+        return this.getRuleContext(0, Diskgroup_directory_clausesContext);
+    }
+    public diskgroup_alias_clauses(): Diskgroup_alias_clausesContext | null {
+        return this.getRuleContext(0, Diskgroup_alias_clausesContext);
+    }
+    public diskgroup_volume_clauses(): Diskgroup_volume_clausesContext | null {
+        return this.getRuleContext(0, Diskgroup_volume_clausesContext);
+    }
+    public diskgroup_attributes(): Diskgroup_attributesContext | null {
+        return this.getRuleContext(0, Diskgroup_attributesContext);
+    }
+    public drop_diskgroup_file_clause(): Drop_diskgroup_file_clauseContext | null {
+        return this.getRuleContext(0, Drop_diskgroup_file_clauseContext);
+    }
+    public convert_redundancy_clause(): Convert_redundancy_clauseContext | null {
+        return this.getRuleContext(0, Convert_redundancy_clauseContext);
+    }
+    public usergroup_clauses(): Usergroup_clausesContext | null {
+        return this.getRuleContext(0, Usergroup_clausesContext);
+    }
+    public user_clauses(): User_clausesContext | null {
+        return this.getRuleContext(0, User_clausesContext);
+    }
+    public file_permissions_clause(): File_permissions_clauseContext | null {
+        return this.getRuleContext(0, File_permissions_clauseContext);
+    }
+    public file_owner_clause(): File_owner_clauseContext | null {
+        return this.getRuleContext(0, File_owner_clauseContext);
+    }
+    public scrub_clause(): Scrub_clauseContext | null {
+        return this.getRuleContext(0, Scrub_clauseContext);
+    }
+    public quotagroup_clauses(): Quotagroup_clausesContext | null {
+        return this.getRuleContext(0, Quotagroup_clausesContext);
+    }
+    public filegroup_clauses(): Filegroup_clausesContext | null {
+        return this.getRuleContext(0, Filegroup_clausesContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public add_disk_clause(): Add_disk_clauseContext[];
+    public add_disk_clause(i: number): Add_disk_clauseContext | null;
+    public add_disk_clause(i?: number): Add_disk_clauseContext[] | Add_disk_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Add_disk_clauseContext);
+        }
+
+        return this.getRuleContext(i, Add_disk_clauseContext);
+    }
+    public drop_disk_clause(): Drop_disk_clauseContext[];
+    public drop_disk_clause(i: number): Drop_disk_clauseContext | null;
+    public drop_disk_clause(i?: number): Drop_disk_clauseContext[] | Drop_disk_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Drop_disk_clauseContext);
+        }
+
+        return this.getRuleContext(i, Drop_disk_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_diskgroup;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_diskgroup) {
+             listener.enterAlter_diskgroup(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_diskgroup) {
+             listener.exitAlter_diskgroup(this);
+        }
+    }
+}
+
+
+export class Add_disk_clauseContext extends antlr.ParserRuleContext {
+    public _sn?: Id_expressionContext;
+    public _fgn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public DISK(): antlr.TerminalNode[];
+    public DISK(i: number): antlr.TerminalNode | null;
+    public DISK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISK);
+    	} else {
+    		return this.getToken(PlSqlParser.DISK, i);
+    	}
+    }
+    public qualified_disk_clause(): Qualified_disk_clauseContext[];
+    public qualified_disk_clause(i: number): Qualified_disk_clauseContext | null;
+    public qualified_disk_clause(i?: number): Qualified_disk_clauseContext[] | Qualified_disk_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Qualified_disk_clauseContext);
+        }
+
+        return this.getRuleContext(i, Qualified_disk_clauseContext);
+    }
+    public SITE(): antlr.TerminalNode[];
+    public SITE(i: number): antlr.TerminalNode | null;
+    public SITE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SITE);
+    	} else {
+    		return this.getToken(PlSqlParser.SITE, i);
+    	}
+    }
+    public quorum_regular(): Quorum_regularContext[];
+    public quorum_regular(i: number): Quorum_regularContext | null;
+    public quorum_regular(i?: number): Quorum_regularContext[] | Quorum_regularContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quorum_regularContext);
+        }
+
+        return this.getRuleContext(i, Quorum_regularContext);
+    }
+    public FAILGROUP(): antlr.TerminalNode[];
+    public FAILGROUP(i: number): antlr.TerminalNode | null;
+    public FAILGROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FAILGROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.FAILGROUP, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_disk_clause) {
+             listener.enterAdd_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_disk_clause) {
+             listener.exitAdd_disk_clause(this);
+        }
+    }
+}
+
+
+export class Drop_disk_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public DISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISK, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public DISKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISKS, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public FAILGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILGROUP, 0);
+    }
+    public quorum_regular(): Quorum_regularContext | null {
+        return this.getRuleContext(0, Quorum_regularContext);
+    }
+    public force_noforce(): Force_noforceContext[];
+    public force_noforce(i: number): Force_noforceContext | null;
+    public force_noforce(i?: number): Force_noforceContext[] | Force_noforceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Force_noforceContext);
+        }
+
+        return this.getRuleContext(i, Force_noforceContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_disk_clause) {
+             listener.enterDrop_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_disk_clause) {
+             listener.exitDrop_disk_clause(this);
+        }
+    }
+}
+
+
+export class Resize_disk_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RESIZE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESIZE, 0)!;
+    }
+    public ALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALL, 0)!;
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_resize_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterResize_disk_clause) {
+             listener.enterResize_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitResize_disk_clause) {
+             listener.exitResize_disk_clause(this);
+        }
+    }
+}
+
+
+export class Replace_disk_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REPLACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REPLACE, 0)!;
+    }
+    public DISK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISK, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public force_noforce(): Force_noforceContext[];
+    public force_noforce(i: number): Force_noforceContext | null;
+    public force_noforce(i?: number): Force_noforceContext[] | Force_noforceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Force_noforceContext);
+        }
+
+        return this.getRuleContext(i, Force_noforceContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public POWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWER, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public wait_nowait(): Wait_nowaitContext | null {
+        return this.getRuleContext(0, Wait_nowaitContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_replace_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReplace_disk_clause) {
+             listener.enterReplace_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReplace_disk_clause) {
+             listener.exitReplace_disk_clause(this);
+        }
+    }
+}
+
+
+export class Wait_nowaitContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WAIT, 0);
+    }
+    public NOWAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOWAIT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_wait_nowait;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWait_nowait) {
+             listener.enterWait_nowait(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWait_nowait) {
+             listener.exitWait_nowait(this);
+        }
+    }
+}
+
+
+export class Rename_disk_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RENAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RENAME, 0)!;
+    }
+    public DISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISK, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public TO(): antlr.TerminalNode[];
+    public TO(i: number): antlr.TerminalNode | null;
+    public TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TO);
+    	} else {
+    		return this.getToken(PlSqlParser.TO, i);
+    	}
+    }
+    public DISKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISKS, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rename_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRename_disk_clause) {
+             listener.enterRename_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRename_disk_clause) {
+             listener.exitRename_disk_clause(this);
+        }
+    }
+}
+
+
+export class Disk_online_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ONLINE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ONLINE, 0)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public POWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWER, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public wait_nowait(): Wait_nowaitContext | null {
+        return this.getRuleContext(0, Wait_nowaitContext);
+    }
+    public DISK(): antlr.TerminalNode[];
+    public DISK(i: number): antlr.TerminalNode | null;
+    public DISK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISK);
+    	} else {
+    		return this.getToken(PlSqlParser.DISK, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public DISKS(): antlr.TerminalNode[];
+    public DISKS(i: number): antlr.TerminalNode | null;
+    public DISKS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISKS);
+    	} else {
+    		return this.getToken(PlSqlParser.DISKS, i);
+    	}
+    }
+    public IN(): antlr.TerminalNode[];
+    public IN(i: number): antlr.TerminalNode | null;
+    public IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IN);
+    	} else {
+    		return this.getToken(PlSqlParser.IN, i);
+    	}
+    }
+    public FAILGROUP(): antlr.TerminalNode[];
+    public FAILGROUP(i: number): antlr.TerminalNode | null;
+    public FAILGROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FAILGROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.FAILGROUP, i);
+    	}
+    }
+    public quorum_regular(): Quorum_regularContext[];
+    public quorum_regular(i: number): Quorum_regularContext | null;
+    public quorum_regular(i?: number): Quorum_regularContext[] | Quorum_regularContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quorum_regularContext);
+        }
+
+        return this.getRuleContext(i, Quorum_regularContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_disk_online_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDisk_online_clause) {
+             listener.enterDisk_online_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDisk_online_clause) {
+             listener.exitDisk_online_clause(this);
+        }
+    }
+}
+
+
+export class Disk_offline_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OFFLINE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OFFLINE, 0)!;
+    }
+    public DISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISK, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public DISKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISKS, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public FAILGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILGROUP, 0);
+    }
+    public timeout_clause(): Timeout_clauseContext | null {
+        return this.getRuleContext(0, Timeout_clauseContext);
+    }
+    public quorum_regular(): Quorum_regularContext | null {
+        return this.getRuleContext(0, Quorum_regularContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_disk_offline_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDisk_offline_clause) {
+             listener.enterDisk_offline_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDisk_offline_clause) {
+             listener.exitDisk_offline_clause(this);
+        }
+    }
+}
+
+
+export class Timeout_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public AFTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AFTER, 0)!;
+    }
+    public numeric(): NumericContext {
+        return this.getRuleContext(0, NumericContext)!;
+    }
+    public M_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.M_LETTER, 0);
+    }
+    public H_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.H_LETTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_timeout_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTimeout_clause) {
+             listener.enterTimeout_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTimeout_clause) {
+             listener.exitTimeout_clause(this);
+        }
+    }
+}
+
+
+export class Rebalance_diskgroup_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REBALANCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REBALANCE, 0)!;
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public POWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWER, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public WAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WAIT, 0);
+    }
+    public NOWAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOWAIT, 0);
+    }
+    public phase(): PhaseContext[];
+    public phase(i: number): PhaseContext | null;
+    public phase(i?: number): PhaseContext[] | PhaseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(PhaseContext);
+        }
+
+        return this.getRuleContext(i, PhaseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rebalance_diskgroup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRebalance_diskgroup_clause) {
+             listener.enterRebalance_diskgroup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRebalance_diskgroup_clause) {
+             listener.exitRebalance_diskgroup_clause(this);
+        }
+    }
+}
+
+
+export class PhaseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_phase;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPhase) {
+             listener.enterPhase(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPhase) {
+             listener.exitPhase(this);
+        }
+    }
+}
+
+
+export class Check_diskgroup_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHECK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHECK, 0)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public REPAIR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPAIR, 0);
+    }
+    public NOREPAIR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREPAIR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_check_diskgroup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCheck_diskgroup_clause) {
+             listener.enterCheck_diskgroup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCheck_diskgroup_clause) {
+             listener.exitCheck_diskgroup_clause(this);
+        }
+    }
+}
+
+
+export class Diskgroup_template_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TEMPLATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TEMPLATE, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public qualified_template_clause(): Qualified_template_clauseContext[];
+    public qualified_template_clause(i: number): Qualified_template_clauseContext | null;
+    public qualified_template_clause(i?: number): Qualified_template_clauseContext[] | Qualified_template_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Qualified_template_clauseContext);
+        }
+
+        return this.getRuleContext(i, Qualified_template_clauseContext);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_diskgroup_template_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDiskgroup_template_clauses) {
+             listener.enterDiskgroup_template_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDiskgroup_template_clauses) {
+             listener.exitDiskgroup_template_clauses(this);
+        }
+    }
+}
+
+
+export class Qualified_template_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ATTRIBUTES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public redundancy_clause(): Redundancy_clauseContext | null {
+        return this.getRuleContext(0, Redundancy_clauseContext);
+    }
+    public striping_clause(): Striping_clauseContext | null {
+        return this.getRuleContext(0, Striping_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_qualified_template_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQualified_template_clause) {
+             listener.enterQualified_template_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQualified_template_clause) {
+             listener.exitQualified_template_clause(this);
+        }
+    }
+}
+
+
+export class Redundancy_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MIRROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIRROR, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public UNPROTECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNPROTECTED, 0);
+    }
+    public PARITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARITY, 0);
+    }
+    public DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_redundancy_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRedundancy_clause) {
+             listener.enterRedundancy_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRedundancy_clause) {
+             listener.exitRedundancy_clause(this);
+        }
+    }
+}
+
+
+export class Striping_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINE, 0);
+    }
+    public COARSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COARSE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_striping_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStriping_clause) {
+             listener.enterStriping_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStriping_clause) {
+             listener.exitStriping_clause(this);
+        }
+    }
+}
+
+
+export class Force_noforceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public NOFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOFORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_force_noforce;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterForce_noforce) {
+             listener.enterForce_noforce(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitForce_noforce) {
+             listener.exitForce_noforce(this);
+        }
+    }
+}
+
+
+export class Diskgroup_directory_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIRECTORY, 0)!;
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public force_noforce(): Force_noforceContext[];
+    public force_noforce(i: number): Force_noforceContext | null;
+    public force_noforce(i?: number): Force_noforceContext[] | Force_noforceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Force_noforceContext);
+        }
+
+        return this.getRuleContext(i, Force_noforceContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public dir_name(): Dir_nameContext[];
+    public dir_name(i: number): Dir_nameContext | null;
+    public dir_name(i?: number): Dir_nameContext[] | Dir_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Dir_nameContext);
+        }
+
+        return this.getRuleContext(i, Dir_nameContext);
+    }
+    public TO(): antlr.TerminalNode[];
+    public TO(i: number): antlr.TerminalNode | null;
+    public TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TO);
+    	} else {
+    		return this.getToken(PlSqlParser.TO, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_diskgroup_directory_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDiskgroup_directory_clauses) {
+             listener.enterDiskgroup_directory_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDiskgroup_directory_clauses) {
+             listener.exitDiskgroup_directory_clauses(this);
+        }
+    }
+}
+
+
+export class Dir_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dir_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDir_name) {
+             listener.enterDir_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDir_name) {
+             listener.exitDir_name(this);
+        }
+    }
+}
+
+
+export class Diskgroup_alias_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public ALIAS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALIAS, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public FOR(): antlr.TerminalNode[];
+    public FOR(i: number): antlr.TerminalNode | null;
+    public FOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FOR);
+    	} else {
+    		return this.getToken(PlSqlParser.FOR, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode[];
+    public TO(i: number): antlr.TerminalNode | null;
+    public TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TO);
+    	} else {
+    		return this.getToken(PlSqlParser.TO, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_diskgroup_alias_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDiskgroup_alias_clauses) {
+             listener.enterDiskgroup_alias_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDiskgroup_alias_clauses) {
+             listener.exitDiskgroup_alias_clauses(this);
+        }
+    }
+}
+
+
+export class Diskgroup_volume_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_volume_clause(): Add_volume_clauseContext | null {
+        return this.getRuleContext(0, Add_volume_clauseContext);
+    }
+    public modify_volume_clause(): Modify_volume_clauseContext | null {
+        return this.getRuleContext(0, Modify_volume_clauseContext);
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public VOLUME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VOLUME, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_diskgroup_volume_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDiskgroup_volume_clauses) {
+             listener.enterDiskgroup_volume_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDiskgroup_volume_clauses) {
+             listener.exitDiskgroup_volume_clauses(this);
+        }
+    }
+}
+
+
+export class Add_volume_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public VOLUME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VOLUME, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public SIZE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SIZE, 0)!;
+    }
+    public size_clause(): Size_clauseContext {
+        return this.getRuleContext(0, Size_clauseContext)!;
+    }
+    public redundancy_clause(): Redundancy_clauseContext | null {
+        return this.getRuleContext(0, Redundancy_clauseContext);
+    }
+    public STRIPE_WIDTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRIPE_WIDTH, 0);
+    }
+    public numeric(): NumericContext[];
+    public numeric(i: number): NumericContext | null;
+    public numeric(i?: number): NumericContext[] | NumericContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(NumericContext);
+        }
+
+        return this.getRuleContext(i, NumericContext);
+    }
+    public STRIPE_COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRIPE_COLUMNS, 0);
+    }
+    public K_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.K_LETTER, 0);
+    }
+    public M_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.M_LETTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_volume_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_volume_clause) {
+             listener.enterAdd_volume_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_volume_clause) {
+             listener.exitAdd_volume_clause(this);
+        }
+    }
+}
+
+
+export class Modify_volume_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public VOLUME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VOLUME, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public MOUNTPATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNTPATH, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public USAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USAGE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_volume_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_volume_clause) {
+             listener.enterModify_volume_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_volume_clause) {
+             listener.exitModify_volume_clause(this);
+        }
+    }
+}
+
+
+export class Diskgroup_attributesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public ATTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_diskgroup_attributes;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDiskgroup_attributes) {
+             listener.enterDiskgroup_attributes(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDiskgroup_attributes) {
+             listener.exitDiskgroup_attributes(this);
+        }
+    }
+}
+
+
+export class Drop_diskgroup_file_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public FILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILE, 0)!;
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_diskgroup_file_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_diskgroup_file_clause) {
+             listener.enterDrop_diskgroup_file_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_diskgroup_file_clause) {
+             listener.exitDrop_diskgroup_file_clause(this);
+        }
+    }
+}
+
+
+export class Convert_redundancy_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONVERT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONVERT, 0)!;
+    }
+    public REDUNDANCY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REDUNDANCY, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public FLEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLEX, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_convert_redundancy_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConvert_redundancy_clause) {
+             listener.enterConvert_redundancy_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConvert_redundancy_clause) {
+             listener.exitConvert_redundancy_clause(this);
+        }
+    }
+}
+
+
+export class Usergroup_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public USERGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USERGROUP, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_usergroup_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsergroup_clauses) {
+             listener.enterUsergroup_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsergroup_clauses) {
+             listener.exitUsergroup_clauses(this);
+        }
+    }
+}
+
+
+export class User_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public USER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USER, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_user_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUser_clauses) {
+             listener.enterUser_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUser_clauses) {
+             listener.exitUser_clauses(this);
+        }
+    }
+}
+
+
+export class File_permissions_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public PERMISSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PERMISSION, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode[];
+    public EQUALS_OP(i: number): antlr.TerminalNode | null;
+    public EQUALS_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EQUALS_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.EQUALS_OP, i);
+    	}
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public FILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILE, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public OWNER(): antlr.TerminalNode[];
+    public OWNER(i: number): antlr.TerminalNode | null;
+    public OWNER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OWNER);
+    	} else {
+    		return this.getToken(PlSqlParser.OWNER, i);
+    	}
+    }
+    public GROUP(): antlr.TerminalNode[];
+    public GROUP(i: number): antlr.TerminalNode | null;
+    public GROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.GROUP, i);
+    	}
+    }
+    public OTHER(): antlr.TerminalNode[];
+    public OTHER(i: number): antlr.TerminalNode | null;
+    public OTHER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OTHER);
+    	} else {
+    		return this.getToken(PlSqlParser.OTHER, i);
+    	}
+    }
+    public NONE(): antlr.TerminalNode[];
+    public NONE(i: number): antlr.TerminalNode | null;
+    public NONE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NONE);
+    	} else {
+    		return this.getToken(PlSqlParser.NONE, i);
+    	}
+    }
+    public READ(): antlr.TerminalNode[];
+    public READ(i: number): antlr.TerminalNode | null;
+    public READ(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.READ);
+    	} else {
+    		return this.getToken(PlSqlParser.READ, i);
+    	}
+    }
+    public ONLY(): antlr.TerminalNode[];
+    public ONLY(i: number): antlr.TerminalNode | null;
+    public ONLY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ONLY);
+    	} else {
+    		return this.getToken(PlSqlParser.ONLY, i);
+    	}
+    }
+    public WRITE(): antlr.TerminalNode[];
+    public WRITE(i: number): antlr.TerminalNode | null;
+    public WRITE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WRITE);
+    	} else {
+    		return this.getToken(PlSqlParser.WRITE, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_file_permissions_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFile_permissions_clause) {
+             listener.enterFile_permissions_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFile_permissions_clause) {
+             listener.exitFile_permissions_clause(this);
+        }
+    }
+}
+
+
+export class File_owner_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public OWNERSHIP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OWNERSHIP, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode[];
+    public EQUALS_OP(i: number): antlr.TerminalNode | null;
+    public EQUALS_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EQUALS_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.EQUALS_OP, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public FILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILE, 0)!;
+    }
+    public OWNER(): antlr.TerminalNode[];
+    public OWNER(i: number): antlr.TerminalNode | null;
+    public OWNER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OWNER);
+    	} else {
+    		return this.getToken(PlSqlParser.OWNER, i);
+    	}
+    }
+    public GROUP(): antlr.TerminalNode[];
+    public GROUP(i: number): antlr.TerminalNode | null;
+    public GROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.GROUP, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_file_owner_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFile_owner_clause) {
+             listener.enterFile_owner_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFile_owner_clause) {
+             listener.exitFile_owner_clause(this);
+        }
+    }
+}
+
+
+export class Scrub_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SCRUB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SCRUB, 0)!;
+    }
+    public FILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public DISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISK, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public POWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWER, 0);
+    }
+    public wait_nowait(): Wait_nowaitContext | null {
+        return this.getRuleContext(0, Wait_nowaitContext);
+    }
+    public force_noforce(): Force_noforceContext | null {
+        return this.getRuleContext(0, Force_noforceContext);
+    }
+    public STOP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STOP, 0);
+    }
+    public REPAIR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPAIR, 0);
+    }
+    public NOREPAIR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREPAIR, 0);
+    }
+    public AUTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAX, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_scrub_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterScrub_clause) {
+             listener.enterScrub_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitScrub_clause) {
+             listener.exitScrub_clause(this);
+        }
+    }
+}
+
+
+export class Quotagroup_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public QUOTAGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.QUOTAGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public property_name(): Property_nameContext | null {
+        return this.getRuleContext(0, Property_nameContext);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public property_value(): Property_valueContext | null {
+        return this.getRuleContext(0, Property_valueContext);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public MOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOVE, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_quotagroup_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuotagroup_clauses) {
+             listener.enterQuotagroup_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuotagroup_clauses) {
+             listener.exitQuotagroup_clauses(this);
+        }
+    }
+}
+
+
+export class Property_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_property_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProperty_name) {
+             listener.enterProperty_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProperty_name) {
+             listener.exitProperty_name(this);
+        }
+    }
+}
+
+
+export class Property_valueContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_property_value;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProperty_value) {
+             listener.enterProperty_value(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProperty_value) {
+             listener.exitProperty_value(this);
+        }
+    }
+}
+
+
+export class Filegroup_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_filegroup_clause(): Add_filegroup_clauseContext | null {
+        return this.getRuleContext(0, Add_filegroup_clauseContext);
+    }
+    public modify_filegroup_clause(): Modify_filegroup_clauseContext | null {
+        return this.getRuleContext(0, Modify_filegroup_clauseContext);
+    }
+    public move_to_filegroup_clause(): Move_to_filegroup_clauseContext | null {
+        return this.getRuleContext(0, Move_to_filegroup_clauseContext);
+    }
+    public drop_filegroup_clause(): Drop_filegroup_clauseContext | null {
+        return this.getRuleContext(0, Drop_filegroup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filegroup_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilegroup_clauses) {
+             listener.enterFilegroup_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilegroup_clauses) {
+             listener.exitFilegroup_clauses(this);
+        }
+    }
+}
+
+
+export class Add_filegroup_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public FILEGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILEGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public TEMPLATE(): antlr.TerminalNode[];
+    public TEMPLATE(i: number): antlr.TerminalNode | null;
+    public TEMPLATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TEMPLATE);
+    	} else {
+    		return this.getToken(PlSqlParser.TEMPLATE, i);
+    	}
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public VOLUME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VOLUME, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_filegroup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_filegroup_clause) {
+             listener.enterAdd_filegroup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_filegroup_clause) {
+             listener.exitAdd_filegroup_clause(this);
+        }
+    }
+}
+
+
+export class Modify_filegroup_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public FILEGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILEGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_filegroup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_filegroup_clause) {
+             listener.enterModify_filegroup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_filegroup_clause) {
+             listener.exitModify_filegroup_clause(this);
+        }
+    }
+}
+
+
+export class Move_to_filegroup_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVE, 0)!;
+    }
+    public FILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILE, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public FILEGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILEGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_move_to_filegroup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMove_to_filegroup_clause) {
+             listener.enterMove_to_filegroup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMove_to_filegroup_clause) {
+             listener.exitMove_to_filegroup_clause(this);
+        }
+    }
+}
+
+
+export class Drop_filegroup_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public FILEGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILEGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_filegroup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_filegroup_clause) {
+             listener.enterDrop_filegroup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_filegroup_clause) {
+             listener.exitDrop_filegroup_clause(this);
+        }
+    }
+}
+
+
+export class Quorum_regularContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public QUORUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUORUM, 0);
+    }
+    public REGULAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGULAR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_quorum_regular;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuorum_regular) {
+             listener.enterQuorum_regular(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuorum_regular) {
+             listener.exitQuorum_regular(this);
+        }
+    }
+}
+
+
+export class Undrop_disk_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNDROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNDROP, 0)!;
+    }
+    public DISKS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISKS, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_undrop_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUndrop_disk_clause) {
+             listener.enterUndrop_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUndrop_disk_clause) {
+             listener.exitUndrop_disk_clause(this);
+        }
+    }
+}
+
+
+export class Diskgroup_availabilityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNT, 0);
+    }
+    public RESTRICTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICTED, 0);
+    }
+    public NORMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORMAL, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public NOFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOFORCE, 0);
+    }
+    public DISMOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISMOUNT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_diskgroup_availability;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDiskgroup_availability) {
+             listener.enterDiskgroup_availability(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDiskgroup_availability) {
+             listener.exitDiskgroup_availability(this);
+        }
+    }
+}
+
+
+export class Enable_disable_volumeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VOLUME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VOLUME, 0)!;
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_enable_disable_volume;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEnable_disable_volume) {
+             listener.enterEnable_disable_volume(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEnable_disable_volume) {
+             listener.exitEnable_disable_volume(this);
+        }
+    }
+}
+
+
+export class Drop_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_function) {
+             listener.enterDrop_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_function) {
+             listener.exitDrop_function(this);
+        }
+    }
+}
+
+
+export class Alter_flashback_archiveContext extends antlr.ParserRuleContext {
+    public _fa?: Id_expressionContext;
+    public _ts?: Id_expressionContext;
+    public _rts?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public FLASHBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLASHBACK, 0)!;
+    }
+    public ARCHIVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ARCHIVE, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public flashback_archive_retention(): Flashback_archive_retentionContext | null {
+        return this.getRuleContext(0, Flashback_archive_retentionContext);
+    }
+    public PURGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PURGE, 0);
+    }
+    public OPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIMIZE, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public flashback_archive_quota(): Flashback_archive_quotaContext | null {
+        return this.getRuleContext(0, Flashback_archive_quotaContext);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public SCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCN, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_flashback_archive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_flashback_archive) {
+             listener.enterAlter_flashback_archive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_flashback_archive) {
+             listener.exitAlter_flashback_archive(this);
+        }
+    }
+}
+
+
+export class Alter_hierarchyContext extends antlr.ParserRuleContext {
+    public _hn?: Id_expressionContext;
+    public _nhn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public HIERARCHY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHY, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_hierarchy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_hierarchy) {
+             listener.enterAlter_hierarchy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_hierarchy) {
+             listener.exitAlter_hierarchy(this);
+        }
+    }
+}
+
+
+export class Alter_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext[];
+    public compiler_parameters_clause(i: number): Compiler_parameters_clauseContext | null;
+    public compiler_parameters_clause(i?: number): Compiler_parameters_clauseContext[] | Compiler_parameters_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compiler_parameters_clauseContext);
+        }
+
+        return this.getRuleContext(i, Compiler_parameters_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_function) {
+             listener.enterAlter_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_function) {
+             listener.exitAlter_function(this);
+        }
+    }
+}
+
+
+export class Alter_javaContext extends antlr.ParserRuleContext {
+    public _o?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public JAVA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JAVA, 0)!;
+    }
+    public SOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE, 0);
+    }
+    public CLASS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASS, 0);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public RESOLVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOLVE, 0);
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext | null {
+        return this.getRuleContext(0, Invoker_rights_clauseContext);
+    }
+    public schema_name(): Schema_nameContext[];
+    public schema_name(i: number): Schema_nameContext | null;
+    public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Schema_nameContext);
+        }
+
+        return this.getRuleContext(i, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public RESOLVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOLVER, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public match_string(): Match_stringContext[];
+    public match_string(i: number): Match_stringContext | null;
+    public match_string(i?: number): Match_stringContext[] | Match_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Match_stringContext);
+        }
+
+        return this.getRuleContext(i, Match_stringContext);
+    }
+    public MINUS_SIGN(): antlr.TerminalNode[];
+    public MINUS_SIGN(i: number): antlr.TerminalNode | null;
+    public MINUS_SIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MINUS_SIGN);
+    	} else {
+    		return this.getToken(PlSqlParser.MINUS_SIGN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_java;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_java) {
+             listener.enterAlter_java(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_java) {
+             listener.exitAlter_java(this);
+        }
+    }
+}
+
+
+export class Match_stringContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_match_string;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMatch_string) {
+             listener.enterMatch_string(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMatch_string) {
+             listener.exitMatch_string(this);
+        }
+    }
+}
+
+
+export class Create_function_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public aggregate_clause(): Aggregate_clauseContext | null {
+        return this.getRuleContext(0, Aggregate_clauseContext);
+    }
+    public pipelined_using_clause(): Pipelined_using_clauseContext | null {
+        return this.getRuleContext(0, Pipelined_using_clauseContext);
+    }
+    public sql_macro_body(): Sql_macro_bodyContext | null {
+        return this.getRuleContext(0, Sql_macro_bodyContext);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter(): ParameterContext[];
+    public parameter(i: number): ParameterContext | null;
+    public parameter(i?: number): ParameterContext[] | ParameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ParameterContext);
+        }
+
+        return this.getRuleContext(i, ParameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext[];
+    public invoker_rights_clause(i: number): Invoker_rights_clauseContext | null;
+    public invoker_rights_clause(i?: number): Invoker_rights_clauseContext[] | Invoker_rights_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Invoker_rights_clauseContext);
+        }
+
+        return this.getRuleContext(i, Invoker_rights_clauseContext);
+    }
+    public accessible_by_clause(): Accessible_by_clauseContext[];
+    public accessible_by_clause(i: number): Accessible_by_clauseContext | null;
+    public accessible_by_clause(i?: number): Accessible_by_clauseContext[] | Accessible_by_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Accessible_by_clauseContext);
+        }
+
+        return this.getRuleContext(i, Accessible_by_clauseContext);
+    }
+    public default_collation_clause(): Default_collation_clauseContext[];
+    public default_collation_clause(i: number): Default_collation_clauseContext | null;
+    public default_collation_clause(i?: number): Default_collation_clauseContext[] | Default_collation_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Default_collation_clauseContext);
+        }
+
+        return this.getRuleContext(i, Default_collation_clauseContext);
+    }
+    public parallel_enable_clause(): Parallel_enable_clauseContext[];
+    public parallel_enable_clause(i: number): Parallel_enable_clauseContext | null;
+    public parallel_enable_clause(i?: number): Parallel_enable_clauseContext[] | Parallel_enable_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_enable_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_enable_clauseContext);
+    }
+    public result_cache_clause(): Result_cache_clauseContext[];
+    public result_cache_clause(i: number): Result_cache_clauseContext | null;
+    public result_cache_clause(i?: number): Result_cache_clauseContext[] | Result_cache_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Result_cache_clauseContext);
+        }
+
+        return this.getRuleContext(i, Result_cache_clauseContext);
+    }
+    public PIPELINED(): antlr.TerminalNode[];
+    public PIPELINED(i: number): antlr.TerminalNode | null;
+    public PIPELINED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PIPELINED);
+    	} else {
+    		return this.getToken(PlSqlParser.PIPELINED, i);
+    	}
+    }
+    public DETERMINISTIC(): antlr.TerminalNode[];
+    public DETERMINISTIC(i: number): antlr.TerminalNode | null;
+    public DETERMINISTIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINISTIC);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINISTIC, i);
+    	}
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_function_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_function_body) {
+             listener.enterCreate_function_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_function_body) {
+             listener.exitCreate_function_body(this);
+        }
+    }
+}
+
+
+export class Sql_macro_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SQL_MACRO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SQL_MACRO, 0)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public BEGIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BEGIN, 0)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public quoted_string(): Quoted_stringContext {
+        return this.getRuleContext(0, Quoted_stringContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_macro_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_macro_body) {
+             listener.enterSql_macro_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_macro_body) {
+             listener.exitSql_macro_body(this);
+        }
+    }
+}
+
+
+export class Parallel_enable_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARALLEL_ENABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARALLEL_ENABLE, 0)!;
+    }
+    public partition_by_clause(): Partition_by_clauseContext | null {
+        return this.getRuleContext(0, Partition_by_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parallel_enable_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParallel_enable_clause) {
+             listener.enterParallel_enable_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParallel_enable_clause) {
+             listener.exitParallel_enable_clause(this);
+        }
+    }
+}
+
+
+export class Partition_by_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public ANY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANY, 0);
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASH, 0);
+    }
+    public RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANGE, 0);
+    }
+    public LIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIST, 0);
+    }
+    public streaming_clause(): Streaming_clauseContext | null {
+        return this.getRuleContext(0, Streaming_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_by_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_by_clause) {
+             listener.enterPartition_by_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_by_clause) {
+             listener.exitPartition_by_clause(this);
+        }
+    }
+}
+
+
+export class Result_cache_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RESULT_CACHE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESULT_CACHE, 0)!;
+    }
+    public relies_on_part(): Relies_on_partContext | null {
+        return this.getRuleContext(0, Relies_on_partContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public MODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODE, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_result_cache_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterResult_cache_clause) {
+             listener.enterResult_cache_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitResult_cache_clause) {
+             listener.exitResult_cache_clause(this);
+        }
+    }
+}
+
+
+export class Accessible_by_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACCESSIBLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ACCESSIBLE, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public accessor(): AccessorContext[];
+    public accessor(i: number): AccessorContext | null;
+    public accessor(i?: number): AccessorContext[] | AccessorContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(AccessorContext);
+        }
+
+        return this.getRuleContext(i, AccessorContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_accessible_by_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAccessible_by_clause) {
+             listener.enterAccessible_by_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAccessible_by_clause) {
+             listener.exitAccessible_by_clause(this);
+        }
+    }
+}
+
+
+export class Default_collation_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public COLLATION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLLATION, 0)!;
+    }
+    public USING_NLS_COMP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING_NLS_COMP, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_collation_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_collation_clause) {
+             listener.enterDefault_collation_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_collation_clause) {
+             listener.exitDefault_collation_clause(this);
+        }
+    }
+}
+
+
+export class Aggregate_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AGGREGATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AGGREGATE, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public implementation_type_name(): Implementation_type_nameContext {
+        return this.getRuleContext(0, Implementation_type_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_aggregate_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAggregate_clause) {
+             listener.enterAggregate_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAggregate_clause) {
+             listener.exitAggregate_clause(this);
+        }
+    }
+}
+
+
+export class Pipelined_using_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PIPELINED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PIPELINED, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public implementation_type_name(): Implementation_type_nameContext {
+        return this.getRuleContext(0, Implementation_type_nameContext)!;
+    }
+    public POLYMORPHIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POLYMORPHIC, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pipelined_using_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPipelined_using_clause) {
+             listener.enterPipelined_using_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPipelined_using_clause) {
+             listener.exitPipelined_using_clause(this);
+        }
+    }
+}
+
+
+export class AccessorContext extends antlr.ParserRuleContext {
+    public _unitKind?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FUNCTION, 0);
+    }
+    public PROCEDURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURE, 0);
+    }
+    public PACKAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PACKAGE, 0);
+    }
+    public TRIGGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIGGER, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_accessor;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAccessor) {
+             listener.enterAccessor(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAccessor) {
+             listener.exitAccessor(this);
+        }
+    }
+}
+
+
+export class Relies_on_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RELIES_ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RELIES_ON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext[];
+    public tableview_name(i: number): Tableview_nameContext | null;
+    public tableview_name(i?: number): Tableview_nameContext[] | Tableview_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tableview_nameContext);
+        }
+
+        return this.getRuleContext(i, Tableview_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relies_on_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelies_on_part) {
+             listener.enterRelies_on_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelies_on_part) {
+             listener.exitRelies_on_part(this);
+        }
+    }
+}
+
+
+export class Streaming_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public paren_column_list(): Paren_column_listContext {
+        return this.getRuleContext(0, Paren_column_listContext)!;
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_streaming_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStreaming_clause) {
+             listener.enterStreaming_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStreaming_clause) {
+             listener.exitStreaming_clause(this);
+        }
+    }
+}
+
+
+export class Alter_outlineContext extends antlr.ParserRuleContext {
+    public _o?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public OUTLINE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OUTLINE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public outline_options(): Outline_optionsContext[];
+    public outline_options(i: number): Outline_optionsContext | null;
+    public outline_options(i?: number): Outline_optionsContext[] | Outline_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Outline_optionsContext);
+        }
+
+        return this.getRuleContext(i, Outline_optionsContext);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public PRIVATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_outline;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_outline) {
+             listener.enterAlter_outline(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_outline) {
+             listener.exitAlter_outline(this);
+        }
+    }
+}
+
+
+export class Outline_optionsContext extends antlr.ParserRuleContext {
+    public _non?: Id_expressionContext;
+    public _ncn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REBUILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REBUILD, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHANGE, 0);
+    }
+    public CATEGORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CATEGORY, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_outline_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOutline_options) {
+             listener.enterOutline_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOutline_options) {
+             listener.exitOutline_options(this);
+        }
+    }
+}
+
+
+export class Alter_lockdown_profileContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public LOCKDOWN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCKDOWN, 0)!;
+    }
+    public PROFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROFILE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public lockdown_feature(): Lockdown_featureContext | null {
+        return this.getRuleContext(0, Lockdown_featureContext);
+    }
+    public lockdown_options(): Lockdown_optionsContext | null {
+        return this.getRuleContext(0, Lockdown_optionsContext);
+    }
+    public lockdown_statements(): Lockdown_statementsContext | null {
+        return this.getRuleContext(0, Lockdown_statementsContext);
+    }
+    public USERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USERS, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COMMON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMON, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_lockdown_profile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_lockdown_profile) {
+             listener.enterAlter_lockdown_profile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_lockdown_profile) {
+             listener.exitAlter_lockdown_profile(this);
+        }
+    }
+}
+
+
+export class Lockdown_featureContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public disable_enable(): Disable_enableContext {
+        return this.getRuleContext(0, Disable_enableContext)!;
+    }
+    public FEATURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FEATURE, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_list(): String_listContext | null {
+        return this.getRuleContext(0, String_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lockdown_feature;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLockdown_feature) {
+             listener.enterLockdown_feature(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLockdown_feature) {
+             listener.exitLockdown_feature(this);
+        }
+    }
+}
+
+
+export class Lockdown_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public disable_enable(): Disable_enableContext {
+        return this.getRuleContext(0, Disable_enableContext)!;
+    }
+    public OPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPTION, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_list(): String_listContext | null {
+        return this.getRuleContext(0, String_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lockdown_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLockdown_options) {
+             listener.enterLockdown_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLockdown_options) {
+             listener.exitLockdown_options(this);
+        }
+    }
+}
+
+
+export class Lockdown_statementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public disable_enable(): Disable_enableContext {
+        return this.getRuleContext(0, Disable_enableContext)!;
+    }
+    public STATEMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STATEMENT, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_list(): String_listContext | null {
+        return this.getRuleContext(0, String_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public statement_clauses(): Statement_clausesContext | null {
+        return this.getRuleContext(0, Statement_clausesContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lockdown_statements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLockdown_statements) {
+             listener.enterLockdown_statements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLockdown_statements) {
+             listener.exitLockdown_statements(this);
+        }
+    }
+}
+
+
+export class Statement_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CLAUSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLAUSE, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_list(): String_listContext | null {
+        return this.getRuleContext(0, String_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public clause_options(): Clause_optionsContext | null {
+        return this.getRuleContext(0, Clause_optionsContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_statement_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStatement_clauses) {
+             listener.enterStatement_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStatement_clauses) {
+             listener.exitStatement_clauses(this);
+        }
+    }
+}
+
+
+export class Clause_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPTION, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_list(): String_listContext | null {
+        return this.getRuleContext(0, String_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public option_values(): Option_valuesContext[];
+    public option_values(i: number): Option_valuesContext | null;
+    public option_values(i?: number): Option_valuesContext[] | Option_valuesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Option_valuesContext);
+        }
+
+        return this.getRuleContext(i, Option_valuesContext);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_clause_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClause_options) {
+             listener.enterClause_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClause_options) {
+             listener.exitClause_options(this);
+        }
+    }
+}
+
+
+export class Option_valuesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_list(): String_listContext | null {
+        return this.getRuleContext(0, String_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public MINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINVALUE, 0);
+    }
+    public MAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXVALUE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_option_values;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOption_values) {
+             listener.enterOption_values(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOption_values) {
+             listener.exitOption_values(this);
+        }
+    }
+}
+
+
+export class String_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_string_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterString_list) {
+             listener.enterString_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitString_list) {
+             listener.exitString_list(this);
+        }
+    }
+}
+
+
+export class Disable_enableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_disable_enable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDisable_enable) {
+             listener.enterDisable_enable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDisable_enable) {
+             listener.exitDisable_enable(this);
+        }
+    }
+}
+
+
+export class Drop_lockdown_profileContext extends antlr.ParserRuleContext {
+    public _p?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public LOCKDOWN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCKDOWN, 0)!;
+    }
+    public PROFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROFILE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_lockdown_profile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_lockdown_profile) {
+             listener.enterDrop_lockdown_profile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_lockdown_profile) {
+             listener.exitDrop_lockdown_profile(this);
+        }
+    }
+}
+
+
+export class Drop_packageContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public PACKAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PACKAGE, 0)!;
+    }
+    public package_name(): Package_nameContext {
+        return this.getRuleContext(0, Package_nameContext)!;
+    }
+    public BODY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BODY, 0);
+    }
+    public schema_object_name(): Schema_object_nameContext | null {
+        return this.getRuleContext(0, Schema_object_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_package;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_package) {
+             listener.enterDrop_package(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_package) {
+             listener.exitDrop_package(this);
+        }
+    }
+}
+
+
+export class Alter_packageContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public PACKAGE(): antlr.TerminalNode[];
+    public PACKAGE(i: number): antlr.TerminalNode | null;
+    public PACKAGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PACKAGE);
+    	} else {
+    		return this.getToken(PlSqlParser.PACKAGE, i);
+    	}
+    }
+    public package_name(): Package_nameContext {
+        return this.getRuleContext(0, Package_nameContext)!;
+    }
+    public COMPILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMPILE, 0)!;
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext[];
+    public compiler_parameters_clause(i: number): Compiler_parameters_clauseContext | null;
+    public compiler_parameters_clause(i?: number): Compiler_parameters_clauseContext[] | Compiler_parameters_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compiler_parameters_clauseContext);
+        }
+
+        return this.getRuleContext(i, Compiler_parameters_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public BODY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BODY, 0);
+    }
+    public SPECIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPECIFICATION, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_package;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_package) {
+             listener.enterAlter_package(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_package) {
+             listener.exitAlter_package(this);
+        }
+    }
+}
+
+
+export class Create_packageContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public PACKAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PACKAGE, 0)!;
+    }
+    public package_name(): Package_nameContext[];
+    public package_name(i: number): Package_nameContext | null;
+    public package_name(i?: number): Package_nameContext[] | Package_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Package_nameContext);
+        }
+
+        return this.getRuleContext(i, Package_nameContext);
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public schema_object_name(): Schema_object_nameContext | null {
+        return this.getRuleContext(0, Schema_object_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext | null {
+        return this.getRuleContext(0, Invoker_rights_clauseContext);
+    }
+    public package_obj_spec(): Package_obj_specContext[];
+    public package_obj_spec(i: number): Package_obj_specContext | null;
+    public package_obj_spec(i?: number): Package_obj_specContext[] | Package_obj_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Package_obj_specContext);
+        }
+
+        return this.getRuleContext(i, Package_obj_specContext);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_package;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_package) {
+             listener.enterCreate_package(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_package) {
+             listener.exitCreate_package(this);
+        }
+    }
+}
+
+
+export class Create_package_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public PACKAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PACKAGE, 0)!;
+    }
+    public BODY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BODY, 0)!;
+    }
+    public package_name(): Package_nameContext[];
+    public package_name(i: number): Package_nameContext | null;
+    public package_name(i?: number): Package_nameContext[] | Package_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Package_nameContext);
+        }
+
+        return this.getRuleContext(i, Package_nameContext);
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public schema_object_name(): Schema_object_nameContext | null {
+        return this.getRuleContext(0, Schema_object_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public package_obj_body(): Package_obj_bodyContext[];
+    public package_obj_body(i: number): Package_obj_bodyContext | null;
+    public package_obj_body(i?: number): Package_obj_bodyContext[] | Package_obj_bodyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Package_obj_bodyContext);
+        }
+
+        return this.getRuleContext(i, Package_obj_bodyContext);
+    }
+    public BEGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGIN, 0);
+    }
+    public seq_of_statements(): Seq_of_statementsContext | null {
+        return this.getRuleContext(0, Seq_of_statementsContext);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public EXCEPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTION, 0);
+    }
+    public exception_handler(): Exception_handlerContext[];
+    public exception_handler(i: number): Exception_handlerContext | null;
+    public exception_handler(i?: number): Exception_handlerContext[] | Exception_handlerContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Exception_handlerContext);
+        }
+
+        return this.getRuleContext(i, Exception_handlerContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_package_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_package_body) {
+             listener.enterCreate_package_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_package_body) {
+             listener.exitCreate_package_body(this);
+        }
+    }
+}
+
+
+export class Package_obj_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public pragma_declaration(): Pragma_declarationContext | null {
+        return this.getRuleContext(0, Pragma_declarationContext);
+    }
+    public exception_declaration(): Exception_declarationContext | null {
+        return this.getRuleContext(0, Exception_declarationContext);
+    }
+    public procedure_spec(): Procedure_specContext | null {
+        return this.getRuleContext(0, Procedure_specContext);
+    }
+    public function_spec(): Function_specContext | null {
+        return this.getRuleContext(0, Function_specContext);
+    }
+    public variable_declaration(): Variable_declarationContext | null {
+        return this.getRuleContext(0, Variable_declarationContext);
+    }
+    public subtype_declaration(): Subtype_declarationContext | null {
+        return this.getRuleContext(0, Subtype_declarationContext);
+    }
+    public cursor_declaration(): Cursor_declarationContext | null {
+        return this.getRuleContext(0, Cursor_declarationContext);
+    }
+    public type_declaration(): Type_declarationContext | null {
+        return this.getRuleContext(0, Type_declarationContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_package_obj_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPackage_obj_spec) {
+             listener.enterPackage_obj_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPackage_obj_spec) {
+             listener.exitPackage_obj_spec(this);
+        }
+    }
+}
+
+
+export class Procedure_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter(): ParameterContext[];
+    public parameter(i: number): ParameterContext | null;
+    public parameter(i?: number): ParameterContext[] | ParameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ParameterContext);
+        }
+
+        return this.getRuleContext(i, ParameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public accessible_by_clause(): Accessible_by_clauseContext[];
+    public accessible_by_clause(i: number): Accessible_by_clauseContext | null;
+    public accessible_by_clause(i?: number): Accessible_by_clauseContext[] | Accessible_by_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Accessible_by_clauseContext);
+        }
+
+        return this.getRuleContext(i, Accessible_by_clauseContext);
+    }
+    public PARALLEL_ENABLE(): antlr.TerminalNode[];
+    public PARALLEL_ENABLE(i: number): antlr.TerminalNode | null;
+    public PARALLEL_ENABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARALLEL_ENABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.PARALLEL_ENABLE, i);
+    	}
+    }
+    public DETERMINISTIC(): antlr.TerminalNode[];
+    public DETERMINISTIC(i: number): antlr.TerminalNode | null;
+    public DETERMINISTIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINISTIC);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINISTIC, i);
+    	}
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_procedure_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProcedure_spec) {
+             listener.enterProcedure_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProcedure_spec) {
+             listener.exitProcedure_spec(this);
+        }
+    }
+}
+
+
+export class Function_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter(): ParameterContext[];
+    public parameter(i: number): ParameterContext | null;
+    public parameter(i?: number): ParameterContext[] | ParameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ParameterContext);
+        }
+
+        return this.getRuleContext(i, ParameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DETERMINISTIC(): antlr.TerminalNode[];
+    public DETERMINISTIC(i: number): antlr.TerminalNode | null;
+    public DETERMINISTIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINISTIC);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINISTIC, i);
+    	}
+    }
+    public PIPELINED(): antlr.TerminalNode[];
+    public PIPELINED(i: number): antlr.TerminalNode | null;
+    public PIPELINED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PIPELINED);
+    	} else {
+    		return this.getToken(PlSqlParser.PIPELINED, i);
+    	}
+    }
+    public parallel_enable_clause(): Parallel_enable_clauseContext[];
+    public parallel_enable_clause(i: number): Parallel_enable_clauseContext | null;
+    public parallel_enable_clause(i?: number): Parallel_enable_clauseContext[] | Parallel_enable_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_enable_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_enable_clauseContext);
+    }
+    public RESULT_CACHE(): antlr.TerminalNode[];
+    public RESULT_CACHE(i: number): antlr.TerminalNode | null;
+    public RESULT_CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RESULT_CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.RESULT_CACHE, i);
+    	}
+    }
+    public streaming_clause(): Streaming_clauseContext[];
+    public streaming_clause(i: number): Streaming_clauseContext | null;
+    public streaming_clause(i?: number): Streaming_clauseContext[] | Streaming_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Streaming_clauseContext);
+        }
+
+        return this.getRuleContext(i, Streaming_clauseContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_spec) {
+             listener.enterFunction_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_spec) {
+             listener.exitFunction_spec(this);
+        }
+    }
+}
+
+
+export class Package_obj_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public pragma_declaration(): Pragma_declarationContext | null {
+        return this.getRuleContext(0, Pragma_declarationContext);
+    }
+    public exception_declaration(): Exception_declarationContext | null {
+        return this.getRuleContext(0, Exception_declarationContext);
+    }
+    public procedure_spec(): Procedure_specContext | null {
+        return this.getRuleContext(0, Procedure_specContext);
+    }
+    public function_spec(): Function_specContext | null {
+        return this.getRuleContext(0, Function_specContext);
+    }
+    public subtype_declaration(): Subtype_declarationContext | null {
+        return this.getRuleContext(0, Subtype_declarationContext);
+    }
+    public cursor_declaration(): Cursor_declarationContext | null {
+        return this.getRuleContext(0, Cursor_declarationContext);
+    }
+    public variable_declaration(): Variable_declarationContext | null {
+        return this.getRuleContext(0, Variable_declarationContext);
+    }
+    public type_declaration(): Type_declarationContext | null {
+        return this.getRuleContext(0, Type_declarationContext);
+    }
+    public procedure_body(): Procedure_bodyContext | null {
+        return this.getRuleContext(0, Procedure_bodyContext);
+    }
+    public function_body(): Function_bodyContext | null {
+        return this.getRuleContext(0, Function_bodyContext);
+    }
+    public selection_directive(): Selection_directiveContext | null {
+        return this.getRuleContext(0, Selection_directiveContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_package_obj_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPackage_obj_body) {
+             listener.enterPackage_obj_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPackage_obj_body) {
+             listener.exitPackage_obj_body(this);
+        }
+    }
+}
+
+
+export class Alter_pmem_filestoreContext extends antlr.ParserRuleContext {
+    public _fsn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public PMEM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PMEM, 0)!;
+    }
+    public FILESTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILESTORE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public MOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNT, 0);
+    }
+    public DISMOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISMOUNT, 0);
+    }
+    public MOUNTPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNTPOINT, 0);
+    }
+    public file_path(): File_pathContext | null {
+        return this.getRuleContext(0, File_pathContext);
+    }
+    public BACKINGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKINGFILE, 0);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_pmem_filestore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_pmem_filestore) {
+             listener.enterAlter_pmem_filestore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_pmem_filestore) {
+             listener.exitAlter_pmem_filestore(this);
+        }
+    }
+}
+
+
+export class Drop_pmem_filestoreContext extends antlr.ParserRuleContext {
+    public _fsn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public PMEM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PMEM, 0)!;
+    }
+    public FILESTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILESTORE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public CONTENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTENTS, 0);
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public EXCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDING, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_pmem_filestore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_pmem_filestore) {
+             listener.enterDrop_pmem_filestore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_pmem_filestore) {
+             listener.exitDrop_pmem_filestore(this);
+        }
+    }
+}
+
+
+export class Drop_procedureContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public procedure_name(): Procedure_nameContext {
+        return this.getRuleContext(0, Procedure_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_procedure;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_procedure) {
+             listener.enterDrop_procedure(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_procedure) {
+             listener.exitDrop_procedure(this);
+        }
+    }
+}
+
+
+export class Alter_procedureContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public procedure_name(): Procedure_nameContext {
+        return this.getRuleContext(0, Procedure_nameContext)!;
+    }
+    public COMPILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMPILE, 0)!;
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext[];
+    public compiler_parameters_clause(i: number): Compiler_parameters_clauseContext | null;
+    public compiler_parameters_clause(i?: number): Compiler_parameters_clauseContext[] | Compiler_parameters_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compiler_parameters_clauseContext);
+        }
+
+        return this.getRuleContext(i, Compiler_parameters_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_procedure;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_procedure) {
+             listener.enterAlter_procedure(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_procedure) {
+             listener.exitAlter_procedure(this);
+        }
+    }
+}
+
+
+export class Function_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public implementation_type_name(): Implementation_type_nameContext | null {
+        return this.getRuleContext(0, Implementation_type_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter(): ParameterContext[];
+    public parameter(i: number): ParameterContext | null;
+    public parameter(i?: number): ParameterContext[] | ParameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ParameterContext);
+        }
+
+        return this.getRuleContext(i, ParameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public PIPELINED(): antlr.TerminalNode[];
+    public PIPELINED(i: number): antlr.TerminalNode | null;
+    public PIPELINED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PIPELINED);
+    	} else {
+    		return this.getToken(PlSqlParser.PIPELINED, i);
+    	}
+    }
+    public DETERMINISTIC(): antlr.TerminalNode[];
+    public DETERMINISTIC(i: number): antlr.TerminalNode | null;
+    public DETERMINISTIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINISTIC);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINISTIC, i);
+    	}
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext[];
+    public invoker_rights_clause(i: number): Invoker_rights_clauseContext | null;
+    public invoker_rights_clause(i?: number): Invoker_rights_clauseContext[] | Invoker_rights_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Invoker_rights_clauseContext);
+        }
+
+        return this.getRuleContext(i, Invoker_rights_clauseContext);
+    }
+    public parallel_enable_clause(): Parallel_enable_clauseContext[];
+    public parallel_enable_clause(i: number): Parallel_enable_clauseContext | null;
+    public parallel_enable_clause(i?: number): Parallel_enable_clauseContext[] | Parallel_enable_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_enable_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_enable_clauseContext);
+    }
+    public result_cache_clause(): Result_cache_clauseContext[];
+    public result_cache_clause(i: number): Result_cache_clauseContext | null;
+    public result_cache_clause(i?: number): Result_cache_clauseContext[] | Result_cache_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Result_cache_clauseContext);
+        }
+
+        return this.getRuleContext(i, Result_cache_clauseContext);
+    }
+    public streaming_clause(): Streaming_clauseContext[];
+    public streaming_clause(i: number): Streaming_clauseContext | null;
+    public streaming_clause(i?: number): Streaming_clauseContext[] | Streaming_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Streaming_clauseContext);
+        }
+
+        return this.getRuleContext(i, Streaming_clauseContext);
+    }
+    public AGGREGATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AGGREGATE, 0);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_body) {
+             listener.enterFunction_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_body) {
+             listener.exitFunction_body(this);
+        }
+    }
+}
+
+
+export class Procedure_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter(): ParameterContext[];
+    public parameter(i: number): ParameterContext | null;
+    public parameter(i?: number): ParameterContext[] | ParameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ParameterContext);
+        }
+
+        return this.getRuleContext(i, ParameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public accessible_by_clause(): Accessible_by_clauseContext[];
+    public accessible_by_clause(i: number): Accessible_by_clauseContext | null;
+    public accessible_by_clause(i?: number): Accessible_by_clauseContext[] | Accessible_by_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Accessible_by_clauseContext);
+        }
+
+        return this.getRuleContext(i, Accessible_by_clauseContext);
+    }
+    public PARALLEL_ENABLE(): antlr.TerminalNode[];
+    public PARALLEL_ENABLE(i: number): antlr.TerminalNode | null;
+    public PARALLEL_ENABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARALLEL_ENABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.PARALLEL_ENABLE, i);
+    	}
+    }
+    public DETERMINISTIC(): antlr.TerminalNode[];
+    public DETERMINISTIC(i: number): antlr.TerminalNode | null;
+    public DETERMINISTIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINISTIC);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINISTIC, i);
+    	}
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_procedure_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProcedure_body) {
+             listener.enterProcedure_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProcedure_body) {
+             listener.exitProcedure_body(this);
+        }
+    }
+}
+
+
+export class Create_procedure_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public procedure_name(): Procedure_nameContext {
+        return this.getRuleContext(0, Procedure_nameContext)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter(): ParameterContext[];
+    public parameter(i: number): ParameterContext | null;
+    public parameter(i?: number): ParameterContext[] | ParameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ParameterContext);
+        }
+
+        return this.getRuleContext(i, ParameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext | null {
+        return this.getRuleContext(0, Invoker_rights_clauseContext);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public PARALLEL_ENABLE(): antlr.TerminalNode[];
+    public PARALLEL_ENABLE(i: number): antlr.TerminalNode | null;
+    public PARALLEL_ENABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARALLEL_ENABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.PARALLEL_ENABLE, i);
+    	}
+    }
+    public DETERMINISTIC(): antlr.TerminalNode[];
+    public DETERMINISTIC(i: number): antlr.TerminalNode | null;
+    public DETERMINISTIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINISTIC);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINISTIC, i);
+    	}
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_procedure_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_procedure_body) {
+             listener.enterCreate_procedure_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_procedure_body) {
+             listener.exitCreate_procedure_body(this);
+        }
+    }
+}
+
+
+export class Alter_resource_costContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public RESOURCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESOURCE, 0)!;
+    }
+    public COST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COST, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public CPU_PER_SESSION(): antlr.TerminalNode[];
+    public CPU_PER_SESSION(i: number): antlr.TerminalNode | null;
+    public CPU_PER_SESSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CPU_PER_SESSION);
+    	} else {
+    		return this.getToken(PlSqlParser.CPU_PER_SESSION, i);
+    	}
+    }
+    public CONNECT_TIME(): antlr.TerminalNode[];
+    public CONNECT_TIME(i: number): antlr.TerminalNode | null;
+    public CONNECT_TIME(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONNECT_TIME);
+    	} else {
+    		return this.getToken(PlSqlParser.CONNECT_TIME, i);
+    	}
+    }
+    public LOGICAL_READS_PER_SESSION(): antlr.TerminalNode[];
+    public LOGICAL_READS_PER_SESSION(i: number): antlr.TerminalNode | null;
+    public LOGICAL_READS_PER_SESSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOGICAL_READS_PER_SESSION);
+    	} else {
+    		return this.getToken(PlSqlParser.LOGICAL_READS_PER_SESSION, i);
+    	}
+    }
+    public PRIVATE_SGA(): antlr.TerminalNode[];
+    public PRIVATE_SGA(i: number): antlr.TerminalNode | null;
+    public PRIVATE_SGA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIVATE_SGA);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIVATE_SGA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_resource_cost;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_resource_cost) {
+             listener.enterAlter_resource_cost(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_resource_cost) {
+             listener.exitAlter_resource_cost(this);
+        }
+    }
+}
+
+
+export class Drop_outlineContext extends antlr.ParserRuleContext {
+    public _o?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public OUTLINE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OUTLINE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_outline;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_outline) {
+             listener.enterDrop_outline(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_outline) {
+             listener.exitDrop_outline(this);
+        }
+    }
+}
+
+
+export class Alter_rollback_segmentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public ROLLBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLLBACK, 0)!;
+    }
+    public SEGMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEGMENT, 0)!;
+    }
+    public rollback_segment_name(): Rollback_segment_nameContext {
+        return this.getRuleContext(0, Rollback_segment_nameContext)!;
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public storage_clause(): Storage_clauseContext | null {
+        return this.getRuleContext(0, Storage_clauseContext);
+    }
+    public SHRINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHRINK, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_rollback_segment;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_rollback_segment) {
+             listener.enterAlter_rollback_segment(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_rollback_segment) {
+             listener.exitAlter_rollback_segment(this);
+        }
+    }
+}
+
+
+export class Drop_restore_pointContext extends antlr.ParserRuleContext {
+    public _rp?: Id_expressionContext;
+    public _pdb?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public RESTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESTORE, 0)!;
+    }
+    public POINT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.POINT, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public PLUGGABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_restore_point;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_restore_point) {
+             listener.enterDrop_restore_point(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_restore_point) {
+             listener.exitDrop_restore_point(this);
+        }
+    }
+}
+
+
+export class Drop_rollback_segmentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public ROLLBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLLBACK, 0)!;
+    }
+    public SEGMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEGMENT, 0)!;
+    }
+    public rollback_segment_name(): Rollback_segment_nameContext {
+        return this.getRuleContext(0, Rollback_segment_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_rollback_segment;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_rollback_segment) {
+             listener.enterDrop_rollback_segment(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_rollback_segment) {
+             listener.exitDrop_rollback_segment(this);
+        }
+    }
+}
+
+
+export class Drop_roleContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public ROLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLE, 0)!;
+    }
+    public role_name(): Role_nameContext {
+        return this.getRuleContext(0, Role_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_role;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_role) {
+             listener.enterDrop_role(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_role) {
+             listener.exitDrop_role(this);
+        }
+    }
+}
+
+
+export class Create_pmem_filestoreContext extends antlr.ParserRuleContext {
+    public _fsn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public PMEM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PMEM, 0)!;
+    }
+    public FILESTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILESTORE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public pmem_filestore_options(): Pmem_filestore_optionsContext[];
+    public pmem_filestore_options(i: number): Pmem_filestore_optionsContext | null;
+    public pmem_filestore_options(i?: number): Pmem_filestore_optionsContext[] | Pmem_filestore_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Pmem_filestore_optionsContext);
+        }
+
+        return this.getRuleContext(i, Pmem_filestore_optionsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_pmem_filestore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_pmem_filestore) {
+             listener.enterCreate_pmem_filestore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_pmem_filestore) {
+             listener.exitCreate_pmem_filestore(this);
+        }
+    }
+}
+
+
+export class Pmem_filestore_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOUNTPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNTPOINT, 0);
+    }
+    public file_path(): File_pathContext | null {
+        return this.getRuleContext(0, File_pathContext);
+    }
+    public BACKINGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKINGFILE, 0);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public BLOCKSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKSIZE, 0);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pmem_filestore_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPmem_filestore_options) {
+             listener.enterPmem_filestore_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPmem_filestore_options) {
+             listener.exitPmem_filestore_options(this);
+        }
+    }
+}
+
+
+export class File_pathContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_file_path;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFile_path) {
+             listener.enterFile_path(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFile_path) {
+             listener.exitFile_path(this);
+        }
+    }
+}
+
+
+export class Create_rollback_segmentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public ROLLBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLLBACK, 0)!;
+    }
+    public SEGMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEGMENT, 0)!;
+    }
+    public rollback_segment_name(): Rollback_segment_nameContext {
+        return this.getRuleContext(0, Rollback_segment_nameContext)!;
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public storage_clause(): Storage_clauseContext[];
+    public storage_clause(i: number): Storage_clauseContext | null;
+    public storage_clause(i?: number): Storage_clauseContext[] | Storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_rollback_segment;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_rollback_segment) {
+             listener.enterCreate_rollback_segment(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_rollback_segment) {
+             listener.exitCreate_rollback_segment(this);
+        }
+    }
+}
+
+
+export class Drop_triggerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public TRIGGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRIGGER, 0)!;
+    }
+    public trigger_name(): Trigger_nameContext {
+        return this.getRuleContext(0, Trigger_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_trigger;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_trigger) {
+             listener.enterDrop_trigger(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_trigger) {
+             listener.exitDrop_trigger(this);
+        }
+    }
+}
+
+
+export class Alter_triggerContext extends antlr.ParserRuleContext {
+    public _alter_trigger_name?: Trigger_nameContext;
+    public _rename_trigger_name?: Trigger_nameContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public TRIGGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRIGGER, 0)!;
+    }
+    public trigger_name(): Trigger_nameContext[];
+    public trigger_name(i: number): Trigger_nameContext | null;
+    public trigger_name(i?: number): Trigger_nameContext[] | Trigger_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Trigger_nameContext);
+        }
+
+        return this.getRuleContext(i, Trigger_nameContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext[];
+    public compiler_parameters_clause(i: number): Compiler_parameters_clauseContext | null;
+    public compiler_parameters_clause(i?: number): Compiler_parameters_clauseContext[] | Compiler_parameters_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compiler_parameters_clauseContext);
+        }
+
+        return this.getRuleContext(i, Compiler_parameters_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_trigger;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_trigger) {
+             listener.enterAlter_trigger(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_trigger) {
+             listener.exitAlter_trigger(this);
+        }
+    }
+}
+
+
+export class Create_triggerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public TRIGGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRIGGER, 0)!;
+    }
+    public trigger_name(): Trigger_nameContext {
+        return this.getRuleContext(0, Trigger_nameContext)!;
+    }
+    public trigger_body(): Trigger_bodyContext {
+        return this.getRuleContext(0, Trigger_bodyContext)!;
+    }
+    public simple_dml_trigger(): Simple_dml_triggerContext | null {
+        return this.getRuleContext(0, Simple_dml_triggerContext);
+    }
+    public compound_dml_trigger(): Compound_dml_triggerContext | null {
+        return this.getRuleContext(0, Compound_dml_triggerContext);
+    }
+    public non_dml_trigger(): Non_dml_triggerContext | null {
+        return this.getRuleContext(0, Non_dml_triggerContext);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public trigger_follows_clause(): Trigger_follows_clauseContext | null {
+        return this.getRuleContext(0, Trigger_follows_clauseContext);
+    }
+    public trigger_when_clause(): Trigger_when_clauseContext | null {
+        return this.getRuleContext(0, Trigger_when_clauseContext);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_trigger;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_trigger) {
+             listener.enterCreate_trigger(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_trigger) {
+             listener.exitCreate_trigger(this);
+        }
+    }
+}
+
+
+export class Trigger_follows_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOLLOWS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOLLOWS, 0)!;
+    }
+    public trigger_name(): Trigger_nameContext[];
+    public trigger_name(i: number): Trigger_nameContext | null;
+    public trigger_name(i?: number): Trigger_nameContext[] | Trigger_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Trigger_nameContext);
+        }
+
+        return this.getRuleContext(i, Trigger_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_trigger_follows_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTrigger_follows_clause) {
+             listener.enterTrigger_follows_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTrigger_follows_clause) {
+             listener.exitTrigger_follows_clause(this);
+        }
+    }
+}
+
+
+export class Trigger_when_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_trigger_when_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTrigger_when_clause) {
+             listener.enterTrigger_when_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTrigger_when_clause) {
+             listener.exitTrigger_when_clause(this);
+        }
+    }
+}
+
+
+export class Simple_dml_triggerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public dml_event_clause(): Dml_event_clauseContext {
+        return this.getRuleContext(0, Dml_event_clauseContext)!;
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public INSTEAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTEAD, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public referencing_clause(): Referencing_clauseContext | null {
+        return this.getRuleContext(0, Referencing_clauseContext);
+    }
+    public for_each_row(): For_each_rowContext | null {
+        return this.getRuleContext(0, For_each_rowContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_simple_dml_trigger;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSimple_dml_trigger) {
+             listener.enterSimple_dml_trigger(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSimple_dml_trigger) {
+             listener.exitSimple_dml_trigger(this);
+        }
+    }
+}
+
+
+export class For_each_rowContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public EACH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EACH, 0)!;
+    }
+    public ROW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROW, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_for_each_row;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFor_each_row) {
+             listener.enterFor_each_row(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFor_each_row) {
+             listener.exitFor_each_row(this);
+        }
+    }
+}
+
+
+export class Compound_dml_triggerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public dml_event_clause(): Dml_event_clauseContext {
+        return this.getRuleContext(0, Dml_event_clauseContext)!;
+    }
+    public referencing_clause(): Referencing_clauseContext | null {
+        return this.getRuleContext(0, Referencing_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_compound_dml_trigger;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCompound_dml_trigger) {
+             listener.enterCompound_dml_trigger(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCompound_dml_trigger) {
+             listener.exitCompound_dml_trigger(this);
+        }
+    }
+}
+
+
+export class Non_dml_triggerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public non_dml_event(): Non_dml_eventContext[];
+    public non_dml_event(i: number): Non_dml_eventContext | null;
+    public non_dml_event(i?: number): Non_dml_eventContext[] | Non_dml_eventContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Non_dml_eventContext);
+        }
+
+        return this.getRuleContext(i, Non_dml_eventContext);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public SCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEMA, 0);
+    }
+    public OR(): antlr.TerminalNode[];
+    public OR(i: number): antlr.TerminalNode | null;
+    public OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OR);
+    	} else {
+    		return this.getToken(PlSqlParser.OR, i);
+    	}
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_non_dml_trigger;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNon_dml_trigger) {
+             listener.enterNon_dml_trigger(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNon_dml_trigger) {
+             listener.exitNon_dml_trigger(this);
+        }
+    }
+}
+
+
+export class Trigger_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public compound_trigger_block(): Compound_trigger_blockContext | null {
+        return this.getRuleContext(0, Compound_trigger_blockContext);
+    }
+    public CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CALL, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public trigger_block(): Trigger_blockContext | null {
+        return this.getRuleContext(0, Trigger_blockContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_trigger_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTrigger_body) {
+             listener.enterTrigger_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTrigger_body) {
+             listener.exitTrigger_body(this);
+        }
+    }
+}
+
+
+export class Compound_trigger_blockContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMPOUND(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMPOUND, 0)!;
+    }
+    public TRIGGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRIGGER, 0)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public timing_point_section(): Timing_point_sectionContext[];
+    public timing_point_section(i: number): Timing_point_sectionContext | null;
+    public timing_point_section(i?: number): Timing_point_sectionContext[] | Timing_point_sectionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Timing_point_sectionContext);
+        }
+
+        return this.getRuleContext(i, Timing_point_sectionContext);
+    }
+    public trigger_name(): Trigger_nameContext | null {
+        return this.getRuleContext(0, Trigger_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_compound_trigger_block;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCompound_trigger_block) {
+             listener.enterCompound_trigger_block(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCompound_trigger_block) {
+             listener.exitCompound_trigger_block(this);
+        }
+    }
+}
+
+
+export class Timing_point_sectionContext extends antlr.ParserRuleContext {
+    public _bk?: Token | null;
+    public _ak?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STATEMENT(): antlr.TerminalNode[];
+    public STATEMENT(i: number): antlr.TerminalNode | null;
+    public STATEMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.STATEMENT);
+    	} else {
+    		return this.getToken(PlSqlParser.STATEMENT, i);
+    	}
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public tps_block(): Tps_blockContext {
+        return this.getRuleContext(0, Tps_blockContext)!;
+    }
+    public BEFORE(): antlr.TerminalNode[];
+    public BEFORE(i: number): antlr.TerminalNode | null;
+    public BEFORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BEFORE);
+    	} else {
+    		return this.getToken(PlSqlParser.BEFORE, i);
+    	}
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public EACH(): antlr.TerminalNode[];
+    public EACH(i: number): antlr.TerminalNode | null;
+    public EACH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EACH);
+    	} else {
+    		return this.getToken(PlSqlParser.EACH, i);
+    	}
+    }
+    public ROW(): antlr.TerminalNode[];
+    public ROW(i: number): antlr.TerminalNode | null;
+    public ROW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROW);
+    	} else {
+    		return this.getToken(PlSqlParser.ROW, i);
+    	}
+    }
+    public AFTER(): antlr.TerminalNode[];
+    public AFTER(i: number): antlr.TerminalNode | null;
+    public AFTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AFTER);
+    	} else {
+    		return this.getToken(PlSqlParser.AFTER, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_timing_point_section;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTiming_point_section) {
+             listener.enterTiming_point_section(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTiming_point_section) {
+             listener.exitTiming_point_section(this);
+        }
+    }
+}
+
+
+export class Non_dml_eventContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public ANALYZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANALYZE, 0);
+    }
+    public ASSOCIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASSOCIATE, 0);
+    }
+    public STATISTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATISTICS, 0);
+    }
+    public AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUDIT, 0);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public CREATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE, 0);
+    }
+    public DISASSOCIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISASSOCIATE, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public GRANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GRANT, 0);
+    }
+    public NOAUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOAUDIT, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public REVOKE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REVOKE, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public DDL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DDL, 0);
+    }
+    public STARTUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STARTUP, 0);
+    }
+    public SHUTDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHUTDOWN, 0);
+    }
+    public DB_ROLE_CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DB_ROLE_CHANGE, 0);
+    }
+    public LOGON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGON, 0);
+    }
+    public LOGOFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGOFF, 0);
+    }
+    public SERVERERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVERERROR, 0);
+    }
+    public SUSPEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUSPEND, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public SCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEMA, 0);
+    }
+    public FOLLOWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOLLOWS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_non_dml_event;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNon_dml_event) {
+             listener.enterNon_dml_event(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNon_dml_event) {
+             listener.exitNon_dml_event(this);
+        }
+    }
+}
+
+
+export class Dml_event_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public dml_event_element(): Dml_event_elementContext[];
+    public dml_event_element(i: number): Dml_event_elementContext | null;
+    public dml_event_element(i?: number): Dml_event_elementContext[] | Dml_event_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Dml_event_elementContext);
+        }
+
+        return this.getRuleContext(i, Dml_event_elementContext);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public OR(): antlr.TerminalNode[];
+    public OR(i: number): antlr.TerminalNode | null;
+    public OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OR);
+    	} else {
+    		return this.getToken(PlSqlParser.OR, i);
+    	}
+    }
+    public dml_event_nested_clause(): Dml_event_nested_clauseContext | null {
+        return this.getRuleContext(0, Dml_event_nested_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dml_event_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDml_event_clause) {
+             listener.enterDml_event_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDml_event_clause) {
+             listener.exitDml_event_clause(this);
+        }
+    }
+}
+
+
+export class Dml_event_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public column_list(): Column_listContext | null {
+        return this.getRuleContext(0, Column_listContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dml_event_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDml_event_element) {
+             listener.enterDml_event_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDml_event_element) {
+             listener.exitDml_event_element(this);
+        }
+    }
+}
+
+
+export class Dml_event_nested_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NESTED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NESTED, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dml_event_nested_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDml_event_nested_clause) {
+             listener.enterDml_event_nested_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDml_event_nested_clause) {
+             listener.exitDml_event_nested_clause(this);
+        }
+    }
+}
+
+
+export class Referencing_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REFERENCING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCING, 0);
+    }
+    public referencing_element(): Referencing_elementContext[];
+    public referencing_element(i: number): Referencing_elementContext | null;
+    public referencing_element(i?: number): Referencing_elementContext[] | Referencing_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Referencing_elementContext);
+        }
+
+        return this.getRuleContext(i, Referencing_elementContext);
+    }
+    public REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_referencing_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReferencing_clause) {
+             listener.enterReferencing_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReferencing_clause) {
+             listener.exitReferencing_clause(this);
+        }
+    }
+}
+
+
+export class Referencing_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_alias(): Column_aliasContext {
+        return this.getRuleContext(0, Column_aliasContext)!;
+    }
+    public NEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEW, 0);
+    }
+    public OLD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLD, 0);
+    }
+    public PARENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_referencing_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReferencing_element) {
+             listener.enterReferencing_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReferencing_element) {
+             listener.exitReferencing_element(this);
+        }
+    }
+}
+
+
+export class Drop_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public TYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TYPE, 0)!;
+    }
+    public type_name(): Type_nameContext {
+        return this.getRuleContext(0, Type_nameContext)!;
+    }
+    public BODY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BODY, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public VALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_type) {
+             listener.enterDrop_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_type) {
+             listener.exitDrop_type(this);
+        }
+    }
+}
+
+
+export class Alter_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public TYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TYPE, 0)!;
+    }
+    public type_name(): Type_nameContext {
+        return this.getRuleContext(0, Type_nameContext)!;
+    }
+    public compile_type_clause(): Compile_type_clauseContext | null {
+        return this.getRuleContext(0, Compile_type_clauseContext);
+    }
+    public replace_type_clause(): Replace_type_clauseContext | null {
+        return this.getRuleContext(0, Replace_type_clauseContext);
+    }
+    public alter_method_spec(): Alter_method_specContext | null {
+        return this.getRuleContext(0, Alter_method_specContext);
+    }
+    public alter_attribute_definition(): Alter_attribute_definitionContext | null {
+        return this.getRuleContext(0, Alter_attribute_definitionContext);
+    }
+    public alter_collection_clauses(): Alter_collection_clausesContext | null {
+        return this.getRuleContext(0, Alter_collection_clausesContext);
+    }
+    public modifier_clause(): Modifier_clauseContext | null {
+        return this.getRuleContext(0, Modifier_clauseContext);
+    }
+    public overriding_subprogram_spec(): Overriding_subprogram_specContext | null {
+        return this.getRuleContext(0, Overriding_subprogram_specContext);
+    }
+    public dependent_handling_clause(): Dependent_handling_clauseContext | null {
+        return this.getRuleContext(0, Dependent_handling_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_type) {
+             listener.enterAlter_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_type) {
+             listener.exitAlter_type(this);
+        }
+    }
+}
+
+
+export class Compile_type_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMPILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMPILE, 0)!;
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext[];
+    public compiler_parameters_clause(i: number): Compiler_parameters_clauseContext | null;
+    public compiler_parameters_clause(i?: number): Compiler_parameters_clauseContext[] | Compiler_parameters_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compiler_parameters_clauseContext);
+        }
+
+        return this.getRuleContext(i, Compiler_parameters_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public SPECIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPECIFICATION, 0);
+    }
+    public BODY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BODY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_compile_type_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCompile_type_clause) {
+             listener.enterCompile_type_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCompile_type_clause) {
+             listener.exitCompile_type_clause(this);
+        }
+    }
+}
+
+
+export class Replace_type_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REPLACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REPLACE, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public OBJECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OBJECT, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public object_member_spec(): Object_member_specContext[];
+    public object_member_spec(i: number): Object_member_specContext | null;
+    public object_member_spec(i?: number): Object_member_specContext[] | Object_member_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_member_specContext);
+        }
+
+        return this.getRuleContext(i, Object_member_specContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext | null {
+        return this.getRuleContext(0, Invoker_rights_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_replace_type_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReplace_type_clause) {
+             listener.enterReplace_type_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReplace_type_clause) {
+             listener.exitReplace_type_clause(this);
+        }
+    }
+}
+
+
+export class Alter_method_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public alter_method_element(): Alter_method_elementContext[];
+    public alter_method_element(i: number): Alter_method_elementContext | null;
+    public alter_method_element(i?: number): Alter_method_elementContext[] | Alter_method_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Alter_method_elementContext);
+        }
+
+        return this.getRuleContext(i, Alter_method_elementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_method_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_method_spec) {
+             listener.enterAlter_method_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_method_spec) {
+             listener.exitAlter_method_spec(this);
+        }
+    }
+}
+
+
+export class Alter_method_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public map_order_function_spec(): Map_order_function_specContext | null {
+        return this.getRuleContext(0, Map_order_function_specContext);
+    }
+    public subprogram_spec(): Subprogram_specContext | null {
+        return this.getRuleContext(0, Subprogram_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_method_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_method_element) {
+             listener.enterAlter_method_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_method_element) {
+             listener.exitAlter_method_element(this);
+        }
+    }
+}
+
+
+export class Alter_attribute_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ATTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_spec(): Type_specContext[];
+    public type_spec(i: number): Type_specContext | null;
+    public type_spec(i?: number): Type_specContext[] | Type_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_specContext);
+        }
+
+        return this.getRuleContext(i, Type_specContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_attribute_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_attribute_definition) {
+             listener.enterAlter_attribute_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_attribute_definition) {
+             listener.exitAlter_attribute_definition(this);
+        }
+    }
+}
+
+
+export class Alter_collection_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public ELEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELEMENT, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_collection_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_collection_clauses) {
+             listener.enterAlter_collection_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_collection_clauses) {
+             listener.exitAlter_collection_clauses(this);
+        }
+    }
+}
+
+
+export class Dependent_handling_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INVALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVALIDATE, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONVERT, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public SUBSTITUTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTITUTABLE, 0);
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public dependent_exceptions_part(): Dependent_exceptions_partContext | null {
+        return this.getRuleContext(0, Dependent_exceptions_partContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dependent_handling_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDependent_handling_clause) {
+             listener.enterDependent_handling_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDependent_handling_clause) {
+             listener.exitDependent_handling_clause(this);
+        }
+    }
+}
+
+
+export class Dependent_exceptions_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXCEPTIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXCEPTIONS, 0)!;
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dependent_exceptions_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDependent_exceptions_part) {
+             listener.enterDependent_exceptions_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDependent_exceptions_part) {
+             listener.exitDependent_exceptions_part(this);
+        }
+    }
+}
+
+
+export class Create_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public create_type_spec(): Create_type_specContext | null {
+        return this.getRuleContext(0, Create_type_specContext);
+    }
+    public create_type_body(): Create_type_bodyContext | null {
+        return this.getRuleContext(0, Create_type_bodyContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_type) {
+             listener.enterCreate_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_type) {
+             listener.exitCreate_type(this);
+        }
+    }
+}
+
+
+export class Create_type_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public TYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TYPE, 0)!;
+    }
+    public type_definition(): Type_definitionContext {
+        return this.getRuleContext(0, Type_definitionContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_type_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_type_spec) {
+             listener.enterCreate_type_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_type_spec) {
+             listener.exitCreate_type_spec(this);
+        }
+    }
+}
+
+
+export class Create_type_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public TYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TYPE, 0)!;
+    }
+    public type_body(): Type_bodyContext {
+        return this.getRuleContext(0, Type_bodyContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_type_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_type_body) {
+             listener.enterCreate_type_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_type_body) {
+             listener.exitCreate_type_body(this);
+        }
+    }
+}
+
+
+export class Type_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public type_name(): Type_nameContext {
+        return this.getRuleContext(0, Type_nameContext)!;
+    }
+    public OID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OID, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public object_type_def(): Object_type_defContext | null {
+        return this.getRuleContext(0, Object_type_defContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_definition) {
+             listener.enterType_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_definition) {
+             listener.exitType_definition(this);
+        }
+    }
+}
+
+
+export class Object_type_defContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public object_as_part(): Object_as_partContext | null {
+        return this.getRuleContext(0, Object_as_partContext);
+    }
+    public object_under_part(): Object_under_partContext | null {
+        return this.getRuleContext(0, Object_under_partContext);
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext | null {
+        return this.getRuleContext(0, Invoker_rights_clauseContext);
+    }
+    public sqlj_object_type(): Sqlj_object_typeContext | null {
+        return this.getRuleContext(0, Sqlj_object_typeContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public object_member_spec(): Object_member_specContext[];
+    public object_member_spec(i: number): Object_member_specContext | null;
+    public object_member_spec(i?: number): Object_member_specContext[] | Object_member_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_member_specContext);
+        }
+
+        return this.getRuleContext(i, Object_member_specContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public modifier_clause(): Modifier_clauseContext[];
+    public modifier_clause(i: number): Modifier_clauseContext | null;
+    public modifier_clause(i?: number): Modifier_clauseContext[] | Modifier_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Modifier_clauseContext);
+        }
+
+        return this.getRuleContext(i, Modifier_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_type_def;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_type_def) {
+             listener.enterObject_type_def(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_type_def) {
+             listener.exitObject_type_def(this);
+        }
+    }
+}
+
+
+export class Object_as_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public varray_type_def(): Varray_type_defContext | null {
+        return this.getRuleContext(0, Varray_type_defContext);
+    }
+    public nested_table_type_def(): Nested_table_type_defContext | null {
+        return this.getRuleContext(0, Nested_table_type_defContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_as_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_as_part) {
+             listener.enterObject_as_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_as_part) {
+             listener.exitObject_as_part(this);
+        }
+    }
+}
+
+
+export class Object_under_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNDER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNDER, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_under_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_under_part) {
+             listener.enterObject_under_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_under_part) {
+             listener.exitObject_under_part(this);
+        }
+    }
+}
+
+
+export class Nested_table_type_defContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_nested_table_type_def;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNested_table_type_def) {
+             listener.enterNested_table_type_def(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNested_table_type_def) {
+             listener.exitNested_table_type_def(this);
+        }
+    }
+}
+
+
+export class Sqlj_object_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXTERNAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXTERNAL, 0)!;
+    }
+    public NAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NAME, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public LANGUAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LANGUAGE, 0)!;
+    }
+    public JAVA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JAVA, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public SQLDATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQLDATA, 0);
+    }
+    public CUSTOMDATUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUSTOMDATUM, 0);
+    }
+    public ORADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORADATA, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sqlj_object_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSqlj_object_type) {
+             listener.enterSqlj_object_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSqlj_object_type) {
+             listener.exitSqlj_object_type(this);
+        }
+    }
+}
+
+
+export class Type_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BODY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BODY, 0)!;
+    }
+    public type_name(): Type_nameContext {
+        return this.getRuleContext(0, Type_nameContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public type_body_elements(): Type_body_elementsContext[];
+    public type_body_elements(i: number): Type_body_elementsContext | null;
+    public type_body_elements(i?: number): Type_body_elementsContext[] | Type_body_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_body_elementsContext);
+        }
+
+        return this.getRuleContext(i, Type_body_elementsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_body) {
+             listener.enterType_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_body) {
+             listener.exitType_body(this);
+        }
+    }
+}
+
+
+export class Type_body_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public map_order_func_declaration(): Map_order_func_declarationContext | null {
+        return this.getRuleContext(0, Map_order_func_declarationContext);
+    }
+    public subprog_decl_in_type(): Subprog_decl_in_typeContext | null {
+        return this.getRuleContext(0, Subprog_decl_in_typeContext);
+    }
+    public overriding_subprogram_spec(): Overriding_subprogram_specContext | null {
+        return this.getRuleContext(0, Overriding_subprogram_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_body_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_body_elements) {
+             listener.enterType_body_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_body_elements) {
+             listener.exitType_body_elements(this);
+        }
+    }
+}
+
+
+export class Map_order_func_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEMBER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEMBER, 0)!;
+    }
+    public func_decl_in_type(): Func_decl_in_typeContext {
+        return this.getRuleContext(0, Func_decl_in_typeContext)!;
+    }
+    public MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAP, 0);
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_map_order_func_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMap_order_func_declaration) {
+             listener.enterMap_order_func_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMap_order_func_declaration) {
+             listener.exitMap_order_func_declaration(this);
+        }
+    }
+}
+
+
+export class Subprog_decl_in_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public proc_decl_in_type(): Proc_decl_in_typeContext | null {
+        return this.getRuleContext(0, Proc_decl_in_typeContext);
+    }
+    public func_decl_in_type(): Func_decl_in_typeContext | null {
+        return this.getRuleContext(0, Func_decl_in_typeContext);
+    }
+    public constructor_declaration(): Constructor_declarationContext | null {
+        return this.getRuleContext(0, Constructor_declarationContext);
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public STATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATIC, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subprog_decl_in_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubprog_decl_in_type) {
+             listener.enterSubprog_decl_in_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubprog_decl_in_type) {
+             listener.exitSubprog_decl_in_type(this);
+        }
+    }
+}
+
+
+export class Proc_decl_in_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public procedure_name(): Procedure_nameContext {
+        return this.getRuleContext(0, Procedure_nameContext)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMICOLON, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_proc_decl_in_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProc_decl_in_type) {
+             listener.enterProc_decl_in_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProc_decl_in_type) {
+             listener.exitProc_decl_in_type(this);
+        }
+    }
+}
+
+
+export class Func_decl_in_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMICOLON, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_func_decl_in_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunc_decl_in_type) {
+             listener.enterFunc_decl_in_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunc_decl_in_type) {
+             listener.exitFunc_decl_in_type(this);
+        }
+    }
+}
+
+
+export class Constructor_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONSTRUCTOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONSTRUCTOR, 0)!;
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public SELF(): antlr.TerminalNode[];
+    public SELF(i: number): antlr.TerminalNode | null;
+    public SELF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SELF);
+    	} else {
+    		return this.getToken(PlSqlParser.SELF, i);
+    	}
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public RESULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESULT, 0)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMICOLON, 0);
+    }
+    public FINAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINAL, 0);
+    }
+    public INSTANTIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANTIABLE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public OUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUT, 0);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_constructor_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConstructor_declaration) {
+             listener.enterConstructor_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConstructor_declaration) {
+             listener.exitConstructor_declaration(this);
+        }
+    }
+}
+
+
+export class Modifier_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INSTANTIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANTIABLE, 0);
+    }
+    public FINAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINAL, 0);
+    }
+    public OVERRIDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERRIDING, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modifier_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModifier_clause) {
+             listener.enterModifier_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModifier_clause) {
+             listener.exitModifier_clause(this);
+        }
+    }
+}
+
+
+export class Object_member_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public sqlj_object_type_attr(): Sqlj_object_type_attrContext | null {
+        return this.getRuleContext(0, Sqlj_object_type_attrContext);
+    }
+    public element_spec(): Element_specContext | null {
+        return this.getRuleContext(0, Element_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_member_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_member_spec) {
+             listener.enterObject_member_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_member_spec) {
+             listener.exitObject_member_spec(this);
+        }
+    }
+}
+
+
+export class Sqlj_object_type_attrContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXTERNAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXTERNAL, 0)!;
+    }
+    public NAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NAME, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sqlj_object_type_attr;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSqlj_object_type_attr) {
+             listener.enterSqlj_object_type_attr(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSqlj_object_type_attr) {
+             listener.exitSqlj_object_type_attr(this);
+        }
+    }
+}
+
+
+export class Element_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public modifier_clause(): Modifier_clauseContext | null {
+        return this.getRuleContext(0, Modifier_clauseContext);
+    }
+    public element_spec_options(): Element_spec_optionsContext[];
+    public element_spec_options(i: number): Element_spec_optionsContext | null;
+    public element_spec_options(i?: number): Element_spec_optionsContext[] | Element_spec_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Element_spec_optionsContext);
+        }
+
+        return this.getRuleContext(i, Element_spec_optionsContext);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public pragma_clause(): Pragma_clauseContext | null {
+        return this.getRuleContext(0, Pragma_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_element_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterElement_spec) {
+             listener.enterElement_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitElement_spec) {
+             listener.exitElement_spec(this);
+        }
+    }
+}
+
+
+export class Element_spec_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public subprogram_spec(): Subprogram_specContext | null {
+        return this.getRuleContext(0, Subprogram_specContext);
+    }
+    public constructor_spec(): Constructor_specContext | null {
+        return this.getRuleContext(0, Constructor_specContext);
+    }
+    public map_order_function_spec(): Map_order_function_specContext | null {
+        return this.getRuleContext(0, Map_order_function_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_element_spec_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterElement_spec_options) {
+             listener.enterElement_spec_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitElement_spec_options) {
+             listener.exitElement_spec_options(this);
+        }
+    }
+}
+
+
+export class Subprogram_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public STATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATIC, 0);
+    }
+    public type_procedure_spec(): Type_procedure_specContext | null {
+        return this.getRuleContext(0, Type_procedure_specContext);
+    }
+    public type_function_spec(): Type_function_specContext | null {
+        return this.getRuleContext(0, Type_function_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subprogram_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubprogram_spec) {
+             listener.enterSubprogram_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubprogram_spec) {
+             listener.exitSubprogram_spec(this);
+        }
+    }
+}
+
+
+export class Overriding_subprogram_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OVERRIDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OVERRIDING, 0)!;
+    }
+    public MEMBER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEMBER, 0)!;
+    }
+    public overriding_function_spec(): Overriding_function_specContext | null {
+        return this.getRuleContext(0, Overriding_function_specContext);
+    }
+    public overriding_procedure_spec(): Overriding_procedure_specContext | null {
+        return this.getRuleContext(0, Overriding_procedure_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_overriding_subprogram_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOverriding_subprogram_spec) {
+             listener.enterOverriding_subprogram_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOverriding_subprogram_spec) {
+             listener.exitOverriding_subprogram_spec(this);
+        }
+    }
+}
+
+
+export class Overriding_function_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public SELF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELF, 0);
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public RESULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESULT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public SEMICOLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMICOLON, 0);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public PIPELINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PIPELINED, 0);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_overriding_function_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOverriding_function_spec) {
+             listener.enterOverriding_function_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOverriding_function_spec) {
+             listener.exitOverriding_function_spec(this);
+        }
+    }
+}
+
+
+export class Overriding_procedure_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public procedure_name(): Procedure_nameContext {
+        return this.getRuleContext(0, Procedure_nameContext)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMICOLON, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_overriding_procedure_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOverriding_procedure_spec) {
+             listener.enterOverriding_procedure_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOverriding_procedure_spec) {
+             listener.exitOverriding_procedure_spec(this);
+        }
+    }
+}
+
+
+export class Type_procedure_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROCEDURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURE, 0)!;
+    }
+    public procedure_name(): Procedure_nameContext {
+        return this.getRuleContext(0, Procedure_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_procedure_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_procedure_spec) {
+             listener.enterType_procedure_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_procedure_spec) {
+             listener.exitType_procedure_spec(this);
+        }
+    }
+}
+
+
+export class Type_function_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public function_name(): Function_nameContext {
+        return this.getRuleContext(0, Function_nameContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public SELF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELF, 0);
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public RESULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESULT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public VARIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARIABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_function_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_function_spec) {
+             listener.enterType_function_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_function_spec) {
+             listener.exitType_function_spec(this);
+        }
+    }
+}
+
+
+export class Constructor_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONSTRUCTOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONSTRUCTOR, 0)!;
+    }
+    public FUNCTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FUNCTION, 0)!;
+    }
+    public type_spec(): Type_specContext[];
+    public type_spec(i: number): Type_specContext | null;
+    public type_spec(i?: number): Type_specContext[] | Type_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_specContext);
+        }
+
+        return this.getRuleContext(i, Type_specContext);
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public SELF(): antlr.TerminalNode[];
+    public SELF(i: number): antlr.TerminalNode | null;
+    public SELF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SELF);
+    	} else {
+    		return this.getToken(PlSqlParser.SELF, i);
+    	}
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public RESULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESULT, 0)!;
+    }
+    public FINAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINAL, 0);
+    }
+    public INSTANTIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANTIABLE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public call_spec(): Call_specContext | null {
+        return this.getRuleContext(0, Call_specContext);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public OUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUT, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public type_elements_parameter(): Type_elements_parameterContext[];
+    public type_elements_parameter(i: number): Type_elements_parameterContext | null;
+    public type_elements_parameter(i?: number): Type_elements_parameterContext[] | Type_elements_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_elements_parameterContext);
+        }
+
+        return this.getRuleContext(i, Type_elements_parameterContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_constructor_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConstructor_spec) {
+             listener.enterConstructor_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConstructor_spec) {
+             listener.exitConstructor_spec(this);
+        }
+    }
+}
+
+
+export class Map_order_function_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEMBER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEMBER, 0)!;
+    }
+    public type_function_spec(): Type_function_specContext {
+        return this.getRuleContext(0, Type_function_specContext)!;
+    }
+    public MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAP, 0);
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_map_order_function_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMap_order_function_spec) {
+             listener.enterMap_order_function_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMap_order_function_spec) {
+             listener.exitMap_order_function_spec(this);
+        }
+    }
+}
+
+
+export class Pragma_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PRAGMA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PRAGMA, 0)!;
+    }
+    public RESTRICT_REFERENCES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESTRICT_REFERENCES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public pragma_elements(): Pragma_elementsContext[];
+    public pragma_elements(i: number): Pragma_elementsContext | null;
+    public pragma_elements(i?: number): Pragma_elementsContext[] | Pragma_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Pragma_elementsContext);
+        }
+
+        return this.getRuleContext(i, Pragma_elementsContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pragma_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPragma_clause) {
+             listener.enterPragma_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPragma_clause) {
+             listener.exitPragma_clause(this);
+        }
+    }
+}
+
+
+export class Pragma_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pragma_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPragma_elements) {
+             listener.enterPragma_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPragma_elements) {
+             listener.exitPragma_elements(this);
+        }
+    }
+}
+
+
+export class Type_elements_parameterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public parameter_name(): Parameter_nameContext {
+        return this.getRuleContext(0, Parameter_nameContext)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public OUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUT, 0);
+    }
+    public NOCOPY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOPY, 0);
+    }
+    public ASSIGN_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASSIGN_OP, 0);
+    }
+    public constant(): ConstantContext | null {
+        return this.getRuleContext(0, ConstantContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_elements_parameter;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_elements_parameter) {
+             listener.enterType_elements_parameter(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_elements_parameter) {
+             listener.exitType_elements_parameter(this);
+        }
+    }
+}
+
+
+export class Drop_sequenceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public SEQUENCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEQUENCE, 0)!;
+    }
+    public sequence_name(): Sequence_nameContext {
+        return this.getRuleContext(0, Sequence_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_sequence;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_sequence) {
+             listener.enterDrop_sequence(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_sequence) {
+             listener.exitDrop_sequence(this);
+        }
+    }
+}
+
+
+export class Alter_sequenceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public SEQUENCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEQUENCE, 0)!;
+    }
+    public sequence_name(): Sequence_nameContext {
+        return this.getRuleContext(0, Sequence_nameContext)!;
+    }
+    public sequence_spec(): Sequence_specContext[];
+    public sequence_spec(i: number): Sequence_specContext | null;
+    public sequence_spec(i?: number): Sequence_specContext[] | Sequence_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sequence_specContext);
+        }
+
+        return this.getRuleContext(i, Sequence_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_sequence;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_sequence) {
+             listener.enterAlter_sequence(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_sequence) {
+             listener.exitAlter_sequence(this);
+        }
+    }
+}
+
+
+export class Alter_sessionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public SESSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SESSION, 0)!;
+    }
+    public ADVISE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVISE, 0);
+    }
+    public CLOSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOSE, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public LINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINK, 0);
+    }
+    public parameter_name(): Parameter_nameContext | null {
+        return this.getRuleContext(0, Parameter_nameContext);
+    }
+    public enable_or_disable(): Enable_or_disableContext | null {
+        return this.getRuleContext(0, Enable_or_disableContext);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public PROCEDURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURE, 0);
+    }
+    public GUARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GUARD, 0);
+    }
+    public PARALLEL(): antlr.TerminalNode[];
+    public PARALLEL(i: number): antlr.TerminalNode | null;
+    public PARALLEL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARALLEL);
+    	} else {
+    		return this.getToken(PlSqlParser.PARALLEL, i);
+    	}
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public alter_session_set_clause(): Alter_session_set_clauseContext | null {
+        return this.getRuleContext(0, Alter_session_set_clauseContext);
+    }
+    public ROLLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLBACK, 0);
+    }
+    public NOTHING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOTHING, 0);
+    }
+    public DML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DML, 0);
+    }
+    public DDL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DDL, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public literal(): LiteralContext | null {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_session;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_session) {
+             listener.enterAlter_session(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_session) {
+             listener.exitAlter_session(this);
+        }
+    }
+}
+
+
+export class Alter_session_set_clauseContext extends antlr.ParserRuleContext {
+    public _en?: Id_expressionContext;
+    public _cn?: Id_expressionContext;
+    public _sn?: Id_expressionContext;
+    public _c?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public parameter_name(): Parameter_nameContext[];
+    public parameter_name(i: number): Parameter_nameContext | null;
+    public parameter_name(i?: number): Parameter_nameContext[] | Parameter_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parameter_nameContext);
+        }
+
+        return this.getRuleContext(i, Parameter_nameContext);
+    }
+    public EQUALS_OP(): antlr.TerminalNode[];
+    public EQUALS_OP(i: number): antlr.TerminalNode | null;
+    public EQUALS_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EQUALS_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.EQUALS_OP, i);
+    	}
+    }
+    public parameter_value(): Parameter_valueContext[];
+    public parameter_value(i: number): Parameter_valueContext | null;
+    public parameter_value(i?: number): Parameter_valueContext[] | Parameter_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parameter_valueContext);
+        }
+
+        return this.getRuleContext(i, Parameter_valueContext);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public CONTAINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER, 0);
+    }
+    public SERVICE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVICE, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public ARCHIVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVAL, 0);
+    }
+    public VISIBILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBILITY, 0);
+    }
+    public ACTIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVE, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public DEFAULT_COLLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT_COLLATION, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_session_set_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_session_set_clause) {
+             listener.enterAlter_session_set_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_session_set_clause) {
+             listener.exitAlter_session_set_clause(this);
+        }
+    }
+}
+
+
+export class Create_sequenceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public SEQUENCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEQUENCE, 0)!;
+    }
+    public sequence_name(): Sequence_nameContext {
+        return this.getRuleContext(0, Sequence_nameContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public sequence_spec(): Sequence_specContext[];
+    public sequence_spec(i: number): Sequence_specContext | null;
+    public sequence_spec(i?: number): Sequence_specContext[] | Sequence_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sequence_specContext);
+        }
+
+        return this.getRuleContext(i, Sequence_specContext);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_sequence;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_sequence) {
+             listener.enterCreate_sequence(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_sequence) {
+             listener.exitCreate_sequence(this);
+        }
+    }
+}
+
+
+export class Sequence_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INCREMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCREMENT, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public sequence_start_clause(): Sequence_start_clauseContext | null {
+        return this.getRuleContext(0, Sequence_start_clauseContext);
+    }
+    public MAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXVALUE, 0);
+    }
+    public NOMAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMAXVALUE, 0);
+    }
+    public MINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINVALUE, 0);
+    }
+    public NOMINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMINVALUE, 0);
+    }
+    public CYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CYCLE, 0);
+    }
+    public NOCYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCYCLE, 0);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public NOORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOORDER, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public NOKEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOKEEP, 0);
+    }
+    public SCALE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCALE, 0);
+    }
+    public EXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTEND, 0);
+    }
+    public NOEXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOEXTEND, 0);
+    }
+    public NOSCALE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSCALE, 0);
+    }
+    public SHARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARD, 0);
+    }
+    public NOSHARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSHARD, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public GLOBAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sequence_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSequence_spec) {
+             listener.enterSequence_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSequence_spec) {
+             listener.exitSequence_spec(this);
+        }
+    }
+}
+
+
+export class Sequence_start_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public START(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.START, 0)!;
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public APPROXIMATE_NUM_LIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPROXIMATE_NUM_LIT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sequence_start_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSequence_start_clause) {
+             listener.enterSequence_start_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSequence_start_clause) {
+             listener.exitSequence_start_clause(this);
+        }
+    }
+}
+
+
+export class Create_analytic_viewContext extends antlr.ParserRuleContext {
+    public _av?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public ANALYTIC(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ANALYTIC, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public cav_using_clause(): Cav_using_clauseContext | null {
+        return this.getRuleContext(0, Cav_using_clauseContext);
+    }
+    public dim_by_clause(): Dim_by_clauseContext | null {
+        return this.getRuleContext(0, Dim_by_clauseContext);
+    }
+    public measures_clause(): Measures_clauseContext | null {
+        return this.getRuleContext(0, Measures_clauseContext);
+    }
+    public default_measure_clause(): Default_measure_clauseContext | null {
+        return this.getRuleContext(0, Default_measure_clauseContext);
+    }
+    public default_aggregate_clause(): Default_aggregate_clauseContext | null {
+        return this.getRuleContext(0, Default_aggregate_clauseContext);
+    }
+    public cache_clause(): Cache_clauseContext | null {
+        return this.getRuleContext(0, Cache_clauseContext);
+    }
+    public fact_columns_clause(): Fact_columns_clauseContext | null {
+        return this.getRuleContext(0, Fact_columns_clauseContext);
+    }
+    public qry_transform_clause(): Qry_transform_clauseContext | null {
+        return this.getRuleContext(0, Qry_transform_clauseContext);
+    }
+    public NOFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOFORCE, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_analytic_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_analytic_view) {
+             listener.enterCreate_analytic_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_analytic_view) {
+             listener.exitCreate_analytic_view(this);
+        }
+    }
+}
+
+
+export class Classification_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public caption_clause(): Caption_clauseContext | null {
+        return this.getRuleContext(0, Caption_clauseContext);
+    }
+    public description_clause(): Description_clauseContext | null {
+        return this.getRuleContext(0, Description_clauseContext);
+    }
+    public classification_item(): Classification_itemContext[];
+    public classification_item(i: number): Classification_itemContext | null;
+    public classification_item(i?: number): Classification_itemContext[] | Classification_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_itemContext);
+        }
+
+        return this.getRuleContext(i, Classification_itemContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_classification_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClassification_clause) {
+             listener.enterClassification_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClassification_clause) {
+             listener.exitClassification_clause(this);
+        }
+    }
+}
+
+
+export class Caption_clauseContext extends antlr.ParserRuleContext {
+    public _c?: Quoted_stringContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CAPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CAPTION, 0)!;
+    }
+    public quoted_string(): Quoted_stringContext {
+        return this.getRuleContext(0, Quoted_stringContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_caption_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCaption_clause) {
+             listener.enterCaption_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCaption_clause) {
+             listener.exitCaption_clause(this);
+        }
+    }
+}
+
+
+export class Description_clauseContext extends antlr.ParserRuleContext {
+    public _d?: Quoted_stringContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DESCRIPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DESCRIPTION, 0)!;
+    }
+    public quoted_string(): Quoted_stringContext {
+        return this.getRuleContext(0, Quoted_stringContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_description_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDescription_clause) {
+             listener.enterDescription_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDescription_clause) {
+             listener.exitDescription_clause(this);
+        }
+    }
+}
+
+
+export class Classification_itemContext extends antlr.ParserRuleContext {
+    public _cn?: Id_expressionContext;
+    public _cv?: Quoted_stringContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CLASSIFICATION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLASSIFICATION, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public LANGUAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LANGUAGE, 0);
+    }
+    public language(): LanguageContext | null {
+        return this.getRuleContext(0, LanguageContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_classification_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClassification_item) {
+             listener.enterClassification_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClassification_item) {
+             listener.exitClassification_item(this);
+        }
+    }
+}
+
+
+export class LanguageContext extends antlr.ParserRuleContext {
+    public _nls?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_language;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLanguage) {
+             listener.enterLanguage(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLanguage) {
+             listener.exitLanguage(this);
+        }
+    }
+}
+
+
+export class Cav_using_clauseContext extends antlr.ParserRuleContext {
+    public _t?: Id_expressionContext;
+    public _ta?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public REMOTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOTE, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cav_using_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCav_using_clause) {
+             listener.enterCav_using_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCav_using_clause) {
+             listener.exitCav_using_clause(this);
+        }
+    }
+}
+
+
+export class Dim_by_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DIMENSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIMENSION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public dim_key(): Dim_keyContext[];
+    public dim_key(i: number): Dim_keyContext | null;
+    public dim_key(i?: number): Dim_keyContext[] | Dim_keyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Dim_keyContext);
+        }
+
+        return this.getRuleContext(i, Dim_keyContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dim_by_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDim_by_clause) {
+             listener.enterDim_by_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDim_by_clause) {
+             listener.exitDim_by_clause(this);
+        }
+    }
+}
+
+
+export class Dim_keyContext extends antlr.ParserRuleContext {
+    public _id_expression?: Id_expressionContext;
+    public _a: Id_expressionContext[] = [];
+    public _column_name?: Column_nameContext;
+    public _f: Column_nameContext[] = [];
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public dim_ref(): Dim_refContext {
+        return this.getRuleContext(0, Dim_refContext)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public REFERENCES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REFERENCES, 0)!;
+    }
+    public HIERARCHIES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHIES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public hier_ref(): Hier_refContext[];
+    public hier_ref(i: number): Hier_refContext | null;
+    public hier_ref(i?: number): Hier_refContext[] | Hier_refContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Hier_refContext);
+        }
+
+        return this.getRuleContext(i, Hier_refContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public attribute_name(): Attribute_nameContext[];
+    public attribute_name(i: number): Attribute_nameContext | null;
+    public attribute_name(i?: number): Attribute_nameContext[] | Attribute_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Attribute_nameContext);
+        }
+
+        return this.getRuleContext(i, Attribute_nameContext);
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINCT, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dim_key;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDim_key) {
+             listener.enterDim_key(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDim_key) {
+             listener.exitDim_key(this);
+        }
+    }
+}
+
+
+export class Dim_refContext extends antlr.ParserRuleContext {
+    public _ad?: Id_expressionContext;
+    public _da?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dim_ref;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDim_ref) {
+             listener.enterDim_ref(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDim_ref) {
+             listener.exitDim_ref(this);
+        }
+    }
+}
+
+
+export class Hier_refContext extends antlr.ParserRuleContext {
+    public _h?: Id_expressionContext;
+    public _ha?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hier_ref;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHier_ref) {
+             listener.enterHier_ref(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHier_ref) {
+             listener.exitHier_ref(this);
+        }
+    }
+}
+
+
+export class Measures_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEASURES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public av_measure(): Av_measureContext[];
+    public av_measure(i: number): Av_measureContext | null;
+    public av_measure(i?: number): Av_measureContext[] | Av_measureContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Av_measureContext);
+        }
+
+        return this.getRuleContext(i, Av_measureContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_measures_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMeasures_clause) {
+             listener.enterMeasures_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMeasures_clause) {
+             listener.exitMeasures_clause(this);
+        }
+    }
+}
+
+
+export class Av_measureContext extends antlr.ParserRuleContext {
+    public _mn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public base_meas_clause(): Base_meas_clauseContext | null {
+        return this.getRuleContext(0, Base_meas_clauseContext);
+    }
+    public calc_meas_clause(): Calc_meas_clauseContext | null {
+        return this.getRuleContext(0, Calc_meas_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_av_measure;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAv_measure) {
+             listener.enterAv_measure(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAv_measure) {
+             listener.exitAv_measure(this);
+        }
+    }
+}
+
+
+export class Base_meas_clauseContext extends antlr.ParserRuleContext {
+    public _bm?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FACT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FACT, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public meas_aggregate_clause(): Meas_aggregate_clauseContext | null {
+        return this.getRuleContext(0, Meas_aggregate_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_base_meas_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBase_meas_clause) {
+             listener.enterBase_meas_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBase_meas_clause) {
+             listener.exitBase_meas_clause(this);
+        }
+    }
+}
+
+
+export class Meas_aggregate_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AGGREGATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AGGREGATE, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public aggregate_function_name(): Aggregate_function_nameContext {
+        return this.getRuleContext(0, Aggregate_function_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_meas_aggregate_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMeas_aggregate_clause) {
+             listener.enterMeas_aggregate_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMeas_aggregate_clause) {
+             listener.exitMeas_aggregate_clause(this);
+        }
+    }
+}
+
+
+export class Calc_meas_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_calc_meas_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCalc_meas_clause) {
+             listener.enterCalc_meas_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCalc_meas_clause) {
+             listener.exitCalc_meas_clause(this);
+        }
+    }
+}
+
+
+export class Default_measure_clauseContext extends antlr.ParserRuleContext {
+    public _m?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public MEASURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_measure_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_measure_clause) {
+             listener.enterDefault_measure_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_measure_clause) {
+             listener.exitDefault_measure_clause(this);
+        }
+    }
+}
+
+
+export class Default_aggregate_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public AGGREGATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AGGREGATE, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public aggregate_function_name(): Aggregate_function_nameContext {
+        return this.getRuleContext(0, Aggregate_function_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_aggregate_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_aggregate_clause) {
+             listener.enterDefault_aggregate_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_aggregate_clause) {
+             listener.exitDefault_aggregate_clause(this);
+        }
+    }
+}
+
+
+export class Cache_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CACHE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CACHE, 0)!;
+    }
+    public cache_specification(): Cache_specificationContext[];
+    public cache_specification(i: number): Cache_specificationContext | null;
+    public cache_specification(i?: number): Cache_specificationContext[] | Cache_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Cache_specificationContext);
+        }
+
+        return this.getRuleContext(i, Cache_specificationContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cache_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCache_clause) {
+             listener.enterCache_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCache_clause) {
+             listener.exitCache_clause(this);
+        }
+    }
+}
+
+
+export class Cache_specificationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEASURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURE, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public levels_clause(): Levels_clauseContext[];
+    public levels_clause(i: number): Levels_clauseContext | null;
+    public levels_clause(i?: number): Levels_clauseContext[] | Levels_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Levels_clauseContext);
+        }
+
+        return this.getRuleContext(i, Levels_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cache_specification;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCache_specification) {
+             listener.enterCache_specification(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCache_specification) {
+             listener.exitCache_specification(this);
+        }
+    }
+}
+
+
+export class Levels_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEVELS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEVELS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public level_specification(): Level_specificationContext[];
+    public level_specification(i: number): Level_specificationContext | null;
+    public level_specification(i?: number): Level_specificationContext[] | Level_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Level_specificationContext);
+        }
+
+        return this.getRuleContext(i, Level_specificationContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public level_group_type(): Level_group_typeContext {
+        return this.getRuleContext(0, Level_group_typeContext)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_levels_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLevels_clause) {
+             listener.enterLevels_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLevels_clause) {
+             listener.exitLevels_clause(this);
+        }
+    }
+}
+
+
+export class Level_specificationContext extends antlr.ParserRuleContext {
+    public _d?: Id_expressionContext;
+    public _h?: Id_expressionContext;
+    public _l?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_level_specification;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLevel_specification) {
+             listener.enterLevel_specification(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLevel_specification) {
+             listener.exitLevel_specification(this);
+        }
+    }
+}
+
+
+export class Level_group_typeContext extends antlr.ParserRuleContext {
+    public _t?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DYNAMIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DYNAMIC, 0);
+    }
+    public MATERIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_level_group_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLevel_group_type) {
+             listener.enterLevel_group_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLevel_group_type) {
+             listener.exitLevel_group_type(this);
+        }
+    }
+}
+
+
+export class Fact_columns_clauseContext extends antlr.ParserRuleContext {
+    public _f?: Column_nameContext;
+    public _fa?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FACT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FACT, 0)!;
+    }
+    public COLUMN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_fact_columns_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFact_columns_clause) {
+             listener.enterFact_columns_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFact_columns_clause) {
+             listener.exitFact_columns_clause(this);
+        }
+    }
+}
+
+
+export class Qry_transform_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ENABLE, 0)!;
+    }
+    public QUERY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.QUERY, 0)!;
+    }
+    public TRANSFORM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRANSFORM, 0)!;
+    }
+    public RELY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELY, 0);
+    }
+    public NORELY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORELY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_qry_transform_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQry_transform_clause) {
+             listener.enterQry_transform_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQry_transform_clause) {
+             listener.exitQry_transform_clause(this);
+        }
+    }
+}
+
+
+export class Create_attribute_dimensionContext extends antlr.ParserRuleContext {
+    public _ad?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public ATTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0)!;
+    }
+    public DIMENSION(): antlr.TerminalNode[];
+    public DIMENSION(i: number): antlr.TerminalNode | null;
+    public DIMENSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DIMENSION);
+    	} else {
+    		return this.getToken(PlSqlParser.DIMENSION, i);
+    	}
+    }
+    public ad_using_clause(): Ad_using_clauseContext {
+        return this.getRuleContext(0, Ad_using_clauseContext)!;
+    }
+    public attributes_clause(): Attributes_clauseContext {
+        return this.getRuleContext(0, Attributes_clauseContext)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public ad_level_clause(): Ad_level_clauseContext[];
+    public ad_level_clause(i: number): Ad_level_clauseContext | null;
+    public ad_level_clause(i?: number): Ad_level_clauseContext[] | Ad_level_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Ad_level_clauseContext);
+        }
+
+        return this.getRuleContext(i, Ad_level_clauseContext);
+    }
+    public all_clause(): All_clauseContext | null {
+        return this.getRuleContext(0, All_clauseContext);
+    }
+    public NOFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOFORCE, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public STANDARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDARD, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_attribute_dimension;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_attribute_dimension) {
+             listener.enterCreate_attribute_dimension(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_attribute_dimension) {
+             listener.exitCreate_attribute_dimension(this);
+        }
+    }
+}
+
+
+export class Ad_using_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public source_clause(): Source_clauseContext[];
+    public source_clause(i: number): Source_clauseContext | null;
+    public source_clause(i?: number): Source_clauseContext[] | Source_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Source_clauseContext);
+        }
+
+        return this.getRuleContext(i, Source_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public join_path_clause(): Join_path_clauseContext[];
+    public join_path_clause(i: number): Join_path_clauseContext | null;
+    public join_path_clause(i?: number): Join_path_clauseContext[] | Join_path_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Join_path_clauseContext);
+        }
+
+        return this.getRuleContext(i, Join_path_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ad_using_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAd_using_clause) {
+             listener.enterAd_using_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAd_using_clause) {
+             listener.exitAd_using_clause(this);
+        }
+    }
+}
+
+
+export class Source_clauseContext extends antlr.ParserRuleContext {
+    public _ftov?: Id_expressionContext;
+    public _a?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public REMOTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOTE, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_source_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSource_clause) {
+             listener.enterSource_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSource_clause) {
+             listener.exitSource_clause(this);
+        }
+    }
+}
+
+
+export class Join_path_clauseContext extends antlr.ParserRuleContext {
+    public _jpn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public JOIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JOIN, 0)!;
+    }
+    public PATH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PATH, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public join_condition(): Join_conditionContext {
+        return this.getRuleContext(0, Join_conditionContext)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_join_path_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJoin_path_clause) {
+             listener.enterJoin_path_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJoin_path_clause) {
+             listener.exitJoin_path_clause(this);
+        }
+    }
+}
+
+
+export class Join_conditionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public join_condition_item(): Join_condition_itemContext[];
+    public join_condition_item(i: number): Join_condition_itemContext | null;
+    public join_condition_item(i?: number): Join_condition_itemContext[] | Join_condition_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Join_condition_itemContext);
+        }
+
+        return this.getRuleContext(i, Join_condition_itemContext);
+    }
+    public AND(): antlr.TerminalNode[];
+    public AND(i: number): antlr.TerminalNode | null;
+    public AND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AND);
+    	} else {
+    		return this.getToken(PlSqlParser.AND, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_join_condition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJoin_condition) {
+             listener.enterJoin_condition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJoin_condition) {
+             listener.exitJoin_condition(this);
+        }
+    }
+}
+
+
+export class Join_condition_itemContext extends antlr.ParserRuleContext {
+    public _a?: Id_expressionContext;
+    public _b?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_join_condition_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJoin_condition_item) {
+             listener.enterJoin_condition_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJoin_condition_item) {
+             listener.exitJoin_condition_item(this);
+        }
+    }
+}
+
+
+export class Attributes_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ATTRIBUTES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public ad_attributes_clause(): Ad_attributes_clauseContext[];
+    public ad_attributes_clause(i: number): Ad_attributes_clauseContext | null;
+    public ad_attributes_clause(i?: number): Ad_attributes_clauseContext[] | Ad_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Ad_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Ad_attributes_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_attributes_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAttributes_clause) {
+             listener.enterAttributes_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAttributes_clause) {
+             listener.exitAttributes_clause(this);
+        }
+    }
+}
+
+
+export class Ad_attributes_clauseContext extends antlr.ParserRuleContext {
+    public _a?: Id_expressionContext;
+    public _an?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ad_attributes_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAd_attributes_clause) {
+             listener.enterAd_attributes_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAd_attributes_clause) {
+             listener.exitAd_attributes_clause(this);
+        }
+    }
+}
+
+
+export class Ad_level_clauseContext extends antlr.ParserRuleContext {
+    public _l?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEVEL(): antlr.TerminalNode[];
+    public LEVEL(i: number): antlr.TerminalNode | null;
+    public LEVEL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEVEL);
+    	} else {
+    		return this.getToken(PlSqlParser.LEVEL, i);
+    	}
+    }
+    public key_clause(): Key_clauseContext {
+        return this.getRuleContext(0, Key_clauseContext)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public SKIP_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_, 0);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public alternate_key_clause(): Alternate_key_clauseContext | null {
+        return this.getRuleContext(0, Alternate_key_clauseContext);
+    }
+    public MEMBER(): antlr.TerminalNode[];
+    public MEMBER(i: number): antlr.TerminalNode | null;
+    public MEMBER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MEMBER);
+    	} else {
+    		return this.getToken(PlSqlParser.MEMBER, i);
+    	}
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public CAPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAPTION, 0);
+    }
+    public DESCRIPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DESCRIPTION, 0);
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public dim_order_clause(): Dim_order_clauseContext[];
+    public dim_order_clause(i: number): Dim_order_clauseContext | null;
+    public dim_order_clause(i?: number): Dim_order_clauseContext[] | Dim_order_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Dim_order_clauseContext);
+        }
+
+        return this.getRuleContext(i, Dim_order_clauseContext);
+    }
+    public DETERMINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DETERMINES, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public STANDARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDARD, 0);
+    }
+    public YEARS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEARS, 0);
+    }
+    public HALF_YEARS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HALF_YEARS, 0);
+    }
+    public QUARTERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUARTERS, 0);
+    }
+    public MONTHS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTHS, 0);
+    }
+    public WEEKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WEEKS, 0);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public HOURS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HOURS, 0);
+    }
+    public MINUTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUTES, 0);
+    }
+    public SECONDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECONDS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public MIN(): antlr.TerminalNode[];
+    public MIN(i: number): antlr.TerminalNode | null;
+    public MIN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MIN);
+    	} else {
+    		return this.getToken(PlSqlParser.MIN, i);
+    	}
+    }
+    public MAX(): antlr.TerminalNode[];
+    public MAX(i: number): antlr.TerminalNode | null;
+    public MAX(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MAX);
+    	} else {
+    		return this.getToken(PlSqlParser.MAX, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ad_level_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAd_level_clause) {
+             listener.enterAd_level_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAd_level_clause) {
+             listener.exitAd_level_clause(this);
+        }
+    }
+}
+
+
+export class Key_clauseContext extends antlr.ParserRuleContext {
+    public _a?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_key_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterKey_clause) {
+             listener.enterKey_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitKey_clause) {
+             listener.exitKey_clause(this);
+        }
+    }
+}
+
+
+export class Alternate_key_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTERNATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTERNATE, 0)!;
+    }
+    public key_clause(): Key_clauseContext {
+        return this.getRuleContext(0, Key_clauseContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alternate_key_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlternate_key_clause) {
+             listener.enterAlternate_key_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlternate_key_clause) {
+             listener.exitAlternate_key_clause(this);
+        }
+    }
+}
+
+
+export class Dim_order_clauseContext extends antlr.ParserRuleContext {
+    public _a?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public NULLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLS, 0);
+    }
+    public ASC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASC, 0);
+    }
+    public DESC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DESC, 0);
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public LAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dim_order_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDim_order_clause) {
+             listener.enterDim_order_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDim_order_clause) {
+             listener.exitDim_order_clause(this);
+        }
+    }
+}
+
+
+export class All_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALL, 0)!;
+    }
+    public MEMBER(): antlr.TerminalNode[];
+    public MEMBER(i: number): antlr.TerminalNode | null;
+    public MEMBER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MEMBER);
+    	} else {
+    		return this.getToken(PlSqlParser.MEMBER, i);
+    	}
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public CAPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAPTION, 0);
+    }
+    public DESCRIPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DESCRIPTION, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_all_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAll_clause) {
+             listener.enterAll_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAll_clause) {
+             listener.exitAll_clause(this);
+        }
+    }
+}
+
+
+export class Create_audit_policyContext extends antlr.ParserRuleContext {
+    public _p?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public AUDIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUDIT, 0)!;
+    }
+    public POLICY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.POLICY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public privilege_audit_clause(): Privilege_audit_clauseContext | null {
+        return this.getRuleContext(0, Privilege_audit_clauseContext);
+    }
+    public action_audit_clause(): Action_audit_clauseContext | null {
+        return this.getRuleContext(0, Action_audit_clauseContext);
+    }
+    public role_audit_clause(): Role_audit_clauseContext | null {
+        return this.getRuleContext(0, Role_audit_clauseContext);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public EVALUATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALUATE, 0);
+    }
+    public PER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PER, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public TOPLEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TOPLEVEL, 0);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public STATEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENT, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public INSTANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_audit_policy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_audit_policy) {
+             listener.enterCreate_audit_policy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_audit_policy) {
+             listener.exitCreate_audit_policy(this);
+        }
+    }
+}
+
+
+export class Privilege_audit_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PRIVILEGES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PRIVILEGES, 0)!;
+    }
+    public system_privilege(): System_privilegeContext[];
+    public system_privilege(i: number): System_privilegeContext | null;
+    public system_privilege(i?: number): System_privilegeContext[] | System_privilegeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(System_privilegeContext);
+        }
+
+        return this.getRuleContext(i, System_privilegeContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_privilege_audit_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPrivilege_audit_clause) {
+             listener.enterPrivilege_audit_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPrivilege_audit_clause) {
+             listener.exitPrivilege_audit_clause(this);
+        }
+    }
+}
+
+
+export class Action_audit_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public standard_actions(): Standard_actionsContext[];
+    public standard_actions(i: number): Standard_actionsContext | null;
+    public standard_actions(i?: number): Standard_actionsContext[] | Standard_actionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Standard_actionsContext);
+        }
+
+        return this.getRuleContext(i, Standard_actionsContext);
+    }
+    public component_actions(): Component_actionsContext[];
+    public component_actions(i: number): Component_actionsContext | null;
+    public component_actions(i?: number): Component_actionsContext[] | Component_actionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Component_actionsContext);
+        }
+
+        return this.getRuleContext(i, Component_actionsContext);
+    }
+    public system_actions(): System_actionsContext[];
+    public system_actions(i: number): System_actionsContext | null;
+    public system_actions(i?: number): System_actionsContext[] | System_actionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(System_actionsContext);
+        }
+
+        return this.getRuleContext(i, System_actionsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_action_audit_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAction_audit_clause) {
+             listener.enterAction_audit_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAction_audit_clause) {
+             listener.exitAction_audit_clause(this);
+        }
+    }
+}
+
+
+export class System_actionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACTIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ACTIONS, 0)!;
+    }
+    public system_privilege(): System_privilegeContext[];
+    public system_privilege(i: number): System_privilegeContext | null;
+    public system_privilege(i?: number): System_privilegeContext[] | System_privilegeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(System_privilegeContext);
+        }
+
+        return this.getRuleContext(i, System_privilegeContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_system_actions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSystem_actions) {
+             listener.enterSystem_actions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSystem_actions) {
+             listener.exitSystem_actions(this);
+        }
+    }
+}
+
+
+export class Standard_actionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACTIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ACTIONS, 0)!;
+    }
+    public actions_clause(): Actions_clauseContext[];
+    public actions_clause(i: number): Actions_clauseContext | null;
+    public actions_clause(i?: number): Actions_clauseContext[] | Actions_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Actions_clauseContext);
+        }
+
+        return this.getRuleContext(i, Actions_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_standard_actions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStandard_actions) {
+             listener.enterStandard_actions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStandard_actions) {
+             listener.exitStandard_actions(this);
+        }
+    }
+}
+
+
+export class Actions_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public object_action(): Object_actionContext | null {
+        return this.getRuleContext(0, Object_actionContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public directory_name(): Directory_nameContext | null {
+        return this.getRuleContext(0, Directory_nameContext);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public MINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINING, 0);
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public system_action(): System_actionContext | null {
+        return this.getRuleContext(0, System_actionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_actions_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterActions_clause) {
+             listener.enterActions_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitActions_clause) {
+             listener.exitActions_clause(this);
+        }
+    }
+}
+
+
+export class Object_actionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public GRANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GRANT, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUDIT, 0);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public LOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCK, 0);
+    }
+    public SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELECT, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public FLASHBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASHBACK, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_action;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_action) {
+             listener.enterObject_action(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_action) {
+             listener.exitObject_action(this);
+        }
+    }
+}
+
+
+export class System_actionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public JAVA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JAVA, 0);
+    }
+    public CREATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE, 0);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public LOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCK, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_system_action;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSystem_action) {
+             listener.enterSystem_action(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSystem_action) {
+             listener.exitSystem_action(this);
+        }
+    }
+}
+
+
+export class Component_actionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACTIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ACTIONS, 0)!;
+    }
+    public COMPONENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMPONENT, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public component_action(): Component_actionContext[];
+    public component_action(i: number): Component_actionContext | null;
+    public component_action(i?: number): Component_actionContext[] | Component_actionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Component_actionContext);
+        }
+
+        return this.getRuleContext(i, Component_actionContext);
+    }
+    public DV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DV, 0);
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PROTOCOL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROTOCOL, 0);
+    }
+    public DATAPUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAPUMP, 0);
+    }
+    public DIRECT_LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECT_LOAD, 0);
+    }
+    public OLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLS, 0);
+    }
+    public XS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XS, 0);
+    }
+    public FTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FTP, 0);
+    }
+    public HTTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HTTP, 0);
+    }
+    public AUTHENTICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHENTICATION, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_component_actions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComponent_actions) {
+             listener.enterComponent_actions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComponent_actions) {
+             listener.exitComponent_actions(this);
+        }
+    }
+}
+
+
+export class Component_actionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_component_action;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComponent_action) {
+             listener.enterComponent_action(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComponent_action) {
+             listener.exitComponent_action(this);
+        }
+    }
+}
+
+
+export class Role_audit_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ROLES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLES, 0)!;
+    }
+    public role_name(): Role_nameContext[];
+    public role_name(i: number): Role_nameContext | null;
+    public role_name(i?: number): Role_nameContext[] | Role_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Role_nameContext);
+        }
+
+        return this.getRuleContext(i, Role_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_role_audit_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRole_audit_clause) {
+             listener.enterRole_audit_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRole_audit_clause) {
+             listener.exitRole_audit_clause(this);
+        }
+    }
+}
+
+
+export class Create_controlfileContext extends antlr.ParserRuleContext {
+    public _d?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public CONTROLFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTROLFILE, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public RESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESETLOGS, 0);
+    }
+    public NORESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORESETLOGS, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public logfile_clause(): Logfile_clauseContext | null {
+        return this.getRuleContext(0, Logfile_clauseContext);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public file_specification(): File_specificationContext[];
+    public file_specification(i: number): File_specificationContext | null;
+    public file_specification(i?: number): File_specificationContext[] | File_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(File_specificationContext);
+        }
+
+        return this.getRuleContext(i, File_specificationContext);
+    }
+    public controlfile_options(): Controlfile_optionsContext[];
+    public controlfile_options(i: number): Controlfile_optionsContext | null;
+    public controlfile_options(i?: number): Controlfile_optionsContext[] | Controlfile_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Controlfile_optionsContext);
+        }
+
+        return this.getRuleContext(i, Controlfile_optionsContext);
+    }
+    public character_set_clause(): Character_set_clauseContext | null {
+        return this.getRuleContext(0, Character_set_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_controlfile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_controlfile) {
+             listener.enterCreate_controlfile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_controlfile) {
+             listener.exitCreate_controlfile(this);
+        }
+    }
+}
+
+
+export class Controlfile_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MAXLOGFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGFILES, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public MAXLOGMEMBERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGMEMBERS, 0);
+    }
+    public MAXLOGHISTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGHISTORY, 0);
+    }
+    public MAXDATAFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXDATAFILES, 0);
+    }
+    public MAXINSTANCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXINSTANCES, 0);
+    }
+    public ARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVELOG, 0);
+    }
+    public NOARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOARCHIVELOG, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public NOLOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOGGING, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public AVAILABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVAILABILITY, 0);
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public PERFORMANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERFORMANCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_controlfile_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterControlfile_options) {
+             listener.enterControlfile_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitControlfile_options) {
+             listener.exitControlfile_options(this);
+        }
+    }
+}
+
+
+export class Logfile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOGFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGFILE, 0)!;
+    }
+    public file_specification(): File_specificationContext[];
+    public file_specification(i: number): File_specificationContext | null;
+    public file_specification(i?: number): File_specificationContext[] | File_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(File_specificationContext);
+        }
+
+        return this.getRuleContext(i, File_specificationContext);
+    }
+    public numeric(): NumericContext[];
+    public numeric(i: number): NumericContext | null;
+    public numeric(i?: number): NumericContext[] | NumericContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(NumericContext);
+        }
+
+        return this.getRuleContext(i, NumericContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public GROUP(): antlr.TerminalNode[];
+    public GROUP(i: number): antlr.TerminalNode | null;
+    public GROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.GROUP, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logfile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogfile_clause) {
+             listener.enterLogfile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogfile_clause) {
+             listener.exitLogfile_clause(this);
+        }
+    }
+}
+
+
+export class Character_set_clauseContext extends antlr.ParserRuleContext {
+    public _cs?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHARACTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHARACTER, 0)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_character_set_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCharacter_set_clause) {
+             listener.enterCharacter_set_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCharacter_set_clause) {
+             listener.exitCharacter_set_clause(this);
+        }
+    }
+}
+
+
+export class File_specificationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public datafile_tempfile_spec(): Datafile_tempfile_specContext | null {
+        return this.getRuleContext(0, Datafile_tempfile_specContext);
+    }
+    public redo_log_file_spec(): Redo_log_file_specContext | null {
+        return this.getRuleContext(0, Redo_log_file_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_file_specification;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFile_specification) {
+             listener.enterFile_specification(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFile_specification) {
+             listener.exitFile_specification(this);
+        }
+    }
+}
+
+
+export class Create_diskgroupContext extends antlr.ParserRuleContext {
+    public _sn?: Id_expressionContext;
+    public _fg?: Id_expressionContext;
+    public _an?: Token | null;
+    public _av?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public DISKGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISKGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public REDUNDANCY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDUNDANCY, 0);
+    }
+    public DISK(): antlr.TerminalNode[];
+    public DISK(i: number): antlr.TerminalNode | null;
+    public DISK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISK);
+    	} else {
+    		return this.getToken(PlSqlParser.DISK, i);
+    	}
+    }
+    public qualified_disk_clause(): Qualified_disk_clauseContext[];
+    public qualified_disk_clause(i: number): Qualified_disk_clauseContext | null;
+    public qualified_disk_clause(i?: number): Qualified_disk_clauseContext[] | Qualified_disk_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Qualified_disk_clauseContext);
+        }
+
+        return this.getRuleContext(i, Qualified_disk_clauseContext);
+    }
+    public ATTRIBUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode[];
+    public EQUALS_OP(i: number): antlr.TerminalNode | null;
+    public EQUALS_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EQUALS_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.EQUALS_OP, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public NORMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORMAL, 0);
+    }
+    public FLEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLEX, 0);
+    }
+    public EXTENDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENDED, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public quorum_regular(): Quorum_regularContext[];
+    public quorum_regular(i: number): Quorum_regularContext | null;
+    public quorum_regular(i?: number): Quorum_regularContext[] | Quorum_regularContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quorum_regularContext);
+        }
+
+        return this.getRuleContext(i, Quorum_regularContext);
+    }
+    public FAILGROUP(): antlr.TerminalNode[];
+    public FAILGROUP(i: number): antlr.TerminalNode | null;
+    public FAILGROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FAILGROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.FAILGROUP, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public SITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SITE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_diskgroup;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_diskgroup) {
+             listener.enterCreate_diskgroup(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_diskgroup) {
+             listener.exitCreate_diskgroup(this);
+        }
+    }
+}
+
+
+export class Qualified_disk_clauseContext extends antlr.ParserRuleContext {
+    public _ss?: Token | null;
+    public _dn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public force_noforce(): Force_noforceContext | null {
+        return this.getRuleContext(0, Force_noforceContext);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_qualified_disk_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQualified_disk_clause) {
+             listener.enterQualified_disk_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQualified_disk_clause) {
+             listener.exitQualified_disk_clause(this);
+        }
+    }
+}
+
+
+export class Create_editionContext extends antlr.ParserRuleContext {
+    public _e?: Id_expressionContext;
+    public _pe?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public EDITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EDITION, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public CHILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHILD, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_edition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_edition) {
+             listener.enterCreate_edition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_edition) {
+             listener.exitCreate_edition(this);
+        }
+    }
+}
+
+
+export class Create_flashback_archiveContext extends antlr.ParserRuleContext {
+    public _fa?: Id_expressionContext;
+    public _ts?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public FLASHBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLASHBACK, 0)!;
+    }
+    public ARCHIVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ARCHIVE, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public flashback_archive_retention(): Flashback_archive_retentionContext {
+        return this.getRuleContext(0, Flashback_archive_retentionContext)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public flashback_archive_quota(): Flashback_archive_quotaContext | null {
+        return this.getRuleContext(0, Flashback_archive_quotaContext);
+    }
+    public OPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIMIZE, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_flashback_archive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_flashback_archive) {
+             listener.enterCreate_flashback_archive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_flashback_archive) {
+             listener.exitCreate_flashback_archive(this);
+        }
+    }
+}
+
+
+export class Flashback_archive_quotaContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public QUOTA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.QUOTA, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public M_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.M_LETTER, 0);
+    }
+    public G_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.G_LETTER, 0);
+    }
+    public T_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.T_LETTER, 0);
+    }
+    public P_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.P_LETTER, 0);
+    }
+    public E_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.E_LETTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_flashback_archive_quota;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFlashback_archive_quota) {
+             listener.enterFlashback_archive_quota(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFlashback_archive_quota) {
+             listener.exitFlashback_archive_quota(this);
+        }
+    }
+}
+
+
+export class Flashback_archive_retentionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETENTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETENTION, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTH, 0);
+    }
+    public DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_flashback_archive_retention;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFlashback_archive_retention) {
+             listener.enterFlashback_archive_retention(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFlashback_archive_retention) {
+             listener.exitFlashback_archive_retention(this);
+        }
+    }
+}
+
+
+export class Create_hierarchyContext extends antlr.ParserRuleContext {
+    public _h?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public HIERARCHY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHY, 0)!;
+    }
+    public hier_using_clause(): Hier_using_clauseContext {
+        return this.getRuleContext(0, Hier_using_clauseContext)!;
+    }
+    public level_hier_clause(): Level_hier_clauseContext {
+        return this.getRuleContext(0, Level_hier_clauseContext)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public hier_attrs_clause(): Hier_attrs_clauseContext | null {
+        return this.getRuleContext(0, Hier_attrs_clauseContext);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_hierarchy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_hierarchy) {
+             listener.enterCreate_hierarchy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_hierarchy) {
+             listener.exitCreate_hierarchy(this);
+        }
+    }
+}
+
+
+export class Hier_using_clauseContext extends antlr.ParserRuleContext {
+    public _ad?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hier_using_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHier_using_clause) {
+             listener.enterHier_using_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHier_using_clause) {
+             listener.exitHier_using_clause(this);
+        }
+    }
+}
+
+
+export class Level_hier_clauseContext extends antlr.ParserRuleContext {
+    public _l?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public CHILD(): antlr.TerminalNode[];
+    public CHILD(i: number): antlr.TerminalNode | null;
+    public CHILD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHILD);
+    	} else {
+    		return this.getToken(PlSqlParser.CHILD, i);
+    	}
+    }
+    public OF(): antlr.TerminalNode[];
+    public OF(i: number): antlr.TerminalNode | null;
+    public OF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OF);
+    	} else {
+    		return this.getToken(PlSqlParser.OF, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_level_hier_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLevel_hier_clause) {
+             listener.enterLevel_hier_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLevel_hier_clause) {
+             listener.exitLevel_hier_clause(this);
+        }
+    }
+}
+
+
+export class Hier_attrs_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public HIERARCHICAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHICAL, 0)!;
+    }
+    public ATTRIBUTES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public hier_attr_clause(): Hier_attr_clauseContext {
+        return this.getRuleContext(0, Hier_attr_clauseContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hier_attrs_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHier_attrs_clause) {
+             listener.enterHier_attrs_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHier_attrs_clause) {
+             listener.exitHier_attrs_clause(this);
+        }
+    }
+}
+
+
+export class Hier_attr_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public hier_attr_name(): Hier_attr_nameContext {
+        return this.getRuleContext(0, Hier_attr_nameContext)!;
+    }
+    public classification_clause(): Classification_clauseContext[];
+    public classification_clause(i: number): Classification_clauseContext | null;
+    public classification_clause(i?: number): Classification_clauseContext[] | Classification_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Classification_clauseContext);
+        }
+
+        return this.getRuleContext(i, Classification_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hier_attr_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHier_attr_clause) {
+             listener.enterHier_attr_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHier_attr_clause) {
+             listener.exitHier_attr_clause(this);
+        }
+    }
+}
+
+
+export class Hier_attr_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEMBER_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_NAME, 0);
+    }
+    public MEMBER_UNIQUE_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_UNIQUE_NAME, 0);
+    }
+    public MEMBER_CAPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_CAPTION, 0);
+    }
+    public MEMBER_DESCRIPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_DESCRIPTION, 0);
+    }
+    public LEVEL_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVEL_NAME, 0);
+    }
+    public HIER_ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIER_ORDER, 0);
+    }
+    public DEPTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEPTH, 0);
+    }
+    public IS_LEAF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS_LEAF, 0);
+    }
+    public PARENT_LEVEL_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT_LEVEL_NAME, 0);
+    }
+    public PARENT_UNIQUE_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT_UNIQUE_NAME, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hier_attr_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHier_attr_name) {
+             listener.enterHier_attr_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHier_attr_name) {
+             listener.exitHier_attr_name(this);
+        }
+    }
+}
+
+
+export class Create_indexContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public INDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEX, 0)!;
+    }
+    public index_name(): Index_nameContext {
+        return this.getRuleContext(0, Index_nameContext)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public cluster_index_clause(): Cluster_index_clauseContext | null {
+        return this.getRuleContext(0, Cluster_index_clauseContext);
+    }
+    public table_index_clause(): Table_index_clauseContext | null {
+        return this.getRuleContext(0, Table_index_clauseContext);
+    }
+    public bitmap_join_index_clause(): Bitmap_join_index_clauseContext | null {
+        return this.getRuleContext(0, Bitmap_join_index_clauseContext);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public INVALIDATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVALIDATION, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public BITMAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITMAP, 0);
+    }
+    public USABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USABLE, 0);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public DEFERRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFERRED, 0);
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_index;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_index) {
+             listener.enterCreate_index(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_index) {
+             listener.exitCreate_index(this);
+        }
+    }
+}
+
+
+export class Cluster_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CLUSTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLUSTER, 0)!;
+    }
+    public cluster_name(): Cluster_nameContext {
+        return this.getRuleContext(0, Cluster_nameContext)!;
+    }
+    public index_attributes(): Index_attributesContext | null {
+        return this.getRuleContext(0, Index_attributesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cluster_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCluster_index_clause) {
+             listener.enterCluster_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCluster_index_clause) {
+             listener.exitCluster_index_clause(this);
+        }
+    }
+}
+
+
+export class Cluster_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cluster_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCluster_name) {
+             listener.enterCluster_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCluster_name) {
+             listener.exitCluster_name(this);
+        }
+    }
+}
+
+
+export class Table_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public index_expr(): Index_exprContext[];
+    public index_expr(i: number): Index_exprContext | null;
+    public index_expr(i?: number): Index_exprContext[] | Index_exprContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Index_exprContext);
+        }
+
+        return this.getRuleContext(i, Index_exprContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public index_properties(): Index_propertiesContext | null {
+        return this.getRuleContext(0, Index_propertiesContext);
+    }
+    public ASC(): antlr.TerminalNode[];
+    public ASC(i: number): antlr.TerminalNode | null;
+    public ASC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ASC);
+    	} else {
+    		return this.getToken(PlSqlParser.ASC, i);
+    	}
+    }
+    public DESC(): antlr.TerminalNode[];
+    public DESC(i: number): antlr.TerminalNode | null;
+    public DESC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DESC);
+    	} else {
+    		return this.getToken(PlSqlParser.DESC, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_index_clause) {
+             listener.enterTable_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_index_clause) {
+             listener.exitTable_index_clause(this);
+        }
+    }
+}
+
+
+export class Bitmap_join_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext[];
+    public tableview_name(i: number): Tableview_nameContext | null;
+    public tableview_name(i?: number): Tableview_nameContext[] | Tableview_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tableview_nameContext);
+        }
+
+        return this.getRuleContext(i, Tableview_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public table_alias(): Table_aliasContext[];
+    public table_alias(i: number): Table_aliasContext | null;
+    public table_alias(i?: number): Table_aliasContext[] | Table_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_aliasContext);
+        }
+
+        return this.getRuleContext(i, Table_aliasContext);
+    }
+    public where_clause(): Where_clauseContext {
+        return this.getRuleContext(0, Where_clauseContext)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public local_partitioned_index(): Local_partitioned_indexContext | null {
+        return this.getRuleContext(0, Local_partitioned_indexContext);
+    }
+    public index_attributes(): Index_attributesContext | null {
+        return this.getRuleContext(0, Index_attributesContext);
+    }
+    public ASC(): antlr.TerminalNode[];
+    public ASC(i: number): antlr.TerminalNode | null;
+    public ASC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ASC);
+    	} else {
+    		return this.getToken(PlSqlParser.ASC, i);
+    	}
+    }
+    public DESC(): antlr.TerminalNode[];
+    public DESC(i: number): antlr.TerminalNode | null;
+    public DESC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DESC);
+    	} else {
+    		return this.getToken(PlSqlParser.DESC, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_bitmap_join_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBitmap_join_index_clause) {
+             listener.enterBitmap_join_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBitmap_join_index_clause) {
+             listener.exitBitmap_join_index_clause(this);
+        }
+    }
+}
+
+
+export class Index_exprContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_expr;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_expr) {
+             listener.enterIndex_expr(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_expr) {
+             listener.exitIndex_expr(this);
+        }
+    }
+}
+
+
+export class Index_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INDEXTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXTYPE, 0);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public domain_index_clause(): Domain_index_clauseContext | null {
+        return this.getRuleContext(0, Domain_index_clauseContext);
+    }
+    public xmlindex_clause(): Xmlindex_clauseContext | null {
+        return this.getRuleContext(0, Xmlindex_clauseContext);
+    }
+    public global_partitioned_index(): Global_partitioned_indexContext[];
+    public global_partitioned_index(i: number): Global_partitioned_indexContext | null;
+    public global_partitioned_index(i?: number): Global_partitioned_indexContext[] | Global_partitioned_indexContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Global_partitioned_indexContext);
+        }
+
+        return this.getRuleContext(i, Global_partitioned_indexContext);
+    }
+    public local_partitioned_index(): Local_partitioned_indexContext[];
+    public local_partitioned_index(i: number): Local_partitioned_indexContext | null;
+    public local_partitioned_index(i?: number): Local_partitioned_indexContext[] | Local_partitioned_indexContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Local_partitioned_indexContext);
+        }
+
+        return this.getRuleContext(i, Local_partitioned_indexContext);
+    }
+    public index_attributes(): Index_attributesContext[];
+    public index_attributes(i: number): Index_attributesContext | null;
+    public index_attributes(i?: number): Index_attributesContext[] | Index_attributesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Index_attributesContext);
+        }
+
+        return this.getRuleContext(i, Index_attributesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_properties) {
+             listener.enterIndex_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_properties) {
+             listener.exitIndex_properties(this);
+        }
+    }
+}
+
+
+export class Domain_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public indextype(): IndextypeContext {
+        return this.getRuleContext(0, IndextypeContext)!;
+    }
+    public local_domain_index_clause(): Local_domain_index_clauseContext | null {
+        return this.getRuleContext(0, Local_domain_index_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public PARAMETERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAMETERS, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public odci_parameters(): Odci_parametersContext | null {
+        return this.getRuleContext(0, Odci_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_domain_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDomain_index_clause) {
+             listener.enterDomain_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDomain_index_clause) {
+             listener.exitDomain_index_clause(this);
+        }
+    }
+}
+
+
+export class Local_domain_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOCAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCAL, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public PARAMETERS(): antlr.TerminalNode[];
+    public PARAMETERS(i: number): antlr.TerminalNode | null;
+    public PARAMETERS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARAMETERS);
+    	} else {
+    		return this.getToken(PlSqlParser.PARAMETERS, i);
+    	}
+    }
+    public odci_parameters(): Odci_parametersContext[];
+    public odci_parameters(i: number): Odci_parametersContext | null;
+    public odci_parameters(i?: number): Odci_parametersContext[] | Odci_parametersContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Odci_parametersContext);
+        }
+
+        return this.getRuleContext(i, Odci_parametersContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_local_domain_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLocal_domain_index_clause) {
+             listener.enterLocal_domain_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLocal_domain_index_clause) {
+             listener.exitLocal_domain_index_clause(this);
+        }
+    }
+}
+
+
+export class Xmlindex_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public XMLINDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.XMLINDEX, 0)!;
+    }
+    public XDB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XDB, 0);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public local_xmlindex_clause(): Local_xmlindex_clauseContext | null {
+        return this.getRuleContext(0, Local_xmlindex_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlindex_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlindex_clause) {
+             listener.enterXmlindex_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlindex_clause) {
+             listener.exitXmlindex_clause(this);
+        }
+    }
+}
+
+
+export class Local_xmlindex_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOCAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCAL, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_local_xmlindex_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLocal_xmlindex_clause) {
+             listener.enterLocal_xmlindex_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLocal_xmlindex_clause) {
+             listener.exitLocal_xmlindex_clause(this);
+        }
+    }
+}
+
+
+export class Global_partitioned_indexContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GLOBAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GLOBAL, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANGE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public index_partitioning_clause(): Index_partitioning_clauseContext[];
+    public index_partitioning_clause(i: number): Index_partitioning_clauseContext | null;
+    public index_partitioning_clause(i?: number): Index_partitioning_clauseContext[] | Index_partitioning_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Index_partitioning_clauseContext);
+        }
+
+        return this.getRuleContext(i, Index_partitioning_clauseContext);
+    }
+    public HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASH, 0);
+    }
+    public individual_hash_partitions(): Individual_hash_partitionsContext | null {
+        return this.getRuleContext(0, Individual_hash_partitionsContext);
+    }
+    public hash_partitions_by_quantity(): Hash_partitions_by_quantityContext | null {
+        return this.getRuleContext(0, Hash_partitions_by_quantityContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_global_partitioned_index;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGlobal_partitioned_index) {
+             listener.enterGlobal_partitioned_index(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGlobal_partitioned_index) {
+             listener.exitGlobal_partitioned_index(this);
+        }
+    }
+}
+
+
+export class Index_partitioning_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public VALUES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VALUES, 0)!;
+    }
+    public LESS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LESS, 0)!;
+    }
+    public THAN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THAN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public index_partitioning_values_list(): Index_partitioning_values_listContext {
+        return this.getRuleContext(0, Index_partitioning_values_listContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext | null {
+        return this.getRuleContext(0, Segment_attributes_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_partitioning_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_partitioning_clause) {
+             listener.enterIndex_partitioning_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_partitioning_clause) {
+             listener.exitIndex_partitioning_clause(this);
+        }
+    }
+}
+
+
+export class Index_partitioning_values_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public literal(): LiteralContext[];
+    public literal(i: number): LiteralContext | null;
+    public literal(i?: number): LiteralContext[] | LiteralContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(LiteralContext);
+        }
+
+        return this.getRuleContext(i, LiteralContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public TIMESTAMP(): antlr.TerminalNode[];
+    public TIMESTAMP(i: number): antlr.TerminalNode | null;
+    public TIMESTAMP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TIMESTAMP);
+    	} else {
+    		return this.getToken(PlSqlParser.TIMESTAMP, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_partitioning_values_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_partitioning_values_list) {
+             listener.enterIndex_partitioning_values_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_partitioning_values_list) {
+             listener.exitIndex_partitioning_values_list(this);
+        }
+    }
+}
+
+
+export class Local_partitioned_indexContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOCAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCAL, 0)!;
+    }
+    public on_range_partitioned_table(): On_range_partitioned_tableContext | null {
+        return this.getRuleContext(0, On_range_partitioned_tableContext);
+    }
+    public on_list_partitioned_table(): On_list_partitioned_tableContext | null {
+        return this.getRuleContext(0, On_list_partitioned_tableContext);
+    }
+    public on_hash_partitioned_table(): On_hash_partitioned_tableContext | null {
+        return this.getRuleContext(0, On_hash_partitioned_tableContext);
+    }
+    public on_comp_partitioned_table(): On_comp_partitioned_tableContext | null {
+        return this.getRuleContext(0, On_comp_partitioned_tableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_local_partitioned_index;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLocal_partitioned_index) {
+             listener.enterLocal_partitioned_index(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLocal_partitioned_index) {
+             listener.exitLocal_partitioned_index(this);
+        }
+    }
+}
+
+
+export class On_range_partitioned_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public partitioned_table(): Partitioned_tableContext[];
+    public partitioned_table(i: number): Partitioned_tableContext | null;
+    public partitioned_table(i?: number): Partitioned_tableContext[] | Partitioned_tableContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partitioned_tableContext);
+        }
+
+        return this.getRuleContext(i, Partitioned_tableContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_range_partitioned_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_range_partitioned_table) {
+             listener.enterOn_range_partitioned_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_range_partitioned_table) {
+             listener.exitOn_range_partitioned_table(this);
+        }
+    }
+}
+
+
+export class On_list_partitioned_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public partitioned_table(): Partitioned_tableContext[];
+    public partitioned_table(i: number): Partitioned_tableContext | null;
+    public partitioned_table(i?: number): Partitioned_tableContext[] | Partitioned_tableContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partitioned_tableContext);
+        }
+
+        return this.getRuleContext(i, Partitioned_tableContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_list_partitioned_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_list_partitioned_table) {
+             listener.enterOn_list_partitioned_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_list_partitioned_table) {
+             listener.exitOn_list_partitioned_table(this);
+        }
+    }
+}
+
+
+export class Partitioned_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext[];
+    public segment_attributes_clause(i: number): Segment_attributes_clauseContext | null;
+    public segment_attributes_clause(i?: number): Segment_attributes_clauseContext[] | Segment_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_attributes_clauseContext);
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partitioned_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartitioned_table) {
+             listener.enterPartitioned_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartitioned_table) {
+             listener.exitPartitioned_table(this);
+        }
+    }
+}
+
+
+export class On_hash_partitioned_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public on_hash_partitioned_clause(): On_hash_partitioned_clauseContext[];
+    public on_hash_partitioned_clause(i: number): On_hash_partitioned_clauseContext | null;
+    public on_hash_partitioned_clause(i?: number): On_hash_partitioned_clauseContext[] | On_hash_partitioned_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(On_hash_partitioned_clauseContext);
+        }
+
+        return this.getRuleContext(i, On_hash_partitioned_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_hash_partitioned_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_hash_partitioned_table) {
+             listener.enterOn_hash_partitioned_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_hash_partitioned_table) {
+             listener.exitOn_hash_partitioned_table(this);
+        }
+    }
+}
+
+
+export class On_hash_partitioned_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_hash_partitioned_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_hash_partitioned_clause) {
+             listener.enterOn_hash_partitioned_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_hash_partitioned_clause) {
+             listener.exitOn_hash_partitioned_clause(this);
+        }
+    }
+}
+
+
+export class On_comp_partitioned_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public on_comp_partitioned_clause(): On_comp_partitioned_clauseContext[];
+    public on_comp_partitioned_clause(i: number): On_comp_partitioned_clauseContext | null;
+    public on_comp_partitioned_clause(i?: number): On_comp_partitioned_clauseContext[] | On_comp_partitioned_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(On_comp_partitioned_clauseContext);
+        }
+
+        return this.getRuleContext(i, On_comp_partitioned_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_comp_partitioned_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_comp_partitioned_table) {
+             listener.enterOn_comp_partitioned_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_comp_partitioned_table) {
+             listener.exitOn_comp_partitioned_table(this);
+        }
+    }
+}
+
+
+export class On_comp_partitioned_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext[];
+    public segment_attributes_clause(i: number): Segment_attributes_clauseContext | null;
+    public segment_attributes_clause(i?: number): Segment_attributes_clauseContext[] | Segment_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_attributes_clauseContext);
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public index_subpartition_clause(): Index_subpartition_clauseContext | null {
+        return this.getRuleContext(0, Index_subpartition_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_comp_partitioned_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_comp_partitioned_clause) {
+             listener.enterOn_comp_partitioned_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_comp_partitioned_clause) {
+             listener.exitOn_comp_partitioned_clause(this);
+        }
+    }
+}
+
+
+export class Index_subpartition_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public index_subpartition_subclause(): Index_subpartition_subclauseContext[];
+    public index_subpartition_subclause(i: number): Index_subpartition_subclauseContext | null;
+    public index_subpartition_subclause(i?: number): Index_subpartition_subclauseContext[] | Index_subpartition_subclauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Index_subpartition_subclauseContext);
+        }
+
+        return this.getRuleContext(i, Index_subpartition_subclauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_subpartition_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_subpartition_clause) {
+             listener.enterIndex_subpartition_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_subpartition_clause) {
+             listener.exitIndex_subpartition_clause(this);
+        }
+    }
+}
+
+
+export class Index_subpartition_subclauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_subpartition_subclause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_subpartition_subclause) {
+             listener.enterIndex_subpartition_subclause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_subpartition_subclause) {
+             listener.exitIndex_subpartition_subclause(this);
+        }
+    }
+}
+
+
+export class Odci_parametersContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_odci_parameters;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOdci_parameters) {
+             listener.enterOdci_parameters(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOdci_parameters) {
+             listener.exitOdci_parameters(this);
+        }
+    }
+}
+
+
+export class IndextypeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_indextype;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndextype) {
+             listener.enterIndextype(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndextype) {
+             listener.exitIndextype(this);
+        }
+    }
+}
+
+
+export class Alter_indexContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public INDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEX, 0)!;
+    }
+    public index_name(): Index_nameContext {
+        return this.getRuleContext(0, Index_nameContext)!;
+    }
+    public alter_index_ops_set1(): Alter_index_ops_set1Context | null {
+        return this.getRuleContext(0, Alter_index_ops_set1Context);
+    }
+    public alter_index_ops_set2(): Alter_index_ops_set2Context | null {
+        return this.getRuleContext(0, Alter_index_ops_set2Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_index;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_index) {
+             listener.enterAlter_index(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_index) {
+             listener.exitAlter_index(this);
+        }
+    }
+}
+
+
+export class Alter_index_ops_set1Context extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext[];
+    public deallocate_unused_clause(i: number): Deallocate_unused_clauseContext | null;
+    public deallocate_unused_clause(i?: number): Deallocate_unused_clauseContext[] | Deallocate_unused_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Deallocate_unused_clauseContext);
+        }
+
+        return this.getRuleContext(i, Deallocate_unused_clauseContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext[];
+    public allocate_extent_clause(i: number): Allocate_extent_clauseContext | null;
+    public allocate_extent_clause(i?: number): Allocate_extent_clauseContext[] | Allocate_extent_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allocate_extent_clauseContext);
+        }
+
+        return this.getRuleContext(i, Allocate_extent_clauseContext);
+    }
+    public shrink_clause(): Shrink_clauseContext[];
+    public shrink_clause(i: number): Shrink_clauseContext | null;
+    public shrink_clause(i?: number): Shrink_clauseContext[] | Shrink_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Shrink_clauseContext);
+        }
+
+        return this.getRuleContext(i, Shrink_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_index_ops_set1;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_index_ops_set1) {
+             listener.enterAlter_index_ops_set1(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_index_ops_set1) {
+             listener.exitAlter_index_ops_set1(this);
+        }
+    }
+}
+
+
+export class Alter_index_ops_set2Context extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public rebuild_clause(): Rebuild_clauseContext | null {
+        return this.getRuleContext(0, Rebuild_clauseContext);
+    }
+    public PARAMETERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAMETERS, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public odci_parameters(): Odci_parametersContext | null {
+        return this.getRuleContext(0, Odci_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public enable_or_disable(): Enable_or_disableContext | null {
+        return this.getRuleContext(0, Enable_or_disableContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public visible_or_invisible(): Visible_or_invisibleContext | null {
+        return this.getRuleContext(0, Visible_or_invisibleContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public new_index_name(): New_index_nameContext | null {
+        return this.getRuleContext(0, New_index_nameContext);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public monitoring_nomonitoring(): Monitoring_nomonitoringContext | null {
+        return this.getRuleContext(0, Monitoring_nomonitoringContext);
+    }
+    public USAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USAGE, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCK, 0);
+    }
+    public REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCES, 0);
+    }
+    public alter_index_partitioning(): Alter_index_partitioningContext | null {
+        return this.getRuleContext(0, Alter_index_partitioningContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_index_ops_set2;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_index_ops_set2) {
+             listener.enterAlter_index_ops_set2(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_index_ops_set2) {
+             listener.exitAlter_index_ops_set2(this);
+        }
+    }
+}
+
+
+export class Visible_or_invisibleContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBLE, 0);
+    }
+    public INVISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVISIBLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_visible_or_invisible;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVisible_or_invisible) {
+             listener.enterVisible_or_invisible(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVisible_or_invisible) {
+             listener.exitVisible_or_invisible(this);
+        }
+    }
+}
+
+
+export class Monitoring_nomonitoringContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MONITORING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONITORING, 0);
+    }
+    public NOMONITORING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMONITORING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_monitoring_nomonitoring;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMonitoring_nomonitoring) {
+             listener.enterMonitoring_nomonitoring(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMonitoring_nomonitoring) {
+             listener.exitMonitoring_nomonitoring(this);
+        }
+    }
+}
+
+
+export class Rebuild_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REBUILD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REBUILD, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public REVERSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REVERSE, 0);
+    }
+    public NOREVERSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREVERSE, 0);
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public PARAMETERS(): antlr.TerminalNode[];
+    public PARAMETERS(i: number): antlr.TerminalNode | null;
+    public PARAMETERS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARAMETERS);
+    	} else {
+    		return this.getToken(PlSqlParser.PARAMETERS, i);
+    	}
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public odci_parameters(): Odci_parametersContext[];
+    public odci_parameters(i: number): Odci_parametersContext | null;
+    public odci_parameters(i?: number): Odci_parametersContext[] | Odci_parametersContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Odci_parametersContext);
+        }
+
+        return this.getRuleContext(i, Odci_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public ONLINE(): antlr.TerminalNode[];
+    public ONLINE(i: number): antlr.TerminalNode | null;
+    public ONLINE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ONLINE);
+    	} else {
+    		return this.getToken(PlSqlParser.ONLINE, i);
+    	}
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rebuild_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRebuild_clause) {
+             listener.enterRebuild_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRebuild_clause) {
+             listener.exitRebuild_clause(this);
+        }
+    }
+}
+
+
+export class Alter_index_partitioningContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public modify_index_default_attrs(): Modify_index_default_attrsContext | null {
+        return this.getRuleContext(0, Modify_index_default_attrsContext);
+    }
+    public add_hash_index_partition(): Add_hash_index_partitionContext | null {
+        return this.getRuleContext(0, Add_hash_index_partitionContext);
+    }
+    public modify_index_partition(): Modify_index_partitionContext | null {
+        return this.getRuleContext(0, Modify_index_partitionContext);
+    }
+    public rename_index_partition(): Rename_index_partitionContext | null {
+        return this.getRuleContext(0, Rename_index_partitionContext);
+    }
+    public drop_index_partition(): Drop_index_partitionContext | null {
+        return this.getRuleContext(0, Drop_index_partitionContext);
+    }
+    public split_index_partition(): Split_index_partitionContext | null {
+        return this.getRuleContext(0, Split_index_partitionContext);
+    }
+    public coalesce_index_partition(): Coalesce_index_partitionContext | null {
+        return this.getRuleContext(0, Coalesce_index_partitionContext);
+    }
+    public modify_index_subpartition(): Modify_index_subpartitionContext | null {
+        return this.getRuleContext(0, Modify_index_subpartitionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_index_partitioning;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_index_partitioning) {
+             listener.enterAlter_index_partitioning(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_index_partitioning) {
+             listener.exitAlter_index_partitioning(this);
+        }
+    }
+}
+
+
+export class Modify_index_default_attrsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public ATTRIBUTES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0)!;
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext | null {
+        return this.getRuleContext(0, Physical_attributes_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public logging_clause(): Logging_clauseContext | null {
+        return this.getRuleContext(0, Logging_clauseContext);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_index_default_attrs;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_index_default_attrs) {
+             listener.enterModify_index_default_attrs(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_index_default_attrs) {
+             listener.exitModify_index_default_attrs(this);
+        }
+    }
+}
+
+
+export class Add_hash_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_hash_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_hash_index_partition) {
+             listener.enterAdd_hash_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_hash_index_partition) {
+             listener.exitAdd_hash_index_partition(this);
+        }
+    }
+}
+
+
+export class Coalesce_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COALESCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COALESCE, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_coalesce_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCoalesce_index_partition) {
+             listener.enterCoalesce_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCoalesce_index_partition) {
+             listener.exitCoalesce_index_partition(this);
+        }
+    }
+}
+
+
+export class Modify_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public PARAMETERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAMETERS, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public odci_parameters(): Odci_parametersContext | null {
+        return this.getRuleContext(0, Odci_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCK, 0);
+    }
+    public REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCES, 0);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public modify_index_partitions_ops(): Modify_index_partitions_opsContext[];
+    public modify_index_partitions_ops(i: number): Modify_index_partitions_opsContext | null;
+    public modify_index_partitions_ops(i?: number): Modify_index_partitions_opsContext[] | Modify_index_partitions_opsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Modify_index_partitions_opsContext);
+        }
+
+        return this.getRuleContext(i, Modify_index_partitions_opsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_index_partition) {
+             listener.enterModify_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_index_partition) {
+             listener.exitModify_index_partition(this);
+        }
+    }
+}
+
+
+export class Modify_index_partitions_opsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext | null {
+        return this.getRuleContext(0, Deallocate_unused_clauseContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext | null {
+        return this.getRuleContext(0, Allocate_extent_clauseContext);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext | null {
+        return this.getRuleContext(0, Physical_attributes_clauseContext);
+    }
+    public logging_clause(): Logging_clauseContext | null {
+        return this.getRuleContext(0, Logging_clauseContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public shrink_clause(): Shrink_clauseContext | null {
+        return this.getRuleContext(0, Shrink_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_index_partitions_ops;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_index_partitions_ops) {
+             listener.enterModify_index_partitions_ops(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_index_partitions_ops) {
+             listener.exitModify_index_partitions_ops(this);
+        }
+    }
+}
+
+
+export class Rename_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RENAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RENAME, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public new_partition_name(): New_partition_nameContext {
+        return this.getRuleContext(0, New_partition_nameContext)!;
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rename_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRename_index_partition) {
+             listener.enterRename_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRename_index_partition) {
+             listener.exitRename_index_partition(this);
+        }
+    }
+}
+
+
+export class Drop_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_index_partition) {
+             listener.enterDrop_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_index_partition) {
+             listener.exitDrop_index_partition(this);
+        }
+    }
+}
+
+
+export class Split_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SPLIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SPLIT, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name_old(): Partition_name_oldContext {
+        return this.getRuleContext(0, Partition_name_oldContext)!;
+    }
+    public AT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AT, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public literal(): LiteralContext[];
+    public literal(i: number): LiteralContext | null;
+    public literal(i?: number): LiteralContext[] | LiteralContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(LiteralContext);
+        }
+
+        return this.getRuleContext(i, LiteralContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public INTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTO, 0);
+    }
+    public index_partition_description(): Index_partition_descriptionContext[];
+    public index_partition_description(i: number): Index_partition_descriptionContext | null;
+    public index_partition_description(i?: number): Index_partition_descriptionContext[] | Index_partition_descriptionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Index_partition_descriptionContext);
+        }
+
+        return this.getRuleContext(i, Index_partition_descriptionContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_split_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSplit_index_partition) {
+             listener.enterSplit_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSplit_index_partition) {
+             listener.exitSplit_index_partition(this);
+        }
+    }
+}
+
+
+export class Index_partition_descriptionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public PARAMETERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAMETERS, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public odci_parameters(): Odci_parametersContext | null {
+        return this.getRuleContext(0, Odci_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext[];
+    public segment_attributes_clause(i: number): Segment_attributes_clauseContext | null;
+    public segment_attributes_clause(i?: number): Segment_attributes_clauseContext[] | Segment_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_attributes_clauseContext);
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_partition_description;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_partition_description) {
+             listener.enterIndex_partition_description(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_partition_description) {
+             listener.exitIndex_partition_description(this);
+        }
+    }
+}
+
+
+export class Modify_index_subpartitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public subpartition_name(): Subpartition_nameContext {
+        return this.getRuleContext(0, Subpartition_nameContext)!;
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public modify_index_partitions_ops(): Modify_index_partitions_opsContext | null {
+        return this.getRuleContext(0, Modify_index_partitions_opsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_index_subpartition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_index_subpartition) {
+             listener.enterModify_index_subpartition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_index_subpartition) {
+             listener.exitModify_index_subpartition(this);
+        }
+    }
+}
+
+
+export class Partition_name_oldContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_name_old;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_name_old) {
+             listener.enterPartition_name_old(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_name_old) {
+             listener.exitPartition_name_old(this);
+        }
+    }
+}
+
+
+export class New_partition_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_new_partition_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNew_partition_name) {
+             listener.enterNew_partition_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNew_partition_name) {
+             listener.exitNew_partition_name(this);
+        }
+    }
+}
+
+
+export class New_index_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public index_name(): Index_nameContext {
+        return this.getRuleContext(0, Index_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_new_index_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNew_index_name) {
+             listener.enterNew_index_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNew_index_name) {
+             listener.exitNew_index_name(this);
+        }
+    }
+}
+
+
+export class Alter_inmemory_join_groupContext extends antlr.ParserRuleContext {
+    public _jg?: Id_expressionContext;
+    public _t?: Id_expressionContext;
+    public _c?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public INMEMORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INMEMORY, 0)!;
+    }
+    public JOIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JOIN, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public schema_name(): Schema_nameContext[];
+    public schema_name(i: number): Schema_nameContext | null;
+    public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Schema_nameContext);
+        }
+
+        return this.getRuleContext(i, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_inmemory_join_group;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_inmemory_join_group) {
+             listener.enterAlter_inmemory_join_group(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_inmemory_join_group) {
+             listener.exitAlter_inmemory_join_group(this);
+        }
+    }
+}
+
+
+export class Create_userContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public USER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USER, 0)!;
+    }
+    public user_object_name(): User_object_nameContext {
+        return this.getRuleContext(0, User_object_nameContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public identified_by(): Identified_byContext[];
+    public identified_by(i: number): Identified_byContext | null;
+    public identified_by(i?: number): Identified_byContext[] | Identified_byContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Identified_byContext);
+        }
+
+        return this.getRuleContext(i, Identified_byContext);
+    }
+    public identified_other_clause(): Identified_other_clauseContext[];
+    public identified_other_clause(i: number): Identified_other_clauseContext | null;
+    public identified_other_clause(i?: number): Identified_other_clauseContext[] | Identified_other_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Identified_other_clauseContext);
+        }
+
+        return this.getRuleContext(i, Identified_other_clauseContext);
+    }
+    public user_tablespace_clause(): User_tablespace_clauseContext[];
+    public user_tablespace_clause(i: number): User_tablespace_clauseContext | null;
+    public user_tablespace_clause(i?: number): User_tablespace_clauseContext[] | User_tablespace_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_tablespace_clauseContext);
+        }
+
+        return this.getRuleContext(i, User_tablespace_clauseContext);
+    }
+    public quota_clause(): Quota_clauseContext[];
+    public quota_clause(i: number): Quota_clauseContext | null;
+    public quota_clause(i?: number): Quota_clauseContext[] | Quota_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quota_clauseContext);
+        }
+
+        return this.getRuleContext(i, Quota_clauseContext);
+    }
+    public profile_clause(): Profile_clauseContext[];
+    public profile_clause(i: number): Profile_clauseContext | null;
+    public profile_clause(i?: number): Profile_clauseContext[] | Profile_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Profile_clauseContext);
+        }
+
+        return this.getRuleContext(i, Profile_clauseContext);
+    }
+    public password_expire_clause(): Password_expire_clauseContext[];
+    public password_expire_clause(i: number): Password_expire_clauseContext | null;
+    public password_expire_clause(i?: number): Password_expire_clauseContext[] | Password_expire_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Password_expire_clauseContext);
+        }
+
+        return this.getRuleContext(i, Password_expire_clauseContext);
+    }
+    public user_lock_clause(): User_lock_clauseContext[];
+    public user_lock_clause(i: number): User_lock_clauseContext | null;
+    public user_lock_clause(i?: number): User_lock_clauseContext[] | User_lock_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_lock_clauseContext);
+        }
+
+        return this.getRuleContext(i, User_lock_clauseContext);
+    }
+    public user_editions_clause(): User_editions_clauseContext[];
+    public user_editions_clause(i: number): User_editions_clauseContext | null;
+    public user_editions_clause(i?: number): User_editions_clauseContext[] | User_editions_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_editions_clauseContext);
+        }
+
+        return this.getRuleContext(i, User_editions_clauseContext);
+    }
+    public container_clause(): Container_clauseContext[];
+    public container_clause(i: number): Container_clauseContext | null;
+    public container_clause(i?: number): Container_clauseContext[] | Container_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Container_clauseContext);
+        }
+
+        return this.getRuleContext(i, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_user;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_user) {
+             listener.enterCreate_user(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_user) {
+             listener.exitCreate_user(this);
+        }
+    }
+}
+
+
+export class Alter_userContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public user_object_name(): User_object_nameContext[];
+    public user_object_name(i: number): User_object_nameContext | null;
+    public user_object_name(i?: number): User_object_nameContext[] | User_object_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_object_nameContext);
+        }
+
+        return this.getRuleContext(i, User_object_nameContext);
+    }
+    public alter_identified_by(): Alter_identified_byContext[];
+    public alter_identified_by(i: number): Alter_identified_byContext | null;
+    public alter_identified_by(i?: number): Alter_identified_byContext[] | Alter_identified_byContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Alter_identified_byContext);
+        }
+
+        return this.getRuleContext(i, Alter_identified_byContext);
+    }
+    public identified_other_clause(): Identified_other_clauseContext[];
+    public identified_other_clause(i: number): Identified_other_clauseContext | null;
+    public identified_other_clause(i?: number): Identified_other_clauseContext[] | Identified_other_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Identified_other_clauseContext);
+        }
+
+        return this.getRuleContext(i, Identified_other_clauseContext);
+    }
+    public user_tablespace_clause(): User_tablespace_clauseContext[];
+    public user_tablespace_clause(i: number): User_tablespace_clauseContext | null;
+    public user_tablespace_clause(i?: number): User_tablespace_clauseContext[] | User_tablespace_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_tablespace_clauseContext);
+        }
+
+        return this.getRuleContext(i, User_tablespace_clauseContext);
+    }
+    public quota_clause(): Quota_clauseContext[];
+    public quota_clause(i: number): Quota_clauseContext | null;
+    public quota_clause(i?: number): Quota_clauseContext[] | Quota_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quota_clauseContext);
+        }
+
+        return this.getRuleContext(i, Quota_clauseContext);
+    }
+    public profile_clause(): Profile_clauseContext[];
+    public profile_clause(i: number): Profile_clauseContext | null;
+    public profile_clause(i?: number): Profile_clauseContext[] | Profile_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Profile_clauseContext);
+        }
+
+        return this.getRuleContext(i, Profile_clauseContext);
+    }
+    public user_default_role_clause(): User_default_role_clauseContext[];
+    public user_default_role_clause(i: number): User_default_role_clauseContext | null;
+    public user_default_role_clause(i?: number): User_default_role_clauseContext[] | User_default_role_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_default_role_clauseContext);
+        }
+
+        return this.getRuleContext(i, User_default_role_clauseContext);
+    }
+    public password_expire_clause(): Password_expire_clauseContext[];
+    public password_expire_clause(i: number): Password_expire_clauseContext | null;
+    public password_expire_clause(i?: number): Password_expire_clauseContext[] | Password_expire_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Password_expire_clauseContext);
+        }
+
+        return this.getRuleContext(i, Password_expire_clauseContext);
+    }
+    public user_lock_clause(): User_lock_clauseContext[];
+    public user_lock_clause(i: number): User_lock_clauseContext | null;
+    public user_lock_clause(i?: number): User_lock_clauseContext[] | User_lock_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_lock_clauseContext);
+        }
+
+        return this.getRuleContext(i, User_lock_clauseContext);
+    }
+    public alter_user_editions_clause(): Alter_user_editions_clauseContext[];
+    public alter_user_editions_clause(i: number): Alter_user_editions_clauseContext | null;
+    public alter_user_editions_clause(i?: number): Alter_user_editions_clauseContext[] | Alter_user_editions_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Alter_user_editions_clauseContext);
+        }
+
+        return this.getRuleContext(i, Alter_user_editions_clauseContext);
+    }
+    public container_clause(): Container_clauseContext[];
+    public container_clause(i: number): Container_clauseContext | null;
+    public container_clause(i?: number): Container_clauseContext[] | Container_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Container_clauseContext);
+        }
+
+        return this.getRuleContext(i, Container_clauseContext);
+    }
+    public container_data_clause(): Container_data_clauseContext[];
+    public container_data_clause(i: number): Container_data_clauseContext | null;
+    public container_data_clause(i?: number): Container_data_clauseContext[] | Container_data_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Container_data_clauseContext);
+        }
+
+        return this.getRuleContext(i, Container_data_clauseContext);
+    }
+    public proxy_clause(): Proxy_clauseContext | null {
+        return this.getRuleContext(0, Proxy_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_user;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_user) {
+             listener.enterAlter_user(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_user) {
+             listener.exitAlter_user(this);
+        }
+    }
+}
+
+
+export class Drop_userContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public USER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USER, 0)!;
+    }
+    public user_object_name(): User_object_nameContext {
+        return this.getRuleContext(0, User_object_nameContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_user;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_user) {
+             listener.enterDrop_user(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_user) {
+             listener.exitDrop_user(this);
+        }
+    }
+}
+
+
+export class Alter_identified_byContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identified_by(): Identified_byContext {
+        return this.getRuleContext(0, Identified_byContext)!;
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_identified_by;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_identified_by) {
+             listener.enterAlter_identified_by(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_identified_by) {
+             listener.exitAlter_identified_by(this);
+        }
+    }
+}
+
+
+export class Identified_byContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identified_by;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentified_by) {
+             listener.enterIdentified_by(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentified_by) {
+             listener.exitIdentified_by(this);
+        }
+    }
+}
+
+
+export class Identified_other_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public EXTERNALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNALLY, 0);
+    }
+    public GLOBALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBALLY, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identified_other_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentified_other_clause) {
+             listener.enterIdentified_other_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentified_other_clause) {
+             listener.exitIdentified_other_clause(this);
+        }
+    }
+}
+
+
+export class User_tablespace_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public TEMPORARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPORARY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_user_tablespace_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUser_tablespace_clause) {
+             listener.enterUser_tablespace_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUser_tablespace_clause) {
+             listener.exitUser_tablespace_clause(this);
+        }
+    }
+}
+
+
+export class Quota_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public QUOTA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.QUOTA, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_quota_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuota_clause) {
+             listener.enterQuota_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuota_clause) {
+             listener.exitQuota_clause(this);
+        }
+    }
+}
+
+
+export class Profile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROFILE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_profile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProfile_clause) {
+             listener.enterProfile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProfile_clause) {
+             listener.exitProfile_clause(this);
+        }
+    }
+}
+
+
+export class Role_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public role_name(): Role_nameContext[];
+    public role_name(i: number): Role_nameContext | null;
+    public role_name(i?: number): Role_nameContext[] | Role_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Role_nameContext);
+        }
+
+        return this.getRuleContext(i, Role_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode[];
+    public EXCEPT(i: number): antlr.TerminalNode | null;
+    public EXCEPT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EXCEPT);
+    	} else {
+    		return this.getToken(PlSqlParser.EXCEPT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_role_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRole_clause) {
+             listener.enterRole_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRole_clause) {
+             listener.exitRole_clause(this);
+        }
+    }
+}
+
+
+export class User_default_role_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public ROLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLE, 0)!;
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public role_clause(): Role_clauseContext | null {
+        return this.getRuleContext(0, Role_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_user_default_role_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUser_default_role_clause) {
+             listener.enterUser_default_role_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUser_default_role_clause) {
+             listener.exitUser_default_role_clause(this);
+        }
+    }
+}
+
+
+export class Password_expire_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PASSWORD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PASSWORD, 0)!;
+    }
+    public EXPIRE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXPIRE, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_password_expire_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPassword_expire_clause) {
+             listener.enterPassword_expire_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPassword_expire_clause) {
+             listener.exitPassword_expire_clause(this);
+        }
+    }
+}
+
+
+export class User_lock_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACCOUNT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ACCOUNT, 0)!;
+    }
+    public LOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCK, 0);
+    }
+    public UNLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLOCK, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_user_lock_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUser_lock_clause) {
+             listener.enterUser_lock_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUser_lock_clause) {
+             listener.exitUser_lock_clause(this);
+        }
+    }
+}
+
+
+export class User_editions_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ENABLE, 0)!;
+    }
+    public EDITIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EDITIONS, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_user_editions_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUser_editions_clause) {
+             listener.enterUser_editions_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUser_editions_clause) {
+             listener.exitUser_editions_clause(this);
+        }
+    }
+}
+
+
+export class Alter_user_editions_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public user_editions_clause(): User_editions_clauseContext {
+        return this.getRuleContext(0, User_editions_clauseContext)!;
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public regular_id(): Regular_idContext[];
+    public regular_id(i: number): Regular_idContext | null;
+    public regular_id(i?: number): Regular_idContext[] | Regular_idContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Regular_idContext);
+        }
+
+        return this.getRuleContext(i, Regular_idContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_user_editions_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_user_editions_clause) {
+             listener.enterAlter_user_editions_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_user_editions_clause) {
+             listener.exitAlter_user_editions_clause(this);
+        }
+    }
+}
+
+
+export class Proxy_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REVOKE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REVOKE, 0);
+    }
+    public CONNECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONNECT, 0)!;
+    }
+    public THROUGH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THROUGH, 0)!;
+    }
+    public ENTERPRISE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENTERPRISE, 0);
+    }
+    public USERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USERS, 0);
+    }
+    public user_object_name(): User_object_nameContext | null {
+        return this.getRuleContext(0, User_object_nameContext);
+    }
+    public GRANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GRANT, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public AUTHENTICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHENTICATION, 0);
+    }
+    public REQUIRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REQUIRED, 0);
+    }
+    public AUTHENTICATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHENTICATED, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public ROLES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLES, 0);
+    }
+    public ROLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLE, 0);
+    }
+    public role_clause(): Role_clauseContext | null {
+        return this.getRuleContext(0, Role_clauseContext);
+    }
+    public PASSWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD, 0);
+    }
+    public CERTIFICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CERTIFICATE, 0);
+    }
+    public DISTINGUISHED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINGUISHED, 0);
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_proxy_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProxy_clause) {
+             listener.enterProxy_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProxy_clause) {
+             listener.exitProxy_clause(this);
+        }
+    }
+}
+
+
+export class Container_namesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_container_names;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterContainer_names) {
+             listener.enterContainer_names(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitContainer_names) {
+             listener.exitContainer_names(this);
+        }
+    }
+}
+
+
+export class Set_container_dataContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public CONTAINER_DATA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTAINER_DATA, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public container_names(): Container_namesContext | null {
+        return this.getRuleContext(0, Container_namesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_container_data;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_container_data) {
+             listener.enterSet_container_data(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_container_data) {
+             listener.exitSet_container_data(this);
+        }
+    }
+}
+
+
+export class Add_rem_container_dataContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONTAINER_DATA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTAINER_DATA, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public container_names(): Container_namesContext {
+        return this.getRuleContext(0, Container_namesContext)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_rem_container_data;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_rem_container_data) {
+             listener.enterAdd_rem_container_data(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_rem_container_data) {
+             listener.exitAdd_rem_container_data(this);
+        }
+    }
+}
+
+
+export class Container_data_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public set_container_data(): Set_container_dataContext | null {
+        return this.getRuleContext(0, Set_container_dataContext);
+    }
+    public add_rem_container_data(): Add_rem_container_dataContext | null {
+        return this.getRuleContext(0, Add_rem_container_dataContext);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public container_tableview_name(): Container_tableview_nameContext | null {
+        return this.getRuleContext(0, Container_tableview_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_container_data_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterContainer_data_clause) {
+             listener.enterContainer_data_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitContainer_data_clause) {
+             listener.exitContainer_data_clause(this);
+        }
+    }
+}
+
+
+export class Administer_key_managementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADMINISTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADMINISTER, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public MANAGEMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MANAGEMENT, 0)!;
+    }
+    public keystore_management_clauses(): Keystore_management_clausesContext | null {
+        return this.getRuleContext(0, Keystore_management_clausesContext);
+    }
+    public key_management_clauses(): Key_management_clausesContext | null {
+        return this.getRuleContext(0, Key_management_clausesContext);
+    }
+    public secret_management_clauses(): Secret_management_clausesContext | null {
+        return this.getRuleContext(0, Secret_management_clausesContext);
+    }
+    public zero_downtime_software_patching_clauses(): Zero_downtime_software_patching_clausesContext | null {
+        return this.getRuleContext(0, Zero_downtime_software_patching_clausesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_administer_key_management;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdminister_key_management) {
+             listener.enterAdminister_key_management(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdminister_key_management) {
+             listener.exitAdminister_key_management(this);
+        }
+    }
+}
+
+
+export class Keystore_management_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public create_keystore(): Create_keystoreContext | null {
+        return this.getRuleContext(0, Create_keystoreContext);
+    }
+    public open_keystore(): Open_keystoreContext | null {
+        return this.getRuleContext(0, Open_keystoreContext);
+    }
+    public close_keystore(): Close_keystoreContext | null {
+        return this.getRuleContext(0, Close_keystoreContext);
+    }
+    public backup_keystore(): Backup_keystoreContext | null {
+        return this.getRuleContext(0, Backup_keystoreContext);
+    }
+    public alter_keystore_password(): Alter_keystore_passwordContext | null {
+        return this.getRuleContext(0, Alter_keystore_passwordContext);
+    }
+    public merge_into_new_keystore(): Merge_into_new_keystoreContext | null {
+        return this.getRuleContext(0, Merge_into_new_keystoreContext);
+    }
+    public merge_into_existing_keystore(): Merge_into_existing_keystoreContext | null {
+        return this.getRuleContext(0, Merge_into_existing_keystoreContext);
+    }
+    public isolate_keystore(): Isolate_keystoreContext | null {
+        return this.getRuleContext(0, Isolate_keystoreContext);
+    }
+    public unite_keystore(): Unite_keystoreContext | null {
+        return this.getRuleContext(0, Unite_keystoreContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_keystore_management_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterKeystore_management_clauses) {
+             listener.enterKeystore_management_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitKeystore_management_clauses) {
+             listener.exitKeystore_management_clauses(this);
+        }
+    }
+}
+
+
+export class Create_keystoreContext extends antlr.ParserRuleContext {
+    public _ksl?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public keystore_password(): Keystore_passwordContext {
+        return this.getRuleContext(0, Keystore_passwordContext)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode[];
+    public KEYSTORE(i: number): antlr.TerminalNode | null;
+    public KEYSTORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEYSTORE);
+    	} else {
+    		return this.getToken(PlSqlParser.KEYSTORE, i);
+    	}
+    }
+    public AUTO_LOGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO_LOGIN, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_keystore) {
+             listener.enterCreate_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_keystore) {
+             listener.exitCreate_keystore(this);
+        }
+    }
+}
+
+
+export class Open_keystoreContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public OPEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPEN, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_open_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOpen_keystore) {
+             listener.enterOpen_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOpen_keystore) {
+             listener.exitOpen_keystore(this);
+        }
+    }
+}
+
+
+export class Force_keystoreContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FORCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FORCE, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_force_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterForce_keystore) {
+             listener.enterForce_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitForce_keystore) {
+             listener.exitForce_keystore(this);
+        }
+    }
+}
+
+
+export class Close_keystoreContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public CLOSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLOSE, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext | null {
+        return this.getRuleContext(0, Identified_by_storeContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_close_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClose_keystore) {
+             listener.enterClose_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClose_keystore) {
+             listener.exitClose_keystore(this);
+        }
+    }
+}
+
+
+export class Backup_keystoreContext extends antlr.ParserRuleContext {
+    public _bi?: Token | null;
+    public _ksl?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BACKUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BACKUP, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_backup_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBackup_keystore) {
+             listener.enterBackup_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBackup_keystore) {
+             listener.exitBackup_keystore(this);
+        }
+    }
+}
+
+
+export class Alter_keystore_passwordContext extends antlr.ParserRuleContext {
+    public _o?: Keystore_passwordContext;
+    public _n?: Keystore_passwordContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public PASSWORD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PASSWORD, 0)!;
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public keystore_password(): Keystore_passwordContext[];
+    public keystore_password(i: number): Keystore_passwordContext | null;
+    public keystore_password(i?: number): Keystore_passwordContext[] | Keystore_passwordContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Keystore_passwordContext);
+        }
+
+        return this.getRuleContext(i, Keystore_passwordContext);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_keystore_password;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_keystore_password) {
+             listener.enterAlter_keystore_password(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_keystore_password) {
+             listener.exitAlter_keystore_password(this);
+        }
+    }
+}
+
+
+export class Merge_into_new_keystoreContext extends antlr.ParserRuleContext {
+    public _ksl1?: Token | null;
+    public _ksl2?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MERGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MERGE, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode[];
+    public KEYSTORE(i: number): antlr.TerminalNode | null;
+    public KEYSTORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEYSTORE);
+    	} else {
+    		return this.getToken(PlSqlParser.KEYSTORE, i);
+    	}
+    }
+    public AND(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AND, 0)!;
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public NEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NEW, 0)!;
+    }
+    public identified_by_password_clause(): Identified_by_password_clauseContext[];
+    public identified_by_password_clause(i: number): Identified_by_password_clauseContext | null;
+    public identified_by_password_clause(i?: number): Identified_by_password_clauseContext[] | Identified_by_password_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Identified_by_password_clauseContext);
+        }
+
+        return this.getRuleContext(i, Identified_by_password_clauseContext);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_into_new_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_into_new_keystore) {
+             listener.enterMerge_into_new_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_into_new_keystore) {
+             listener.exitMerge_into_new_keystore(this);
+        }
+    }
+}
+
+
+export class Merge_into_existing_keystoreContext extends antlr.ParserRuleContext {
+    public _ksl1?: Token | null;
+    public _ksl2?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MERGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MERGE, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode[];
+    public KEYSTORE(i: number): antlr.TerminalNode | null;
+    public KEYSTORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEYSTORE);
+    	} else {
+    		return this.getToken(PlSqlParser.KEYSTORE, i);
+    	}
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public EXISTING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXISTING, 0)!;
+    }
+    public identified_by_password_clause(): Identified_by_password_clauseContext[];
+    public identified_by_password_clause(i: number): Identified_by_password_clauseContext | null;
+    public identified_by_password_clause(i?: number): Identified_by_password_clauseContext[] | Identified_by_password_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Identified_by_password_clauseContext);
+        }
+
+        return this.getRuleContext(i, Identified_by_password_clauseContext);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_into_existing_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_into_existing_keystore) {
+             listener.enterMerge_into_existing_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_into_existing_keystore) {
+             listener.exitMerge_into_existing_keystore(this);
+        }
+    }
+}
+
+
+export class Isolate_keystoreContext extends antlr.ParserRuleContext {
+    public _i?: Keystore_passwordContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ISOLATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ISOLATE, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode[];
+    public KEYSTORE(i: number): antlr.TerminalNode | null;
+    public KEYSTORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEYSTORE);
+    	} else {
+    		return this.getToken(PlSqlParser.KEYSTORE, i);
+    	}
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public ROOT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROOT, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public keystore_password(): Keystore_passwordContext {
+        return this.getRuleContext(0, Keystore_passwordContext)!;
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_isolate_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIsolate_keystore) {
+             listener.enterIsolate_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIsolate_keystore) {
+             listener.exitIsolate_keystore(this);
+        }
+    }
+}
+
+
+export class Unite_keystoreContext extends antlr.ParserRuleContext {
+    public _i?: Keystore_passwordContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNITE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNITE, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode[];
+    public KEYSTORE(i: number): antlr.TerminalNode | null;
+    public KEYSTORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEYSTORE);
+    	} else {
+    		return this.getToken(PlSqlParser.KEYSTORE, i);
+    	}
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public ROOT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROOT, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public keystore_password(): Keystore_passwordContext {
+        return this.getRuleContext(0, Keystore_passwordContext)!;
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unite_keystore;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnite_keystore) {
+             listener.enterUnite_keystore(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnite_keystore) {
+             listener.exitUnite_keystore(this);
+        }
+    }
+}
+
+
+export class Key_management_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public set_key(): Set_keyContext | null {
+        return this.getRuleContext(0, Set_keyContext);
+    }
+    public create_key(): Create_keyContext | null {
+        return this.getRuleContext(0, Create_keyContext);
+    }
+    public use_key(): Use_keyContext | null {
+        return this.getRuleContext(0, Use_keyContext);
+    }
+    public set_key_tag(): Set_key_tagContext | null {
+        return this.getRuleContext(0, Set_key_tagContext);
+    }
+    public export_keys(): Export_keysContext | null {
+        return this.getRuleContext(0, Export_keysContext);
+    }
+    public import_keys(): Import_keysContext | null {
+        return this.getRuleContext(0, Import_keysContext);
+    }
+    public migrate_keys(): Migrate_keysContext | null {
+        return this.getRuleContext(0, Migrate_keysContext);
+    }
+    public reverse_migrate_keys(): Reverse_migrate_keysContext | null {
+        return this.getRuleContext(0, Reverse_migrate_keysContext);
+    }
+    public move_keys(): Move_keysContext | null {
+        return this.getRuleContext(0, Move_keysContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_key_management_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterKey_management_clauses) {
+             listener.enterKey_management_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitKey_management_clauses) {
+             listener.exitKey_management_clauses(this);
+        }
+    }
+}
+
+
+export class Set_keyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public mk(): MkContext | null {
+        return this.getRuleContext(0, MkContext);
+    }
+    public using_tag_clause(): Using_tag_clauseContext | null {
+        return this.getRuleContext(0, Using_tag_clauseContext);
+    }
+    public using_algorithm_clause(): Using_algorithm_clauseContext | null {
+        return this.getRuleContext(0, Using_algorithm_clauseContext);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public mkid(): MkidContext | null {
+        return this.getRuleContext(0, MkidContext);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_key;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_key) {
+             listener.enterSet_key(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_key) {
+             listener.exitSet_key(this);
+        }
+    }
+}
+
+
+export class Create_keyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public mk(): MkContext | null {
+        return this.getRuleContext(0, MkContext);
+    }
+    public using_tag_clause(): Using_tag_clauseContext | null {
+        return this.getRuleContext(0, Using_tag_clauseContext);
+    }
+    public using_algorithm_clause(): Using_algorithm_clauseContext | null {
+        return this.getRuleContext(0, Using_algorithm_clauseContext);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public mkid(): MkidContext | null {
+        return this.getRuleContext(0, MkidContext);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_key;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_key) {
+             listener.enterCreate_key(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_key) {
+             listener.exitCreate_key(this);
+        }
+    }
+}
+
+
+export class MkidContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_mkid;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMkid) {
+             listener.enterMkid(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMkid) {
+             listener.exitMkid(this);
+        }
+    }
+}
+
+
+export class MkContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_mk;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMk) {
+             listener.enterMk(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMk) {
+             listener.exitMk(this);
+        }
+    }
+}
+
+
+export class Use_keyContext extends antlr.ParserRuleContext {
+    public _k?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USE, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public using_tag_clause(): Using_tag_clauseContext | null {
+        return this.getRuleContext(0, Using_tag_clauseContext);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_use_key;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUse_key) {
+             listener.enterUse_key(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUse_key) {
+             listener.exitUse_key(this);
+        }
+    }
+}
+
+
+export class Set_key_tagContext extends antlr.ParserRuleContext {
+    public _t?: Token | null;
+    public _k?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public TAG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TAG, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_key_tag;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_key_tag) {
+             listener.enterSet_key_tag(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_key_tag) {
+             listener.exitSet_key_tag(this);
+        }
+    }
+}
+
+
+export class Export_keysContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXPORT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXPORT, 0)!;
+    }
+    public KEYS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYS, 0)!;
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public SECRET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SECRET, 0)!;
+    }
+    public secret(): SecretContext {
+        return this.getRuleContext(0, SecretContext)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public filename(): FilenameContext {
+        return this.getRuleContext(0, FilenameContext)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public IDENTIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIER, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_export_keys;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExport_keys) {
+             listener.enterExport_keys(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExport_keys) {
+             listener.exitExport_keys(this);
+        }
+    }
+}
+
+
+export class Import_keysContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IMPORT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IMPORT, 0)!;
+    }
+    public KEYS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYS, 0)!;
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public SECRET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SECRET, 0)!;
+    }
+    public secret(): SecretContext {
+        return this.getRuleContext(0, SecretContext)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public filename(): FilenameContext {
+        return this.getRuleContext(0, FilenameContext)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_import_keys;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImport_keys) {
+             listener.enterImport_keys(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImport_keys) {
+             listener.exitImport_keys(this);
+        }
+    }
+}
+
+
+export class Migrate_keysContext extends antlr.ParserRuleContext {
+    public _hsm?: SecretContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public MIGRATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MIGRATE, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public keystore_password(): Keystore_passwordContext {
+        return this.getRuleContext(0, Keystore_passwordContext)!;
+    }
+    public secret(): SecretContext {
+        return this.getRuleContext(0, SecretContext)!;
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_migrate_keys;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMigrate_keys) {
+             listener.enterMigrate_keys(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMigrate_keys) {
+             listener.exitMigrate_keys(this);
+        }
+    }
+}
+
+
+export class Reverse_migrate_keysContext extends antlr.ParserRuleContext {
+    public _s?: SecretContext;
+    public _hsm?: SecretContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public REVERSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REVERSE, 0)!;
+    }
+    public MIGRATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MIGRATE, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public secret(): SecretContext[];
+    public secret(i: number): SecretContext | null;
+    public secret(i?: number): SecretContext[] | SecretContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(SecretContext);
+        }
+
+        return this.getRuleContext(i, SecretContext);
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_reverse_migrate_keys;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReverse_migrate_keys) {
+             listener.enterReverse_migrate_keys(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReverse_migrate_keys) {
+             listener.exitReverse_migrate_keys(this);
+        }
+    }
+}
+
+
+export class Move_keysContext extends antlr.ParserRuleContext {
+    public _ksl1?: Token | null;
+    public _ksp1?: Keystore_passwordContext;
+    public _ksp?: Keystore_passwordContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVE, 0)!;
+    }
+    public KEYS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYS, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public NEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NEW, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode[];
+    public KEYSTORE(i: number): antlr.TerminalNode | null;
+    public KEYSTORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEYSTORE);
+    	} else {
+    		return this.getToken(PlSqlParser.KEYSTORE, i);
+    	}
+    }
+    public IDENTIFIED(): antlr.TerminalNode[];
+    public IDENTIFIED(i: number): antlr.TerminalNode | null;
+    public IDENTIFIED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IDENTIFIED);
+    	} else {
+    		return this.getToken(PlSqlParser.IDENTIFIED, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode[];
+    public BY(i: number): antlr.TerminalNode | null;
+    public BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BY);
+    	} else {
+    		return this.getToken(PlSqlParser.BY, i);
+    	}
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public keystore_password(): Keystore_passwordContext[];
+    public keystore_password(i: number): Keystore_passwordContext | null;
+    public keystore_password(i?: number): Keystore_passwordContext[] | Keystore_passwordContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Keystore_passwordContext);
+        }
+
+        return this.getRuleContext(i, Keystore_passwordContext);
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public IDENTIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIER, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_move_keys;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMove_keys) {
+             listener.enterMove_keys(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMove_keys) {
+             listener.exitMove_keys(this);
+        }
+    }
+}
+
+
+export class Identified_by_storeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public keystore_password(): Keystore_passwordContext | null {
+        return this.getRuleContext(0, Keystore_passwordContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identified_by_store;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentified_by_store) {
+             listener.enterIdentified_by_store(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentified_by_store) {
+             listener.exitIdentified_by_store(this);
+        }
+    }
+}
+
+
+export class Using_algorithm_clauseContext extends antlr.ParserRuleContext {
+    public _ea?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public ALGORITHM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALGORITHM, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_algorithm_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_algorithm_clause) {
+             listener.enterUsing_algorithm_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_algorithm_clause) {
+             listener.exitUsing_algorithm_clause(this);
+        }
+    }
+}
+
+
+export class Using_tag_clauseContext extends antlr.ParserRuleContext {
+    public _t?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public TAG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TAG, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_tag_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_tag_clause) {
+             listener.enterUsing_tag_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_tag_clause) {
+             listener.exitUsing_tag_clause(this);
+        }
+    }
+}
+
+
+export class Secret_management_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_update_secret(): Add_update_secretContext | null {
+        return this.getRuleContext(0, Add_update_secretContext);
+    }
+    public delete_secret(): Delete_secretContext | null {
+        return this.getRuleContext(0, Delete_secretContext);
+    }
+    public add_update_secret_seps(): Add_update_secret_sepsContext | null {
+        return this.getRuleContext(0, Add_update_secret_sepsContext);
+    }
+    public delete_secret_seps(): Delete_secret_sepsContext | null {
+        return this.getRuleContext(0, Delete_secret_sepsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_secret_management_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSecret_management_clauses) {
+             listener.enterSecret_management_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSecret_management_clauses) {
+             listener.exitSecret_management_clauses(this);
+        }
+    }
+}
+
+
+export class Add_update_secretContext extends antlr.ParserRuleContext {
+    public _s?: Token | null;
+    public _ci?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SECRET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SECRET, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public CLIENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLIENT, 0)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public using_tag_clause(): Using_tag_clauseContext | null {
+        return this.getRuleContext(0, Using_tag_clauseContext);
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public identified_by_store(): Identified_by_storeContext | null {
+        return this.getRuleContext(0, Identified_by_storeContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_update_secret;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_update_secret) {
+             listener.enterAdd_update_secret(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_update_secret) {
+             listener.exitAdd_update_secret(this);
+        }
+    }
+}
+
+
+export class Delete_secretContext extends antlr.ParserRuleContext {
+    public _ci?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public SECRET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SECRET, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public CLIENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLIENT, 0)!;
+    }
+    public identified_by_store(): Identified_by_storeContext {
+        return this.getRuleContext(0, Identified_by_storeContext)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public force_keystore(): Force_keystoreContext | null {
+        return this.getRuleContext(0, Force_keystoreContext);
+    }
+    public with_backup_clause(): With_backup_clauseContext | null {
+        return this.getRuleContext(0, With_backup_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_delete_secret;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDelete_secret) {
+             listener.enterDelete_secret(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDelete_secret) {
+             listener.exitDelete_secret(this);
+        }
+    }
+}
+
+
+export class Add_update_secret_sepsContext extends antlr.ParserRuleContext {
+    public _s?: Token | null;
+    public _ci?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SECRET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SECRET, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public CLIENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLIENT, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public AUTO_LOGIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUTO_LOGIN, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public directory_path(): Directory_pathContext {
+        return this.getRuleContext(0, Directory_pathContext)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public using_tag_clause(): Using_tag_clauseContext | null {
+        return this.getRuleContext(0, Using_tag_clauseContext);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_update_secret_seps;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_update_secret_seps) {
+             listener.enterAdd_update_secret_seps(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_update_secret_seps) {
+             listener.exitAdd_update_secret_seps(this);
+        }
+    }
+}
+
+
+export class Delete_secret_sepsContext extends antlr.ParserRuleContext {
+    public _s?: Token | null;
+    public _ci?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public SECRET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SECRET, 0)!;
+    }
+    public SQ(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SQ, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public CLIENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLIENT, 0)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public AUTO_LOGIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUTO_LOGIN, 0)!;
+    }
+    public KEYSTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEYSTORE, 0)!;
+    }
+    public directory_path(): Directory_pathContext {
+        return this.getRuleContext(0, Directory_pathContext)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_delete_secret_seps;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDelete_secret_seps) {
+             listener.enterDelete_secret_seps(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDelete_secret_seps) {
+             listener.exitDelete_secret_seps(this);
+        }
+    }
+}
+
+
+export class Zero_downtime_software_patching_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SWITCHOVER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SWITCHOVER, 0)!;
+    }
+    public LIBRARY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIBRARY, 0)!;
+    }
+    public path(): PathContext {
+        return this.getRuleContext(0, PathContext)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public ALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALL, 0)!;
+    }
+    public CONTAINERS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTAINERS, 0)!;
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_zero_downtime_software_patching_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterZero_downtime_software_patching_clauses) {
+             listener.enterZero_downtime_software_patching_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitZero_downtime_software_patching_clauses) {
+             listener.exitZero_downtime_software_patching_clauses(this);
+        }
+    }
+}
+
+
+export class With_backup_clauseContext extends antlr.ParserRuleContext {
+    public _bi?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public BACKUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BACKUP, 0)!;
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_with_backup_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWith_backup_clause) {
+             listener.enterWith_backup_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWith_backup_clause) {
+             listener.exitWith_backup_clause(this);
+        }
+    }
+}
+
+
+export class Identified_by_password_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public keystore_password(): Keystore_passwordContext {
+        return this.getRuleContext(0, Keystore_passwordContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identified_by_password_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentified_by_password_clause) {
+             listener.enterIdentified_by_password_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentified_by_password_clause) {
+             listener.exitIdentified_by_password_clause(this);
+        }
+    }
+}
+
+
+export class Keystore_passwordContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_keystore_password;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterKeystore_password) {
+             listener.enterKeystore_password(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitKeystore_password) {
+             listener.exitKeystore_password(this);
+        }
+    }
+}
+
+
+export class PathContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_path;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPath) {
+             listener.enterPath(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPath) {
+             listener.exitPath(this);
+        }
+    }
+}
+
+
+export class SecretContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_secret;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSecret) {
+             listener.enterSecret(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSecret) {
+             listener.exitSecret(this);
+        }
+    }
+}
+
+
+export class AnalyzeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ANALYZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANALYZE, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public cluster_name(): Cluster_nameContext | null {
+        return this.getRuleContext(0, Cluster_nameContext);
+    }
+    public validation_clauses(): Validation_clausesContext | null {
+        return this.getRuleContext(0, Validation_clausesContext);
+    }
+    public compute_clauses(): Compute_clausesContext | null {
+        return this.getRuleContext(0, Compute_clausesContext);
+    }
+    public ESTIMATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ESTIMATE, 0);
+    }
+    public STATISTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATISTICS, 0);
+    }
+    public LIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIST, 0);
+    }
+    public CHAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAINED, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public index_name(): Index_nameContext | null {
+        return this.getRuleContext(0, Index_nameContext);
+    }
+    public partition_extention_clause(): Partition_extention_clauseContext | null {
+        return this.getRuleContext(0, Partition_extention_clauseContext);
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public for_clause(): For_clauseContext | null {
+        return this.getRuleContext(0, For_clauseContext);
+    }
+    public SAMPLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAMPLE, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public into_clause1(): Into_clause1Context | null {
+        return this.getRuleContext(0, Into_clause1Context);
+    }
+    public PERCENT_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_KEYWORD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_analyze;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAnalyze) {
+             listener.enterAnalyze(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAnalyze) {
+             listener.exitAnalyze(this);
+        }
+    }
+}
+
+
+export class Partition_extention_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public partition_key_value(): Partition_key_valueContext[];
+    public partition_key_value(i: number): Partition_key_valueContext | null;
+    public partition_key_value(i?: number): Partition_key_valueContext[] | Partition_key_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_key_valueContext);
+        }
+
+        return this.getRuleContext(i, Partition_key_valueContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public subpartition_key_value(): Subpartition_key_valueContext[];
+    public subpartition_key_value(i: number): Subpartition_key_valueContext | null;
+    public subpartition_key_value(i?: number): Subpartition_key_valueContext[] | Subpartition_key_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Subpartition_key_valueContext);
+        }
+
+        return this.getRuleContext(i, Subpartition_key_valueContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_extention_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_extention_clause) {
+             listener.enterPartition_extention_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_extention_clause) {
+             listener.exitPartition_extention_clause(this);
+        }
+    }
+}
+
+
+export class Validation_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VALIDATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VALIDATE, 0)!;
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public DANGLING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DANGLING, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public STRUCTURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRUCTURE, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public FAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAST, 0);
+    }
+    public online_or_offline(): Online_or_offlineContext[];
+    public online_or_offline(i: number): Online_or_offlineContext | null;
+    public online_or_offline(i?: number): Online_or_offlineContext[] | Online_or_offlineContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Online_or_offlineContext);
+        }
+
+        return this.getRuleContext(i, Online_or_offlineContext);
+    }
+    public into_clause(): Into_clauseContext[];
+    public into_clause(i: number): Into_clauseContext | null;
+    public into_clause(i?: number): Into_clauseContext[] | Into_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Into_clauseContext);
+        }
+
+        return this.getRuleContext(i, Into_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_validation_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterValidation_clauses) {
+             listener.enterValidation_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitValidation_clauses) {
+             listener.exitValidation_clauses(this);
+        }
+    }
+}
+
+
+export class Compute_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMPUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMPUTE, 0)!;
+    }
+    public STATISTICS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STATISTICS, 0)!;
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public for_clause(): For_clauseContext | null {
+        return this.getRuleContext(0, For_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_compute_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCompute_clauses) {
+             listener.enterCompute_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCompute_clauses) {
+             listener.exitCompute_clauses(this);
+        }
+    }
+}
+
+
+export class For_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMNS, 0);
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public for_clause(): For_clauseContext[];
+    public for_clause(i: number): For_clauseContext | null;
+    public for_clause(i?: number): For_clauseContext[] | For_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(For_clauseContext);
+        }
+
+        return this.getRuleContext(i, For_clauseContext);
+    }
+    public SIZE(): antlr.TerminalNode[];
+    public SIZE(i: number): antlr.TerminalNode | null;
+    public SIZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SIZE);
+    	} else {
+    		return this.getToken(PlSqlParser.SIZE, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public INDEXED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXED, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_for_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFor_clause) {
+             listener.enterFor_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFor_clause) {
+             listener.exitFor_clause(this);
+        }
+    }
+}
+
+
+export class Online_or_offlineContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_online_or_offline;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOnline_or_offline) {
+             listener.enterOnline_or_offline(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOnline_or_offline) {
+             listener.exitOnline_or_offline(this);
+        }
+    }
+}
+
+
+export class Into_clause1Context extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_into_clause1;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInto_clause1) {
+             listener.enterInto_clause1(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInto_clause1) {
+             listener.exitInto_clause1(this);
+        }
+    }
+}
+
+
+export class Partition_key_valueContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public literal(): LiteralContext | null {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_key_value;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_key_value) {
+             listener.enterPartition_key_value(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_key_value) {
+             listener.exitPartition_key_value(this);
+        }
+    }
+}
+
+
+export class Subpartition_key_valueContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public literal(): LiteralContext | null {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_key_value;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_key_value) {
+             listener.enterSubpartition_key_value(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_key_value) {
+             listener.exitSubpartition_key_value(this);
+        }
+    }
+}
+
+
+export class Associate_statisticsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ASSOCIATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ASSOCIATE, 0)!;
+    }
+    public STATISTICS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STATISTICS, 0)!;
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public column_association(): Column_associationContext | null {
+        return this.getRuleContext(0, Column_associationContext);
+    }
+    public function_association(): Function_associationContext | null {
+        return this.getRuleContext(0, Function_associationContext);
+    }
+    public storage_table_clause(): Storage_table_clauseContext | null {
+        return this.getRuleContext(0, Storage_table_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_associate_statistics;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAssociate_statistics) {
+             listener.enterAssociate_statistics(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAssociate_statistics) {
+             listener.exitAssociate_statistics(this);
+        }
+    }
+}
+
+
+export class Column_associationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COLUMNS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMNS, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext[];
+    public tableview_name(i: number): Tableview_nameContext | null;
+    public tableview_name(i?: number): Tableview_nameContext[] | Tableview_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tableview_nameContext);
+        }
+
+        return this.getRuleContext(i, Tableview_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public using_statistics_type(): Using_statistics_typeContext {
+        return this.getRuleContext(0, Using_statistics_typeContext)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_association;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_association) {
+             listener.enterColumn_association(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_association) {
+             listener.exitColumn_association(this);
+        }
+    }
+}
+
+
+export class Function_associationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FUNCTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FUNCTIONS, 0);
+    }
+    public function_name(): Function_nameContext[];
+    public function_name(i: number): Function_nameContext | null;
+    public function_name(i?: number): Function_nameContext[] | Function_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Function_nameContext);
+        }
+
+        return this.getRuleContext(i, Function_nameContext);
+    }
+    public PACKAGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PACKAGES, 0);
+    }
+    public package_name(): Package_nameContext[];
+    public package_name(i: number): Package_nameContext | null;
+    public package_name(i?: number): Package_nameContext[] | Package_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Package_nameContext);
+        }
+
+        return this.getRuleContext(i, Package_nameContext);
+    }
+    public TYPES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPES, 0);
+    }
+    public type_name(): Type_nameContext[];
+    public type_name(i: number): Type_nameContext | null;
+    public type_name(i?: number): Type_nameContext[] | Type_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_nameContext);
+        }
+
+        return this.getRuleContext(i, Type_nameContext);
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public index_name(): Index_nameContext[];
+    public index_name(i: number): Index_nameContext | null;
+    public index_name(i?: number): Index_nameContext[] | Index_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Index_nameContext);
+        }
+
+        return this.getRuleContext(i, Index_nameContext);
+    }
+    public INDEXTYPES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXTYPES, 0);
+    }
+    public indextype_name(): Indextype_nameContext[];
+    public indextype_name(i: number): Indextype_nameContext | null;
+    public indextype_name(i?: number): Indextype_nameContext[] | Indextype_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Indextype_nameContext);
+        }
+
+        return this.getRuleContext(i, Indextype_nameContext);
+    }
+    public using_statistics_type(): Using_statistics_typeContext | null {
+        return this.getRuleContext(0, Using_statistics_typeContext);
+    }
+    public default_cost_clause(): Default_cost_clauseContext | null {
+        return this.getRuleContext(0, Default_cost_clauseContext);
+    }
+    public default_selectivity_clause(): Default_selectivity_clauseContext | null {
+        return this.getRuleContext(0, Default_selectivity_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_association;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_association) {
+             listener.enterFunction_association(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_association) {
+             listener.exitFunction_association(this);
+        }
+    }
+}
+
+
+export class Indextype_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_indextype_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndextype_name) {
+             listener.enterIndextype_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndextype_name) {
+             listener.exitIndextype_name(this);
+        }
+    }
+}
+
+
+export class Using_statistics_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public statistics_type_name(): Statistics_type_nameContext | null {
+        return this.getRuleContext(0, Statistics_type_nameContext);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_statistics_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_statistics_type) {
+             listener.enterUsing_statistics_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_statistics_type) {
+             listener.exitUsing_statistics_type(this);
+        }
+    }
+}
+
+
+export class Statistics_type_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_statistics_type_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStatistics_type_name) {
+             listener.enterStatistics_type_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStatistics_type_name) {
+             listener.exitStatistics_type_name(this);
+        }
+    }
+}
+
+
+export class Default_cost_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public COST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COST, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public cpu_cost(): Cpu_costContext {
+        return this.getRuleContext(0, Cpu_costContext)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public io_cost(): Io_costContext {
+        return this.getRuleContext(0, Io_costContext)!;
+    }
+    public network_cost(): Network_costContext {
+        return this.getRuleContext(0, Network_costContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_cost_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_cost_clause) {
+             listener.enterDefault_cost_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_cost_clause) {
+             listener.exitDefault_cost_clause(this);
+        }
+    }
+}
+
+
+export class Cpu_costContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cpu_cost;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCpu_cost) {
+             listener.enterCpu_cost(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCpu_cost) {
+             listener.exitCpu_cost(this);
+        }
+    }
+}
+
+
+export class Io_costContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_io_cost;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIo_cost) {
+             listener.enterIo_cost(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIo_cost) {
+             listener.exitIo_cost(this);
+        }
+    }
+}
+
+
+export class Network_costContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_network_cost;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNetwork_cost) {
+             listener.enterNetwork_cost(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNetwork_cost) {
+             listener.exitNetwork_cost(this);
+        }
+    }
+}
+
+
+export class Default_selectivity_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public SELECTIVITY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SELECTIVITY, 0)!;
+    }
+    public default_selectivity(): Default_selectivityContext {
+        return this.getRuleContext(0, Default_selectivityContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_selectivity_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_selectivity_clause) {
+             listener.enterDefault_selectivity_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_selectivity_clause) {
+             listener.exitDefault_selectivity_clause(this);
+        }
+    }
+}
+
+
+export class Default_selectivityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_selectivity;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_selectivity) {
+             listener.enterDefault_selectivity(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_selectivity) {
+             listener.exitDefault_selectivity(this);
+        }
+    }
+}
+
+
+export class Storage_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public MANAGED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MANAGED, 0)!;
+    }
+    public STORAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STORAGE, 0)!;
+    }
+    public TABLES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLES, 0)!;
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_storage_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStorage_table_clause) {
+             listener.enterStorage_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStorage_table_clause) {
+             listener.exitStorage_table_clause(this);
+        }
+    }
+}
+
+
+export class Unified_auditingContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AUDIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUDIT, 0)!;
+    }
+    public POLICY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POLICY, 0);
+    }
+    public policy_name(): Policy_nameContext | null {
+        return this.getRuleContext(0, Policy_nameContext);
+    }
+    public CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTEXT, 0);
+    }
+    public NAMESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAMESPACE, 0);
+    }
+    public oracle_namespace(): Oracle_namespaceContext | null {
+        return this.getRuleContext(0, Oracle_namespaceContext);
+    }
+    public ATTRIBUTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0);
+    }
+    public attribute_name(): Attribute_nameContext[];
+    public attribute_name(i: number): Attribute_nameContext | null;
+    public attribute_name(i?: number): Attribute_nameContext[] | Attribute_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Attribute_nameContext);
+        }
+
+        return this.getRuleContext(i, Attribute_nameContext);
+    }
+    public audit_user(): Audit_userContext[];
+    public audit_user(i: number): Audit_userContext | null;
+    public audit_user(i?: number): Audit_userContext[] | Audit_userContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Audit_userContext);
+        }
+
+        return this.getRuleContext(i, Audit_userContext);
+    }
+    public WHENEVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHENEVER, 0);
+    }
+    public SUCCESSFUL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUCCESSFUL, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unified_auditing;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnified_auditing) {
+             listener.enterUnified_auditing(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnified_auditing) {
+             listener.exitUnified_auditing(this);
+        }
+    }
+}
+
+
+export class Policy_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_policy_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPolicy_name) {
+             listener.enterPolicy_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPolicy_name) {
+             listener.exitPolicy_name(this);
+        }
+    }
+}
+
+
+export class Audit_traditionalContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AUDIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUDIT, 0)!;
+    }
+    public audit_operation_clause(): Audit_operation_clauseContext | null {
+        return this.getRuleContext(0, Audit_operation_clauseContext);
+    }
+    public audit_schema_object_clause(): Audit_schema_object_clauseContext | null {
+        return this.getRuleContext(0, Audit_schema_object_clauseContext);
+    }
+    public NETWORK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NETWORK, 0);
+    }
+    public audit_direct_path(): Audit_direct_pathContext | null {
+        return this.getRuleContext(0, Audit_direct_pathContext);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public WHENEVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHENEVER, 0);
+    }
+    public SUCCESSFUL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUCCESSFUL, 0);
+    }
+    public audit_container_clause(): Audit_container_clauseContext | null {
+        return this.getRuleContext(0, Audit_container_clauseContext);
+    }
+    public SESSION(): antlr.TerminalNode[];
+    public SESSION(i: number): antlr.TerminalNode | null;
+    public SESSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SESSION);
+    	} else {
+    		return this.getToken(PlSqlParser.SESSION, i);
+    	}
+    }
+    public ACCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESS, 0);
+    }
+    public auditing_by_clause(): Auditing_by_clauseContext | null {
+        return this.getRuleContext(0, Auditing_by_clauseContext);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_audit_traditional;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAudit_traditional) {
+             listener.enterAudit_traditional(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAudit_traditional) {
+             listener.exitAudit_traditional(this);
+        }
+    }
+}
+
+
+export class Audit_direct_pathContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DIRECT_PATH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIRECT_PATH, 0)!;
+    }
+    public auditing_by_clause(): Auditing_by_clauseContext {
+        return this.getRuleContext(0, Auditing_by_clauseContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_audit_direct_path;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAudit_direct_path) {
+             listener.enterAudit_direct_path(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAudit_direct_path) {
+             listener.exitAudit_direct_path(this);
+        }
+    }
+}
+
+
+export class Audit_container_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONTAINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_audit_container_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAudit_container_clause) {
+             listener.enterAudit_container_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAudit_container_clause) {
+             listener.exitAudit_container_clause(this);
+        }
+    }
+}
+
+
+export class Audit_operation_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public sql_statement_shortcut(): Sql_statement_shortcutContext[];
+    public sql_statement_shortcut(i: number): Sql_statement_shortcutContext | null;
+    public sql_statement_shortcut(i?: number): Sql_statement_shortcutContext[] | Sql_statement_shortcutContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sql_statement_shortcutContext);
+        }
+
+        return this.getRuleContext(i, Sql_statement_shortcutContext);
+    }
+    public ALL(): antlr.TerminalNode[];
+    public ALL(i: number): antlr.TerminalNode | null;
+    public ALL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ALL);
+    	} else {
+    		return this.getToken(PlSqlParser.ALL, i);
+    	}
+    }
+    public system_privilege(): System_privilegeContext[];
+    public system_privilege(i: number): System_privilegeContext | null;
+    public system_privilege(i?: number): System_privilegeContext[] | System_privilegeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(System_privilegeContext);
+        }
+
+        return this.getRuleContext(i, System_privilegeContext);
+    }
+    public PRIVILEGES(): antlr.TerminalNode[];
+    public PRIVILEGES(i: number): antlr.TerminalNode | null;
+    public PRIVILEGES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIVILEGES);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIVILEGES, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public STATEMENTS(): antlr.TerminalNode[];
+    public STATEMENTS(i: number): antlr.TerminalNode | null;
+    public STATEMENTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.STATEMENTS);
+    	} else {
+    		return this.getToken(PlSqlParser.STATEMENTS, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_audit_operation_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAudit_operation_clause) {
+             listener.enterAudit_operation_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAudit_operation_clause) {
+             listener.exitAudit_operation_clause(this);
+        }
+    }
+}
+
+
+export class Auditing_by_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public audit_user(): Audit_userContext[];
+    public audit_user(i: number): Audit_userContext | null;
+    public audit_user(i?: number): Audit_userContext[] | Audit_userContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Audit_userContext);
+        }
+
+        return this.getRuleContext(i, Audit_userContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_auditing_by_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAuditing_by_clause) {
+             listener.enterAuditing_by_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAuditing_by_clause) {
+             listener.exitAuditing_by_clause(this);
+        }
+    }
+}
+
+
+export class Audit_userContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_audit_user;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAudit_user) {
+             listener.enterAudit_user(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAudit_user) {
+             listener.exitAudit_user(this);
+        }
+    }
+}
+
+
+export class Audit_schema_object_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public auditing_on_clause(): Auditing_on_clauseContext {
+        return this.getRuleContext(0, Auditing_on_clauseContext)!;
+    }
+    public sql_operation(): Sql_operationContext[];
+    public sql_operation(i: number): Sql_operationContext | null;
+    public sql_operation(i?: number): Sql_operationContext[] | Sql_operationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sql_operationContext);
+        }
+
+        return this.getRuleContext(i, Sql_operationContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_audit_schema_object_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAudit_schema_object_clause) {
+             listener.enterAudit_schema_object_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAudit_schema_object_clause) {
+             listener.exitAudit_schema_object_clause(this);
+        }
+    }
+}
+
+
+export class Sql_operationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUDIT, 0);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public FLASHBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASHBACK, 0);
+    }
+    public GRANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GRANT, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public LOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCK, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELECT, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_operation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_operation) {
+             listener.enterSql_operation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_operation) {
+             listener.exitSql_operation(this);
+        }
+    }
+}
+
+
+export class Auditing_on_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public object_name(): Object_nameContext | null {
+        return this.getRuleContext(0, Object_nameContext);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public MINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINING, 0);
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public model_name(): Model_nameContext | null {
+        return this.getRuleContext(0, Model_nameContext);
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public TRANSLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATION, 0);
+    }
+    public PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROFILE, 0);
+    }
+    public profile_name(): Profile_nameContext | null {
+        return this.getRuleContext(0, Profile_nameContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_auditing_on_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAuditing_on_clause) {
+             listener.enterAuditing_on_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAuditing_on_clause) {
+             listener.exitAuditing_on_clause(this);
+        }
+    }
+}
+
+
+export class Model_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_name) {
+             listener.enterModel_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_name) {
+             listener.exitModel_name(this);
+        }
+    }
+}
+
+
+export class Object_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_name) {
+             listener.enterObject_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_name) {
+             listener.exitObject_name(this);
+        }
+    }
+}
+
+
+export class Profile_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_profile_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProfile_name) {
+             listener.enterProfile_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProfile_name) {
+             listener.exitProfile_name(this);
+        }
+    }
+}
+
+
+export class Sql_statement_shortcutContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTEXT, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public LINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINK, 0);
+    }
+    public DIMENSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIMENSION, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public MATERIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0);
+    }
+    public VIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIEW, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public OUTLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTLINE, 0);
+    }
+    public PLUGGABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0);
+    }
+    public PROCEDURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURE, 0);
+    }
+    public PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROFILE, 0);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public SYNONYM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYNONYM, 0);
+    }
+    public ROLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLE, 0);
+    }
+    public ROLLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLBACK, 0);
+    }
+    public SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEGMENT, 0);
+    }
+    public SEQUENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCE, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUDIT, 0);
+    }
+    public GRANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GRANT, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public TRIGGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIGGER, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public LOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCK, 0);
+    }
+    public SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELECT, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_statement_shortcut;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_statement_shortcut) {
+             listener.enterSql_statement_shortcut(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_statement_shortcut) {
+             listener.exitSql_statement_shortcut(this);
+        }
+    }
+}
+
+
+export class Drop_indexContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public INDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEX, 0)!;
+    }
+    public index_name(): Index_nameContext {
+        return this.getRuleContext(0, Index_nameContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_index;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_index) {
+             listener.enterDrop_index(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_index) {
+             listener.exitDrop_index(this);
+        }
+    }
+}
+
+
+export class Disassociate_statisticsContext extends antlr.ParserRuleContext {
+    public _tb?: Id_expressionContext;
+    public _c?: Id_expressionContext;
+    public _fn?: Id_expressionContext;
+    public _pkg?: Id_expressionContext;
+    public _t?: Id_expressionContext;
+    public _ix?: Id_expressionContext;
+    public _it?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DISASSOCIATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISASSOCIATE, 0)!;
+    }
+    public STATISTICS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STATISTICS, 0)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMNS, 0);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public FUNCTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FUNCTIONS, 0);
+    }
+    public PACKAGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PACKAGES, 0);
+    }
+    public TYPES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPES, 0);
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public INDEXTYPES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXTYPES, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public schema_name(): Schema_nameContext[];
+    public schema_name(i: number): Schema_nameContext | null;
+    public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Schema_nameContext);
+        }
+
+        return this.getRuleContext(i, Schema_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_disassociate_statistics;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDisassociate_statistics) {
+             listener.enterDisassociate_statistics(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDisassociate_statistics) {
+             listener.exitDisassociate_statistics(this);
+        }
+    }
+}
+
+
+export class Drop_indextypeContext extends antlr.ParserRuleContext {
+    public _it?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public INDEXTYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEXTYPE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_indextype;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_indextype) {
+             listener.enterDrop_indextype(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_indextype) {
+             listener.exitDrop_indextype(this);
+        }
+    }
+}
+
+
+export class Drop_inmemory_join_groupContext extends antlr.ParserRuleContext {
+    public _jg?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public INMEMORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INMEMORY, 0)!;
+    }
+    public JOIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JOIN, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_inmemory_join_group;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_inmemory_join_group) {
+             listener.enterDrop_inmemory_join_group(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_inmemory_join_group) {
+             listener.exitDrop_inmemory_join_group(this);
+        }
+    }
+}
+
+
+export class Flashback_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FLASHBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLASHBACK, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext[];
+    public tableview_name(i: number): Tableview_nameContext | null;
+    public tableview_name(i?: number): Tableview_nameContext[] | Tableview_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tableview_nameContext);
+        }
+
+        return this.getRuleContext(i, Tableview_nameContext);
+    }
+    public TO(): antlr.TerminalNode[];
+    public TO(i: number): antlr.TerminalNode | null;
+    public TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TO);
+    	} else {
+    		return this.getToken(PlSqlParser.TO, i);
+    	}
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public RESTORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTORE, 0);
+    }
+    public POINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POINT, 0);
+    }
+    public restore_point(): Restore_pointContext | null {
+        return this.getRuleContext(0, Restore_pointContext);
+    }
+    public SCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCN, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public TRIGGERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIGGERS, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_flashback_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFlashback_table) {
+             listener.enterFlashback_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFlashback_table) {
+             listener.exitFlashback_table(this);
+        }
+    }
+}
+
+
+export class Restore_pointContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_restore_point;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRestore_point) {
+             listener.enterRestore_point(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRestore_point) {
+             listener.exitRestore_point(this);
+        }
+    }
+}
+
+
+export class Purge_statementContext extends antlr.ParserRuleContext {
+    public _ts?: Id_expressionContext;
+    public _u?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PURGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PURGE, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public RECYCLEBIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECYCLEBIN, 0);
+    }
+    public DBA_RECYCLEBIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBA_RECYCLEBIN, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_purge_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPurge_statement) {
+             listener.enterPurge_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPurge_statement) {
+             listener.exitPurge_statement(this);
+        }
+    }
+}
+
+
+export class Noaudit_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NOAUDIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NOAUDIT, 0)!;
+    }
+    public audit_operation_clause(): Audit_operation_clauseContext | null {
+        return this.getRuleContext(0, Audit_operation_clauseContext);
+    }
+    public audit_schema_object_clause(): Audit_schema_object_clauseContext | null {
+        return this.getRuleContext(0, Audit_schema_object_clauseContext);
+    }
+    public NETWORK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NETWORK, 0);
+    }
+    public DIRECT_PATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECT_PATH, 0);
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public WHENEVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHENEVER, 0);
+    }
+    public SUCCESSFUL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUCCESSFUL, 0);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public auditing_by_clause(): Auditing_by_clauseContext | null {
+        return this.getRuleContext(0, Auditing_by_clauseContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_noaudit_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNoaudit_statement) {
+             listener.enterNoaudit_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNoaudit_statement) {
+             listener.exitNoaudit_statement(this);
+        }
+    }
+}
+
+
+export class Rename_objectContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RENAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RENAME, 0)!;
+    }
+    public object_name(): Object_nameContext[];
+    public object_name(i: number): Object_nameContext | null;
+    public object_name(i?: number): Object_nameContext[] | Object_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_nameContext);
+        }
+
+        return this.getRuleContext(i, Object_nameContext);
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rename_object;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRename_object) {
+             listener.enterRename_object(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRename_object) {
+             listener.exitRename_object(this);
+        }
+    }
+}
+
+
+export class Grant_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GRANT(): antlr.TerminalNode[];
+    public GRANT(i: number): antlr.TerminalNode | null;
+    public GRANT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GRANT);
+    	} else {
+    		return this.getToken(PlSqlParser.GRANT, i);
+    	}
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public grantee_name(): Grantee_nameContext[];
+    public grantee_name(i: number): Grantee_nameContext | null;
+    public grantee_name(i?: number): Grantee_nameContext[] | Grantee_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Grantee_nameContext);
+        }
+
+        return this.getRuleContext(i, Grantee_nameContext);
+    }
+    public PUBLIC(): antlr.TerminalNode[];
+    public PUBLIC(i: number): antlr.TerminalNode | null;
+    public PUBLIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PUBLIC);
+    	} else {
+    		return this.getToken(PlSqlParser.PUBLIC, i);
+    	}
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public grant_object_name(): Grant_object_nameContext | null {
+        return this.getRuleContext(0, Grant_object_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public OPTION(): antlr.TerminalNode[];
+    public OPTION(i: number): antlr.TerminalNode | null;
+    public OPTION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OPTION);
+    	} else {
+    		return this.getToken(PlSqlParser.OPTION, i);
+    	}
+    }
+    public HIERARCHY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIERARCHY, 0);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public ADMIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADMIN, 0);
+    }
+    public DELEGATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELEGATE, 0);
+    }
+    public role_name(): Role_nameContext[];
+    public role_name(i: number): Role_nameContext | null;
+    public role_name(i?: number): Role_nameContext[] | Role_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Role_nameContext);
+        }
+
+        return this.getRuleContext(i, Role_nameContext);
+    }
+    public system_privilege(): System_privilegeContext[];
+    public system_privilege(i: number): System_privilegeContext | null;
+    public system_privilege(i?: number): System_privilegeContext[] | System_privilegeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(System_privilegeContext);
+        }
+
+        return this.getRuleContext(i, System_privilegeContext);
+    }
+    public object_privilege(): Object_privilegeContext[];
+    public object_privilege(i: number): Object_privilegeContext | null;
+    public object_privilege(i?: number): Object_privilegeContext[] | Object_privilegeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_privilegeContext);
+        }
+
+        return this.getRuleContext(i, Object_privilegeContext);
+    }
+    public paren_column_list(): Paren_column_listContext[];
+    public paren_column_list(i: number): Paren_column_listContext | null;
+    public paren_column_list(i?: number): Paren_column_listContext[] | Paren_column_listContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Paren_column_listContext);
+        }
+
+        return this.getRuleContext(i, Paren_column_listContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_grant_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGrant_statement) {
+             listener.enterGrant_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGrant_statement) {
+             listener.exitGrant_statement(this);
+        }
+    }
+}
+
+
+export class Container_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONTAINER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTAINER, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_container_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterContainer_clause) {
+             listener.enterContainer_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitContainer_clause) {
+             listener.exitContainer_clause(this);
+        }
+    }
+}
+
+
+export class Revoke_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REVOKE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REVOKE, 0)!;
+    }
+    public revoke_roles_from_programs(): Revoke_roles_from_programsContext | null {
+        return this.getRuleContext(0, Revoke_roles_from_programsContext);
+    }
+    public revoke_system_privilege(): Revoke_system_privilegeContext | null {
+        return this.getRuleContext(0, Revoke_system_privilegeContext);
+    }
+    public revoke_object_privileges(): Revoke_object_privilegesContext | null {
+        return this.getRuleContext(0, Revoke_object_privilegesContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_revoke_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRevoke_statement) {
+             listener.enterRevoke_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRevoke_statement) {
+             listener.exitRevoke_statement(this);
+        }
+    }
+}
+
+
+export class Revoke_system_privilegeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public revokee_clause(): Revokee_clauseContext {
+        return this.getRuleContext(0, Revokee_clauseContext)!;
+    }
+    public system_privilege(): System_privilegeContext | null {
+        return this.getRuleContext(0, System_privilegeContext);
+    }
+    public role_name(): Role_nameContext | null {
+        return this.getRuleContext(0, Role_nameContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public PRIVILEGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_revoke_system_privilege;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRevoke_system_privilege) {
+             listener.enterRevoke_system_privilege(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRevoke_system_privilege) {
+             listener.exitRevoke_system_privilege(this);
+        }
+    }
+}
+
+
+export class Revokee_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PUBLIC(): antlr.TerminalNode[];
+    public PUBLIC(i: number): antlr.TerminalNode | null;
+    public PUBLIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PUBLIC);
+    	} else {
+    		return this.getToken(PlSqlParser.PUBLIC, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_revokee_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRevokee_clause) {
+             listener.enterRevokee_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRevokee_clause) {
+             listener.exitRevokee_clause(this);
+        }
+    }
+}
+
+
+export class Revoke_object_privilegesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public on_object_clause(): On_object_clauseContext {
+        return this.getRuleContext(0, On_object_clauseContext)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public revokee_clause(): Revokee_clauseContext {
+        return this.getRuleContext(0, Revokee_clauseContext)!;
+    }
+    public object_privilege(): Object_privilegeContext[];
+    public object_privilege(i: number): Object_privilegeContext | null;
+    public object_privilege(i?: number): Object_privilegeContext[] | Object_privilegeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_privilegeContext);
+        }
+
+        return this.getRuleContext(i, Object_privilegeContext);
+    }
+    public ALL(): antlr.TerminalNode[];
+    public ALL(i: number): antlr.TerminalNode | null;
+    public ALL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ALL);
+    	} else {
+    		return this.getToken(PlSqlParser.ALL, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public PRIVILEGES(): antlr.TerminalNode[];
+    public PRIVILEGES(i: number): antlr.TerminalNode | null;
+    public PRIVILEGES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIVILEGES);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIVILEGES, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_revoke_object_privileges;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRevoke_object_privileges) {
+             listener.enterRevoke_object_privileges(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRevoke_object_privileges) {
+             listener.exitRevoke_object_privileges(this);
+        }
+    }
+}
+
+
+export class On_object_clauseContext extends antlr.ParserRuleContext {
+    public _o?: Id_expressionContext;
+    public _mmn?: Id_expressionContext;
+    public _o2?: Id_expressionContext;
+    public _p?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public directory_name(): Directory_nameContext | null {
+        return this.getRuleContext(0, Directory_nameContext);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public edition_name(): Edition_nameContext | null {
+        return this.getRuleContext(0, Edition_nameContext);
+    }
+    public MINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINING, 0);
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public JAVA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JAVA, 0);
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public TRANSLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATION, 0);
+    }
+    public PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROFILE, 0);
+    }
+    public SOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE, 0);
+    }
+    public RESOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOURCE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_object_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_object_clause) {
+             listener.enterOn_object_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_object_clause) {
+             listener.exitOn_object_clause(this);
+        }
+    }
+}
+
+
+export class Revoke_roles_from_programsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public program_unit(): Program_unitContext[];
+    public program_unit(i: number): Program_unitContext | null;
+    public program_unit(i?: number): Program_unitContext[] | Program_unitContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Program_unitContext);
+        }
+
+        return this.getRuleContext(i, Program_unitContext);
+    }
+    public role_name(): Role_nameContext[];
+    public role_name(i: number): Role_nameContext | null;
+    public role_name(i?: number): Role_nameContext[] | Role_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Role_nameContext);
+        }
+
+        return this.getRuleContext(i, Role_nameContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_revoke_roles_from_programs;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRevoke_roles_from_programs) {
+             listener.enterRevoke_roles_from_programs(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRevoke_roles_from_programs) {
+             listener.exitRevoke_roles_from_programs(this);
+        }
+    }
+}
+
+
+export class Program_unitContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FUNCTION, 0);
+    }
+    public PROCEDURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURE, 0);
+    }
+    public PACKAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PACKAGE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_program_unit;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProgram_unit) {
+             listener.enterProgram_unit(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProgram_unit) {
+             listener.exitProgram_unit(this);
+        }
+    }
+}
+
+
+export class Create_dimensionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public DIMENSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIMENSION, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public level_clause(): Level_clauseContext[];
+    public level_clause(i: number): Level_clauseContext | null;
+    public level_clause(i?: number): Level_clauseContext[] | Level_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Level_clauseContext);
+        }
+
+        return this.getRuleContext(i, Level_clauseContext);
+    }
+    public hierarchy_clause(): Hierarchy_clauseContext[];
+    public hierarchy_clause(i: number): Hierarchy_clauseContext | null;
+    public hierarchy_clause(i?: number): Hierarchy_clauseContext[] | Hierarchy_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Hierarchy_clauseContext);
+        }
+
+        return this.getRuleContext(i, Hierarchy_clauseContext);
+    }
+    public attribute_clause(): Attribute_clauseContext[];
+    public attribute_clause(i: number): Attribute_clauseContext | null;
+    public attribute_clause(i?: number): Attribute_clauseContext[] | Attribute_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Attribute_clauseContext);
+        }
+
+        return this.getRuleContext(i, Attribute_clauseContext);
+    }
+    public extended_attribute_clause(): Extended_attribute_clauseContext[];
+    public extended_attribute_clause(i: number): Extended_attribute_clauseContext | null;
+    public extended_attribute_clause(i?: number): Extended_attribute_clauseContext[] | Extended_attribute_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Extended_attribute_clauseContext);
+        }
+
+        return this.getRuleContext(i, Extended_attribute_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_dimension;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_dimension) {
+             listener.enterCreate_dimension(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_dimension) {
+             listener.exitCreate_dimension(this);
+        }
+    }
+}
+
+
+export class Create_directoryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public DIRECTORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIRECTORY, 0)!;
+    }
+    public directory_name(): Directory_nameContext {
+        return this.getRuleContext(0, Directory_nameContext)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public directory_path(): Directory_pathContext {
+        return this.getRuleContext(0, Directory_pathContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_directory;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_directory) {
+             listener.enterCreate_directory(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_directory) {
+             listener.exitCreate_directory(this);
+        }
+    }
+}
+
+
+export class Directory_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_directory_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDirectory_name) {
+             listener.enterDirectory_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDirectory_name) {
+             listener.exitDirectory_name(this);
+        }
+    }
+}
+
+
+export class Directory_pathContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_directory_path;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDirectory_path) {
+             listener.enterDirectory_path(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDirectory_path) {
+             listener.exitDirectory_path(this);
+        }
+    }
+}
+
+
+export class Create_inmemory_join_groupContext extends antlr.ParserRuleContext {
+    public _jg?: Id_expressionContext;
+    public _t?: Id_expressionContext;
+    public _c?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public INMEMORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INMEMORY, 0)!;
+    }
+    public JOIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JOIN, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public schema_name(): Schema_nameContext[];
+    public schema_name(i: number): Schema_nameContext | null;
+    public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Schema_nameContext);
+        }
+
+        return this.getRuleContext(i, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_inmemory_join_group;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_inmemory_join_group) {
+             listener.enterCreate_inmemory_join_group(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_inmemory_join_group) {
+             listener.exitCreate_inmemory_join_group(this);
+        }
+    }
+}
+
+
+export class Drop_hierarchyContext extends antlr.ParserRuleContext {
+    public _hn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public HIERARCHY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_hierarchy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_hierarchy) {
+             listener.enterDrop_hierarchy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_hierarchy) {
+             listener.exitDrop_hierarchy(this);
+        }
+    }
+}
+
+
+export class Alter_libraryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public LIBRARY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIBRARY, 0)!;
+    }
+    public library_name(): Library_nameContext {
+        return this.getRuleContext(0, Library_nameContext)!;
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public library_editionable(): Library_editionableContext | null {
+        return this.getRuleContext(0, Library_editionableContext);
+    }
+    public library_debug(): Library_debugContext | null {
+        return this.getRuleContext(0, Library_debugContext);
+    }
+    public compiler_parameters_clause(): Compiler_parameters_clauseContext[];
+    public compiler_parameters_clause(i: number): Compiler_parameters_clauseContext | null;
+    public compiler_parameters_clause(i?: number): Compiler_parameters_clauseContext[] | Compiler_parameters_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compiler_parameters_clauseContext);
+        }
+
+        return this.getRuleContext(i, Compiler_parameters_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_library;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_library) {
+             listener.enterAlter_library(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_library) {
+             listener.exitAlter_library(this);
+        }
+    }
+}
+
+
+export class Drop_javaContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public JAVA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JAVA, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public SOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE, 0);
+    }
+    public CLASS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASS, 0);
+    }
+    public RESOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOURCE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_java;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_java) {
+             listener.enterDrop_java(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_java) {
+             listener.exitDrop_java(this);
+        }
+    }
+}
+
+
+export class Drop_libraryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public LIBRARY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIBRARY, 0)!;
+    }
+    public library_name(): Library_nameContext {
+        return this.getRuleContext(0, Library_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_library;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_library) {
+             listener.enterDrop_library(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_library) {
+             listener.exitDrop_library(this);
+        }
+    }
+}
+
+
+export class Create_javaContext extends antlr.ParserRuleContext {
+    public _pn?: Id_expressionContext;
+    public _sn?: Id_expressionContext;
+    public _d?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public JAVA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JAVA, 0)!;
+    }
+    public NAMED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAMED, 0);
+    }
+    public CLASS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASS, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public NOFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOFORCE, 0);
+    }
+    public SOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE, 0);
+    }
+    public RESOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOURCE, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public invoker_rights_clause(): Invoker_rights_clauseContext | null {
+        return this.getRuleContext(0, Invoker_rights_clauseContext);
+    }
+    public RESOLVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOLVER, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public RESOLVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOLVE, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public BFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BFILE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public SCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEMA, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public MINUS_SIGN(): antlr.TerminalNode[];
+    public MINUS_SIGN(i: number): antlr.TerminalNode | null;
+    public MINUS_SIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MINUS_SIGN);
+    	} else {
+    		return this.getToken(PlSqlParser.MINUS_SIGN, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_java;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_java) {
+             listener.enterCreate_java(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_java) {
+             listener.exitCreate_java(this);
+        }
+    }
+}
+
+
+export class Create_libraryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public LIBRARY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIBRARY, 0)!;
+    }
+    public plsql_library_source(): Plsql_library_sourceContext {
+        return this.getRuleContext(0, Plsql_library_sourceContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_library;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_library) {
+             listener.enterCreate_library(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_library) {
+             listener.exitCreate_library(this);
+        }
+    }
+}
+
+
+export class Plsql_library_sourceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public library_name(): Library_nameContext {
+        return this.getRuleContext(0, Library_nameContext)!;
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public directory_name(): Directory_nameContext | null {
+        return this.getRuleContext(0, Directory_nameContext);
+    }
+    public AGENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AGENT, 0);
+    }
+    public CREDENTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREDENTIAL, 0);
+    }
+    public credential_name(): Credential_nameContext | null {
+        return this.getRuleContext(0, Credential_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_plsql_library_source;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPlsql_library_source) {
+             listener.enterPlsql_library_source(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPlsql_library_source) {
+             listener.exitPlsql_library_source(this);
+        }
+    }
+}
+
+
+export class Credential_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_credential_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCredential_name) {
+             listener.enterCredential_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCredential_name) {
+             listener.exitCredential_name(this);
+        }
+    }
+}
+
+
+export class Library_editionableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_library_editionable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLibrary_editionable) {
+             listener.enterLibrary_editionable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLibrary_editionable) {
+             listener.exitLibrary_editionable(this);
+        }
+    }
+}
+
+
+export class Library_debugContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEBUG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEBUG, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_library_debug;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLibrary_debug) {
+             listener.enterLibrary_debug(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLibrary_debug) {
+             listener.exitLibrary_debug(this);
+        }
+    }
+}
+
+
+export class Compiler_parameters_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public parameter_name(): Parameter_nameContext {
+        return this.getRuleContext(0, Parameter_nameContext)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public parameter_value(): Parameter_valueContext {
+        return this.getRuleContext(0, Parameter_valueContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_compiler_parameters_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCompiler_parameters_clause) {
+             listener.enterCompiler_parameters_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCompiler_parameters_clause) {
+             listener.exitCompiler_parameters_clause(this);
+        }
+    }
+}
+
+
+export class Parameter_valueContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parameter_value;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParameter_value) {
+             listener.enterParameter_value(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParameter_value) {
+             listener.exitParameter_value(this);
+        }
+    }
+}
+
+
+export class Library_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext[];
+    public regular_id(i: number): Regular_idContext | null;
+    public regular_id(i?: number): Regular_idContext[] | Regular_idContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Regular_idContext);
+        }
+
+        return this.getRuleContext(i, Regular_idContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_library_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLibrary_name) {
+             listener.enterLibrary_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLibrary_name) {
+             listener.exitLibrary_name(this);
+        }
+    }
+}
+
+
+export class Alter_dimensionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public DIMENSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIMENSION, 0)!;
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public ADD(): antlr.TerminalNode[];
+    public ADD(i: number): antlr.TerminalNode | null;
+    public ADD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ADD);
+    	} else {
+    		return this.getToken(PlSqlParser.ADD, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode[];
+    public DROP(i: number): antlr.TerminalNode | null;
+    public DROP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DROP);
+    	} else {
+    		return this.getToken(PlSqlParser.DROP, i);
+    	}
+    }
+    public level_clause(): Level_clauseContext[];
+    public level_clause(i: number): Level_clauseContext | null;
+    public level_clause(i?: number): Level_clauseContext[] | Level_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Level_clauseContext);
+        }
+
+        return this.getRuleContext(i, Level_clauseContext);
+    }
+    public hierarchy_clause(): Hierarchy_clauseContext[];
+    public hierarchy_clause(i: number): Hierarchy_clauseContext | null;
+    public hierarchy_clause(i?: number): Hierarchy_clauseContext[] | Hierarchy_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Hierarchy_clauseContext);
+        }
+
+        return this.getRuleContext(i, Hierarchy_clauseContext);
+    }
+    public attribute_clause(): Attribute_clauseContext[];
+    public attribute_clause(i: number): Attribute_clauseContext | null;
+    public attribute_clause(i?: number): Attribute_clauseContext[] | Attribute_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Attribute_clauseContext);
+        }
+
+        return this.getRuleContext(i, Attribute_clauseContext);
+    }
+    public extended_attribute_clause(): Extended_attribute_clauseContext[];
+    public extended_attribute_clause(i: number): Extended_attribute_clauseContext | null;
+    public extended_attribute_clause(i?: number): Extended_attribute_clauseContext[] | Extended_attribute_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Extended_attribute_clauseContext);
+        }
+
+        return this.getRuleContext(i, Extended_attribute_clauseContext);
+    }
+    public LEVEL(): antlr.TerminalNode[];
+    public LEVEL(i: number): antlr.TerminalNode | null;
+    public LEVEL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEVEL);
+    	} else {
+    		return this.getToken(PlSqlParser.LEVEL, i);
+    	}
+    }
+    public HIERARCHY(): antlr.TerminalNode[];
+    public HIERARCHY(i: number): antlr.TerminalNode | null;
+    public HIERARCHY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.HIERARCHY);
+    	} else {
+    		return this.getToken(PlSqlParser.HIERARCHY, i);
+    	}
+    }
+    public ATTRIBUTE(): antlr.TerminalNode[];
+    public ATTRIBUTE(i: number): antlr.TerminalNode | null;
+    public ATTRIBUTE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ATTRIBUTE);
+    	} else {
+    		return this.getToken(PlSqlParser.ATTRIBUTE, i);
+    	}
+    }
+    public RESTRICT(): antlr.TerminalNode[];
+    public RESTRICT(i: number): antlr.TerminalNode | null;
+    public RESTRICT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RESTRICT);
+    	} else {
+    		return this.getToken(PlSqlParser.RESTRICT, i);
+    	}
+    }
+    public CASCADE(): antlr.TerminalNode[];
+    public CASCADE(i: number): antlr.TerminalNode | null;
+    public CASCADE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CASCADE);
+    	} else {
+    		return this.getToken(PlSqlParser.CASCADE, i);
+    	}
+    }
+    public COLUMN(): antlr.TerminalNode[];
+    public COLUMN(i: number): antlr.TerminalNode | null;
+    public COLUMN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COLUMN);
+    	} else {
+    		return this.getToken(PlSqlParser.COLUMN, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_dimension;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_dimension) {
+             listener.enterAlter_dimension(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_dimension) {
+             listener.exitAlter_dimension(this);
+        }
+    }
+}
+
+
+export class Level_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEVEL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEVEL, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public table_name(): Table_nameContext[];
+    public table_name(i: number): Table_nameContext | null;
+    public table_name(i?: number): Table_nameContext[] | Table_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_nameContext);
+        }
+
+        return this.getRuleContext(i, Table_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public SKIP_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_, 0);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_level_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLevel_clause) {
+             listener.enterLevel_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLevel_clause) {
+             listener.exitLevel_clause(this);
+        }
+    }
+}
+
+
+export class Hierarchy_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public HIERARCHY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHY, 0)!;
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public CHILD(): antlr.TerminalNode[];
+    public CHILD(i: number): antlr.TerminalNode | null;
+    public CHILD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHILD);
+    	} else {
+    		return this.getToken(PlSqlParser.CHILD, i);
+    	}
+    }
+    public OF(): antlr.TerminalNode[];
+    public OF(i: number): antlr.TerminalNode | null;
+    public OF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OF);
+    	} else {
+    		return this.getToken(PlSqlParser.OF, i);
+    	}
+    }
+    public dimension_join_clause(): Dimension_join_clauseContext | null {
+        return this.getRuleContext(0, Dimension_join_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hierarchy_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHierarchy_clause) {
+             listener.enterHierarchy_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHierarchy_clause) {
+             listener.exitHierarchy_clause(this);
+        }
+    }
+}
+
+
+export class Dimension_join_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public JOIN(): antlr.TerminalNode[];
+    public JOIN(i: number): antlr.TerminalNode | null;
+    public JOIN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.JOIN);
+    	} else {
+    		return this.getToken(PlSqlParser.JOIN, i);
+    	}
+    }
+    public KEY(): antlr.TerminalNode[];
+    public KEY(i: number): antlr.TerminalNode | null;
+    public KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEY);
+    	} else {
+    		return this.getToken(PlSqlParser.KEY, i);
+    	}
+    }
+    public column_one_or_more_sub_clause(): Column_one_or_more_sub_clauseContext[];
+    public column_one_or_more_sub_clause(i: number): Column_one_or_more_sub_clauseContext | null;
+    public column_one_or_more_sub_clause(i?: number): Column_one_or_more_sub_clauseContext[] | Column_one_or_more_sub_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_one_or_more_sub_clauseContext);
+        }
+
+        return this.getRuleContext(i, Column_one_or_more_sub_clauseContext);
+    }
+    public REFERENCES(): antlr.TerminalNode[];
+    public REFERENCES(i: number): antlr.TerminalNode | null;
+    public REFERENCES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.REFERENCES);
+    	} else {
+    		return this.getToken(PlSqlParser.REFERENCES, i);
+    	}
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dimension_join_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDimension_join_clause) {
+             listener.enterDimension_join_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDimension_join_clause) {
+             listener.exitDimension_join_clause(this);
+        }
+    }
+}
+
+
+export class Attribute_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ATTRIBUTE(): antlr.TerminalNode[];
+    public ATTRIBUTE(i: number): antlr.TerminalNode | null;
+    public ATTRIBUTE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ATTRIBUTE);
+    	} else {
+    		return this.getToken(PlSqlParser.ATTRIBUTE, i);
+    	}
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public DETERMINES(): antlr.TerminalNode[];
+    public DETERMINES(i: number): antlr.TerminalNode | null;
+    public DETERMINES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINES);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINES, i);
+    	}
+    }
+    public column_one_or_more_sub_clause(): Column_one_or_more_sub_clauseContext[];
+    public column_one_or_more_sub_clause(i: number): Column_one_or_more_sub_clauseContext | null;
+    public column_one_or_more_sub_clause(i?: number): Column_one_or_more_sub_clauseContext[] | Column_one_or_more_sub_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_one_or_more_sub_clauseContext);
+        }
+
+        return this.getRuleContext(i, Column_one_or_more_sub_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_attribute_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAttribute_clause) {
+             listener.enterAttribute_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAttribute_clause) {
+             listener.exitAttribute_clause(this);
+        }
+    }
+}
+
+
+export class Extended_attribute_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ATTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0)!;
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public LEVEL(): antlr.TerminalNode[];
+    public LEVEL(i: number): antlr.TerminalNode | null;
+    public LEVEL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEVEL);
+    	} else {
+    		return this.getToken(PlSqlParser.LEVEL, i);
+    	}
+    }
+    public DETERMINES(): antlr.TerminalNode[];
+    public DETERMINES(i: number): antlr.TerminalNode | null;
+    public DETERMINES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DETERMINES);
+    	} else {
+    		return this.getToken(PlSqlParser.DETERMINES, i);
+    	}
+    }
+    public column_one_or_more_sub_clause(): Column_one_or_more_sub_clauseContext[];
+    public column_one_or_more_sub_clause(i: number): Column_one_or_more_sub_clauseContext | null;
+    public column_one_or_more_sub_clause(i?: number): Column_one_or_more_sub_clauseContext[] | Column_one_or_more_sub_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_one_or_more_sub_clauseContext);
+        }
+
+        return this.getRuleContext(i, Column_one_or_more_sub_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_extended_attribute_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExtended_attribute_clause) {
+             listener.enterExtended_attribute_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExtended_attribute_clause) {
+             listener.exitExtended_attribute_clause(this);
+        }
+    }
+}
+
+
+export class Column_one_or_more_sub_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_one_or_more_sub_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_one_or_more_sub_clause) {
+             listener.enterColumn_one_or_more_sub_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_one_or_more_sub_clause) {
+             listener.exitColumn_one_or_more_sub_clause(this);
+        }
+    }
+}
+
+
+export class Alter_viewContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext | null {
+        return this.getRuleContext(0, Out_of_line_constraintContext);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public RELY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELY, 0);
+    }
+    public NORELY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORELY, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public alter_view_editionable(): Alter_view_editionableContext | null {
+        return this.getRuleContext(0, Alter_view_editionableContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_view) {
+             listener.enterAlter_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_view) {
+             listener.exitAlter_view(this);
+        }
+    }
+}
+
+
+export class Alter_view_editionableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_view_editionable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_view_editionable) {
+             listener.enterAlter_view_editionable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_view_editionable) {
+             listener.exitAlter_view_editionable(this);
+        }
+    }
+}
+
+
+export class Create_viewContext extends antlr.ParserRuleContext {
+    public _v?: Id_expressionContext;
+    public _cn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public select_only_statement(): Select_only_statementContext {
+        return this.getRuleContext(0, Select_only_statementContext)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public editioning_clause(): Editioning_clauseContext | null {
+        return this.getRuleContext(0, Editioning_clauseContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public view_options(): View_optionsContext | null {
+        return this.getRuleContext(0, View_optionsContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public COLLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATION, 0);
+    }
+    public BEQUEATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEQUEATH, 0);
+    }
+    public subquery_restriction_clause(): Subquery_restriction_clauseContext | null {
+        return this.getRuleContext(0, Subquery_restriction_clauseContext);
+    }
+    public CURRENT_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_USER, 0);
+    }
+    public DEFINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINER, 0);
+    }
+    public CONTAINER_MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER_MAP, 0);
+    }
+    public CONTAINERS_DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINERS_DEFAULT, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public EXTENDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENDED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_view) {
+             listener.enterCreate_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_view) {
+             listener.exitCreate_view(this);
+        }
+    }
+}
+
+
+export class Editioning_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EDITIONING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONING, 0);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_editioning_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEditioning_clause) {
+             listener.enterEditioning_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEditioning_clause) {
+             listener.exitEditioning_clause(this);
+        }
+    }
+}
+
+
+export class View_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public view_alias_constraint(): View_alias_constraintContext | null {
+        return this.getRuleContext(0, View_alias_constraintContext);
+    }
+    public object_view_clause(): Object_view_clauseContext | null {
+        return this.getRuleContext(0, Object_view_clauseContext);
+    }
+    public xmltype_view_clause(): Xmltype_view_clauseContext | null {
+        return this.getRuleContext(0, Xmltype_view_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_view_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterView_options) {
+             listener.enterView_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitView_options) {
+             listener.exitView_options(this);
+        }
+    }
+}
+
+
+export class View_alias_constraintContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public table_alias(): Table_aliasContext[];
+    public table_alias(i: number): Table_aliasContext | null;
+    public table_alias(i?: number): Table_aliasContext[] | Table_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_aliasContext);
+        }
+
+        return this.getRuleContext(i, Table_aliasContext);
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext[];
+    public out_of_line_constraint(i: number): Out_of_line_constraintContext | null;
+    public out_of_line_constraint(i?: number): Out_of_line_constraintContext[] | Out_of_line_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Out_of_line_constraintContext);
+        }
+
+        return this.getRuleContext(i, Out_of_line_constraintContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public inline_constraint(): Inline_constraintContext[];
+    public inline_constraint(i: number): Inline_constraintContext | null;
+    public inline_constraint(i?: number): Inline_constraintContext[] | Inline_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inline_constraintContext);
+        }
+
+        return this.getRuleContext(i, Inline_constraintContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_view_alias_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterView_alias_constraint) {
+             listener.enterView_alias_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitView_alias_constraint) {
+             listener.exitView_alias_constraint(this);
+        }
+    }
+}
+
+
+export class Object_view_clauseContext extends antlr.ParserRuleContext {
+    public _tn?: Id_expressionContext;
+    public _sv?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public UNDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNDER, 0);
+    }
+    public schema_name(): Schema_nameContext[];
+    public schema_name(i: number): Schema_nameContext | null;
+    public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Schema_nameContext);
+        }
+
+        return this.getRuleContext(i, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public IDENTIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIER, 0);
+    }
+    public ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ID, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public REGULAR_ID(): antlr.TerminalNode[];
+    public REGULAR_ID(i: number): antlr.TerminalNode | null;
+    public REGULAR_ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.REGULAR_ID);
+    	} else {
+    		return this.getToken(PlSqlParser.REGULAR_ID, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext[];
+    public out_of_line_constraint(i: number): Out_of_line_constraintContext | null;
+    public out_of_line_constraint(i?: number): Out_of_line_constraintContext[] | Out_of_line_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Out_of_line_constraintContext);
+        }
+
+        return this.getRuleContext(i, Out_of_line_constraintContext);
+    }
+    public inline_constraint(): Inline_constraintContext[];
+    public inline_constraint(i: number): Inline_constraintContext | null;
+    public inline_constraint(i?: number): Inline_constraintContext[] | Inline_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inline_constraintContext);
+        }
+
+        return this.getRuleContext(i, Inline_constraintContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_view_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_view_clause) {
+             listener.enterObject_view_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_view_clause) {
+             listener.exitObject_view_clause(this);
+        }
+    }
+}
+
+
+export class Inline_constraintContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public references_clause(): References_clauseContext | null {
+        return this.getRuleContext(0, References_clauseContext);
+    }
+    public check_constraint(): Check_constraintContext | null {
+        return this.getRuleContext(0, Check_constraintContext);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public constraint_state(): Constraint_stateContext | null {
+        return this.getRuleContext(0, Constraint_stateContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inline_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInline_constraint) {
+             listener.enterInline_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInline_constraint) {
+             listener.exitInline_constraint(this);
+        }
+    }
+}
+
+
+export class Inline_ref_constraintContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SCOPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCOPE, 0);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID, 0);
+    }
+    public references_clause(): References_clauseContext | null {
+        return this.getRuleContext(0, References_clauseContext);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public constraint_state(): Constraint_stateContext | null {
+        return this.getRuleContext(0, Constraint_stateContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inline_ref_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInline_ref_constraint) {
+             listener.enterInline_ref_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInline_ref_constraint) {
+             listener.exitInline_ref_constraint(this);
+        }
+    }
+}
+
+
+export class Out_of_line_ref_constraintContext extends antlr.ParserRuleContext {
+    public _ref_col_or_attr?: Regular_idContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SCOPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCOPE, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public regular_id(): Regular_idContext[];
+    public regular_id(i: number): Regular_idContext | null;
+    public regular_id(i?: number): Regular_idContext[] | Regular_idContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Regular_idContext);
+        }
+
+        return this.getRuleContext(i, Regular_idContext);
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID, 0);
+    }
+    public FOREIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOREIGN, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public references_clause(): References_clauseContext | null {
+        return this.getRuleContext(0, References_clauseContext);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public constraint_state(): Constraint_stateContext | null {
+        return this.getRuleContext(0, Constraint_stateContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_out_of_line_ref_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOut_of_line_ref_constraint) {
+             listener.enterOut_of_line_ref_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOut_of_line_ref_constraint) {
+             listener.exitOut_of_line_ref_constraint(this);
+        }
+    }
+}
+
+
+export class Out_of_line_constraintContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public constraint_state(): Constraint_stateContext | null {
+        return this.getRuleContext(0, Constraint_stateContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public foreign_key_clause(): Foreign_key_clauseContext | null {
+        return this.getRuleContext(0, Foreign_key_clauseContext);
+    }
+    public CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECK, 0);
+    }
+    public condition(): ConditionContext | null {
+        return this.getRuleContext(0, ConditionContext);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_out_of_line_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOut_of_line_constraint) {
+             listener.enterOut_of_line_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOut_of_line_constraint) {
+             listener.exitOut_of_line_constraint(this);
+        }
+    }
+}
+
+
+export class Constraint_stateContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFERRABLE(): antlr.TerminalNode[];
+    public DEFERRABLE(i: number): antlr.TerminalNode | null;
+    public DEFERRABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFERRABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFERRABLE, i);
+    	}
+    }
+    public INITIALLY(): antlr.TerminalNode[];
+    public INITIALLY(i: number): antlr.TerminalNode | null;
+    public INITIALLY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INITIALLY);
+    	} else {
+    		return this.getToken(PlSqlParser.INITIALLY, i);
+    	}
+    }
+    public using_index_clause(): Using_index_clauseContext[];
+    public using_index_clause(i: number): Using_index_clauseContext | null;
+    public using_index_clause(i?: number): Using_index_clauseContext[] | Using_index_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Using_index_clauseContext);
+        }
+
+        return this.getRuleContext(i, Using_index_clauseContext);
+    }
+    public IMMEDIATE(): antlr.TerminalNode[];
+    public IMMEDIATE(i: number): antlr.TerminalNode | null;
+    public IMMEDIATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IMMEDIATE);
+    	} else {
+    		return this.getToken(PlSqlParser.IMMEDIATE, i);
+    	}
+    }
+    public DEFERRED(): antlr.TerminalNode[];
+    public DEFERRED(i: number): antlr.TerminalNode | null;
+    public DEFERRED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFERRED);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFERRED, i);
+    	}
+    }
+    public RELY(): antlr.TerminalNode[];
+    public RELY(i: number): antlr.TerminalNode | null;
+    public RELY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RELY);
+    	} else {
+    		return this.getToken(PlSqlParser.RELY, i);
+    	}
+    }
+    public NORELY(): antlr.TerminalNode[];
+    public NORELY(i: number): antlr.TerminalNode | null;
+    public NORELY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NORELY);
+    	} else {
+    		return this.getToken(PlSqlParser.NORELY, i);
+    	}
+    }
+    public ENABLE(): antlr.TerminalNode[];
+    public ENABLE(i: number): antlr.TerminalNode | null;
+    public ENABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.ENABLE, i);
+    	}
+    }
+    public DISABLE(): antlr.TerminalNode[];
+    public DISABLE(i: number): antlr.TerminalNode | null;
+    public DISABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.DISABLE, i);
+    	}
+    }
+    public VALIDATE(): antlr.TerminalNode[];
+    public VALIDATE(i: number): antlr.TerminalNode | null;
+    public VALIDATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.VALIDATE);
+    	} else {
+    		return this.getToken(PlSqlParser.VALIDATE, i);
+    	}
+    }
+    public NOVALIDATE(): antlr.TerminalNode[];
+    public NOVALIDATE(i: number): antlr.TerminalNode | null;
+    public NOVALIDATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOVALIDATE);
+    	} else {
+    		return this.getToken(PlSqlParser.NOVALIDATE, i);
+    	}
+    }
+    public NOT(): antlr.TerminalNode[];
+    public NOT(i: number): antlr.TerminalNode | null;
+    public NOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOT);
+    	} else {
+    		return this.getToken(PlSqlParser.NOT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_constraint_state;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConstraint_state) {
+             listener.enterConstraint_state(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConstraint_state) {
+             listener.exitConstraint_state(this);
+        }
+    }
+}
+
+
+export class Xmltype_view_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public XMLTYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.XMLTYPE, 0)!;
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public OBJECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OBJECT, 0)!;
+    }
+    public IDENTIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIER, 0);
+    }
+    public ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ID, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public xml_schema_spec(): Xml_schema_specContext | null {
+        return this.getRuleContext(0, Xml_schema_specContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmltype_view_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmltype_view_clause) {
+             listener.enterXmltype_view_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmltype_view_clause) {
+             listener.exitXmltype_view_clause(this);
+        }
+    }
+}
+
+
+export class Xml_schema_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELEMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ELEMENT, 0)!;
+    }
+    public element(): ElementContext | null {
+        return this.getRuleContext(0, ElementContext);
+    }
+    public xml_schema_url(): Xml_schema_urlContext[];
+    public xml_schema_url(i: number): Xml_schema_urlContext | null;
+    public xml_schema_url(i?: number): Xml_schema_urlContext[] | Xml_schema_urlContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Xml_schema_urlContext);
+        }
+
+        return this.getRuleContext(i, Xml_schema_urlContext);
+    }
+    public HASH_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASH_OP, 0);
+    }
+    public XMLSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLSCHEMA, 0);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public VARRAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAYS, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public allow_or_disallow(): Allow_or_disallowContext[];
+    public allow_or_disallow(i: number): Allow_or_disallowContext | null;
+    public allow_or_disallow(i?: number): Allow_or_disallowContext[] | Allow_or_disallowContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allow_or_disallowContext);
+        }
+
+        return this.getRuleContext(i, Allow_or_disallowContext);
+    }
+    public NONSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONSCHEMA, 0);
+    }
+    public ANYSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANYSCHEMA, 0);
+    }
+    public LOBS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOBS, 0);
+    }
+    public TABLES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_schema_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_schema_spec) {
+             listener.enterXml_schema_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_schema_spec) {
+             listener.exitXml_schema_spec(this);
+        }
+    }
+}
+
+
+export class Xml_schema_urlContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_schema_url;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_schema_url) {
+             listener.enterXml_schema_url(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_schema_url) {
+             listener.exitXml_schema_url(this);
+        }
+    }
+}
+
+
+export class ElementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterElement) {
+             listener.enterElement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitElement) {
+             listener.exitElement(this);
+        }
+    }
+}
+
+
+export class Alter_tablespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public tablespace(): TablespaceContext {
+        return this.getRuleContext(0, TablespaceContext)!;
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public MINIMUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINIMUM, 0);
+    }
+    public EXTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENT, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public SHRINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHRINK, 0);
+    }
+    public SPACE_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPACE_KEYWORD, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public new_tablespace_name(): New_tablespace_nameContext | null {
+        return this.getRuleContext(0, New_tablespace_nameContext);
+    }
+    public begin_or_end(): Begin_or_endContext | null {
+        return this.getRuleContext(0, Begin_or_endContext);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public datafile_tempfile_clauses(): Datafile_tempfile_clausesContext | null {
+        return this.getRuleContext(0, Datafile_tempfile_clausesContext);
+    }
+    public tablespace_logging_clauses(): Tablespace_logging_clausesContext | null {
+        return this.getRuleContext(0, Tablespace_logging_clausesContext);
+    }
+    public tablespace_group_clause(): Tablespace_group_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_group_clauseContext);
+    }
+    public tablespace_state_clauses(): Tablespace_state_clausesContext | null {
+        return this.getRuleContext(0, Tablespace_state_clausesContext);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public flashback_mode_clause(): Flashback_mode_clauseContext | null {
+        return this.getRuleContext(0, Flashback_mode_clauseContext);
+    }
+    public tablespace_retention_clause(): Tablespace_retention_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_retention_clauseContext);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public storage_clause(): Storage_clauseContext | null {
+        return this.getRuleContext(0, Storage_clauseContext);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_tablespace) {
+             listener.enterAlter_tablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_tablespace) {
+             listener.exitAlter_tablespace(this);
+        }
+    }
+}
+
+
+export class Datafile_tempfile_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public datafile_specification(): Datafile_specificationContext | null {
+        return this.getRuleContext(0, Datafile_specificationContext);
+    }
+    public tempfile_specification(): Tempfile_specificationContext | null {
+        return this.getRuleContext(0, Tempfile_specificationContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public TEMPFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPFILE, 0);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public SHRINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHRINK, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public online_or_offline(): Online_or_offlineContext | null {
+        return this.getRuleContext(0, Online_or_offlineContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_datafile_tempfile_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatafile_tempfile_clauses) {
+             listener.enterDatafile_tempfile_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatafile_tempfile_clauses) {
+             listener.exitDatafile_tempfile_clauses(this);
+        }
+    }
+}
+
+
+export class Tablespace_logging_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public logging_clause(): Logging_clauseContext | null {
+        return this.getRuleContext(0, Logging_clauseContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_logging_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_logging_clauses) {
+             listener.enterTablespace_logging_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_logging_clauses) {
+             listener.exitTablespace_logging_clauses(this);
+        }
+    }
+}
+
+
+export class Tablespace_group_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public tablespace_group_name(): Tablespace_group_nameContext | null {
+        return this.getRuleContext(0, Tablespace_group_nameContext);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_group_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_group_clause) {
+             listener.enterTablespace_group_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_group_clause) {
+             listener.exitTablespace_group_clause(this);
+        }
+    }
+}
+
+
+export class Tablespace_group_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_group_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_group_name) {
+             listener.enterTablespace_group_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_group_name) {
+             listener.exitTablespace_group_name(this);
+        }
+    }
+}
+
+
+export class Tablespace_state_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public NORMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORMAL, 0);
+    }
+    public TEMPORARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPORARY, 0);
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public PERMANENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERMANENT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_state_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_state_clauses) {
+             listener.enterTablespace_state_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_state_clauses) {
+             listener.exitTablespace_state_clauses(this);
+        }
+    }
+}
+
+
+export class Flashback_mode_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FLASHBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLASHBACK, 0)!;
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public OFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFF, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_flashback_mode_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFlashback_mode_clause) {
+             listener.enterFlashback_mode_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFlashback_mode_clause) {
+             listener.exitFlashback_mode_clause(this);
+        }
+    }
+}
+
+
+export class New_tablespace_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tablespace(): TablespaceContext {
+        return this.getRuleContext(0, TablespaceContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_new_tablespace_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNew_tablespace_name) {
+             listener.enterNew_tablespace_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNew_tablespace_name) {
+             listener.exitNew_tablespace_name(this);
+        }
+    }
+}
+
+
+export class Create_tablespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public permanent_tablespace_clause(): Permanent_tablespace_clauseContext | null {
+        return this.getRuleContext(0, Permanent_tablespace_clauseContext);
+    }
+    public temporary_tablespace_clause(): Temporary_tablespace_clauseContext | null {
+        return this.getRuleContext(0, Temporary_tablespace_clauseContext);
+    }
+    public undo_tablespace_clause(): Undo_tablespace_clauseContext | null {
+        return this.getRuleContext(0, Undo_tablespace_clauseContext);
+    }
+    public BIGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIGFILE, 0);
+    }
+    public SMALLFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLFILE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_tablespace) {
+             listener.enterCreate_tablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_tablespace) {
+             listener.exitCreate_tablespace(this);
+        }
+    }
+}
+
+
+export class Permanent_tablespace_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public datafile_specification(): Datafile_specificationContext | null {
+        return this.getRuleContext(0, Datafile_specificationContext);
+    }
+    public MINIMUM(): antlr.TerminalNode[];
+    public MINIMUM(i: number): antlr.TerminalNode | null;
+    public MINIMUM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MINIMUM);
+    	} else {
+    		return this.getToken(PlSqlParser.MINIMUM, i);
+    	}
+    }
+    public EXTENT(): antlr.TerminalNode[];
+    public EXTENT(i: number): antlr.TerminalNode | null;
+    public EXTENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EXTENT);
+    	} else {
+    		return this.getToken(PlSqlParser.EXTENT, i);
+    	}
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public BLOCKSIZE(): antlr.TerminalNode[];
+    public BLOCKSIZE(i: number): antlr.TerminalNode | null;
+    public BLOCKSIZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BLOCKSIZE);
+    	} else {
+    		return this.getToken(PlSqlParser.BLOCKSIZE, i);
+    	}
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public FORCE(): antlr.TerminalNode[];
+    public FORCE(i: number): antlr.TerminalNode | null;
+    public FORCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FORCE);
+    	} else {
+    		return this.getToken(PlSqlParser.FORCE, i);
+    	}
+    }
+    public LOGGING(): antlr.TerminalNode[];
+    public LOGGING(i: number): antlr.TerminalNode | null;
+    public LOGGING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOGGING);
+    	} else {
+    		return this.getToken(PlSqlParser.LOGGING, i);
+    	}
+    }
+    public ENCRYPTION(): antlr.TerminalNode[];
+    public ENCRYPTION(i: number): antlr.TerminalNode | null;
+    public ENCRYPTION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENCRYPTION);
+    	} else {
+    		return this.getToken(PlSqlParser.ENCRYPTION, i);
+    	}
+    }
+    public tablespace_encryption_spec(): Tablespace_encryption_specContext[];
+    public tablespace_encryption_spec(i: number): Tablespace_encryption_specContext | null;
+    public tablespace_encryption_spec(i?: number): Tablespace_encryption_specContext[] | Tablespace_encryption_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tablespace_encryption_specContext);
+        }
+
+        return this.getRuleContext(i, Tablespace_encryption_specContext);
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public extent_management_clause(): Extent_management_clauseContext[];
+    public extent_management_clause(i: number): Extent_management_clauseContext | null;
+    public extent_management_clause(i?: number): Extent_management_clauseContext[] | Extent_management_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Extent_management_clauseContext);
+        }
+
+        return this.getRuleContext(i, Extent_management_clauseContext);
+    }
+    public segment_management_clause(): Segment_management_clauseContext[];
+    public segment_management_clause(i: number): Segment_management_clauseContext | null;
+    public segment_management_clause(i?: number): Segment_management_clauseContext[] | Segment_management_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_management_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_management_clauseContext);
+    }
+    public flashback_mode_clause(): Flashback_mode_clauseContext[];
+    public flashback_mode_clause(i: number): Flashback_mode_clauseContext | null;
+    public flashback_mode_clause(i?: number): Flashback_mode_clauseContext[] | Flashback_mode_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Flashback_mode_clauseContext);
+        }
+
+        return this.getRuleContext(i, Flashback_mode_clauseContext);
+    }
+    public ONLINE(): antlr.TerminalNode[];
+    public ONLINE(i: number): antlr.TerminalNode | null;
+    public ONLINE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ONLINE);
+    	} else {
+    		return this.getToken(PlSqlParser.ONLINE, i);
+    	}
+    }
+    public OFFLINE(): antlr.TerminalNode[];
+    public OFFLINE(i: number): antlr.TerminalNode | null;
+    public OFFLINE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OFFLINE);
+    	} else {
+    		return this.getToken(PlSqlParser.OFFLINE, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_permanent_tablespace_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPermanent_tablespace_clause) {
+             listener.enterPermanent_tablespace_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPermanent_tablespace_clause) {
+             listener.exitPermanent_tablespace_clause(this);
+        }
+    }
+}
+
+
+export class Tablespace_encryption_specContext extends antlr.ParserRuleContext {
+    public _encrypt_algorithm?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_encryption_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_encryption_spec) {
+             listener.enterTablespace_encryption_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_encryption_spec) {
+             listener.exitTablespace_encryption_spec(this);
+        }
+    }
+}
+
+
+export class Logging_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public NOLOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOGGING, 0);
+    }
+    public FILESYSTEM_LIKE_LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILESYSTEM_LIKE_LOGGING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logging_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogging_clause) {
+             listener.enterLogging_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogging_clause) {
+             listener.exitLogging_clause(this);
+        }
+    }
+}
+
+
+export class Extent_management_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXTENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXTENT, 0)!;
+    }
+    public MANAGEMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MANAGEMENT, 0)!;
+    }
+    public LOCAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCAL, 0)!;
+    }
+    public AUTOALLOCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOALLOCATE, 0);
+    }
+    public UNIFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIFORM, 0);
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_extent_management_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExtent_management_clause) {
+             listener.enterExtent_management_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExtent_management_clause) {
+             listener.exitExtent_management_clause(this);
+        }
+    }
+}
+
+
+export class Segment_management_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SEGMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEGMENT, 0)!;
+    }
+    public SPACE_KEYWORD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SPACE_KEYWORD, 0)!;
+    }
+    public MANAGEMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MANAGEMENT, 0)!;
+    }
+    public AUTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO, 0);
+    }
+    public MANUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANUAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_segment_management_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSegment_management_clause) {
+             listener.enterSegment_management_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSegment_management_clause) {
+             listener.exitSegment_management_clause(this);
+        }
+    }
+}
+
+
+export class Temporary_tablespace_clauseContext extends antlr.ParserRuleContext {
+    public _tablespace_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TEMPORARY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TEMPORARY, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public tempfile_specification(): Tempfile_specificationContext | null {
+        return this.getRuleContext(0, Tempfile_specificationContext);
+    }
+    public tablespace_group_clause(): Tablespace_group_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_group_clauseContext);
+    }
+    public extent_management_clause(): Extent_management_clauseContext | null {
+        return this.getRuleContext(0, Extent_management_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_temporary_tablespace_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTemporary_tablespace_clause) {
+             listener.enterTemporary_tablespace_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTemporary_tablespace_clause) {
+             listener.exitTemporary_tablespace_clause(this);
+        }
+    }
+}
+
+
+export class Undo_tablespace_clauseContext extends antlr.ParserRuleContext {
+    public _tablespace_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNDO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNDO, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public datafile_specification(): Datafile_specificationContext | null {
+        return this.getRuleContext(0, Datafile_specificationContext);
+    }
+    public extent_management_clause(): Extent_management_clauseContext | null {
+        return this.getRuleContext(0, Extent_management_clauseContext);
+    }
+    public tablespace_retention_clause(): Tablespace_retention_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_retention_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_undo_tablespace_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUndo_tablespace_clause) {
+             listener.enterUndo_tablespace_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUndo_tablespace_clause) {
+             listener.exitUndo_tablespace_clause(this);
+        }
+    }
+}
+
+
+export class Tablespace_retention_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETENTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETENTION, 0)!;
+    }
+    public GUARANTEE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GUARANTEE, 0);
+    }
+    public NOGUARANTEE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOGUARANTEE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_retention_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_retention_clause) {
+             listener.enterTablespace_retention_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_retention_clause) {
+             listener.exitTablespace_retention_clause(this);
+        }
+    }
+}
+
+
+export class Create_tablespace_setContext extends antlr.ParserRuleContext {
+    public _tss?: Id_expressionContext;
+    public _ss?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public SHARDSPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARDSPACE, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public TEMPLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPLATE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public file_specification(): File_specificationContext[];
+    public file_specification(i: number): File_specificationContext | null;
+    public file_specification(i?: number): File_specificationContext[] | File_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(File_specificationContext);
+        }
+
+        return this.getRuleContext(i, File_specificationContext);
+    }
+    public permanent_tablespace_attrs(): Permanent_tablespace_attrsContext[];
+    public permanent_tablespace_attrs(i: number): Permanent_tablespace_attrsContext | null;
+    public permanent_tablespace_attrs(i?: number): Permanent_tablespace_attrsContext[] | Permanent_tablespace_attrsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Permanent_tablespace_attrsContext);
+        }
+
+        return this.getRuleContext(i, Permanent_tablespace_attrsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_tablespace_set;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_tablespace_set) {
+             listener.enterCreate_tablespace_set(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_tablespace_set) {
+             listener.exitCreate_tablespace_set(this);
+        }
+    }
+}
+
+
+export class Permanent_tablespace_attrsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MINIMUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINIMUM, 0);
+    }
+    public EXTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENT, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public BLOCKSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKSIZE, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public K_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.K_LETTER, 0);
+    }
+    public logging_clause(): Logging_clauseContext | null {
+        return this.getRuleContext(0, Logging_clauseContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public tablespace_encryption_clause(): Tablespace_encryption_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_encryption_clauseContext);
+    }
+    public default_tablespace_params(): Default_tablespace_paramsContext | null {
+        return this.getRuleContext(0, Default_tablespace_paramsContext);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public extent_management_clause(): Extent_management_clauseContext | null {
+        return this.getRuleContext(0, Extent_management_clauseContext);
+    }
+    public segment_management_clause(): Segment_management_clauseContext | null {
+        return this.getRuleContext(0, Segment_management_clauseContext);
+    }
+    public flashback_mode_clause(): Flashback_mode_clauseContext | null {
+        return this.getRuleContext(0, Flashback_mode_clauseContext);
+    }
+    public lost_write_protection(): Lost_write_protectionContext | null {
+        return this.getRuleContext(0, Lost_write_protectionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_permanent_tablespace_attrs;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPermanent_tablespace_attrs) {
+             listener.enterPermanent_tablespace_attrs(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPermanent_tablespace_attrs) {
+             listener.exitPermanent_tablespace_attrs(this);
+        }
+    }
+}
+
+
+export class Tablespace_encryption_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENCRYPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0)!;
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public DECRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECRYPT, 0);
+    }
+    public tablespace_encryption_spec(): Tablespace_encryption_specContext | null {
+        return this.getRuleContext(0, Tablespace_encryption_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_encryption_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_encryption_clause) {
+             listener.enterTablespace_encryption_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_encryption_clause) {
+             listener.exitTablespace_encryption_clause(this);
+        }
+    }
+}
+
+
+export class Default_tablespace_paramsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public default_table_compression(): Default_table_compressionContext | null {
+        return this.getRuleContext(0, Default_table_compressionContext);
+    }
+    public default_index_compression(): Default_index_compressionContext | null {
+        return this.getRuleContext(0, Default_index_compressionContext);
+    }
+    public inmmemory_clause(): Inmmemory_clauseContext | null {
+        return this.getRuleContext(0, Inmmemory_clauseContext);
+    }
+    public ilm_clause(): Ilm_clauseContext | null {
+        return this.getRuleContext(0, Ilm_clauseContext);
+    }
+    public storage_clause(): Storage_clauseContext | null {
+        return this.getRuleContext(0, Storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_tablespace_params;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_tablespace_params) {
+             listener.enterDefault_tablespace_params(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_tablespace_params) {
+             listener.exitDefault_tablespace_params(this);
+        }
+    }
+}
+
+
+export class Default_table_compressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public COMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESS, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public NOCOMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOMPRESS, 0);
+    }
+    public OLTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLTP, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public low_high(): Low_highContext | null {
+        return this.getRuleContext(0, Low_highContext);
+    }
+    public ARCHIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_table_compression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_table_compression) {
+             listener.enterDefault_table_compression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_table_compression) {
+             listener.exitDefault_table_compression(this);
+        }
+    }
+}
+
+
+export class Low_highContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_low_high;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLow_high) {
+             listener.enterLow_high(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLow_high) {
+             listener.exitLow_high(this);
+        }
+    }
+}
+
+
+export class Default_index_compressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEX, 0)!;
+    }
+    public COMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESS, 0);
+    }
+    public ADVANCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVANCED, 0);
+    }
+    public low_high(): Low_highContext | null {
+        return this.getRuleContext(0, Low_highContext);
+    }
+    public NOCOMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOMPRESS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_index_compression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_index_compression) {
+             listener.enterDefault_index_compression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_index_compression) {
+             listener.exitDefault_index_compression(this);
+        }
+    }
+}
+
+
+export class Inmmemory_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INMEMORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INMEMORY, 0)!;
+    }
+    public inmemory_attributes(): Inmemory_attributesContext | null {
+        return this.getRuleContext(0, Inmemory_attributesContext);
+    }
+    public TEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEXT, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public USING(): antlr.TerminalNode[];
+    public USING(i: number): antlr.TerminalNode | null;
+    public USING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USING);
+    	} else {
+    		return this.getToken(PlSqlParser.USING, i);
+    	}
+    }
+    public policy_name(): Policy_nameContext[];
+    public policy_name(i: number): Policy_nameContext | null;
+    public policy_name(i?: number): Policy_nameContext[] | Policy_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Policy_nameContext);
+        }
+
+        return this.getRuleContext(i, Policy_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmmemory_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmmemory_clause) {
+             listener.enterInmmemory_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmmemory_clause) {
+             listener.exitInmmemory_clause(this);
+        }
+    }
+}
+
+
+export class Datafile_specificationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATAFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATAFILE, 0)!;
+    }
+    public datafile_tempfile_spec(): Datafile_tempfile_specContext | null {
+        return this.getRuleContext(0, Datafile_tempfile_specContext);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_datafile_specification;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatafile_specification) {
+             listener.enterDatafile_specification(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatafile_specification) {
+             listener.exitDatafile_specification(this);
+        }
+    }
+}
+
+
+export class Tempfile_specificationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TEMPFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TEMPFILE, 0)!;
+    }
+    public datafile_tempfile_spec(): Datafile_tempfile_specContext | null {
+        return this.getRuleContext(0, Datafile_tempfile_specContext);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tempfile_specification;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTempfile_specification) {
+             listener.enterTempfile_specification(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTempfile_specification) {
+             listener.exitTempfile_specification(this);
+        }
+    }
+}
+
+
+export class Datafile_tempfile_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_datafile_tempfile_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatafile_tempfile_spec) {
+             listener.enterDatafile_tempfile_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatafile_tempfile_spec) {
+             listener.exitDatafile_tempfile_spec(this);
+        }
+    }
+}
+
+
+export class Redo_log_file_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public BLOCKSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKSIZE, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_redo_log_file_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRedo_log_file_spec) {
+             listener.enterRedo_log_file_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRedo_log_file_spec) {
+             listener.exitRedo_log_file_spec(this);
+        }
+    }
+}
+
+
+export class Autoextend_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AUTOEXTEND(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUTOEXTEND, 0)!;
+    }
+    public OFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFF, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public NEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEXT, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public maxsize_clause(): Maxsize_clauseContext | null {
+        return this.getRuleContext(0, Maxsize_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_autoextend_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAutoextend_clause) {
+             listener.enterAutoextend_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAutoextend_clause) {
+             listener.exitAutoextend_clause(this);
+        }
+    }
+}
+
+
+export class Maxsize_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MAXSIZE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MAXSIZE, 0)!;
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_maxsize_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMaxsize_clause) {
+             listener.enterMaxsize_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMaxsize_clause) {
+             listener.exitMaxsize_clause(this);
+        }
+    }
+}
+
+
+export class Build_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BUILD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BUILD, 0)!;
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public DEFERRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFERRED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_build_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBuild_clause) {
+             listener.enterBuild_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBuild_clause) {
+             listener.exitBuild_clause(this);
+        }
+    }
+}
+
+
+export class Parallel_clauseContext extends antlr.ParserRuleContext {
+    public _parallel_count?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NOPARALLEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOPARALLEL, 0);
+    }
+    public PARALLEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARALLEL, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public DEGREE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEGREE, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public parallel_instances_clause(): Parallel_instances_clauseContext | null {
+        return this.getRuleContext(0, Parallel_instances_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parallel_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParallel_clause) {
+             listener.enterParallel_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParallel_clause) {
+             listener.exitParallel_clause(this);
+        }
+    }
+}
+
+
+export class Parallel_instances_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INSTANCES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INSTANCES, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parallel_instances_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParallel_instances_clause) {
+             listener.enterParallel_instances_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParallel_instances_clause) {
+             listener.exitParallel_instances_clause(this);
+        }
+    }
+}
+
+
+export class Alter_materialized_viewContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public modify_mv_column_clause(): Modify_mv_column_clauseContext | null {
+        return this.getRuleContext(0, Modify_mv_column_clauseContext);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public lob_storage_clause(): Lob_storage_clauseContext[];
+    public lob_storage_clause(i: number): Lob_storage_clauseContext | null;
+    public lob_storage_clause(i?: number): Lob_storage_clauseContext[] | Lob_storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_storage_clauseContext);
+    }
+    public modify_lob_storage_clause(): Modify_lob_storage_clauseContext[];
+    public modify_lob_storage_clause(i: number): Modify_lob_storage_clauseContext | null;
+    public modify_lob_storage_clause(i?: number): Modify_lob_storage_clauseContext[] | Modify_lob_storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Modify_lob_storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Modify_lob_storage_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public logging_clause(): Logging_clauseContext | null {
+        return this.getRuleContext(0, Logging_clauseContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext | null {
+        return this.getRuleContext(0, Allocate_extent_clauseContext);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext | null {
+        return this.getRuleContext(0, Deallocate_unused_clauseContext);
+    }
+    public shrink_clause(): Shrink_clauseContext | null {
+        return this.getRuleContext(0, Shrink_clauseContext);
+    }
+    public alter_iot_clauses(): Alter_iot_clausesContext | null {
+        return this.getRuleContext(0, Alter_iot_clausesContext);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public alter_mv_option1(): Alter_mv_option1Context | null {
+        return this.getRuleContext(0, Alter_mv_option1Context);
+    }
+    public enable_or_disable(): Enable_or_disableContext | null {
+        return this.getRuleContext(0, Enable_or_disableContext);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REWRITE, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public CONSIDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSIDER, 0);
+    }
+    public FRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FRESH, 0);
+    }
+    public cache_or_nocache(): Cache_or_nocacheContext | null {
+        return this.getRuleContext(0, Cache_or_nocacheContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_materialized_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_materialized_view) {
+             listener.enterAlter_materialized_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_materialized_view) {
+             listener.exitAlter_materialized_view(this);
+        }
+    }
+}
+
+
+export class Alter_mv_option1Context extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public alter_mv_refresh(): Alter_mv_refreshContext {
+        return this.getRuleContext(0, Alter_mv_refreshContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_mv_option1;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_mv_option1) {
+             listener.enterAlter_mv_option1(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_mv_option1) {
+             listener.exitAlter_mv_option1(this);
+        }
+    }
+}
+
+
+export class Alter_mv_refreshContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REFRESH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REFRESH, 0)!;
+    }
+    public FAST(): antlr.TerminalNode[];
+    public FAST(i: number): antlr.TerminalNode | null;
+    public FAST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FAST);
+    	} else {
+    		return this.getToken(PlSqlParser.FAST, i);
+    	}
+    }
+    public COMPLETE(): antlr.TerminalNode[];
+    public COMPLETE(i: number): antlr.TerminalNode | null;
+    public COMPLETE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMPLETE);
+    	} else {
+    		return this.getToken(PlSqlParser.COMPLETE, i);
+    	}
+    }
+    public FORCE(): antlr.TerminalNode[];
+    public FORCE(i: number): antlr.TerminalNode | null;
+    public FORCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FORCE);
+    	} else {
+    		return this.getToken(PlSqlParser.FORCE, i);
+    	}
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public START(): antlr.TerminalNode[];
+    public START(i: number): antlr.TerminalNode | null;
+    public START(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.START);
+    	} else {
+    		return this.getToken(PlSqlParser.START, i);
+    	}
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public NEXT(): antlr.TerminalNode[];
+    public NEXT(i: number): antlr.TerminalNode | null;
+    public NEXT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NEXT);
+    	} else {
+    		return this.getToken(PlSqlParser.NEXT, i);
+    	}
+    }
+    public PRIMARY(): antlr.TerminalNode[];
+    public PRIMARY(i: number): antlr.TerminalNode | null;
+    public PRIMARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIMARY);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIMARY, i);
+    	}
+    }
+    public KEY(): antlr.TerminalNode[];
+    public KEY(i: number): antlr.TerminalNode | null;
+    public KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEY);
+    	} else {
+    		return this.getToken(PlSqlParser.KEY, i);
+    	}
+    }
+    public USING(): antlr.TerminalNode[];
+    public USING(i: number): antlr.TerminalNode | null;
+    public USING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USING);
+    	} else {
+    		return this.getToken(PlSqlParser.USING, i);
+    	}
+    }
+    public MASTER(): antlr.TerminalNode[];
+    public MASTER(i: number): antlr.TerminalNode | null;
+    public MASTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MASTER);
+    	} else {
+    		return this.getToken(PlSqlParser.MASTER, i);
+    	}
+    }
+    public ROLLBACK(): antlr.TerminalNode[];
+    public ROLLBACK(i: number): antlr.TerminalNode | null;
+    public ROLLBACK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROLLBACK);
+    	} else {
+    		return this.getToken(PlSqlParser.ROLLBACK, i);
+    	}
+    }
+    public SEGMENT(): antlr.TerminalNode[];
+    public SEGMENT(i: number): antlr.TerminalNode | null;
+    public SEGMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SEGMENT);
+    	} else {
+    		return this.getToken(PlSqlParser.SEGMENT, i);
+    	}
+    }
+    public CONSTRAINTS(): antlr.TerminalNode[];
+    public CONSTRAINTS(i: number): antlr.TerminalNode | null;
+    public CONSTRAINTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONSTRAINTS);
+    	} else {
+    		return this.getToken(PlSqlParser.CONSTRAINTS, i);
+    	}
+    }
+    public DEMAND(): antlr.TerminalNode[];
+    public DEMAND(i: number): antlr.TerminalNode | null;
+    public DEMAND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEMAND);
+    	} else {
+    		return this.getToken(PlSqlParser.DEMAND, i);
+    	}
+    }
+    public COMMIT(): antlr.TerminalNode[];
+    public COMMIT(i: number): antlr.TerminalNode | null;
+    public COMMIT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMIT);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMIT, i);
+    	}
+    }
+    public ENFORCED(): antlr.TerminalNode[];
+    public ENFORCED(i: number): antlr.TerminalNode | null;
+    public ENFORCED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENFORCED);
+    	} else {
+    		return this.getToken(PlSqlParser.ENFORCED, i);
+    	}
+    }
+    public TRUSTED(): antlr.TerminalNode[];
+    public TRUSTED(i: number): antlr.TerminalNode | null;
+    public TRUSTED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TRUSTED);
+    	} else {
+    		return this.getToken(PlSqlParser.TRUSTED, i);
+    	}
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public rollback_segment(): Rollback_segmentContext[];
+    public rollback_segment(i: number): Rollback_segmentContext | null;
+    public rollback_segment(i?: number): Rollback_segmentContext[] | Rollback_segmentContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Rollback_segmentContext);
+        }
+
+        return this.getRuleContext(i, Rollback_segmentContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_mv_refresh;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_mv_refresh) {
+             listener.enterAlter_mv_refresh(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_mv_refresh) {
+             listener.exitAlter_mv_refresh(this);
+        }
+    }
+}
+
+
+export class Rollback_segmentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rollback_segment;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRollback_segment) {
+             listener.enterRollback_segment(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRollback_segment) {
+             listener.exitRollback_segment(this);
+        }
+    }
+}
+
+
+export class Modify_mv_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public encryption_spec(): Encryption_specContext | null {
+        return this.getRuleContext(0, Encryption_specContext);
+    }
+    public DECRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECRYPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_mv_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_mv_column_clause) {
+             listener.enterModify_mv_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_mv_column_clause) {
+             listener.exitModify_mv_column_clause(this);
+        }
+    }
+}
+
+
+export class Alter_materialized_view_logContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public LOG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOG, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext | null {
+        return this.getRuleContext(0, Physical_attributes_clauseContext);
+    }
+    public add_mv_log_column_clause(): Add_mv_log_column_clauseContext | null {
+        return this.getRuleContext(0, Add_mv_log_column_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public logging_clause(): Logging_clauseContext | null {
+        return this.getRuleContext(0, Logging_clauseContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext | null {
+        return this.getRuleContext(0, Allocate_extent_clauseContext);
+    }
+    public shrink_clause(): Shrink_clauseContext | null {
+        return this.getRuleContext(0, Shrink_clauseContext);
+    }
+    public move_mv_log_clause(): Move_mv_log_clauseContext | null {
+        return this.getRuleContext(0, Move_mv_log_clauseContext);
+    }
+    public cache_or_nocache(): Cache_or_nocacheContext | null {
+        return this.getRuleContext(0, Cache_or_nocacheContext);
+    }
+    public mv_log_augmentation(): Mv_log_augmentationContext | null {
+        return this.getRuleContext(0, Mv_log_augmentationContext);
+    }
+    public mv_log_purge_clause(): Mv_log_purge_clauseContext | null {
+        return this.getRuleContext(0, Mv_log_purge_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_materialized_view_log;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_materialized_view_log) {
+             listener.enterAlter_materialized_view_log(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_materialized_view_log) {
+             listener.exitAlter_materialized_view_log(this);
+        }
+    }
+}
+
+
+export class Add_mv_log_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_mv_log_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_mv_log_column_clause) {
+             listener.enterAdd_mv_log_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_mv_log_column_clause) {
+             listener.exitAdd_mv_log_column_clause(this);
+        }
+    }
+}
+
+
+export class Move_mv_log_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVE, 0)!;
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext {
+        return this.getRuleContext(0, Segment_attributes_clauseContext)!;
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_move_mv_log_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMove_mv_log_clause) {
+             listener.enterMove_mv_log_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMove_mv_log_clause) {
+             listener.exitMove_mv_log_clause(this);
+        }
+    }
+}
+
+
+export class Mv_log_augmentationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public new_values_clause(): New_values_clauseContext | null {
+        return this.getRuleContext(0, New_values_clauseContext);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ID, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID, 0);
+    }
+    public SEQUENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_mv_log_augmentation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMv_log_augmentation) {
+             listener.enterMv_log_augmentation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMv_log_augmentation) {
+             listener.exitMv_log_augmentation(this);
+        }
+    }
+}
+
+
+export class Create_materialized_view_logContext extends antlr.ParserRuleContext {
+    public _tablespace_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public LOG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOG, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public new_values_clause(): New_values_clauseContext[];
+    public new_values_clause(i: number): New_values_clauseContext | null;
+    public new_values_clause(i?: number): New_values_clauseContext[] | New_values_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(New_values_clauseContext);
+        }
+
+        return this.getRuleContext(i, New_values_clauseContext);
+    }
+    public mv_log_purge_clause(): Mv_log_purge_clauseContext[];
+    public mv_log_purge_clause(i: number): Mv_log_purge_clauseContext | null;
+    public mv_log_purge_clause(i?: number): Mv_log_purge_clauseContext[] | Mv_log_purge_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Mv_log_purge_clauseContext);
+        }
+
+        return this.getRuleContext(i, Mv_log_purge_clauseContext);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public CACHE(): antlr.TerminalNode[];
+    public CACHE(i: number): antlr.TerminalNode | null;
+    public CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.CACHE, i);
+    	}
+    }
+    public NOCACHE(): antlr.TerminalNode[];
+    public NOCACHE(i: number): antlr.TerminalNode | null;
+    public NOCACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOCACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.NOCACHE, i);
+    	}
+    }
+    public OBJECT(): antlr.TerminalNode[];
+    public OBJECT(i: number): antlr.TerminalNode | null;
+    public OBJECT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OBJECT);
+    	} else {
+    		return this.getToken(PlSqlParser.OBJECT, i);
+    	}
+    }
+    public ID(): antlr.TerminalNode[];
+    public ID(i: number): antlr.TerminalNode | null;
+    public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ID);
+    	} else {
+    		return this.getToken(PlSqlParser.ID, i);
+    	}
+    }
+    public PRIMARY(): antlr.TerminalNode[];
+    public PRIMARY(i: number): antlr.TerminalNode | null;
+    public PRIMARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIMARY);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIMARY, i);
+    	}
+    }
+    public KEY(): antlr.TerminalNode[];
+    public KEY(i: number): antlr.TerminalNode | null;
+    public KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEY);
+    	} else {
+    		return this.getToken(PlSqlParser.KEY, i);
+    	}
+    }
+    public ROWID(): antlr.TerminalNode[];
+    public ROWID(i: number): antlr.TerminalNode | null;
+    public ROWID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROWID);
+    	} else {
+    		return this.getToken(PlSqlParser.ROWID, i);
+    	}
+    }
+    public SEQUENCE(): antlr.TerminalNode[];
+    public SEQUENCE(i: number): antlr.TerminalNode | null;
+    public SEQUENCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SEQUENCE);
+    	} else {
+    		return this.getToken(PlSqlParser.SEQUENCE, i);
+    	}
+    }
+    public COMMIT(): antlr.TerminalNode[];
+    public COMMIT(i: number): antlr.TerminalNode | null;
+    public COMMIT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMIT);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMIT, i);
+    	}
+    }
+    public SCN(): antlr.TerminalNode[];
+    public SCN(i: number): antlr.TerminalNode | null;
+    public SCN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SCN);
+    	} else {
+    		return this.getToken(PlSqlParser.SCN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public regular_id(): Regular_idContext[];
+    public regular_id(i: number): Regular_idContext | null;
+    public regular_id(i?: number): Regular_idContext[] | Regular_idContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Regular_idContext);
+        }
+
+        return this.getRuleContext(i, Regular_idContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_materialized_view_log;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_materialized_view_log) {
+             listener.enterCreate_materialized_view_log(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_materialized_view_log) {
+             listener.exitCreate_materialized_view_log(this);
+        }
+    }
+}
+
+
+export class New_values_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NEW, 0)!;
+    }
+    public VALUES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VALUES, 0)!;
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public EXCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_new_values_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNew_values_clause) {
+             listener.enterNew_values_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNew_values_clause) {
+             listener.exitNew_values_clause(this);
+        }
+    }
+}
+
+
+export class Mv_log_purge_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PURGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PURGE, 0)!;
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public SYNCHRONOUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYNCHRONOUS, 0);
+    }
+    public ASYNCHRONOUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASYNCHRONOUS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_mv_log_purge_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMv_log_purge_clause) {
+             listener.enterMv_log_purge_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMv_log_purge_clause) {
+             listener.exitMv_log_purge_clause(this);
+        }
+    }
+}
+
+
+export class Create_materialized_zonemapContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public ZONEMAP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ZONEMAP, 0)!;
+    }
+    public zonemap_name(): Zonemap_nameContext {
+        return this.getRuleContext(0, Zonemap_nameContext)!;
+    }
+    public create_zonemap_on_table(): Create_zonemap_on_tableContext | null {
+        return this.getRuleContext(0, Create_zonemap_on_tableContext);
+    }
+    public create_zonemap_as_subquery(): Create_zonemap_as_subqueryContext | null {
+        return this.getRuleContext(0, Create_zonemap_as_subqueryContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_list(): Column_listContext | null {
+        return this.getRuleContext(0, Column_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public zonemap_attributes(): Zonemap_attributesContext | null {
+        return this.getRuleContext(0, Zonemap_attributesContext);
+    }
+    public zonemap_refresh_clause(): Zonemap_refresh_clauseContext | null {
+        return this.getRuleContext(0, Zonemap_refresh_clauseContext);
+    }
+    public PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRUNING, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_materialized_zonemap;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_materialized_zonemap) {
+             listener.enterCreate_materialized_zonemap(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_materialized_zonemap) {
+             listener.exitCreate_materialized_zonemap(this);
+        }
+    }
+}
+
+
+export class Alter_materialized_zonemapContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public ZONEMAP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ZONEMAP, 0)!;
+    }
+    public zonemap_name(): Zonemap_nameContext {
+        return this.getRuleContext(0, Zonemap_nameContext)!;
+    }
+    public zonemap_attributes(): Zonemap_attributesContext | null {
+        return this.getRuleContext(0, Zonemap_attributesContext);
+    }
+    public zonemap_refresh_clause(): Zonemap_refresh_clauseContext | null {
+        return this.getRuleContext(0, Zonemap_refresh_clauseContext);
+    }
+    public PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRUNING, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public REBUILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REBUILD, 0);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_materialized_zonemap;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_materialized_zonemap) {
+             listener.enterAlter_materialized_zonemap(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_materialized_zonemap) {
+             listener.exitAlter_materialized_zonemap(this);
+        }
+    }
+}
+
+
+export class Drop_materialized_zonemapContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public ZONEMAP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ZONEMAP, 0)!;
+    }
+    public zonemap_name(): Zonemap_nameContext {
+        return this.getRuleContext(0, Zonemap_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_materialized_zonemap;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_materialized_zonemap) {
+             listener.enterDrop_materialized_zonemap(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_materialized_zonemap) {
+             listener.exitDrop_materialized_zonemap(this);
+        }
+    }
+}
+
+
+export class Zonemap_refresh_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REFRESH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REFRESH, 0)!;
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public FAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAST, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public DEMAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEMAND, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public MOVEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOVEMENT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_zonemap_refresh_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterZonemap_refresh_clause) {
+             listener.enterZonemap_refresh_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitZonemap_refresh_clause) {
+             listener.exitZonemap_refresh_clause(this);
+        }
+    }
+}
+
+
+export class Zonemap_attributesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PCTFREE(): antlr.TerminalNode[];
+    public PCTFREE(i: number): antlr.TerminalNode | null;
+    public PCTFREE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTFREE);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTFREE, i);
+    	}
+    }
+    public numeric(): NumericContext[];
+    public numeric(i: number): NumericContext | null;
+    public numeric(i?: number): NumericContext[] | NumericContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(NumericContext);
+        }
+
+        return this.getRuleContext(i, NumericContext);
+    }
+    public PCTUSED(): antlr.TerminalNode[];
+    public PCTUSED(i: number): antlr.TerminalNode | null;
+    public PCTUSED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTUSED);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTUSED, i);
+    	}
+    }
+    public SCALE(): antlr.TerminalNode[];
+    public SCALE(i: number): antlr.TerminalNode | null;
+    public SCALE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SCALE);
+    	} else {
+    		return this.getToken(PlSqlParser.SCALE, i);
+    	}
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public CACHE(): antlr.TerminalNode[];
+    public CACHE(i: number): antlr.TerminalNode | null;
+    public CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.CACHE, i);
+    	}
+    }
+    public NOCACHE(): antlr.TerminalNode[];
+    public NOCACHE(i: number): antlr.TerminalNode | null;
+    public NOCACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOCACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.NOCACHE, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_zonemap_attributes;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterZonemap_attributes) {
+             listener.enterZonemap_attributes(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitZonemap_attributes) {
+             listener.exitZonemap_attributes(this);
+        }
+    }
+}
+
+
+export class Zonemap_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_zonemap_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterZonemap_name) {
+             listener.enterZonemap_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitZonemap_name) {
+             listener.exitZonemap_name(this);
+        }
+    }
+}
+
+
+export class Operator_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_operator_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOperator_name) {
+             listener.enterOperator_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOperator_name) {
+             listener.exitOperator_name(this);
+        }
+    }
+}
+
+
+export class Operator_function_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_operator_function_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOperator_function_name) {
+             listener.enterOperator_function_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOperator_function_name) {
+             listener.exitOperator_function_name(this);
+        }
+    }
+}
+
+
+export class Create_zonemap_on_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_list(): Column_listContext {
+        return this.getRuleContext(0, Column_listContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_zonemap_on_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_zonemap_on_table) {
+             listener.enterCreate_zonemap_on_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_zonemap_on_table) {
+             listener.exitCreate_zonemap_on_table(this);
+        }
+    }
+}
+
+
+export class Create_zonemap_as_subqueryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public subquery(): SubqueryContext {
+        return this.getRuleContext(0, SubqueryContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_zonemap_as_subquery;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_zonemap_as_subquery) {
+             listener.enterCreate_zonemap_as_subquery(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_zonemap_as_subquery) {
+             listener.exitCreate_zonemap_as_subquery(this);
+        }
+    }
+}
+
+
+export class Alter_operatorContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public OPERATOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPERATOR, 0)!;
+    }
+    public operator_name(): Operator_nameContext {
+        return this.getRuleContext(0, Operator_nameContext)!;
+    }
+    public add_binding_clause(): Add_binding_clauseContext | null {
+        return this.getRuleContext(0, Add_binding_clauseContext);
+    }
+    public drop_binding_clause(): Drop_binding_clauseContext | null {
+        return this.getRuleContext(0, Drop_binding_clauseContext);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_operator;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_operator) {
+             listener.enterAlter_operator(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_operator) {
+             listener.exitAlter_operator(this);
+        }
+    }
+}
+
+
+export class Drop_operatorContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public OPERATOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPERATOR, 0)!;
+    }
+    public operator_name(): Operator_nameContext {
+        return this.getRuleContext(0, Operator_nameContext)!;
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_operator;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_operator) {
+             listener.enterDrop_operator(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_operator) {
+             listener.exitDrop_operator(this);
+        }
+    }
+}
+
+
+export class Create_operatorContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public OPERATOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPERATOR, 0)!;
+    }
+    public operator_name(): Operator_nameContext {
+        return this.getRuleContext(0, Operator_nameContext)!;
+    }
+    public BINDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BINDING, 0)!;
+    }
+    public binding_clause(): Binding_clauseContext[];
+    public binding_clause(i: number): Binding_clauseContext | null;
+    public binding_clause(i?: number): Binding_clauseContext[] | Binding_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Binding_clauseContext);
+        }
+
+        return this.getRuleContext(i, Binding_clauseContext);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_operator;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_operator) {
+             listener.enterCreate_operator(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_operator) {
+             listener.exitCreate_operator(this);
+        }
+    }
+}
+
+
+export class Binding_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public datatype(): DatatypeContext[];
+    public datatype(i: number): DatatypeContext | null;
+    public datatype(i?: number): DatatypeContext[] | DatatypeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(DatatypeContext);
+        }
+
+        return this.getRuleContext(i, DatatypeContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public using_function_clause(): Using_function_clauseContext {
+        return this.getRuleContext(0, Using_function_clauseContext)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public implementation_clause(): Implementation_clauseContext | null {
+        return this.getRuleContext(0, Implementation_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_binding_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBinding_clause) {
+             listener.enterBinding_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBinding_clause) {
+             listener.exitBinding_clause(this);
+        }
+    }
+}
+
+
+export class Add_binding_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public BINDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BINDING, 0)!;
+    }
+    public binding_clause(): Binding_clauseContext {
+        return this.getRuleContext(0, Binding_clauseContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_binding_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_binding_clause) {
+             listener.enterAdd_binding_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_binding_clause) {
+             listener.exitAdd_binding_clause(this);
+        }
+    }
+}
+
+
+export class Implementation_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ANCILLARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANCILLARY, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public primary_operator_list(): Primary_operator_listContext | null {
+        return this.getRuleContext(0, Primary_operator_listContext);
+    }
+    public operator_context_clause(): Operator_context_clauseContext | null {
+        return this.getRuleContext(0, Operator_context_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_implementation_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImplementation_clause) {
+             listener.enterImplementation_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImplementation_clause) {
+             listener.exitImplementation_clause(this);
+        }
+    }
+}
+
+
+export class Primary_operator_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public primary_operator_item(): Primary_operator_itemContext[];
+    public primary_operator_item(i: number): Primary_operator_itemContext | null;
+    public primary_operator_item(i?: number): Primary_operator_itemContext[] | Primary_operator_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Primary_operator_itemContext);
+        }
+
+        return this.getRuleContext(i, Primary_operator_itemContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_primary_operator_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPrimary_operator_list) {
+             listener.enterPrimary_operator_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPrimary_operator_list) {
+             listener.exitPrimary_operator_list(this);
+        }
+    }
+}
+
+
+export class Primary_operator_itemContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public schema_object_name(): Schema_object_nameContext {
+        return this.getRuleContext(0, Schema_object_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public datatype(): DatatypeContext[];
+    public datatype(i: number): DatatypeContext | null;
+    public datatype(i?: number): DatatypeContext[] | DatatypeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(DatatypeContext);
+        }
+
+        return this.getRuleContext(i, DatatypeContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_primary_operator_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPrimary_operator_item) {
+             listener.enterPrimary_operator_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPrimary_operator_item) {
+             listener.exitPrimary_operator_item(this);
+        }
+    }
+}
+
+
+export class Operator_context_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public INDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEX, 0)!;
+    }
+    public CONTEXT(): antlr.TerminalNode[];
+    public CONTEXT(i: number): antlr.TerminalNode | null;
+    public CONTEXT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONTEXT);
+    	} else {
+    		return this.getToken(PlSqlParser.CONTEXT, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMMA, 0)!;
+    }
+    public SCAN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SCAN, 0)!;
+    }
+    public implementation_type_name(): Implementation_type_nameContext {
+        return this.getRuleContext(0, Implementation_type_nameContext)!;
+    }
+    public COMPUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPUTE, 0);
+    }
+    public ANCILLARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANCILLARY, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_operator_context_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOperator_context_clause) {
+             listener.enterOperator_context_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOperator_context_clause) {
+             listener.exitOperator_context_clause(this);
+        }
+    }
+}
+
+
+export class Using_function_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public operator_function_name(): Operator_function_nameContext {
+        return this.getRuleContext(0, Operator_function_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_function_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_function_clause) {
+             listener.enterUsing_function_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_function_clause) {
+             listener.exitUsing_function_clause(this);
+        }
+    }
+}
+
+
+export class Drop_binding_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public BINDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BINDING, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public datatype(): DatatypeContext[];
+    public datatype(i: number): DatatypeContext | null;
+    public datatype(i?: number): DatatypeContext[] | DatatypeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(DatatypeContext);
+        }
+
+        return this.getRuleContext(i, DatatypeContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_binding_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_binding_clause) {
+             listener.enterDrop_binding_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_binding_clause) {
+             listener.exitDrop_binding_clause(this);
+        }
+    }
+}
+
+
+export class Create_materialized_viewContext extends antlr.ParserRuleContext {
+    public _mv_tablespace?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public select_only_statement(): Select_only_statementContext {
+        return this.getRuleContext(0, Select_only_statementContext)!;
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public PREBUILT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREBUILT, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public type_name(): Type_nameContext | null {
+        return this.getRuleContext(0, Type_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public create_mv_refresh(): Create_mv_refreshContext | null {
+        return this.getRuleContext(0, Create_mv_refreshContext);
+    }
+    public evaluation_edition_clause(): Evaluation_edition_clauseContext | null {
+        return this.getRuleContext(0, Evaluation_edition_clauseContext);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public COMPUTATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPUTATION, 0);
+    }
+    public query_rewrite_clause(): Query_rewrite_clauseContext | null {
+        return this.getRuleContext(0, Query_rewrite_clauseContext);
+    }
+    public CONCURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONCURRENT, 0);
+    }
+    public REFRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFRESH, 0);
+    }
+    public annotations_clause(): Annotations_clauseContext | null {
+        return this.getRuleContext(0, Annotations_clauseContext);
+    }
+    public ENABLE(): antlr.TerminalNode[];
+    public ENABLE(i: number): antlr.TerminalNode | null;
+    public ENABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.ENABLE, i);
+    	}
+    }
+    public DISABLE(): antlr.TerminalNode[];
+    public DISABLE(i: number): antlr.TerminalNode | null;
+    public DISABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.DISABLE, i);
+    	}
+    }
+    public scoped_table_ref_constraint(): Scoped_table_ref_constraintContext[];
+    public scoped_table_ref_constraint(i: number): Scoped_table_ref_constraintContext | null;
+    public scoped_table_ref_constraint(i?: number): Scoped_table_ref_constraintContext[] | Scoped_table_ref_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Scoped_table_ref_constraintContext);
+        }
+
+        return this.getRuleContext(i, Scoped_table_ref_constraintContext);
+    }
+    public mv_column_alias(): Mv_column_aliasContext[];
+    public mv_column_alias(i: number): Mv_column_aliasContext | null;
+    public mv_column_alias(i?: number): Mv_column_aliasContext[] | Mv_column_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Mv_column_aliasContext);
+        }
+
+        return this.getRuleContext(i, Mv_column_aliasContext);
+    }
+    public REDUCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDUCED, 0);
+    }
+    public PRECISION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECISION, 0);
+    }
+    public physical_properties(): Physical_propertiesContext | null {
+        return this.getRuleContext(0, Physical_propertiesContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public build_clause(): Build_clauseContext | null {
+        return this.getRuleContext(0, Build_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_materialized_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_materialized_view) {
+             listener.enterCreate_materialized_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_materialized_view) {
+             listener.exitCreate_materialized_view(this);
+        }
+    }
+}
+
+
+export class Scoped_table_ref_constraintContext extends antlr.ParserRuleContext {
+    public _ref_column_or_attribute?: IdentifierContext;
+    public _scope_table_name_or_c_alias?: IdentifierContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SCOPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SCOPE, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_scoped_table_ref_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterScoped_table_ref_constraint) {
+             listener.enterScoped_table_ref_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitScoped_table_ref_constraint) {
+             listener.exitScoped_table_ref_constraint(this);
+        }
+    }
+}
+
+
+export class Mv_column_aliasContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public encryption_spec(): Encryption_specContext | null {
+        return this.getRuleContext(0, Encryption_specContext);
+    }
+    public annotations_clause(): Annotations_clauseContext | null {
+        return this.getRuleContext(0, Annotations_clauseContext);
+    }
+    public scoped_table_ref_constraint(): Scoped_table_ref_constraintContext | null {
+        return this.getRuleContext(0, Scoped_table_ref_constraintContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_mv_column_alias;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMv_column_alias) {
+             listener.enterMv_column_alias(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMv_column_alias) {
+             listener.exitMv_column_alias(this);
+        }
+    }
+}
+
+
+export class Create_mv_refreshContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NEVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEVER, 0);
+    }
+    public REFRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFRESH, 0);
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public USING(): antlr.TerminalNode[];
+    public USING(i: number): antlr.TerminalNode | null;
+    public USING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USING);
+    	} else {
+    		return this.getToken(PlSqlParser.USING, i);
+    	}
+    }
+    public CONSTRAINTS(): antlr.TerminalNode[];
+    public CONSTRAINTS(i: number): antlr.TerminalNode | null;
+    public CONSTRAINTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONSTRAINTS);
+    	} else {
+    		return this.getToken(PlSqlParser.CONSTRAINTS, i);
+    	}
+    }
+    public FAST(): antlr.TerminalNode[];
+    public FAST(i: number): antlr.TerminalNode | null;
+    public FAST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FAST);
+    	} else {
+    		return this.getToken(PlSqlParser.FAST, i);
+    	}
+    }
+    public COMPLETE(): antlr.TerminalNode[];
+    public COMPLETE(i: number): antlr.TerminalNode | null;
+    public COMPLETE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMPLETE);
+    	} else {
+    		return this.getToken(PlSqlParser.COMPLETE, i);
+    	}
+    }
+    public FORCE(): antlr.TerminalNode[];
+    public FORCE(i: number): antlr.TerminalNode | null;
+    public FORCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FORCE);
+    	} else {
+    		return this.getToken(PlSqlParser.FORCE, i);
+    	}
+    }
+    public DEMAND(): antlr.TerminalNode[];
+    public DEMAND(i: number): antlr.TerminalNode | null;
+    public DEMAND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEMAND);
+    	} else {
+    		return this.getToken(PlSqlParser.DEMAND, i);
+    	}
+    }
+    public COMMIT(): antlr.TerminalNode[];
+    public COMMIT(i: number): antlr.TerminalNode | null;
+    public COMMIT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMIT);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMIT, i);
+    	}
+    }
+    public STATEMENT(): antlr.TerminalNode[];
+    public STATEMENT(i: number): antlr.TerminalNode | null;
+    public STATEMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.STATEMENT);
+    	} else {
+    		return this.getToken(PlSqlParser.STATEMENT, i);
+    	}
+    }
+    public ENFORCED(): antlr.TerminalNode[];
+    public ENFORCED(i: number): antlr.TerminalNode | null;
+    public ENFORCED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENFORCED);
+    	} else {
+    		return this.getToken(PlSqlParser.ENFORCED, i);
+    	}
+    }
+    public TRUSTED(): antlr.TerminalNode[];
+    public TRUSTED(i: number): antlr.TerminalNode | null;
+    public TRUSTED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TRUSTED);
+    	} else {
+    		return this.getToken(PlSqlParser.TRUSTED, i);
+    	}
+    }
+    public START(): antlr.TerminalNode[];
+    public START(i: number): antlr.TerminalNode | null;
+    public START(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.START);
+    	} else {
+    		return this.getToken(PlSqlParser.START, i);
+    	}
+    }
+    public NEXT(): antlr.TerminalNode[];
+    public NEXT(i: number): antlr.TerminalNode | null;
+    public NEXT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NEXT);
+    	} else {
+    		return this.getToken(PlSqlParser.NEXT, i);
+    	}
+    }
+    public PRIMARY(): antlr.TerminalNode[];
+    public PRIMARY(i: number): antlr.TerminalNode | null;
+    public PRIMARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIMARY);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIMARY, i);
+    	}
+    }
+    public KEY(): antlr.TerminalNode[];
+    public KEY(i: number): antlr.TerminalNode | null;
+    public KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEY);
+    	} else {
+    		return this.getToken(PlSqlParser.KEY, i);
+    	}
+    }
+    public ROWID(): antlr.TerminalNode[];
+    public ROWID(i: number): antlr.TerminalNode | null;
+    public ROWID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROWID);
+    	} else {
+    		return this.getToken(PlSqlParser.ROWID, i);
+    	}
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public ROLLBACK(): antlr.TerminalNode[];
+    public ROLLBACK(i: number): antlr.TerminalNode | null;
+    public ROLLBACK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROLLBACK);
+    	} else {
+    		return this.getToken(PlSqlParser.ROLLBACK, i);
+    	}
+    }
+    public SEGMENT(): antlr.TerminalNode[];
+    public SEGMENT(i: number): antlr.TerminalNode | null;
+    public SEGMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SEGMENT);
+    	} else {
+    		return this.getToken(PlSqlParser.SEGMENT, i);
+    	}
+    }
+    public rollback_segment_name(): Rollback_segment_nameContext[];
+    public rollback_segment_name(i: number): Rollback_segment_nameContext | null;
+    public rollback_segment_name(i?: number): Rollback_segment_nameContext[] | Rollback_segment_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Rollback_segment_nameContext);
+        }
+
+        return this.getRuleContext(i, Rollback_segment_nameContext);
+    }
+    public MASTER(): antlr.TerminalNode[];
+    public MASTER(i: number): antlr.TerminalNode | null;
+    public MASTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MASTER);
+    	} else {
+    		return this.getToken(PlSqlParser.MASTER, i);
+    	}
+    }
+    public LOCAL(): antlr.TerminalNode[];
+    public LOCAL(i: number): antlr.TerminalNode | null;
+    public LOCAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOCAL);
+    	} else {
+    		return this.getToken(PlSqlParser.LOCAL, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_mv_refresh;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_mv_refresh) {
+             listener.enterCreate_mv_refresh(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_mv_refresh) {
+             listener.exitCreate_mv_refresh(this);
+        }
+    }
+}
+
+
+export class Query_rewrite_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public QUERY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.QUERY, 0)!;
+    }
+    public REWRITE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REWRITE, 0)!;
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public unusable_editions_clause(): Unusable_editions_clauseContext | null {
+        return this.getRuleContext(0, Unusable_editions_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_query_rewrite_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuery_rewrite_clause) {
+             listener.enterQuery_rewrite_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuery_rewrite_clause) {
+             listener.exitQuery_rewrite_clause(this);
+        }
+    }
+}
+
+
+export class Unusable_editions_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNUSABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNUSABLE, 0)!;
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public edition_name(): Edition_nameContext | null {
+        return this.getRuleContext(0, Edition_nameContext);
+    }
+    public BEGINNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGINNING, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unusable_editions_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnusable_editions_clause) {
+             listener.enterUnusable_editions_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnusable_editions_clause) {
+             listener.exitUnusable_editions_clause(this);
+        }
+    }
+}
+
+
+export class Drop_materialized_viewContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_materialized_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_materialized_view) {
+             listener.enterDrop_materialized_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_materialized_view) {
+             listener.exitDrop_materialized_view(this);
+        }
+    }
+}
+
+
+export class Drop_materialized_view_logContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public LOG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOG, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_materialized_view_log;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_materialized_view_log) {
+             listener.enterDrop_materialized_view_log(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_materialized_view_log) {
+             listener.exitDrop_materialized_view_log(this);
+        }
+    }
+}
+
+
+export class Create_contextContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public CONTEXT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTEXT, 0)!;
+    }
+    public oracle_namespace(): Oracle_namespaceContext {
+        return this.getRuleContext(0, Oracle_namespaceContext)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public package_name(): Package_nameContext {
+        return this.getRuleContext(0, Package_nameContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public schema_object_name(): Schema_object_nameContext | null {
+        return this.getRuleContext(0, Schema_object_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public INITIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITIALIZED, 0);
+    }
+    public ACCESSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESSED, 0);
+    }
+    public GLOBALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBALLY, 0);
+    }
+    public EXTERNALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNALLY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_context;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_context) {
+             listener.enterCreate_context(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_context) {
+             listener.exitCreate_context(this);
+        }
+    }
+}
+
+
+export class Oracle_namespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_oracle_namespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOracle_namespace) {
+             listener.enterOracle_namespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOracle_namespace) {
+             listener.exitOracle_namespace(this);
+        }
+    }
+}
+
+
+export class Create_clusterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public CLUSTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLUSTER, 0)!;
+    }
+    public cluster_name(): Cluster_nameContext {
+        return this.getRuleContext(0, Cluster_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public datatype(): DatatypeContext[];
+    public datatype(i: number): DatatypeContext | null;
+    public datatype(i?: number): DatatypeContext[] | DatatypeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(DatatypeContext);
+        }
+
+        return this.getRuleContext(i, DatatypeContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public SORT(): antlr.TerminalNode[];
+    public SORT(i: number): antlr.TerminalNode | null;
+    public SORT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SORT);
+    	} else {
+    		return this.getToken(PlSqlParser.SORT, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public SIZE(): antlr.TerminalNode[];
+    public SIZE(i: number): antlr.TerminalNode | null;
+    public SIZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SIZE);
+    	} else {
+    		return this.getToken(PlSqlParser.SIZE, i);
+    	}
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public INDEX(): antlr.TerminalNode[];
+    public INDEX(i: number): antlr.TerminalNode | null;
+    public INDEX(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INDEX);
+    	} else {
+    		return this.getToken(PlSqlParser.INDEX, i);
+    	}
+    }
+    public HASHKEYS(): antlr.TerminalNode[];
+    public HASHKEYS(i: number): antlr.TerminalNode | null;
+    public HASHKEYS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.HASHKEYS);
+    	} else {
+    		return this.getToken(PlSqlParser.HASHKEYS, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public ROWDEPENDENCIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWDEPENDENCIES, 0);
+    }
+    public NOROWDEPENDENCIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOROWDEPENDENCIES, 0);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public SINGLE(): antlr.TerminalNode[];
+    public SINGLE(i: number): antlr.TerminalNode | null;
+    public SINGLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SINGLE);
+    	} else {
+    		return this.getToken(PlSqlParser.SINGLE, i);
+    	}
+    }
+    public TABLE(): antlr.TerminalNode[];
+    public TABLE(i: number): antlr.TerminalNode | null;
+    public TABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLE, i);
+    	}
+    }
+    public HASH(): antlr.TerminalNode[];
+    public HASH(i: number): antlr.TerminalNode | null;
+    public HASH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.HASH);
+    	} else {
+    		return this.getToken(PlSqlParser.HASH, i);
+    	}
+    }
+    public IS(): antlr.TerminalNode[];
+    public IS(i: number): antlr.TerminalNode | null;
+    public IS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IS);
+    	} else {
+    		return this.getToken(PlSqlParser.IS, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_cluster;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_cluster) {
+             listener.enterCreate_cluster(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_cluster) {
+             listener.exitCreate_cluster(this);
+        }
+    }
+}
+
+
+export class Create_profileContext extends antlr.ParserRuleContext {
+    public _p?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public PROFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROFILE, 0)!;
+    }
+    public LIMIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIMIT, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public MANDATORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANDATORY, 0);
+    }
+    public resource_parameters(): Resource_parametersContext[];
+    public resource_parameters(i: number): Resource_parametersContext | null;
+    public resource_parameters(i?: number): Resource_parametersContext[] | Resource_parametersContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Resource_parametersContext);
+        }
+
+        return this.getRuleContext(i, Resource_parametersContext);
+    }
+    public password_parameters(): Password_parametersContext[];
+    public password_parameters(i: number): Password_parametersContext | null;
+    public password_parameters(i?: number): Password_parametersContext[] | Password_parametersContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Password_parametersContext);
+        }
+
+        return this.getRuleContext(i, Password_parametersContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_profile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_profile) {
+             listener.enterCreate_profile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_profile) {
+             listener.exitCreate_profile(this);
+        }
+    }
+}
+
+
+export class Resource_parametersContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SESSIONS_PER_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSIONS_PER_USER, 0);
+    }
+    public CPU_PER_SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CPU_PER_SESSION, 0);
+    }
+    public CPU_PER_CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CPU_PER_CALL, 0);
+    }
+    public CONNECT_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_TIME, 0);
+    }
+    public IDLE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDLE_TIME, 0);
+    }
+    public LOGICAL_READS_PER_SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL_READS_PER_SESSION, 0);
+    }
+    public LOGICAL_READS_PER_CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL_READS_PER_CALL, 0);
+    }
+    public COMPOSITE_LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPOSITE_LIMIT, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public PRIVATE_SGA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVATE_SGA, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_resource_parameters;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterResource_parameters) {
+             listener.enterResource_parameters(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitResource_parameters) {
+             listener.exitResource_parameters(this);
+        }
+    }
+}
+
+
+export class Password_parametersContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FAILED_LOGIN_ATTEMPTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILED_LOGIN_ATTEMPTS, 0);
+    }
+    public PASSWORD_LIFE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_LIFE_TIME, 0);
+    }
+    public PASSWORD_REUSE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_REUSE_TIME, 0);
+    }
+    public PASSWORD_REUSE_MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_REUSE_MAX, 0);
+    }
+    public PASSWORD_LOCK_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_LOCK_TIME, 0);
+    }
+    public PASSWORD_GRACE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_GRACE_TIME, 0);
+    }
+    public INACTIVE_ACCOUNT_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INACTIVE_ACCOUNT_TIME, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public PASSWORD_VERIFY_FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_VERIFY_FUNCTION, 0);
+    }
+    public function_name(): Function_nameContext | null {
+        return this.getRuleContext(0, Function_nameContext);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public PASSWORD_ROLLOVER_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_ROLLOVER_TIME, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_password_parameters;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPassword_parameters) {
+             listener.enterPassword_parameters(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPassword_parameters) {
+             listener.exitPassword_parameters(this);
+        }
+    }
+}
+
+
+export class Create_lockdown_profileContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public LOCKDOWN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCKDOWN, 0)!;
+    }
+    public PROFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROFILE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public static_base_profile(): Static_base_profileContext | null {
+        return this.getRuleContext(0, Static_base_profileContext);
+    }
+    public dynamic_base_profile(): Dynamic_base_profileContext | null {
+        return this.getRuleContext(0, Dynamic_base_profileContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_lockdown_profile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_lockdown_profile) {
+             listener.enterCreate_lockdown_profile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_lockdown_profile) {
+             listener.exitCreate_lockdown_profile(this);
+        }
+    }
+}
+
+
+export class Static_base_profileContext extends antlr.ParserRuleContext {
+    public _bp?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_static_base_profile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStatic_base_profile) {
+             listener.enterStatic_base_profile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStatic_base_profile) {
+             listener.exitStatic_base_profile(this);
+        }
+    }
+}
+
+
+export class Dynamic_base_profileContext extends antlr.ParserRuleContext {
+    public _bp?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INCLUDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INCLUDING, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dynamic_base_profile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDynamic_base_profile) {
+             listener.enterDynamic_base_profile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDynamic_base_profile) {
+             listener.exitDynamic_base_profile(this);
+        }
+    }
+}
+
+
+export class Create_outlineContext extends antlr.ParserRuleContext {
+    public _o?: Id_expressionContext;
+    public _so?: Id_expressionContext;
+    public _c?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public OUTLINE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OUTLINE, 0)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public CATEGORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CATEGORY, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public statement(): StatementContext | null {
+        return this.getRuleContext(0, StatementContext);
+    }
+    public PUBLIC(): antlr.TerminalNode[];
+    public PUBLIC(i: number): antlr.TerminalNode | null;
+    public PUBLIC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PUBLIC);
+    	} else {
+    		return this.getToken(PlSqlParser.PUBLIC, i);
+    	}
+    }
+    public PRIVATE(): antlr.TerminalNode[];
+    public PRIVATE(i: number): antlr.TerminalNode | null;
+    public PRIVATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIVATE);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIVATE, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_outline;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_outline) {
+             listener.enterCreate_outline(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_outline) {
+             listener.exitCreate_outline(this);
+        }
+    }
+}
+
+
+export class Create_restore_pointContext extends antlr.ParserRuleContext {
+    public _rp?: Id_expressionContext;
+    public _pdb?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public RESTORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RESTORE, 0)!;
+    }
+    public POINT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.POINT, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public CLEAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLEAN, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public PLUGGABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0);
+    }
+    public DATABASE(): antlr.TerminalNode[];
+    public DATABASE(i: number): antlr.TerminalNode | null;
+    public DATABASE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DATABASE);
+    	} else {
+    		return this.getToken(PlSqlParser.DATABASE, i);
+    	}
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public GUARANTEE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GUARANTEE, 0);
+    }
+    public FLASHBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASHBACK, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public SCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_restore_point;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_restore_point) {
+             listener.enterCreate_restore_point(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_restore_point) {
+             listener.exitCreate_restore_point(this);
+        }
+    }
+}
+
+
+export class Create_roleContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public ROLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLE, 0)!;
+    }
+    public role_name(): Role_nameContext {
+        return this.getRuleContext(0, Role_nameContext)!;
+    }
+    public role_identified_clause(): Role_identified_clauseContext | null {
+        return this.getRuleContext(0, Role_identified_clauseContext);
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_role;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_role) {
+             listener.enterCreate_role(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_role) {
+             listener.exitCreate_role(this);
+        }
+    }
+}
+
+
+export class Create_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public table_name(): Table_nameContext {
+        return this.getRuleContext(0, Table_nameContext)!;
+    }
+    public relational_table(): Relational_tableContext | null {
+        return this.getRuleContext(0, Relational_tableContext);
+    }
+    public xmltype_table(): Xmltype_tableContext | null {
+        return this.getRuleContext(0, Xmltype_tableContext);
+    }
+    public object_table(): Object_tableContext | null {
+        return this.getRuleContext(0, Object_tableContext);
+    }
+    public TEMPORARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPORARY, 0);
+    }
+    public SHARDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARDED, 0);
+    }
+    public DUPLICATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DUPLICATED, 0);
+    }
+    public BLOCKCHAIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKCHAIN, 0);
+    }
+    public IMMUTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMUTABLE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public memoptimize_read_write_clause(): Memoptimize_read_write_clauseContext | null {
+        return this.getRuleContext(0, Memoptimize_read_write_clauseContext);
+    }
+    public PARENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public USAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USAGE, 0);
+    }
+    public QUEUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUEUE, 0);
+    }
+    public GLOBAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL, 0);
+    }
+    public PRIVATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVATE, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public EXTENDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENDED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_table) {
+             listener.enterCreate_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_table) {
+             listener.exitCreate_table(this);
+        }
+    }
+}
+
+
+export class Xmltype_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public XMLTYPE(): antlr.TerminalNode[];
+    public XMLTYPE(i: number): antlr.TerminalNode | null;
+    public XMLTYPE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.XMLTYPE);
+    	} else {
+    		return this.getToken(PlSqlParser.XMLTYPE, i);
+    	}
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public object_properties(): Object_propertiesContext | null {
+        return this.getRuleContext(0, Object_propertiesContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public xmltype_storage(): Xmltype_storageContext | null {
+        return this.getRuleContext(0, Xmltype_storageContext);
+    }
+    public xmlschema_spec(): Xmlschema_specContext | null {
+        return this.getRuleContext(0, Xmlschema_specContext);
+    }
+    public xmltype_virtual_columns(): Xmltype_virtual_columnsContext | null {
+        return this.getRuleContext(0, Xmltype_virtual_columnsContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public oid_clause(): Oid_clauseContext | null {
+        return this.getRuleContext(0, Oid_clauseContext);
+    }
+    public oid_index_clause(): Oid_index_clauseContext | null {
+        return this.getRuleContext(0, Oid_index_clauseContext);
+    }
+    public physical_properties(): Physical_propertiesContext | null {
+        return this.getRuleContext(0, Physical_propertiesContext);
+    }
+    public table_properties(): Table_propertiesContext | null {
+        return this.getRuleContext(0, Table_propertiesContext);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmltype_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmltype_table) {
+             listener.enterXmltype_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmltype_table) {
+             listener.exitXmltype_table(this);
+        }
+    }
+}
+
+
+export class Xmltype_virtual_columnsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VIRTUAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIRTUAL, 0)!;
+    }
+    public COLUMNS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMNS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmltype_virtual_columns;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmltype_virtual_columns) {
+             listener.enterXmltype_virtual_columns(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmltype_virtual_columns) {
+             listener.exitXmltype_virtual_columns(this);
+        }
+    }
+}
+
+
+export class Xmltype_column_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public XMLTYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.XMLTYPE, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public xmltype_storage(): Xmltype_storageContext | null {
+        return this.getRuleContext(0, Xmltype_storageContext);
+    }
+    public xmlschema_spec(): Xmlschema_specContext | null {
+        return this.getRuleContext(0, Xmlschema_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmltype_column_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmltype_column_properties) {
+             listener.enterXmltype_column_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmltype_column_properties) {
+             listener.exitXmltype_column_properties(this);
+        }
+    }
+}
+
+
+export class Xmltype_storageContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STORE, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public RELATIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELATIONAL, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public BINARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY, 0);
+    }
+    public XML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XML, 0);
+    }
+    public lob_segname(): Lob_segnameContext | null {
+        return this.getRuleContext(0, Lob_segnameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public lob_parameters(): Lob_parametersContext | null {
+        return this.getRuleContext(0, Lob_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public SECUREFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECUREFILE, 0);
+    }
+    public BASICFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASICFILE, 0);
+    }
+    public VARRAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAYS, 0);
+    }
+    public LOBS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOBS, 0);
+    }
+    public TABLES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmltype_storage;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmltype_storage) {
+             listener.enterXmltype_storage(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmltype_storage) {
+             listener.exitXmltype_storage(this);
+        }
+    }
+}
+
+
+export class Xmlschema_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELEMENT, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public allow_or_disallow(): Allow_or_disallowContext[];
+    public allow_or_disallow(i: number): Allow_or_disallowContext | null;
+    public allow_or_disallow(i?: number): Allow_or_disallowContext[] | Allow_or_disallowContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allow_or_disallowContext);
+        }
+
+        return this.getRuleContext(i, Allow_or_disallowContext);
+    }
+    public NONSCHEMA(): antlr.TerminalNode[];
+    public NONSCHEMA(i: number): antlr.TerminalNode | null;
+    public NONSCHEMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NONSCHEMA);
+    	} else {
+    		return this.getToken(PlSqlParser.NONSCHEMA, i);
+    	}
+    }
+    public ANYSCHEMA(): antlr.TerminalNode[];
+    public ANYSCHEMA(i: number): antlr.TerminalNode | null;
+    public ANYSCHEMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ANYSCHEMA);
+    	} else {
+    		return this.getToken(PlSqlParser.ANYSCHEMA, i);
+    	}
+    }
+    public XMLSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLSCHEMA, 0);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlschema_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlschema_spec) {
+             listener.enterXmlschema_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlschema_spec) {
+             listener.exitXmlschema_spec(this);
+        }
+    }
+}
+
+
+export class Object_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public object_type(): Object_typeContext {
+        return this.getRuleContext(0, Object_typeContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public object_table_substitution(): Object_table_substitutionContext | null {
+        return this.getRuleContext(0, Object_table_substitutionContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public object_properties(): Object_propertiesContext[];
+    public object_properties(i: number): Object_propertiesContext | null;
+    public object_properties(i?: number): Object_propertiesContext[] | Object_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Object_propertiesContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public oid_clause(): Oid_clauseContext | null {
+        return this.getRuleContext(0, Oid_clauseContext);
+    }
+    public oid_index_clause(): Oid_index_clauseContext | null {
+        return this.getRuleContext(0, Oid_index_clauseContext);
+    }
+    public physical_properties(): Physical_propertiesContext | null {
+        return this.getRuleContext(0, Physical_propertiesContext);
+    }
+    public table_properties(): Table_propertiesContext | null {
+        return this.getRuleContext(0, Table_propertiesContext);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_table) {
+             listener.enterObject_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_table) {
+             listener.exitObject_table(this);
+        }
+    }
+}
+
+
+export class Object_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_type) {
+             listener.enterObject_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_type) {
+             listener.exitObject_type(this);
+        }
+    }
+}
+
+
+export class Oid_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OIDINDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OIDINDEX, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public index_name(): Index_nameContext | null {
+        return this.getRuleContext(0, Index_nameContext);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_oid_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOid_index_clause) {
+             listener.enterOid_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOid_index_clause) {
+             listener.exitOid_index_clause(this);
+        }
+    }
+}
+
+
+export class Oid_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OBJECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OBJECT, 0)!;
+    }
+    public IDENTIFIER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIER, 0)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public GENERATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GENERATED, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_oid_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOid_clause) {
+             listener.enterOid_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOid_clause) {
+             listener.exitOid_clause(this);
+        }
+    }
+}
+
+
+export class Object_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public attribute_name(): Attribute_nameContext | null {
+        return this.getRuleContext(0, Attribute_nameContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public inline_constraint(): Inline_constraintContext[];
+    public inline_constraint(i: number): Inline_constraintContext | null;
+    public inline_constraint(i?: number): Inline_constraintContext[] | Inline_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inline_constraintContext);
+        }
+
+        return this.getRuleContext(i, Inline_constraintContext);
+    }
+    public inline_ref_constraint(): Inline_ref_constraintContext | null {
+        return this.getRuleContext(0, Inline_ref_constraintContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext | null {
+        return this.getRuleContext(0, Out_of_line_constraintContext);
+    }
+    public out_of_line_ref_constraint(): Out_of_line_ref_constraintContext | null {
+        return this.getRuleContext(0, Out_of_line_ref_constraintContext);
+    }
+    public supplemental_logging_props(): Supplemental_logging_propsContext | null {
+        return this.getRuleContext(0, Supplemental_logging_propsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_properties) {
+             listener.enterObject_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_properties) {
+             listener.exitObject_properties(this);
+        }
+    }
+}
+
+
+export class Object_table_substitutionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBSTITUTABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBSTITUTABLE, 0)!;
+    }
+    public AT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AT, 0)!;
+    }
+    public ALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALL, 0)!;
+    }
+    public LEVELS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEVELS, 0)!;
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_table_substitution;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_table_substitution) {
+             listener.enterObject_table_substitution(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_table_substitution) {
+             listener.exitObject_table_substitution(this);
+        }
+    }
+}
+
+
+export class Relational_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public relational_property(): Relational_propertyContext[];
+    public relational_property(i: number): Relational_propertyContext | null;
+    public relational_property(i?: number): Relational_propertyContext[] | Relational_propertyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Relational_propertyContext);
+        }
+
+        return this.getRuleContext(i, Relational_propertyContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public relational_table_properties(): Relational_table_propertiesContext | null {
+        return this.getRuleContext(0, Relational_table_propertiesContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relational_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelational_table) {
+             listener.enterRelational_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelational_table) {
+             listener.exitRelational_table(this);
+        }
+    }
+}
+
+
+export class Relational_table_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public relational_table_property(): Relational_table_propertyContext[];
+    public relational_table_property(i: number): Relational_table_propertyContext | null;
+    public relational_table_property(i?: number): Relational_table_propertyContext[] | Relational_table_propertyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Relational_table_propertyContext);
+        }
+
+        return this.getRuleContext(i, Relational_table_propertyContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relational_table_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelational_table_properties) {
+             listener.enterRelational_table_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelational_table_properties) {
+             listener.exitRelational_table_properties(this);
+        }
+    }
+}
+
+
+export class Relational_table_propertyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public immutable_table_clauses(): Immutable_table_clausesContext | null {
+        return this.getRuleContext(0, Immutable_table_clausesContext);
+    }
+    public blockchain_table_clauses(): Blockchain_table_clausesContext | null {
+        return this.getRuleContext(0, Blockchain_table_clausesContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public COLLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATION, 0);
+    }
+    public collation_name(): Collation_nameContext | null {
+        return this.getRuleContext(0, Collation_nameContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public DEFINITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINITION, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public physical_properties(): Physical_propertiesContext | null {
+        return this.getRuleContext(0, Physical_propertiesContext);
+    }
+    public table_properties(): Table_propertiesContext | null {
+        return this.getRuleContext(0, Table_propertiesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relational_table_property;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelational_table_property) {
+             listener.enterRelational_table_property(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelational_table_property) {
+             listener.exitRelational_table_property(this);
+        }
+    }
+}
+
+
+export class Immutable_table_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public immutable_table_no_drop_clause(): Immutable_table_no_drop_clauseContext | null {
+        return this.getRuleContext(0, Immutable_table_no_drop_clauseContext);
+    }
+    public immutable_table_no_delete_clause(): Immutable_table_no_delete_clauseContext | null {
+        return this.getRuleContext(0, Immutable_table_no_delete_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_immutable_table_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImmutable_table_clauses) {
+             listener.enterImmutable_table_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImmutable_table_clauses) {
+             listener.exitImmutable_table_clauses(this);
+        }
+    }
+}
+
+
+export class Immutable_table_no_drop_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NO, 0)!;
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public UNTIL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNTIL, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public IDLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_immutable_table_no_drop_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImmutable_table_no_drop_clause) {
+             listener.enterImmutable_table_no_drop_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImmutable_table_no_drop_clause) {
+             listener.exitImmutable_table_no_drop_clause(this);
+        }
+    }
+}
+
+
+export class Immutable_table_no_delete_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NO, 0)!;
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public UNTIL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNTIL, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public LOCKED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_immutable_table_no_delete_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImmutable_table_no_delete_clause) {
+             listener.enterImmutable_table_no_delete_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImmutable_table_no_delete_clause) {
+             listener.exitImmutable_table_no_delete_clause(this);
+        }
+    }
+}
+
+
+export class Blockchain_table_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public blockchain_drop_table_clause(): Blockchain_drop_table_clauseContext {
+        return this.getRuleContext(0, Blockchain_drop_table_clauseContext)!;
+    }
+    public blockchain_row_retention_clause(): Blockchain_row_retention_clauseContext {
+        return this.getRuleContext(0, Blockchain_row_retention_clauseContext)!;
+    }
+    public blockchain_hash_and_data_format_clause(): Blockchain_hash_and_data_format_clauseContext {
+        return this.getRuleContext(0, Blockchain_hash_and_data_format_clauseContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_blockchain_table_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBlockchain_table_clauses) {
+             listener.enterBlockchain_table_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBlockchain_table_clauses) {
+             listener.exitBlockchain_table_clauses(this);
+        }
+    }
+}
+
+
+export class Blockchain_drop_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NO, 0)!;
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public UNTIL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNTIL, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public IDLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_blockchain_drop_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBlockchain_drop_table_clause) {
+             listener.enterBlockchain_drop_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBlockchain_drop_table_clause) {
+             listener.exitBlockchain_drop_table_clause(this);
+        }
+    }
+}
+
+
+export class Blockchain_row_retention_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NO, 0)!;
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public UNTIL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNTIL, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public LOCKED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_blockchain_row_retention_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBlockchain_row_retention_clause) {
+             listener.enterBlockchain_row_retention_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBlockchain_row_retention_clause) {
+             listener.exitBlockchain_row_retention_clause(this);
+        }
+    }
+}
+
+
+export class Blockchain_hash_and_data_format_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public HASHING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HASHING, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public SHA2_512_Q(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SHA2_512_Q, 0)!;
+    }
+    public VERSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VERSION, 0)!;
+    }
+    public V1_Q(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.V1_Q, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_blockchain_hash_and_data_format_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBlockchain_hash_and_data_format_clause) {
+             listener.enterBlockchain_hash_and_data_format_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBlockchain_hash_and_data_format_clause) {
+             listener.exitBlockchain_hash_and_data_format_clause(this);
+        }
+    }
+}
+
+
+export class Collation_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_collation_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCollation_name) {
+             listener.enterCollation_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCollation_name) {
+             listener.exitCollation_name(this);
+        }
+    }
+}
+
+
+export class Table_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_properties(): Column_propertiesContext | null {
+        return this.getRuleContext(0, Column_propertiesContext);
+    }
+    public read_only_clause(): Read_only_clauseContext | null {
+        return this.getRuleContext(0, Read_only_clauseContext);
+    }
+    public indexing_clause(): Indexing_clauseContext | null {
+        return this.getRuleContext(0, Indexing_clauseContext);
+    }
+    public table_partitioning_clauses(): Table_partitioning_clausesContext | null {
+        return this.getRuleContext(0, Table_partitioning_clausesContext);
+    }
+    public attribute_clustering_clause(): Attribute_clustering_clauseContext | null {
+        return this.getRuleContext(0, Attribute_clustering_clauseContext);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public result_cache_clause(): Result_cache_clauseContext | null {
+        return this.getRuleContext(0, Result_cache_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public monitoring_nomonitoring(): Monitoring_nomonitoringContext | null {
+        return this.getRuleContext(0, Monitoring_nomonitoringContext);
+    }
+    public ROWDEPENDENCIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWDEPENDENCIES, 0);
+    }
+    public NOROWDEPENDENCIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOROWDEPENDENCIES, 0);
+    }
+    public enable_disable_clause(): Enable_disable_clauseContext | null {
+        return this.getRuleContext(0, Enable_disable_clauseContext);
+    }
+    public row_movement_clause(): Row_movement_clauseContext | null {
+        return this.getRuleContext(0, Row_movement_clauseContext);
+    }
+    public logical_replication_clause(): Logical_replication_clauseContext | null {
+        return this.getRuleContext(0, Logical_replication_clauseContext);
+    }
+    public flashback_archive_clause(): Flashback_archive_clauseContext | null {
+        return this.getRuleContext(0, Flashback_archive_clauseContext);
+    }
+    public physical_properties(): Physical_propertiesContext | null {
+        return this.getRuleContext(0, Physical_propertiesContext);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public ARCHIVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVAL, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public select_only_statement(): Select_only_statementContext | null {
+        return this.getRuleContext(0, Select_only_statementContext);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public EXCHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCHANGE, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public table_name(): Table_nameContext | null {
+        return this.getRuleContext(0, Table_nameContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public annotations_clause(): Annotations_clauseContext | null {
+        return this.getRuleContext(0, Annotations_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_properties) {
+             listener.enterTable_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_properties) {
+             listener.exitTable_properties(this);
+        }
+    }
+}
+
+
+export class Read_only_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public READ(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.READ, 0)!;
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_read_only_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRead_only_clause) {
+             listener.enterRead_only_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRead_only_clause) {
+             listener.exitRead_only_clause(this);
+        }
+    }
+}
+
+
+export class Indexing_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INDEXING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEXING, 0)!;
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public OFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFF, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_indexing_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndexing_clause) {
+             listener.enterIndexing_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndexing_clause) {
+             listener.exitIndexing_clause(this);
+        }
+    }
+}
+
+
+export class Attribute_clustering_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CLUSTERING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLUSTERING, 0)!;
+    }
+    public cluster_clause(): Cluster_clauseContext {
+        return this.getRuleContext(0, Cluster_clauseContext)!;
+    }
+    public clustering_join(): Clustering_joinContext | null {
+        return this.getRuleContext(0, Clustering_joinContext);
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public MOVEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOVEMENT, 0);
+    }
+    public zonemap_clause(): Zonemap_clauseContext | null {
+        return this.getRuleContext(0, Zonemap_clauseContext);
+    }
+    public yes_no(): Yes_noContext[];
+    public yes_no(i: number): Yes_noContext | null;
+    public yes_no(i?: number): Yes_noContext[] | Yes_noContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Yes_noContext);
+        }
+
+        return this.getRuleContext(i, Yes_noContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_attribute_clustering_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAttribute_clustering_clause) {
+             listener.enterAttribute_clustering_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAttribute_clustering_clause) {
+             listener.exitAttribute_clustering_clause(this);
+        }
+    }
+}
+
+
+export class Clustering_joinContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_name(): Table_nameContext {
+        return this.getRuleContext(0, Table_nameContext)!;
+    }
+    public clustering_join_item(): Clustering_join_itemContext[];
+    public clustering_join_item(i: number): Clustering_join_itemContext | null;
+    public clustering_join_item(i?: number): Clustering_join_itemContext[] | Clustering_join_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Clustering_join_itemContext);
+        }
+
+        return this.getRuleContext(i, Clustering_join_itemContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_clustering_join;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClustering_join) {
+             listener.enterClustering_join(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClustering_join) {
+             listener.exitClustering_join(this);
+        }
+    }
+}
+
+
+export class Clustering_join_itemContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public JOIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JOIN, 0)!;
+    }
+    public table_name(): Table_nameContext {
+        return this.getRuleContext(0, Table_nameContext)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public equijoin_condition(): Equijoin_conditionContext {
+        return this.getRuleContext(0, Equijoin_conditionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_clustering_join_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClustering_join_item) {
+             listener.enterClustering_join_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClustering_join_item) {
+             listener.exitClustering_join_item(this);
+        }
+    }
+}
+
+
+export class Equijoin_conditionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_equijoin_condition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEquijoin_condition) {
+             listener.enterEquijoin_condition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEquijoin_condition) {
+             listener.exitEquijoin_condition(this);
+        }
+    }
+}
+
+
+export class Cluster_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public ORDER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ORDER, 0)!;
+    }
+    public clustering_columns(): Clustering_columnsContext {
+        return this.getRuleContext(0, Clustering_columnsContext)!;
+    }
+    public LINEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINEAR, 0);
+    }
+    public INTERLEAVED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERLEAVED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cluster_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCluster_clause) {
+             listener.enterCluster_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCluster_clause) {
+             listener.exitCluster_clause(this);
+        }
+    }
+}
+
+
+export class Clustering_columnsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public clustering_column_group(): Clustering_column_groupContext[];
+    public clustering_column_group(i: number): Clustering_column_groupContext | null;
+    public clustering_column_group(i?: number): Clustering_column_groupContext[] | Clustering_column_groupContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Clustering_column_groupContext);
+        }
+
+        return this.getRuleContext(i, Clustering_column_groupContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_clustering_columns;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClustering_columns) {
+             listener.enterClustering_columns(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClustering_columns) {
+             listener.exitClustering_columns(this);
+        }
+    }
+}
+
+
+export class Clustering_column_groupContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_clustering_column_group;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClustering_column_group) {
+             listener.enterClustering_column_group(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClustering_column_group) {
+             listener.exitClustering_column_group(this);
+        }
+    }
+}
+
+
+export class Yes_noContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public YES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YES, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_yes_no;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterYes_no) {
+             listener.enterYes_no(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitYes_no) {
+             listener.exitYes_no(this);
+        }
+    }
+}
+
+
+export class Zonemap_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public ZONEMAP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ZONEMAP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public zonemap_name(): Zonemap_nameContext | null {
+        return this.getRuleContext(0, Zonemap_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_zonemap_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterZonemap_clause) {
+             listener.enterZonemap_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitZonemap_clause) {
+             listener.exitZonemap_clause(this);
+        }
+    }
+}
+
+
+export class Logical_replication_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGICAL, 0)!;
+    }
+    public REPLICATION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REPLICATION, 0)!;
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYS, 0);
+    }
+    public PARTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTIAL, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public ALLOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALLOW, 0);
+    }
+    public NOVALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOVALIDATE, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logical_replication_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogical_replication_clause) {
+             listener.enterLogical_replication_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogical_replication_clause) {
+             listener.exitLogical_replication_clause(this);
+        }
+    }
+}
+
+
+export class Table_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_name) {
+             listener.enterTable_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_name) {
+             listener.exitTable_name(this);
+        }
+    }
+}
+
+
+export class Relational_propertyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext | null {
+        return this.getRuleContext(0, Out_of_line_constraintContext);
+    }
+    public out_of_line_ref_constraint(): Out_of_line_ref_constraintContext | null {
+        return this.getRuleContext(0, Out_of_line_ref_constraintContext);
+    }
+    public column_definition(): Column_definitionContext | null {
+        return this.getRuleContext(0, Column_definitionContext);
+    }
+    public virtual_column_definition(): Virtual_column_definitionContext | null {
+        return this.getRuleContext(0, Virtual_column_definitionContext);
+    }
+    public period_definition(): Period_definitionContext | null {
+        return this.getRuleContext(0, Period_definitionContext);
+    }
+    public supplemental_logging_props(): Supplemental_logging_propsContext | null {
+        return this.getRuleContext(0, Supplemental_logging_propsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relational_property;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelational_property) {
+             listener.enterRelational_property(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelational_property) {
+             listener.exitRelational_property(this);
+        }
+    }
+}
+
+
+export class Table_partitioning_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public range_partitions(): Range_partitionsContext | null {
+        return this.getRuleContext(0, Range_partitionsContext);
+    }
+    public list_partitions(): List_partitionsContext | null {
+        return this.getRuleContext(0, List_partitionsContext);
+    }
+    public hash_partitions(): Hash_partitionsContext | null {
+        return this.getRuleContext(0, Hash_partitionsContext);
+    }
+    public composite_range_partitions(): Composite_range_partitionsContext | null {
+        return this.getRuleContext(0, Composite_range_partitionsContext);
+    }
+    public composite_list_partitions(): Composite_list_partitionsContext | null {
+        return this.getRuleContext(0, Composite_list_partitionsContext);
+    }
+    public composite_hash_partitions(): Composite_hash_partitionsContext | null {
+        return this.getRuleContext(0, Composite_hash_partitionsContext);
+    }
+    public reference_partitioning(): Reference_partitioningContext | null {
+        return this.getRuleContext(0, Reference_partitioningContext);
+    }
+    public system_partitioning(): System_partitioningContext | null {
+        return this.getRuleContext(0, System_partitioningContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_partitioning_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_partitioning_clauses) {
+             listener.enterTable_partitioning_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_partitioning_clauses) {
+             listener.exitTable_partitioning_clauses(this);
+        }
+    }
+}
+
+
+export class Range_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public RANGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RANGE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public range_values_clause(): Range_values_clauseContext[];
+    public range_values_clause(i: number): Range_values_clauseContext | null;
+    public range_values_clause(i?: number): Range_values_clauseContext[] | Range_values_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Range_values_clauseContext);
+        }
+
+        return this.getRuleContext(i, Range_values_clauseContext);
+    }
+    public table_partition_description(): Table_partition_descriptionContext[];
+    public table_partition_description(i: number): Table_partition_descriptionContext | null;
+    public table_partition_description(i?: number): Table_partition_descriptionContext[] | Table_partition_descriptionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_partition_descriptionContext);
+        }
+
+        return this.getRuleContext(i, Table_partition_descriptionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERVAL, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_range_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRange_partitions) {
+             listener.enterRange_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRange_partitions) {
+             listener.exitRange_partitions(this);
+        }
+    }
+}
+
+
+export class List_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public LIST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIST, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public AUTOMATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOMATIC, 0);
+    }
+    public list_values_clause(): List_values_clauseContext[];
+    public list_values_clause(i: number): List_values_clauseContext | null;
+    public list_values_clause(i?: number): List_values_clauseContext[] | List_values_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(List_values_clauseContext);
+        }
+
+        return this.getRuleContext(i, List_values_clauseContext);
+    }
+    public table_partition_description(): Table_partition_descriptionContext[];
+    public table_partition_description(i: number): Table_partition_descriptionContext | null;
+    public table_partition_description(i?: number): Table_partition_descriptionContext[] | Table_partition_descriptionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_partition_descriptionContext);
+        }
+
+        return this.getRuleContext(i, Table_partition_descriptionContext);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_list_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterList_partitions) {
+             listener.enterList_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitList_partitions) {
+             listener.exitList_partitions(this);
+        }
+    }
+}
+
+
+export class Hash_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public HASH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HASH, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public individual_hash_partitions(): Individual_hash_partitionsContext | null {
+        return this.getRuleContext(0, Individual_hash_partitionsContext);
+    }
+    public hash_partitions_by_quantity(): Hash_partitions_by_quantityContext | null {
+        return this.getRuleContext(0, Hash_partitions_by_quantityContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hash_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHash_partitions) {
+             listener.enterHash_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHash_partitions) {
+             listener.exitHash_partitions(this);
+        }
+    }
+}
+
+
+export class Individual_hash_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public partitioning_storage_clause(): Partitioning_storage_clauseContext[];
+    public partitioning_storage_clause(i: number): Partitioning_storage_clauseContext | null;
+    public partitioning_storage_clause(i?: number): Partitioning_storage_clauseContext[] | Partitioning_storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partitioning_storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Partitioning_storage_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_individual_hash_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndividual_hash_partitions) {
+             listener.enterIndividual_hash_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndividual_hash_partitions) {
+             listener.exitIndividual_hash_partitions(this);
+        }
+    }
+}
+
+
+export class Hash_partitions_by_quantityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITIONS, 0)!;
+    }
+    public hash_partition_quantity(): Hash_partition_quantityContext {
+        return this.getRuleContext(0, Hash_partition_quantityContext)!;
+    }
+    public STORE(): antlr.TerminalNode[];
+    public STORE(i: number): antlr.TerminalNode | null;
+    public STORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.STORE);
+    	} else {
+    		return this.getToken(PlSqlParser.STORE, i);
+    	}
+    }
+    public IN(): antlr.TerminalNode[];
+    public IN(i: number): antlr.TerminalNode | null;
+    public IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IN);
+    	} else {
+    		return this.getToken(PlSqlParser.IN, i);
+    	}
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public OVERFLOW_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hash_partitions_by_quantity;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHash_partitions_by_quantity) {
+             listener.enterHash_partitions_by_quantity(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHash_partitions_by_quantity) {
+             listener.exitHash_partitions_by_quantity(this);
+        }
+    }
+}
+
+
+export class Hash_partition_quantityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hash_partition_quantity;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHash_partition_quantity) {
+             listener.enterHash_partition_quantity(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHash_partition_quantity) {
+             listener.exitHash_partition_quantity(this);
+        }
+    }
+}
+
+
+export class Composite_range_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public RANGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RANGE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public range_partition_desc(): Range_partition_descContext[];
+    public range_partition_desc(i: number): Range_partition_descContext | null;
+    public range_partition_desc(i?: number): Range_partition_descContext[] | Range_partition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Range_partition_descContext);
+        }
+
+        return this.getRuleContext(i, Range_partition_descContext);
+    }
+    public subpartition_by_range(): Subpartition_by_rangeContext | null {
+        return this.getRuleContext(0, Subpartition_by_rangeContext);
+    }
+    public subpartition_by_list(): Subpartition_by_listContext | null {
+        return this.getRuleContext(0, Subpartition_by_listContext);
+    }
+    public subpartition_by_hash(): Subpartition_by_hashContext | null {
+        return this.getRuleContext(0, Subpartition_by_hashContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERVAL, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_composite_range_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComposite_range_partitions) {
+             listener.enterComposite_range_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComposite_range_partitions) {
+             listener.exitComposite_range_partitions(this);
+        }
+    }
+}
+
+
+export class Composite_list_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public LIST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIST, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public list_partition_desc(): List_partition_descContext[];
+    public list_partition_desc(i: number): List_partition_descContext | null;
+    public list_partition_desc(i?: number): List_partition_descContext[] | List_partition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(List_partition_descContext);
+        }
+
+        return this.getRuleContext(i, List_partition_descContext);
+    }
+    public subpartition_by_range(): Subpartition_by_rangeContext | null {
+        return this.getRuleContext(0, Subpartition_by_rangeContext);
+    }
+    public subpartition_by_list(): Subpartition_by_listContext | null {
+        return this.getRuleContext(0, Subpartition_by_listContext);
+    }
+    public subpartition_by_hash(): Subpartition_by_hashContext | null {
+        return this.getRuleContext(0, Subpartition_by_hashContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_composite_list_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComposite_list_partitions) {
+             listener.enterComposite_list_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComposite_list_partitions) {
+             listener.exitComposite_list_partitions(this);
+        }
+    }
+}
+
+
+export class Composite_hash_partitionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public HASH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HASH, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public subpartition_by_range(): Subpartition_by_rangeContext | null {
+        return this.getRuleContext(0, Subpartition_by_rangeContext);
+    }
+    public subpartition_by_list(): Subpartition_by_listContext | null {
+        return this.getRuleContext(0, Subpartition_by_listContext);
+    }
+    public subpartition_by_hash(): Subpartition_by_hashContext | null {
+        return this.getRuleContext(0, Subpartition_by_hashContext);
+    }
+    public individual_hash_partitions(): Individual_hash_partitionsContext | null {
+        return this.getRuleContext(0, Individual_hash_partitionsContext);
+    }
+    public hash_partitions_by_quantity(): Hash_partitions_by_quantityContext | null {
+        return this.getRuleContext(0, Hash_partitions_by_quantityContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_composite_hash_partitions;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComposite_hash_partitions) {
+             listener.enterComposite_hash_partitions(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComposite_hash_partitions) {
+             listener.exitComposite_hash_partitions(this);
+        }
+    }
+}
+
+
+export class Reference_partitioningContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public REFERENCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REFERENCE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public constraint_name(): Constraint_nameContext {
+        return this.getRuleContext(0, Constraint_nameContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public reference_partition_desc(): Reference_partition_descContext[];
+    public reference_partition_desc(i: number): Reference_partition_descContext | null;
+    public reference_partition_desc(i?: number): Reference_partition_descContext[] | Reference_partition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Reference_partition_descContext);
+        }
+
+        return this.getRuleContext(i, Reference_partition_descContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_reference_partitioning;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReference_partitioning) {
+             listener.enterReference_partitioning(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReference_partitioning) {
+             listener.exitReference_partitioning(this);
+        }
+    }
+}
+
+
+export class Reference_partition_descContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public table_partition_description(): Table_partition_descriptionContext {
+        return this.getRuleContext(0, Table_partition_descriptionContext)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_reference_partition_desc;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReference_partition_desc) {
+             listener.enterReference_partition_desc(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReference_partition_desc) {
+             listener.exitReference_partition_desc(this);
+        }
+    }
+}
+
+
+export class System_partitioningContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public SYSTEM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SYSTEM, 0)!;
+    }
+    public PARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITIONS, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public reference_partition_desc(): Reference_partition_descContext[];
+    public reference_partition_desc(i: number): Reference_partition_descContext | null;
+    public reference_partition_desc(i?: number): Reference_partition_descContext[] | Reference_partition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Reference_partition_descContext);
+        }
+
+        return this.getRuleContext(i, Reference_partition_descContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_system_partitioning;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSystem_partitioning) {
+             listener.enterSystem_partitioning(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSystem_partitioning) {
+             listener.exitSystem_partitioning(this);
+        }
+    }
+}
+
+
+export class Range_partition_descContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public table_partition_description(): Table_partition_descriptionContext {
+        return this.getRuleContext(0, Table_partition_descriptionContext)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public range_values_clause(): Range_values_clauseContext | null {
+        return this.getRuleContext(0, Range_values_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public hash_subparts_by_quantity(): Hash_subparts_by_quantityContext | null {
+        return this.getRuleContext(0, Hash_subparts_by_quantityContext);
+    }
+    public range_subpartition_desc(): Range_subpartition_descContext[];
+    public range_subpartition_desc(i: number): Range_subpartition_descContext | null;
+    public range_subpartition_desc(i?: number): Range_subpartition_descContext[] | Range_subpartition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Range_subpartition_descContext);
+        }
+
+        return this.getRuleContext(i, Range_subpartition_descContext);
+    }
+    public list_subpartition_desc(): List_subpartition_descContext[];
+    public list_subpartition_desc(i: number): List_subpartition_descContext | null;
+    public list_subpartition_desc(i?: number): List_subpartition_descContext[] | List_subpartition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(List_subpartition_descContext);
+        }
+
+        return this.getRuleContext(i, List_subpartition_descContext);
+    }
+    public individual_hash_subparts(): Individual_hash_subpartsContext[];
+    public individual_hash_subparts(i: number): Individual_hash_subpartsContext | null;
+    public individual_hash_subparts(i?: number): Individual_hash_subpartsContext[] | Individual_hash_subpartsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Individual_hash_subpartsContext);
+        }
+
+        return this.getRuleContext(i, Individual_hash_subpartsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_range_partition_desc;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRange_partition_desc) {
+             listener.enterRange_partition_desc(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRange_partition_desc) {
+             listener.exitRange_partition_desc(this);
+        }
+    }
+}
+
+
+export class List_partition_descContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public table_partition_description(): Table_partition_descriptionContext {
+        return this.getRuleContext(0, Table_partition_descriptionContext)!;
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public list_values_clause(): List_values_clauseContext | null {
+        return this.getRuleContext(0, List_values_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public hash_subparts_by_quantity(): Hash_subparts_by_quantityContext | null {
+        return this.getRuleContext(0, Hash_subparts_by_quantityContext);
+    }
+    public range_subpartition_desc(): Range_subpartition_descContext[];
+    public range_subpartition_desc(i: number): Range_subpartition_descContext | null;
+    public range_subpartition_desc(i?: number): Range_subpartition_descContext[] | Range_subpartition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Range_subpartition_descContext);
+        }
+
+        return this.getRuleContext(i, Range_subpartition_descContext);
+    }
+    public list_subpartition_desc(): List_subpartition_descContext[];
+    public list_subpartition_desc(i: number): List_subpartition_descContext | null;
+    public list_subpartition_desc(i?: number): List_subpartition_descContext[] | List_subpartition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(List_subpartition_descContext);
+        }
+
+        return this.getRuleContext(i, List_subpartition_descContext);
+    }
+    public individual_hash_subparts(): Individual_hash_subpartsContext[];
+    public individual_hash_subparts(i: number): Individual_hash_subpartsContext | null;
+    public individual_hash_subparts(i?: number): Individual_hash_subpartsContext[] | Individual_hash_subpartsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Individual_hash_subpartsContext);
+        }
+
+        return this.getRuleContext(i, Individual_hash_subpartsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_list_partition_desc;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterList_partition_desc) {
+             listener.enterList_partition_desc(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitList_partition_desc) {
+             listener.exitList_partition_desc(this);
+        }
+    }
+}
+
+
+export class Subpartition_templateContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public TEMPLATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TEMPLATE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public hash_subpartition_quantity(): Hash_subpartition_quantityContext | null {
+        return this.getRuleContext(0, Hash_subpartition_quantityContext);
+    }
+    public range_subpartition_desc(): Range_subpartition_descContext[];
+    public range_subpartition_desc(i: number): Range_subpartition_descContext | null;
+    public range_subpartition_desc(i?: number): Range_subpartition_descContext[] | Range_subpartition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Range_subpartition_descContext);
+        }
+
+        return this.getRuleContext(i, Range_subpartition_descContext);
+    }
+    public list_subpartition_desc(): List_subpartition_descContext[];
+    public list_subpartition_desc(i: number): List_subpartition_descContext | null;
+    public list_subpartition_desc(i?: number): List_subpartition_descContext[] | List_subpartition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(List_subpartition_descContext);
+        }
+
+        return this.getRuleContext(i, List_subpartition_descContext);
+    }
+    public individual_hash_subparts(): Individual_hash_subpartsContext[];
+    public individual_hash_subparts(i: number): Individual_hash_subpartsContext | null;
+    public individual_hash_subparts(i?: number): Individual_hash_subpartsContext[] | Individual_hash_subpartsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Individual_hash_subpartsContext);
+        }
+
+        return this.getRuleContext(i, Individual_hash_subpartsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_template;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_template) {
+             listener.enterSubpartition_template(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_template) {
+             listener.exitSubpartition_template(this);
+        }
+    }
+}
+
+
+export class Hash_subpartition_quantityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hash_subpartition_quantity;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHash_subpartition_quantity) {
+             listener.enterHash_subpartition_quantity(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHash_subpartition_quantity) {
+             listener.exitHash_subpartition_quantity(this);
+        }
+    }
+}
+
+
+export class Subpartition_by_rangeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public RANGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RANGE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public subpartition_template(): Subpartition_templateContext | null {
+        return this.getRuleContext(0, Subpartition_templateContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_by_range;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_by_range) {
+             listener.enterSubpartition_by_range(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_by_range) {
+             listener.exitSubpartition_by_range(this);
+        }
+    }
+}
+
+
+export class Subpartition_by_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public LIST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIST, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public subpartition_template(): Subpartition_templateContext | null {
+        return this.getRuleContext(0, Subpartition_templateContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_by_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_by_list) {
+             listener.enterSubpartition_by_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_by_list) {
+             listener.exitSubpartition_by_list(this);
+        }
+    }
+}
+
+
+export class Subpartition_by_hashContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public HASH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HASH, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public SUBPARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITIONS, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public subpartition_template(): Subpartition_templateContext | null {
+        return this.getRuleContext(0, Subpartition_templateContext);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_by_hash;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_by_hash) {
+             listener.enterSubpartition_by_hash(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_by_hash) {
+             listener.exitSubpartition_by_hash(this);
+        }
+    }
+}
+
+
+export class Subpartition_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_name) {
+             listener.enterSubpartition_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_name) {
+             listener.exitSubpartition_name(this);
+        }
+    }
+}
+
+
+export class Range_subpartition_descContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public range_values_clause(): Range_values_clauseContext {
+        return this.getRuleContext(0, Range_values_clauseContext)!;
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public partitioning_storage_clause(): Partitioning_storage_clauseContext | null {
+        return this.getRuleContext(0, Partitioning_storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_range_subpartition_desc;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRange_subpartition_desc) {
+             listener.enterRange_subpartition_desc(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRange_subpartition_desc) {
+             listener.exitRange_subpartition_desc(this);
+        }
+    }
+}
+
+
+export class List_subpartition_descContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public list_values_clause(): List_values_clauseContext {
+        return this.getRuleContext(0, List_values_clauseContext)!;
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public partitioning_storage_clause(): Partitioning_storage_clauseContext | null {
+        return this.getRuleContext(0, Partitioning_storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_list_subpartition_desc;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterList_subpartition_desc) {
+             listener.enterList_subpartition_desc(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitList_subpartition_desc) {
+             listener.exitList_subpartition_desc(this);
+        }
+    }
+}
+
+
+export class Individual_hash_subpartsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public partitioning_storage_clause(): Partitioning_storage_clauseContext | null {
+        return this.getRuleContext(0, Partitioning_storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_individual_hash_subparts;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndividual_hash_subparts) {
+             listener.enterIndividual_hash_subparts(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndividual_hash_subparts) {
+             listener.exitIndividual_hash_subparts(this);
+        }
+    }
+}
+
+
+export class Hash_subparts_by_quantityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITIONS, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hash_subparts_by_quantity;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHash_subparts_by_quantity) {
+             listener.enterHash_subparts_by_quantity(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHash_subparts_by_quantity) {
+             listener.exitHash_subparts_by_quantity(this);
+        }
+    }
+}
+
+
+export class Range_values_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VALUES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VALUES, 0)!;
+    }
+    public LESS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LESS, 0)!;
+    }
+    public THAN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THAN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public range_values_list(): Range_values_listContext {
+        return this.getRuleContext(0, Range_values_listContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_range_values_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRange_values_clause) {
+             listener.enterRange_values_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRange_values_clause) {
+             listener.exitRange_values_clause(this);
+        }
+    }
+}
+
+
+export class Range_values_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public literal(): LiteralContext[];
+    public literal(i: number): LiteralContext | null;
+    public literal(i?: number): LiteralContext[] | LiteralContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(LiteralContext);
+        }
+
+        return this.getRuleContext(i, LiteralContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public TIMESTAMP(): antlr.TerminalNode[];
+    public TIMESTAMP(i: number): antlr.TerminalNode | null;
+    public TIMESTAMP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TIMESTAMP);
+    	} else {
+    		return this.getToken(PlSqlParser.TIMESTAMP, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_range_values_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRange_values_list) {
+             listener.enterRange_values_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRange_values_list) {
+             listener.exitRange_values_list(this);
+        }
+    }
+}
+
+
+export class List_values_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VALUES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VALUES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public literal(): LiteralContext[];
+    public literal(i: number): LiteralContext | null;
+    public literal(i?: number): LiteralContext[] | LiteralContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(LiteralContext);
+        }
+
+        return this.getRuleContext(i, LiteralContext);
+    }
+    public TIMESTAMP(): antlr.TerminalNode[];
+    public TIMESTAMP(i: number): antlr.TerminalNode | null;
+    public TIMESTAMP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TIMESTAMP);
+    	} else {
+    		return this.getToken(PlSqlParser.TIMESTAMP, i);
+    	}
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_list_values_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterList_values_clause) {
+             listener.enterList_values_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitList_values_clause) {
+             listener.exitList_values_clause(this);
+        }
+    }
+}
+
+
+export class Table_partition_descriptionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public deferred_segment_creation(): Deferred_segment_creationContext | null {
+        return this.getRuleContext(0, Deferred_segment_creationContext);
+    }
+    public read_only_clause(): Read_only_clauseContext | null {
+        return this.getRuleContext(0, Read_only_clauseContext);
+    }
+    public indexing_clause(): Indexing_clauseContext | null {
+        return this.getRuleContext(0, Indexing_clauseContext);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext[];
+    public segment_attributes_clause(i: number): Segment_attributes_clauseContext | null;
+    public segment_attributes_clause(i?: number): Segment_attributes_clauseContext[] | Segment_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_attributes_clauseContext);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext | null {
+        return this.getRuleContext(0, Inmemory_table_clauseContext);
+    }
+    public ilm_clause(): Ilm_clauseContext | null {
+        return this.getRuleContext(0, Ilm_clauseContext);
+    }
+    public OVERFLOW_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0);
+    }
+    public lob_storage_clause(): Lob_storage_clauseContext[];
+    public lob_storage_clause(i: number): Lob_storage_clauseContext | null;
+    public lob_storage_clause(i?: number): Lob_storage_clauseContext[] | Lob_storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_storage_clauseContext);
+    }
+    public varray_col_properties(): Varray_col_propertiesContext[];
+    public varray_col_properties(i: number): Varray_col_propertiesContext | null;
+    public varray_col_properties(i?: number): Varray_col_propertiesContext[] | Varray_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Varray_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Varray_col_propertiesContext);
+    }
+    public nested_table_col_properties(): Nested_table_col_propertiesContext[];
+    public nested_table_col_properties(i: number): Nested_table_col_propertiesContext | null;
+    public nested_table_col_properties(i?: number): Nested_table_col_propertiesContext[] | Nested_table_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Nested_table_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Nested_table_col_propertiesContext);
+    }
+    public INTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERNAL, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_partition_description;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_partition_description) {
+             listener.enterTable_partition_description(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_partition_description) {
+             listener.exitTable_partition_description(this);
+        }
+    }
+}
+
+
+export class Partitioning_storage_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public OVERFLOW_(): antlr.TerminalNode[];
+    public OVERFLOW_(i: number): antlr.TerminalNode | null;
+    public OVERFLOW_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OVERFLOW_);
+    	} else {
+    		return this.getToken(PlSqlParser.OVERFLOW_, i);
+    	}
+    }
+    public table_compression(): Table_compressionContext[];
+    public table_compression(i: number): Table_compressionContext | null;
+    public table_compression(i?: number): Table_compressionContext[] | Table_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_compressionContext);
+        }
+
+        return this.getRuleContext(i, Table_compressionContext);
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext[];
+    public inmemory_table_clause(i: number): Inmemory_table_clauseContext | null;
+    public inmemory_table_clause(i?: number): Inmemory_table_clauseContext[] | Inmemory_table_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_table_clauseContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_table_clauseContext);
+    }
+    public lob_partitioning_storage(): Lob_partitioning_storageContext[];
+    public lob_partitioning_storage(i: number): Lob_partitioning_storageContext | null;
+    public lob_partitioning_storage(i?: number): Lob_partitioning_storageContext[] | Lob_partitioning_storageContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_partitioning_storageContext);
+        }
+
+        return this.getRuleContext(i, Lob_partitioning_storageContext);
+    }
+    public VARRAY(): antlr.TerminalNode[];
+    public VARRAY(i: number): antlr.TerminalNode | null;
+    public VARRAY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.VARRAY);
+    	} else {
+    		return this.getToken(PlSqlParser.VARRAY, i);
+    	}
+    }
+    public varray_item(): Varray_itemContext[];
+    public varray_item(i: number): Varray_itemContext | null;
+    public varray_item(i?: number): Varray_itemContext[] | Varray_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Varray_itemContext);
+        }
+
+        return this.getRuleContext(i, Varray_itemContext);
+    }
+    public STORE(): antlr.TerminalNode[];
+    public STORE(i: number): antlr.TerminalNode | null;
+    public STORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.STORE);
+    	} else {
+    		return this.getToken(PlSqlParser.STORE, i);
+    	}
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public LOB(): antlr.TerminalNode[];
+    public LOB(i: number): antlr.TerminalNode | null;
+    public LOB(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOB);
+    	} else {
+    		return this.getToken(PlSqlParser.LOB, i);
+    	}
+    }
+    public lob_segname(): Lob_segnameContext[];
+    public lob_segname(i: number): Lob_segnameContext | null;
+    public lob_segname(i?: number): Lob_segnameContext[] | Lob_segnameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_segnameContext);
+        }
+
+        return this.getRuleContext(i, Lob_segnameContext);
+    }
+    public BASICFILE(): antlr.TerminalNode[];
+    public BASICFILE(i: number): antlr.TerminalNode | null;
+    public BASICFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BASICFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.BASICFILE, i);
+    	}
+    }
+    public SECUREFILE(): antlr.TerminalNode[];
+    public SECUREFILE(i: number): antlr.TerminalNode | null;
+    public SECUREFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SECUREFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.SECUREFILE, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partitioning_storage_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartitioning_storage_clause) {
+             listener.enterPartitioning_storage_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartitioning_storage_clause) {
+             listener.exitPartitioning_storage_clause(this);
+        }
+    }
+}
+
+
+export class Lob_partitioning_storageContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOB, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public lob_item(): Lob_itemContext {
+        return this.getRuleContext(0, Lob_itemContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public STORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STORE, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public lob_segname(): Lob_segnameContext | null {
+        return this.getRuleContext(0, Lob_segnameContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public BASICFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASICFILE, 0);
+    }
+    public SECUREFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECUREFILE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_partitioning_storage;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_partitioning_storage) {
+             listener.enterLob_partitioning_storage(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_partitioning_storage) {
+             listener.exitLob_partitioning_storage(this);
+        }
+    }
+}
+
+
+export class Size_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public K_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.K_LETTER, 0);
+    }
+    public M_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.M_LETTER, 0);
+    }
+    public G_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.G_LETTER, 0);
+    }
+    public T_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.T_LETTER, 0);
+    }
+    public P_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.P_LETTER, 0);
+    }
+    public E_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.E_LETTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_size_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSize_clause) {
+             listener.enterSize_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSize_clause) {
+             listener.exitSize_clause(this);
+        }
+    }
+}
+
+
+export class Table_compressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESS, 0);
+    }
+    public BASIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASIC, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public OLTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLTP, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public OPERATIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPERATIONS, 0);
+    }
+    public DIRECT_LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECT_LOAD, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public ARCHIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVE, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public ADVANCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVANCED, 0);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public LEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVEL, 0);
+    }
+    public LOCKING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKING, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public NOCOMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOMPRESS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_compression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_compression) {
+             listener.enterTable_compression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_compression) {
+             listener.exitTable_compression(this);
+        }
+    }
+}
+
+
+export class Inmemory_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public inmemory_column_clause(): Inmemory_column_clauseContext[];
+    public inmemory_column_clause(i: number): Inmemory_column_clauseContext | null;
+    public inmemory_column_clause(i?: number): Inmemory_column_clauseContext[] | Inmemory_column_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_column_clauseContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_column_clauseContext);
+    }
+    public INMEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INMEMORY, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public inmemory_attributes(): Inmemory_attributesContext | null {
+        return this.getRuleContext(0, Inmemory_attributesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_table_clause) {
+             listener.enterInmemory_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_table_clause) {
+             listener.exitInmemory_table_clause(this);
+        }
+    }
+}
+
+
+export class Inmemory_attributesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public inmemory_memcompress(): Inmemory_memcompressContext[];
+    public inmemory_memcompress(i: number): Inmemory_memcompressContext | null;
+    public inmemory_memcompress(i?: number): Inmemory_memcompressContext[] | Inmemory_memcompressContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_memcompressContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_memcompressContext);
+    }
+    public inmemory_priority(): Inmemory_priorityContext[];
+    public inmemory_priority(i: number): Inmemory_priorityContext | null;
+    public inmemory_priority(i?: number): Inmemory_priorityContext[] | Inmemory_priorityContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_priorityContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_priorityContext);
+    }
+    public inmemory_distribute(): Inmemory_distributeContext[];
+    public inmemory_distribute(i: number): Inmemory_distributeContext | null;
+    public inmemory_distribute(i?: number): Inmemory_distributeContext[] | Inmemory_distributeContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_distributeContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_distributeContext);
+    }
+    public inmemory_duplicate(): Inmemory_duplicateContext[];
+    public inmemory_duplicate(i: number): Inmemory_duplicateContext | null;
+    public inmemory_duplicate(i?: number): Inmemory_duplicateContext[] | Inmemory_duplicateContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_duplicateContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_duplicateContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_attributes;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_attributes) {
+             listener.enterInmemory_attributes(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_attributes) {
+             listener.exitInmemory_attributes(this);
+        }
+    }
+}
+
+
+export class Inmemory_memcompressContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEMCOMPRESS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEMCOMPRESS, 0)!;
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public DML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DML, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public CAPACITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAPACITY, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_memcompress;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_memcompress) {
+             listener.enterInmemory_memcompress(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_memcompress) {
+             listener.exitInmemory_memcompress(this);
+        }
+    }
+}
+
+
+export class Inmemory_priorityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PRIORITY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PRIORITY, 0)!;
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public MEDIUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEDIUM, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public CRITICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CRITICAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_priority;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_priority) {
+             listener.enterInmemory_priority(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_priority) {
+             listener.exitInmemory_priority(this);
+        }
+    }
+}
+
+
+export class Inmemory_distributeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DISTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISTRIBUTE, 0)!;
+    }
+    public AUTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public SERVICE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVICE, 0);
+    }
+    public ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID, 0);
+    }
+    public RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANGE, 0);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_distribute;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_distribute) {
+             listener.enterInmemory_distribute(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_distribute) {
+             listener.exitInmemory_distribute(this);
+        }
+    }
+}
+
+
+export class Inmemory_duplicateContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DUPLICATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DUPLICATE, 0)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_duplicate;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_duplicate) {
+             listener.enterInmemory_duplicate(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_duplicate) {
+             listener.exitInmemory_duplicate(this);
+        }
+    }
+}
+
+
+export class Inmemory_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_list(): Column_listContext {
+        return this.getRuleContext(0, Column_listContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public INMEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INMEMORY, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public inmemory_memcompress(): Inmemory_memcompressContext | null {
+        return this.getRuleContext(0, Inmemory_memcompressContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inmemory_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInmemory_column_clause) {
+             listener.enterInmemory_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInmemory_column_clause) {
+             listener.exitInmemory_column_clause(this);
+        }
+    }
+}
+
+
+export class Physical_attributes_clauseContext extends antlr.ParserRuleContext {
+    public _pctfree?: Token | null;
+    public _pctused?: Token | null;
+    public _inittrans?: Token | null;
+    public _maxtrans?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PCTFREE(): antlr.TerminalNode[];
+    public PCTFREE(i: number): antlr.TerminalNode | null;
+    public PCTFREE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTFREE);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTFREE, i);
+    	}
+    }
+    public PCTUSED(): antlr.TerminalNode[];
+    public PCTUSED(i: number): antlr.TerminalNode | null;
+    public PCTUSED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTUSED);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTUSED, i);
+    	}
+    }
+    public INITRANS(): antlr.TerminalNode[];
+    public INITRANS(i: number): antlr.TerminalNode | null;
+    public INITRANS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INITRANS);
+    	} else {
+    		return this.getToken(PlSqlParser.INITRANS, i);
+    	}
+    }
+    public MAXTRANS(): antlr.TerminalNode[];
+    public MAXTRANS(i: number): antlr.TerminalNode | null;
+    public MAXTRANS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MAXTRANS);
+    	} else {
+    		return this.getToken(PlSqlParser.MAXTRANS, i);
+    	}
+    }
+    public storage_clause(): Storage_clauseContext[];
+    public storage_clause(i: number): Storage_clauseContext | null;
+    public storage_clause(i?: number): Storage_clauseContext[] | Storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Storage_clauseContext);
+    }
+    public compute_clauses(): Compute_clausesContext[];
+    public compute_clauses(i: number): Compute_clausesContext | null;
+    public compute_clauses(i?: number): Compute_clausesContext[] | Compute_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Compute_clausesContext);
+        }
+
+        return this.getRuleContext(i, Compute_clausesContext);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_physical_attributes_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPhysical_attributes_clause) {
+             listener.enterPhysical_attributes_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPhysical_attributes_clause) {
+             listener.exitPhysical_attributes_clause(this);
+        }
+    }
+}
+
+
+export class Storage_clauseContext extends antlr.ParserRuleContext {
+    public _initial_size?: Size_clauseContext;
+    public _next_size?: Size_clauseContext;
+    public _minextents?: Token | null;
+    public _pctincrease?: Token | null;
+    public _freelists?: Token | null;
+    public _freelist_groups?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STORAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STORAGE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public INITIAL(): antlr.TerminalNode[];
+    public INITIAL(i: number): antlr.TerminalNode | null;
+    public INITIAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INITIAL);
+    	} else {
+    		return this.getToken(PlSqlParser.INITIAL, i);
+    	}
+    }
+    public NEXT(): antlr.TerminalNode[];
+    public NEXT(i: number): antlr.TerminalNode | null;
+    public NEXT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NEXT);
+    	} else {
+    		return this.getToken(PlSqlParser.NEXT, i);
+    	}
+    }
+    public MINEXTENTS(): antlr.TerminalNode[];
+    public MINEXTENTS(i: number): antlr.TerminalNode | null;
+    public MINEXTENTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MINEXTENTS);
+    	} else {
+    		return this.getToken(PlSqlParser.MINEXTENTS, i);
+    	}
+    }
+    public MAXEXTENTS(): antlr.TerminalNode[];
+    public MAXEXTENTS(i: number): antlr.TerminalNode | null;
+    public MAXEXTENTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MAXEXTENTS);
+    	} else {
+    		return this.getToken(PlSqlParser.MAXEXTENTS, i);
+    	}
+    }
+    public PCTINCREASE(): antlr.TerminalNode[];
+    public PCTINCREASE(i: number): antlr.TerminalNode | null;
+    public PCTINCREASE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTINCREASE);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTINCREASE, i);
+    	}
+    }
+    public FREELISTS(): antlr.TerminalNode[];
+    public FREELISTS(i: number): antlr.TerminalNode | null;
+    public FREELISTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FREELISTS);
+    	} else {
+    		return this.getToken(PlSqlParser.FREELISTS, i);
+    	}
+    }
+    public FREELIST(): antlr.TerminalNode[];
+    public FREELIST(i: number): antlr.TerminalNode | null;
+    public FREELIST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FREELIST);
+    	} else {
+    		return this.getToken(PlSqlParser.FREELIST, i);
+    	}
+    }
+    public GROUPS(): antlr.TerminalNode[];
+    public GROUPS(i: number): antlr.TerminalNode | null;
+    public GROUPS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GROUPS);
+    	} else {
+    		return this.getToken(PlSqlParser.GROUPS, i);
+    	}
+    }
+    public OPTIMAL(): antlr.TerminalNode[];
+    public OPTIMAL(i: number): antlr.TerminalNode | null;
+    public OPTIMAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OPTIMAL);
+    	} else {
+    		return this.getToken(PlSqlParser.OPTIMAL, i);
+    	}
+    }
+    public BUFFER_POOL(): antlr.TerminalNode[];
+    public BUFFER_POOL(i: number): antlr.TerminalNode | null;
+    public BUFFER_POOL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BUFFER_POOL);
+    	} else {
+    		return this.getToken(PlSqlParser.BUFFER_POOL, i);
+    	}
+    }
+    public FLASH_CACHE(): antlr.TerminalNode[];
+    public FLASH_CACHE(i: number): antlr.TerminalNode | null;
+    public FLASH_CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FLASH_CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.FLASH_CACHE, i);
+    	}
+    }
+    public CELL_FLASH_CACHE(): antlr.TerminalNode[];
+    public CELL_FLASH_CACHE(i: number): antlr.TerminalNode | null;
+    public CELL_FLASH_CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CELL_FLASH_CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.CELL_FLASH_CACHE, i);
+    	}
+    }
+    public ENCRYPT(): antlr.TerminalNode[];
+    public ENCRYPT(i: number): antlr.TerminalNode | null;
+    public ENCRYPT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENCRYPT);
+    	} else {
+    		return this.getToken(PlSqlParser.ENCRYPT, i);
+    	}
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public KEEP(): antlr.TerminalNode[];
+    public KEEP(i: number): antlr.TerminalNode | null;
+    public KEEP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEEP);
+    	} else {
+    		return this.getToken(PlSqlParser.KEEP, i);
+    	}
+    }
+    public RECYCLE(): antlr.TerminalNode[];
+    public RECYCLE(i: number): antlr.TerminalNode | null;
+    public RECYCLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RECYCLE);
+    	} else {
+    		return this.getToken(PlSqlParser.RECYCLE, i);
+    	}
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public NONE(): antlr.TerminalNode[];
+    public NONE(i: number): antlr.TerminalNode | null;
+    public NONE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NONE);
+    	} else {
+    		return this.getToken(PlSqlParser.NONE, i);
+    	}
+    }
+    public UNLIMITED(): antlr.TerminalNode[];
+    public UNLIMITED(i: number): antlr.TerminalNode | null;
+    public UNLIMITED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNLIMITED);
+    	} else {
+    		return this.getToken(PlSqlParser.UNLIMITED, i);
+    	}
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_storage_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStorage_clause) {
+             listener.enterStorage_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStorage_clause) {
+             listener.exitStorage_clause(this);
+        }
+    }
+}
+
+
+export class Deferred_segment_creationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SEGMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEGMENT, 0)!;
+    }
+    public CREATION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATION, 0)!;
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public DEFERRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFERRED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_deferred_segment_creation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDeferred_segment_creation) {
+             listener.enterDeferred_segment_creation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDeferred_segment_creation) {
+             listener.exitDeferred_segment_creation(this);
+        }
+    }
+}
+
+
+export class Segment_attributes_clauseContext extends antlr.ParserRuleContext {
+    public _tablespace_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public table_compression(): Table_compressionContext[];
+    public table_compression(i: number): Table_compressionContext | null;
+    public table_compression(i?: number): Table_compressionContext[] | Table_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_compressionContext);
+        }
+
+        return this.getRuleContext(i, Table_compressionContext);
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public SET(): antlr.TerminalNode[];
+    public SET(i: number): antlr.TerminalNode | null;
+    public SET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SET);
+    	} else {
+    		return this.getToken(PlSqlParser.SET, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_segment_attributes_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSegment_attributes_clause) {
+             listener.enterSegment_attributes_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSegment_attributes_clause) {
+             listener.exitSegment_attributes_clause(this);
+        }
+    }
+}
+
+
+export class Physical_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public deferred_segment_creation(): Deferred_segment_creationContext | null {
+        return this.getRuleContext(0, Deferred_segment_creationContext);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext | null {
+        return this.getRuleContext(0, Segment_attributes_clauseContext);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext | null {
+        return this.getRuleContext(0, Inmemory_table_clauseContext);
+    }
+    public ilm_clause(): Ilm_clauseContext | null {
+        return this.getRuleContext(0, Ilm_clauseContext);
+    }
+    public ORGANIZATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORGANIZATION, 0);
+    }
+    public HEAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEAP, 0);
+    }
+    public heap_org_table_clause(): Heap_org_table_clauseContext | null {
+        return this.getRuleContext(0, Heap_org_table_clauseContext);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public external_table_clause(): External_table_clauseContext | null {
+        return this.getRuleContext(0, External_table_clauseContext);
+    }
+    public index_org_table_clause(): Index_org_table_clauseContext | null {
+        return this.getRuleContext(0, Index_org_table_clauseContext);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public ATTRIBUTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0);
+    }
+    public REJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REJECT, 0);
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public cluster_name(): Cluster_nameContext | null {
+        return this.getRuleContext(0, Cluster_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_physical_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPhysical_properties) {
+             listener.enterPhysical_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPhysical_properties) {
+             listener.exitPhysical_properties(this);
+        }
+    }
+}
+
+
+export class Ilm_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ILM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ILM, 0)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public POLICY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POLICY, 0);
+    }
+    public ilm_policy_clause(): Ilm_policy_clauseContext | null {
+        return this.getRuleContext(0, Ilm_policy_clauseContext);
+    }
+    public DELETE_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE_ALL, 0);
+    }
+    public ENABLE_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE_ALL, 0);
+    }
+    public DISABLE_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE_ALL, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_clause) {
+             listener.enterIlm_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_clause) {
+             listener.exitIlm_clause(this);
+        }
+    }
+}
+
+
+export class Ilm_policy_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ilm_compression_policy(): Ilm_compression_policyContext | null {
+        return this.getRuleContext(0, Ilm_compression_policyContext);
+    }
+    public ilm_tiering_policy(): Ilm_tiering_policyContext | null {
+        return this.getRuleContext(0, Ilm_tiering_policyContext);
+    }
+    public ilm_inmemory_policy(): Ilm_inmemory_policyContext | null {
+        return this.getRuleContext(0, Ilm_inmemory_policyContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_policy_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_policy_clause) {
+             listener.enterIlm_policy_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_policy_clause) {
+             listener.exitIlm_policy_clause(this);
+        }
+    }
+}
+
+
+export class Ilm_compression_policyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public segment_group(): Segment_groupContext | null {
+        return this.getRuleContext(0, Segment_groupContext);
+    }
+    public ilm_after_on(): Ilm_after_onContext | null {
+        return this.getRuleContext(0, Ilm_after_onContext);
+    }
+    public ROW(): antlr.TerminalNode[];
+    public ROW(i: number): antlr.TerminalNode | null;
+    public ROW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROW);
+    	} else {
+    		return this.getToken(PlSqlParser.ROW, i);
+    	}
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public ilm_time_period(): Ilm_time_periodContext | null {
+        return this.getRuleContext(0, Ilm_time_periodContext);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public MODIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFICATION, 0);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public COMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESS, 0);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public ADVANCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVANCED, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_compression_policy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_compression_policy) {
+             listener.enterIlm_compression_policy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_compression_policy) {
+             listener.exitIlm_compression_policy(this);
+        }
+    }
+}
+
+
+export class Ilm_tiering_policyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TIER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TIER, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public tablespace(): TablespaceContext {
+        return this.getRuleContext(0, TablespaceContext)!;
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public ilm_after_on(): Ilm_after_onContext | null {
+        return this.getRuleContext(0, Ilm_after_onContext);
+    }
+    public segment_group(): Segment_groupContext | null {
+        return this.getRuleContext(0, Segment_groupContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public function_name(): Function_nameContext | null {
+        return this.getRuleContext(0, Function_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_tiering_policy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_tiering_policy) {
+             listener.enterIlm_tiering_policy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_tiering_policy) {
+             listener.exitIlm_tiering_policy(this);
+        }
+    }
+}
+
+
+export class Ilm_after_onContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public ilm_time_period(): Ilm_time_periodContext | null {
+        return this.getRuleContext(0, Ilm_time_periodContext);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public CREATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATION, 0);
+    }
+    public ACCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESS, 0);
+    }
+    public MODIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFICATION, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public function_name(): Function_nameContext | null {
+        return this.getRuleContext(0, Function_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_after_on;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_after_on) {
+             listener.enterIlm_after_on(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_after_on) {
+             listener.exitIlm_after_on(this);
+        }
+    }
+}
+
+
+export class Segment_groupContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEGMENT, 0);
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_segment_group;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSegment_group) {
+             listener.enterSegment_group(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSegment_group) {
+             listener.exitSegment_group(this);
+        }
+    }
+}
+
+
+export class Ilm_inmemory_policyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ilm_after_on(): Ilm_after_onContext {
+        return this.getRuleContext(0, Ilm_after_onContext)!;
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public INMEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INMEMORY, 0);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public inmemory_memcompress(): Inmemory_memcompressContext | null {
+        return this.getRuleContext(0, Inmemory_memcompressContext);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEGMENT, 0);
+    }
+    public inmemory_attributes(): Inmemory_attributesContext | null {
+        return this.getRuleContext(0, Inmemory_attributesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_inmemory_policy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_inmemory_policy) {
+             listener.enterIlm_inmemory_policy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_inmemory_policy) {
+             listener.exitIlm_inmemory_policy(this);
+        }
+    }
+}
+
+
+export class Ilm_time_periodContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public numeric(): NumericContext {
+        return this.getRuleContext(0, NumericContext)!;
+    }
+    public DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY, 0);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTH, 0);
+    }
+    public MONTHS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTHS, 0);
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public YEARS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEARS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ilm_time_period;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIlm_time_period) {
+             listener.enterIlm_time_period(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIlm_time_period) {
+             listener.exitIlm_time_period(this);
+        }
+    }
+}
+
+
+export class Heap_org_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext | null {
+        return this.getRuleContext(0, Inmemory_table_clauseContext);
+    }
+    public ilm_clause(): Ilm_clauseContext | null {
+        return this.getRuleContext(0, Ilm_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_heap_org_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHeap_org_table_clause) {
+             listener.enterHeap_org_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHeap_org_table_clause) {
+             listener.exitHeap_org_table_clause(this);
+        }
+    }
+}
+
+
+export class External_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public external_table_data_props(): External_table_data_propsContext {
+        return this.getRuleContext(0, External_table_data_propsContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public access_driver_type(): Access_driver_typeContext | null {
+        return this.getRuleContext(0, Access_driver_typeContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public REJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REJECT, 0);
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext | null {
+        return this.getRuleContext(0, Inmemory_table_clauseContext);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_clause) {
+             listener.enterExternal_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_clause) {
+             listener.exitExternal_table_clause(this);
+        }
+    }
+}
+
+
+export class Access_driver_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ORACLE_LOADER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_LOADER, 0);
+    }
+    public ORACLE_DATAPUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_DATAPUMP, 0);
+    }
+    public ORACLE_HDFS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_HDFS, 0);
+    }
+    public ORACLE_HIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_HIVE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_access_driver_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAccess_driver_type) {
+             listener.enterAccess_driver_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAccess_driver_type) {
+             listener.exitAccess_driver_type(this);
+        }
+    }
+}
+
+
+export class External_table_data_propsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public external_table_directory(): External_table_directoryContext[];
+    public external_table_directory(i: number): External_table_directoryContext | null;
+    public external_table_directory(i?: number): External_table_directoryContext[] | External_table_directoryContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_directoryContext);
+        }
+
+        return this.getRuleContext(i, External_table_directoryContext);
+    }
+    public ACCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESS, 0);
+    }
+    public PARAMETERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAMETERS, 0);
+    }
+    public LOCATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCATION, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public select_only_statement(): Select_only_statementContext | null {
+        return this.getRuleContext(0, Select_only_statementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public external_table_data_format(): External_table_data_formatContext[];
+    public external_table_data_format(i: number): External_table_data_formatContext | null;
+    public external_table_data_format(i?: number): External_table_data_formatContext[] | External_table_data_formatContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_data_formatContext);
+        }
+
+        return this.getRuleContext(i, External_table_data_formatContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_data_props;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_data_props) {
+             listener.enterExternal_table_data_props(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_data_props) {
+             listener.exitExternal_table_data_props(this);
+        }
+    }
+}
+
+
+export class External_table_data_formatContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RECORDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECORDS, 0);
+    }
+    public DELIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public NEWLINE_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEWLINE_, 0);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public TRANSFORMS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSFORMS, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public external_table_transform(): External_table_transformContext[];
+    public external_table_transform(i: number): External_table_transformContext | null;
+    public external_table_transform(i?: number): External_table_transformContext[] | External_table_transformContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_transformContext);
+        }
+
+        return this.getRuleContext(i, External_table_transformContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public external_table_records(): External_table_recordsContext | null {
+        return this.getRuleContext(0, External_table_recordsContext);
+    }
+    public external_table_fields(): External_table_fieldsContext | null {
+        return this.getRuleContext(0, External_table_fieldsContext);
+    }
+    public external_table_datapump(): External_table_datapumpContext | null {
+        return this.getRuleContext(0, External_table_datapumpContext);
+    }
+    public external_table_hive(): External_table_hiveContext | null {
+        return this.getRuleContext(0, External_table_hiveContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_data_format;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_data_format) {
+             listener.enterExternal_table_data_format(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_data_format) {
+             listener.exitExternal_table_data_format(this);
+        }
+    }
+}
+
+
+export class External_table_transformContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public FROM(): antlr.TerminalNode[];
+    public FROM(i: number): antlr.TerminalNode | null;
+    public FROM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FROM);
+    	} else {
+    		return this.getToken(PlSqlParser.FROM, i);
+    	}
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public CONSTANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTANT, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public STARTOF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STARTOF, 0);
+    }
+    public external_table_field_list(): External_table_field_listContext | null {
+        return this.getRuleContext(0, External_table_field_listContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public CONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONCAT, 0);
+    }
+    public LOBFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOBFILE, 0);
+    }
+    public external_table_field(): External_table_fieldContext | null {
+        return this.getRuleContext(0, External_table_fieldContext);
+    }
+    public external_table_directory(): External_table_directoryContext[];
+    public external_table_directory(i: number): External_table_directoryContext | null;
+    public external_table_directory(i?: number): External_table_directoryContext[] | External_table_directoryContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_directoryContext);
+        }
+
+        return this.getRuleContext(i, External_table_directoryContext);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public CHARACTERSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTERSET, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_transform;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_transform) {
+             listener.enterExternal_table_transform(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_transform) {
+             listener.exitExternal_table_transform(this);
+        }
+    }
+}
+
+
+export class External_table_fieldContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public type_name(): Type_nameContext | null {
+        return this.getRuleContext(0, Type_nameContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public default_value_part(): Default_value_partContext | null {
+        return this.getRuleContext(0, Default_value_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_field;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_field) {
+             listener.enterExternal_table_field(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_field) {
+             listener.exitExternal_table_field(this);
+        }
+    }
+}
+
+
+export class External_table_field_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public external_table_fields_clause(): External_table_fields_clauseContext[];
+    public external_table_fields_clause(i: number): External_table_fields_clauseContext | null;
+    public external_table_fields_clause(i?: number): External_table_fields_clauseContext[] | External_table_fields_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_fields_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_fields_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_field_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_field_list) {
+             listener.enterExternal_table_field_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_field_list) {
+             listener.exitExternal_table_field_list(this);
+        }
+    }
+}
+
+
+export class External_table_fields_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public external_table_field(): External_table_fieldContext {
+        return this.getRuleContext(0, External_table_fieldContext)!;
+    }
+    public external_table_position_clause(): External_table_position_clauseContext[];
+    public external_table_position_clause(i: number): External_table_position_clauseContext | null;
+    public external_table_position_clause(i?: number): External_table_position_clauseContext[] | External_table_position_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_position_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_position_clauseContext);
+    }
+    public external_table_datatype_clause(): External_table_datatype_clauseContext[];
+    public external_table_datatype_clause(i: number): External_table_datatype_clauseContext | null;
+    public external_table_datatype_clause(i?: number): External_table_datatype_clauseContext[] | External_table_datatype_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_datatype_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_datatype_clauseContext);
+    }
+    public external_table_init_clause(): External_table_init_clauseContext[];
+    public external_table_init_clause(i: number): External_table_init_clauseContext | null;
+    public external_table_init_clause(i?: number): External_table_init_clauseContext[] | External_table_init_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_init_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_init_clauseContext);
+    }
+    public external_table_lls_clause(): External_table_lls_clauseContext[];
+    public external_table_lls_clause(i: number): External_table_lls_clauseContext | null;
+    public external_table_lls_clause(i?: number): External_table_lls_clauseContext[] | External_table_lls_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_lls_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_lls_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_fields_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_fields_clause) {
+             listener.enterExternal_table_fields_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_fields_clause) {
+             listener.exitExternal_table_fields_clause(this);
+        }
+    }
+}
+
+
+export class External_table_position_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public BINDVAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINDVAR, 0);
+    }
+    public POSITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POSITION, 0);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public PLUS_SIGN(): antlr.TerminalNode[];
+    public PLUS_SIGN(i: number): antlr.TerminalNode | null;
+    public PLUS_SIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PLUS_SIGN);
+    	} else {
+    		return this.getToken(PlSqlParser.PLUS_SIGN, i);
+    	}
+    }
+    public MINUS_SIGN(): antlr.TerminalNode[];
+    public MINUS_SIGN(i: number): antlr.TerminalNode | null;
+    public MINUS_SIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MINUS_SIGN);
+    	} else {
+    		return this.getToken(PlSqlParser.MINUS_SIGN, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_position_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_position_clause) {
+             listener.enterExternal_table_position_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_position_clause) {
+             listener.exitExternal_table_position_clause(this);
+        }
+    }
+}
+
+
+export class External_table_datatype_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTEGER, 0);
+    }
+    public UNSIGNED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public external_table_delimit_clause(): External_table_delimit_clauseContext | null {
+        return this.getRuleContext(0, External_table_delimit_clauseContext);
+    }
+    public DECIMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECIMAL, 0);
+    }
+    public ZONED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONED, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public ORACLE_DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_DATE, 0);
+    }
+    public ORACLE_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_NUMBER, 0);
+    }
+    public COUNTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNTED, 0);
+    }
+    public FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLOAT, 0);
+    }
+    public DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE, 0);
+    }
+    public BINARY_FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_FLOAT, 0);
+    }
+    public BINARY_DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_DOUBLE, 0);
+    }
+    public RAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAW, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public external_table_trim_clause(): External_table_trim_clauseContext | null {
+        return this.getRuleContext(0, External_table_trim_clauseContext);
+    }
+    public external_table_date_format_clause(): External_table_date_format_clauseContext | null {
+        return this.getRuleContext(0, External_table_date_format_clauseContext);
+    }
+    public VARCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR, 0);
+    }
+    public VARRAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAW, 0);
+    }
+    public VARCHARC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHARC, 0);
+    }
+    public VARRAWC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAWC, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_datatype_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_datatype_clause) {
+             listener.enterExternal_table_datatype_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_datatype_clause) {
+             listener.exitExternal_table_datatype_clause(this);
+        }
+    }
+}
+
+
+export class External_table_delimit_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENCLOSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCLOSED, 0);
+    }
+    public BY(): antlr.TerminalNode[];
+    public BY(i: number): antlr.TerminalNode | null;
+    public BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BY);
+    	} else {
+    		return this.getToken(PlSqlParser.BY, i);
+    	}
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public TERMINATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TERMINATED, 0);
+    }
+    public WHITESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHITESPACE, 0);
+    }
+    public OPTIONALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIONALLY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_delimit_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_delimit_clause) {
+             listener.enterExternal_table_delimit_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_delimit_clause) {
+             listener.exitExternal_table_delimit_clause(this);
+        }
+    }
+}
+
+
+export class External_table_trim_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LRTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LRTRIM, 0);
+    }
+    public NOTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOTRIM, 0);
+    }
+    public LTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LTRIM, 0);
+    }
+    public RTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RTRIM, 0);
+    }
+    public LDRTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LDRTRIM, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_trim_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_trim_clause) {
+             listener.enterExternal_table_trim_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_trim_clause) {
+             listener.exitExternal_table_trim_clause(this);
+        }
+    }
+}
+
+
+export class External_table_date_format_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public MASK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MASK, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERVAL, 0);
+    }
+    public DATE_FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE_FORMAT, 0);
+    }
+    public YEAR_TO_MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR_TO_MONTH, 0);
+    }
+    public DAY_TO_SECOND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY_TO_SECOND, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONE, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_date_format_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_date_format_clause) {
+             listener.enterExternal_table_date_format_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_date_format_clause) {
+             listener.exitExternal_table_date_format_clause(this);
+        }
+    }
+}
+
+
+export class External_table_init_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public external_table_condition_clause(): External_table_condition_clauseContext {
+        return this.getRuleContext(0, External_table_condition_clauseContext)!;
+    }
+    public DEFAULTIF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULTIF, 0);
+    }
+    public NULLIF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLIF, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_init_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_init_clause) {
+             listener.enterExternal_table_init_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_init_clause) {
+             listener.exitExternal_table_init_clause(this);
+        }
+    }
+}
+
+
+export class External_table_condition_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public relational_operator(): Relational_operatorContext | null {
+        return this.getRuleContext(0, Relational_operatorContext);
+    }
+    public field_spec(): Field_specContext | null {
+        return this.getRuleContext(0, Field_specContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public BINDVAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINDVAR, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public HEX_STRING_LIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEX_STRING_LIT, 0);
+    }
+    public BLANKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLANKS, 0);
+    }
+    public external_table_condition_clause(): External_table_condition_clauseContext[];
+    public external_table_condition_clause(i: number): External_table_condition_clauseContext | null;
+    public external_table_condition_clause(i?: number): External_table_condition_clauseContext[] | External_table_condition_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_condition_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_condition_clauseContext);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_condition_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_condition_clause) {
+             listener.enterExternal_table_condition_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_condition_clause) {
+             listener.exitExternal_table_condition_clause(this);
+        }
+    }
+}
+
+
+export class External_table_lls_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LLS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LLS, 0)!;
+    }
+    public external_table_directory(): External_table_directoryContext {
+        return this.getRuleContext(0, External_table_directoryContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_lls_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_lls_clause) {
+             listener.enterExternal_table_lls_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_lls_clause) {
+             listener.exitExternal_table_lls_clause(this);
+        }
+    }
+}
+
+
+export class External_table_recordsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RECORDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECORDS, 0);
+    }
+    public FIXED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIXED, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public VARIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARIABLE, 0);
+    }
+    public DELIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public XMLTAG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTAG, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public external_table_record_options_clause(): External_table_record_options_clauseContext[];
+    public external_table_record_options_clause(i: number): External_table_record_options_clauseContext | null;
+    public external_table_record_options_clause(i?: number): External_table_record_options_clauseContext[] | External_table_record_options_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_record_options_clauseContext);
+        }
+
+        return this.getRuleContext(i, External_table_record_options_clauseContext);
+    }
+    public NEWLINE_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEWLINE_, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DETECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DETECTED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_records;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_records) {
+             listener.enterExternal_table_records(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_records) {
+             listener.exitExternal_table_records(this);
+        }
+    }
+}
+
+
+export class External_table_record_options_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHARACTERSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTERSET, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public VARIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARIABLE, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public PREPROCESSOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREPROCESSOR, 0);
+    }
+    public external_table_directory(): External_table_directoryContext | null {
+        return this.getRuleContext(0, External_table_directoryContext);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public ENDIAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENDIAN, 0);
+    }
+    public LITTLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LITTLE, 0);
+    }
+    public BIG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIG, 0);
+    }
+    public BYTEORDERMARK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTEORDERMARK, 0);
+    }
+    public CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECK, 0);
+    }
+    public NOCHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCHECK, 0);
+    }
+    public STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRING, 0);
+    }
+    public SIZES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZES, 0);
+    }
+    public ARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARE, 0);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public BYTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTES, 0);
+    }
+    public CHARACTERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTERS, 0);
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public external_table_condition_clause(): External_table_condition_clauseContext | null {
+        return this.getRuleContext(0, External_table_condition_clauseContext);
+    }
+    public external_table_output_files(): External_table_output_filesContext | null {
+        return this.getRuleContext(0, External_table_output_filesContext);
+    }
+    public READSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READSIZE, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public DISABLE_DIRECTORY_LINK_CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE_DIRECTORY_LINK_CHECK, 0);
+    }
+    public DATE_CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE_CACHE, 0);
+    }
+    public SKIP_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_, 0);
+    }
+    public IO_OPTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IO_OPTIONS, 0);
+    }
+    public DIRECTIO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTIO, 0);
+    }
+    public NODIRECTIO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NODIRECTIO, 0);
+    }
+    public DNFS_ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DNFS_ENABLE, 0);
+    }
+    public DNFS_DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DNFS_DISABLE, 0);
+    }
+    public DNFS_READBUFFERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DNFS_READBUFFERS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_record_options_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_record_options_clause) {
+             listener.enterExternal_table_record_options_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_record_options_clause) {
+             listener.exitExternal_table_record_options_clause(this);
+        }
+    }
+}
+
+
+export class External_table_output_filesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public NOBADFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOBADFILE, 0);
+    }
+    public NODISCARDFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NODISCARDFILE, 0);
+    }
+    public NOLOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOGFILE, 0);
+    }
+    public BADFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BADFILE, 0);
+    }
+    public DISCARDFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISCARDFILE, 0);
+    }
+    public LOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILE, 0);
+    }
+    public external_table_directory(): External_table_directoryContext | null {
+        return this.getRuleContext(0, External_table_directoryContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_output_files;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_output_files) {
+             listener.enterExternal_table_output_files(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_output_files) {
+             listener.exitExternal_table_output_files(this);
+        }
+    }
+}
+
+
+export class External_table_fieldsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FIELDS(): antlr.TerminalNode[];
+    public FIELDS(i: number): antlr.TerminalNode | null;
+    public FIELDS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FIELDS);
+    	} else {
+    		return this.getToken(PlSqlParser.FIELDS, i);
+    	}
+    }
+    public IGNORE_CHARS_AFTER_EOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE_CHARS_AFTER_EOR, 0);
+    }
+    public CSV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CSV, 0);
+    }
+    public EMBEDDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMBEDDED, 0);
+    }
+    public external_table_delimit_clause(): External_table_delimit_clauseContext | null {
+        return this.getRuleContext(0, External_table_delimit_clauseContext);
+    }
+    public external_table_trim_clause(): External_table_trim_clauseContext | null {
+        return this.getRuleContext(0, External_table_trim_clauseContext);
+    }
+    public ALL(): antlr.TerminalNode[];
+    public ALL(i: number): antlr.TerminalNode | null;
+    public ALL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ALL);
+    	} else {
+    		return this.getToken(PlSqlParser.ALL, i);
+    	}
+    }
+    public OVERRIDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERRIDE, 0);
+    }
+    public THESE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THESE, 0);
+    }
+    public MISSING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MISSING, 0);
+    }
+    public FIELD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIELD, 0);
+    }
+    public VALUES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUES, 0);
+    }
+    public ARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARE, 0);
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public REJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REJECT, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public DATE_FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE_FORMAT, 0);
+    }
+    public MASK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MASK, 0);
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public NULLIF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLIF, 0);
+    }
+    public NONULLIF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONULLIF, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public external_table_field_list(): External_table_field_listContext | null {
+        return this.getRuleContext(0, External_table_field_listContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public NOT_EQUAL_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT_EQUAL_OP, 0);
+    }
+    public HEX_STRING_LIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEX_STRING_LIT, 0);
+    }
+    public BLANKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLANKS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_fields;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_fields) {
+             listener.enterExternal_table_fields(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_fields) {
+             listener.exitExternal_table_fields(this);
+        }
+    }
+}
+
+
+export class External_table_datapumpContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLED, 0);
+    }
+    public NOLOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOGFILE, 0);
+    }
+    public LOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILE, 0);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public external_table_directory(): External_table_directoryContext | null {
+        return this.getRuleContext(0, External_table_directoryContext);
+    }
+    public COMPRESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESSION, 0);
+    }
+    public ENABLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLED, 0);
+    }
+    public BASIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASIC, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public MEDIUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEDIUM, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public HADOOP_TRAILERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HADOOP_TRAILERS, 0);
+    }
+    public VERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSION, 0);
+    }
+    public COMPATIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPATIBLE, 0);
+    }
+    public LATEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LATEST, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public NOLOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOG, 0);
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public DATAPUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAPUMP, 0);
+    }
+    public INTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERNAL, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public TEMPLATE_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPLATE_TABLE, 0);
+    }
+    public JOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JOB, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public WORKERID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WORKERID, 0);
+    }
+    public PARALLEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARALLEL, 0);
+    }
+    public ENCRYPTPASSWORDISNULL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTPASSWORDISNULL, 0);
+    }
+    public DBLINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBLINK, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_datapump;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_datapump) {
+             listener.enterExternal_table_datapump(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_datapump) {
+             listener.exitExternal_table_datapump(this);
+        }
+    }
+}
+
+
+export class External_table_hiveContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public EQUALS_OP(): antlr.TerminalNode[];
+    public EQUALS_OP(i: number): antlr.TerminalNode | null;
+    public EQUALS_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EQUALS_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.EQUALS_OP, i);
+    	}
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public external_table_hive_parameter_map(): External_table_hive_parameter_mapContext[];
+    public external_table_hive_parameter_map(i: number): External_table_hive_parameter_mapContext | null;
+    public external_table_hive_parameter_map(i?: number): External_table_hive_parameter_mapContext[] | External_table_hive_parameter_mapContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_hive_parameter_mapContext);
+        }
+
+        return this.getRuleContext(i, External_table_hive_parameter_mapContext);
+    }
+    public LEFT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_BRACKET, 0);
+    }
+    public RIGHT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_BRACKET, 0);
+    }
+    public external_table_field(): External_table_fieldContext | null {
+        return this.getRuleContext(0, External_table_fieldContext);
+    }
+    public datatype(): DatatypeContext | null {
+        return this.getRuleContext(0, DatatypeContext);
+    }
+    public SEQUENCEFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCEFILE, 0);
+    }
+    public TEXTFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEXTFILE, 0);
+    }
+    public RCFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RCFILE, 0);
+    }
+    public ORC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORC, 0);
+    }
+    public PARQUET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARQUET, 0);
+    }
+    public INPUTFORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INPUTFORMAT, 0);
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public OUTPUTFORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTPUTFORMAT, 0);
+    }
+    public external_table_directory(): External_table_directoryContext | null {
+        return this.getRuleContext(0, External_table_directoryContext);
+    }
+    public SERDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERDE, 0);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public external_table_hive(): External_table_hiveContext | null {
+        return this.getRuleContext(0, External_table_hiveContext);
+    }
+    public FIELDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIELDS, 0);
+    }
+    public TERMINATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TERMINATED, 0);
+    }
+    public BY(): antlr.TerminalNode[];
+    public BY(i: number): antlr.TerminalNode | null;
+    public BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BY);
+    	} else {
+    		return this.getToken(PlSqlParser.BY, i);
+    	}
+    }
+    public CHARACTER(): antlr.TerminalNode[];
+    public CHARACTER(i: number): antlr.TerminalNode | null;
+    public CHARACTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHARACTER);
+    	} else {
+    		return this.getToken(PlSqlParser.CHARACTER, i);
+    	}
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public DEFINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINED, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public COMMENT(): antlr.TerminalNode[];
+    public COMMENT(i: number): antlr.TerminalNode | null;
+    public COMMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMENT);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMENT, i);
+    	}
+    }
+    public DELIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public SERDEPROPERTIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERDEPROPERTIES, 0);
+    }
+    public ESCAPED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ESCAPED, 0);
+    }
+    public COLLECTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLECTION, 0);
+    }
+    public ITEMS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ITEMS, 0);
+    }
+    public MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAP, 0);
+    }
+    public KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYS, 0);
+    }
+    public LINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_hive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_hive) {
+             listener.enterExternal_table_hive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_hive) {
+             listener.exitExternal_table_hive(this);
+        }
+    }
+}
+
+
+export class External_table_hive_parameter_mapContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_CURLY_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_CURLY_PAREN, 0)!;
+    }
+    public RIGHT_CURLY_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_CURLY_PAREN, 0)!;
+    }
+    public external_table_hive_parameter_map_entry(): External_table_hive_parameter_map_entryContext[];
+    public external_table_hive_parameter_map_entry(i: number): External_table_hive_parameter_map_entryContext | null;
+    public external_table_hive_parameter_map_entry(i?: number): External_table_hive_parameter_map_entryContext[] | External_table_hive_parameter_map_entryContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(External_table_hive_parameter_map_entryContext);
+        }
+
+        return this.getRuleContext(i, External_table_hive_parameter_map_entryContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_hive_parameter_map;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_hive_parameter_map) {
+             listener.enterExternal_table_hive_parameter_map(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_hive_parameter_map) {
+             listener.exitExternal_table_hive_parameter_map(this);
+        }
+    }
+}
+
+
+export class External_table_hive_parameter_map_entryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public BINDVAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINDVAR, 0);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public LEFT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_BRACKET, 0);
+    }
+    public RIGHT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_BRACKET, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_hive_parameter_map_entry;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_hive_parameter_map_entry) {
+             listener.enterExternal_table_hive_parameter_map_entry(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_hive_parameter_map_entry) {
+             listener.exitExternal_table_hive_parameter_map_entry(this);
+        }
+    }
+}
+
+
+export class External_table_directoryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public directory_name(): Directory_nameContext | null {
+        return this.getRuleContext(0, Directory_nameContext);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public object_name(): Object_nameContext | null {
+        return this.getRuleContext(0, Object_nameContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public variable_name(): Variable_nameContext | null {
+        return this.getRuleContext(0, Variable_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_external_table_directory;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExternal_table_directory) {
+             listener.enterExternal_table_directory(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExternal_table_directory) {
+             listener.exitExternal_table_directory(this);
+        }
+    }
+}
+
+
+export class Row_movement_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ROW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROW, 0)!;
+    }
+    public MOVEMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVEMENT, 0)!;
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_row_movement_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRow_movement_clause) {
+             listener.enterRow_movement_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRow_movement_clause) {
+             listener.exitRow_movement_clause(this);
+        }
+    }
+}
+
+
+export class Flashback_archive_clauseContext extends antlr.ParserRuleContext {
+    public _fa?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FLASHBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLASHBACK, 0)!;
+    }
+    public ARCHIVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ARCHIVE, 0)!;
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_flashback_archive_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFlashback_archive_clause) {
+             listener.enterFlashback_archive_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFlashback_archive_clause) {
+             listener.exitFlashback_archive_clause(this);
+        }
+    }
+}
+
+
+export class Log_grpContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_log_grp;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLog_grp) {
+             listener.enterLog_grp(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLog_grp) {
+             listener.exitLog_grp(this);
+        }
+    }
+}
+
+
+export class Supplemental_table_loggingContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public SUPPLEMENTAL(): antlr.TerminalNode[];
+    public SUPPLEMENTAL(i: number): antlr.TerminalNode | null;
+    public SUPPLEMENTAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SUPPLEMENTAL);
+    	} else {
+    		return this.getToken(PlSqlParser.SUPPLEMENTAL, i);
+    	}
+    }
+    public LOG(): antlr.TerminalNode[];
+    public LOG(i: number): antlr.TerminalNode | null;
+    public LOG(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOG);
+    	} else {
+    		return this.getToken(PlSqlParser.LOG, i);
+    	}
+    }
+    public supplemental_log_grp_clause(): Supplemental_log_grp_clauseContext[];
+    public supplemental_log_grp_clause(i: number): Supplemental_log_grp_clauseContext | null;
+    public supplemental_log_grp_clause(i?: number): Supplemental_log_grp_clauseContext[] | Supplemental_log_grp_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Supplemental_log_grp_clauseContext);
+        }
+
+        return this.getRuleContext(i, Supplemental_log_grp_clauseContext);
+    }
+    public supplemental_id_key_clause(): Supplemental_id_key_clauseContext[];
+    public supplemental_id_key_clause(i: number): Supplemental_id_key_clauseContext | null;
+    public supplemental_id_key_clause(i?: number): Supplemental_id_key_clauseContext[] | Supplemental_id_key_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Supplemental_id_key_clauseContext);
+        }
+
+        return this.getRuleContext(i, Supplemental_id_key_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public GROUP(): antlr.TerminalNode[];
+    public GROUP(i: number): antlr.TerminalNode | null;
+    public GROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GROUP);
+    	} else {
+    		return this.getToken(PlSqlParser.GROUP, i);
+    	}
+    }
+    public log_grp(): Log_grpContext[];
+    public log_grp(i: number): Log_grpContext | null;
+    public log_grp(i?: number): Log_grpContext[] | Log_grpContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Log_grpContext);
+        }
+
+        return this.getRuleContext(i, Log_grpContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_supplemental_table_logging;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSupplemental_table_logging) {
+             listener.enterSupplemental_table_logging(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSupplemental_table_logging) {
+             listener.exitSupplemental_table_logging(this);
+        }
+    }
+}
+
+
+export class Supplemental_log_grp_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public log_grp(): Log_grpContext {
+        return this.getRuleContext(0, Log_grpContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public NO(): antlr.TerminalNode[];
+    public NO(i: number): antlr.TerminalNode | null;
+    public NO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NO);
+    	} else {
+    		return this.getToken(PlSqlParser.NO, i);
+    	}
+    }
+    public LOG(): antlr.TerminalNode[];
+    public LOG(i: number): antlr.TerminalNode | null;
+    public LOG(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOG);
+    	} else {
+    		return this.getToken(PlSqlParser.LOG, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public ALWAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALWAYS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_supplemental_log_grp_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSupplemental_log_grp_clause) {
+             listener.enterSupplemental_log_grp_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSupplemental_log_grp_clause) {
+             listener.exitSupplemental_log_grp_clause(this);
+        }
+    }
+}
+
+
+export class Supplemental_id_key_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATA, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COLUMNS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMNS, 0)!;
+    }
+    public ALL(): antlr.TerminalNode[];
+    public ALL(i: number): antlr.TerminalNode | null;
+    public ALL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ALL);
+    	} else {
+    		return this.getToken(PlSqlParser.ALL, i);
+    	}
+    }
+    public PRIMARY(): antlr.TerminalNode[];
+    public PRIMARY(i: number): antlr.TerminalNode | null;
+    public PRIMARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PRIMARY);
+    	} else {
+    		return this.getToken(PlSqlParser.PRIMARY, i);
+    	}
+    }
+    public KEY(): antlr.TerminalNode[];
+    public KEY(i: number): antlr.TerminalNode | null;
+    public KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEY);
+    	} else {
+    		return this.getToken(PlSqlParser.KEY, i);
+    	}
+    }
+    public UNIQUE(): antlr.TerminalNode[];
+    public UNIQUE(i: number): antlr.TerminalNode | null;
+    public UNIQUE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNIQUE);
+    	} else {
+    		return this.getToken(PlSqlParser.UNIQUE, i);
+    	}
+    }
+    public FOREIGN(): antlr.TerminalNode[];
+    public FOREIGN(i: number): antlr.TerminalNode | null;
+    public FOREIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FOREIGN);
+    	} else {
+    		return this.getToken(PlSqlParser.FOREIGN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public INDEX(): antlr.TerminalNode[];
+    public INDEX(i: number): antlr.TerminalNode | null;
+    public INDEX(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INDEX);
+    	} else {
+    		return this.getToken(PlSqlParser.INDEX, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_supplemental_id_key_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSupplemental_id_key_clause) {
+             listener.enterSupplemental_id_key_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSupplemental_id_key_clause) {
+             listener.exitSupplemental_id_key_clause(this);
+        }
+    }
+}
+
+
+export class Allocate_extent_clauseContext extends antlr.ParserRuleContext {
+    public _datafile?: Token | null;
+    public _inst_num?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALLOCATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALLOCATE, 0)!;
+    }
+    public EXTENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXTENT, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public SIZE(): antlr.TerminalNode[];
+    public SIZE(i: number): antlr.TerminalNode | null;
+    public SIZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SIZE);
+    	} else {
+    		return this.getToken(PlSqlParser.SIZE, i);
+    	}
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public DATAFILE(): antlr.TerminalNode[];
+    public DATAFILE(i: number): antlr.TerminalNode | null;
+    public DATAFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DATAFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.DATAFILE, i);
+    	}
+    }
+    public INSTANCE(): antlr.TerminalNode[];
+    public INSTANCE(i: number): antlr.TerminalNode | null;
+    public INSTANCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INSTANCE);
+    	} else {
+    		return this.getToken(PlSqlParser.INSTANCE, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_allocate_extent_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAllocate_extent_clause) {
+             listener.enterAllocate_extent_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAllocate_extent_clause) {
+             listener.exitAllocate_extent_clause(this);
+        }
+    }
+}
+
+
+export class Deallocate_unused_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEALLOCATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEALLOCATE, 0)!;
+    }
+    public UNUSED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNUSED, 0)!;
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_deallocate_unused_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDeallocate_unused_clause) {
+             listener.enterDeallocate_unused_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDeallocate_unused_clause) {
+             listener.exitDeallocate_unused_clause(this);
+        }
+    }
+}
+
+
+export class Shrink_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SHRINK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SHRINK, 0)!;
+    }
+    public SPACE_KEYWORD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SPACE_KEYWORD, 0)!;
+    }
+    public COMPACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPACT, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECK, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_shrink_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterShrink_clause) {
+             listener.enterShrink_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitShrink_clause) {
+             listener.exitShrink_clause(this);
+        }
+    }
+}
+
+
+export class Records_per_block_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RECORDS_PER_BLOCK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RECORDS_PER_BLOCK, 0)!;
+    }
+    public MINIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINIMIZE, 0);
+    }
+    public NOMINIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMINIMIZE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_records_per_block_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRecords_per_block_clause) {
+             listener.enterRecords_per_block_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRecords_per_block_clause) {
+             listener.exitRecords_per_block_clause(this);
+        }
+    }
+}
+
+
+export class Upgrade_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UPGRADE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UPGRADE, 0)!;
+    }
+    public column_properties(): Column_propertiesContext {
+        return this.getRuleContext(0, Column_propertiesContext)!;
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_upgrade_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpgrade_table_clause) {
+             listener.enterUpgrade_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpgrade_table_clause) {
+             listener.exitUpgrade_table_clause(this);
+        }
+    }
+}
+
+
+export class Truncate_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TRUNCATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRUNCATE, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public STORAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORAGE, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public PURGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PURGE, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public MATERIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0);
+    }
+    public VIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIEW, 0);
+    }
+    public LOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOG, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_truncate_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTruncate_table) {
+             listener.enterTruncate_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTruncate_table) {
+             listener.exitTruncate_table(this);
+        }
+    }
+}
+
+
+export class Drop_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext[];
+    public tableview_name(i: number): Tableview_nameContext | null;
+    public tableview_name(i?: number): Tableview_nameContext[] | Tableview_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tableview_nameContext);
+        }
+
+        return this.getRuleContext(i, Tableview_nameContext);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public PURGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PURGE, 0);
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_table) {
+             listener.enterDrop_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_table) {
+             listener.exitDrop_table(this);
+        }
+    }
+}
+
+
+export class Drop_tablespaceContext extends antlr.ParserRuleContext {
+    public _ts?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode[];
+    public DROP(i: number): antlr.TerminalNode | null;
+    public DROP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DROP);
+    	} else {
+    		return this.getToken(PlSqlParser.DROP, i);
+    	}
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public including_contents_clause(): Including_contents_clauseContext | null {
+        return this.getRuleContext(0, Including_contents_clauseContext);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public QUOTA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUOTA, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_tablespace) {
+             listener.enterDrop_tablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_tablespace) {
+             listener.exitDrop_tablespace(this);
+        }
+    }
+}
+
+
+export class Drop_tablespace_setContext extends antlr.ParserRuleContext {
+    public _tss?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public including_contents_clause(): Including_contents_clauseContext | null {
+        return this.getRuleContext(0, Including_contents_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_tablespace_set;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_tablespace_set) {
+             listener.enterDrop_tablespace_set(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_tablespace_set) {
+             listener.exitDrop_tablespace_set(this);
+        }
+    }
+}
+
+
+export class Including_contents_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INCLUDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INCLUDING, 0)!;
+    }
+    public CONTENTS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTENTS, 0)!;
+    }
+    public DATAFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILES, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_including_contents_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIncluding_contents_clause) {
+             listener.enterIncluding_contents_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIncluding_contents_clause) {
+             listener.exitIncluding_contents_clause(this);
+        }
+    }
+}
+
+
+export class Drop_viewContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_view) {
+             listener.enterDrop_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_view) {
+             listener.exitDrop_view(this);
+        }
+    }
+}
+
+
+export class Comment_on_columnContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMMENT, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public COLUMN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public quoted_string(): Quoted_stringContext {
+        return this.getRuleContext(0, Quoted_stringContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_comment_on_column;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComment_on_column) {
+             listener.enterComment_on_column(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComment_on_column) {
+             listener.exitComment_on_column(this);
+        }
+    }
+}
+
+
+export class Enable_or_disableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_enable_or_disable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEnable_or_disable) {
+             listener.enterEnable_or_disable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEnable_or_disable) {
+             listener.exitEnable_or_disable(this);
+        }
+    }
+}
+
+
+export class Allow_or_disallowContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALLOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALLOW, 0);
+    }
+    public DISALLOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISALLOW, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_allow_or_disallow;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAllow_or_disallow) {
+             listener.enterAllow_or_disallow(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAllow_or_disallow) {
+             listener.exitAllow_or_disallow(this);
+        }
+    }
+}
+
+
+export class Alter_synonymContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public SYNONYM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SYNONYM, 0)!;
+    }
+    public synonym_name(): Synonym_nameContext {
+        return this.getRuleContext(0, Synonym_nameContext)!;
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_synonym;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_synonym) {
+             listener.enterAlter_synonym(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_synonym) {
+             listener.exitAlter_synonym(this);
+        }
+    }
+}
+
+
+export class Create_synonymContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public SYNONYM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SYNONYM, 0)!;
+    }
+    public synonym_name(): Synonym_nameContext {
+        return this.getRuleContext(0, Synonym_nameContext)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public schema_object_name(): Schema_object_nameContext {
+        return this.getRuleContext(0, Schema_object_nameContext)!;
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public schema_name(): Schema_nameContext[];
+    public schema_name(i: number): Schema_nameContext | null;
+    public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Schema_nameContext);
+        }
+
+        return this.getRuleContext(i, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public AT_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT_SIGN, 0);
+    }
+    public link_name(): Link_nameContext | null {
+        return this.getRuleContext(0, Link_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_synonym;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_synonym) {
+             listener.enterCreate_synonym(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_synonym) {
+             listener.exitCreate_synonym(this);
+        }
+    }
+}
+
+
+export class Drop_synonymContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public SYNONYM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SYNONYM, 0)!;
+    }
+    public synonym_name(): Synonym_nameContext {
+        return this.getRuleContext(0, Synonym_nameContext)!;
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_synonym;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_synonym) {
+             listener.enterDrop_synonym(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_synonym) {
+             listener.exitDrop_synonym(this);
+        }
+    }
+}
+
+
+export class Create_spfileContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public SPFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SPFILE, 0)!;
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public PFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PFILE, 0);
+    }
+    public MEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMORY, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode[];
+    public EQUALS_OP(i: number): antlr.TerminalNode | null;
+    public EQUALS_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EQUALS_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.EQUALS_OP, i);
+    	}
+    }
+    public spfile_name(): Spfile_nameContext | null {
+        return this.getRuleContext(0, Spfile_nameContext);
+    }
+    public pfile_name(): Pfile_nameContext | null {
+        return this.getRuleContext(0, Pfile_nameContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COPY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COPY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_spfile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_spfile) {
+             listener.enterCreate_spfile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_spfile) {
+             listener.exitCreate_spfile(this);
+        }
+    }
+}
+
+
+export class Spfile_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_spfile_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSpfile_name) {
+             listener.enterSpfile_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSpfile_name) {
+             listener.exitSpfile_name(this);
+        }
+    }
+}
+
+
+export class Pfile_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pfile_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPfile_name) {
+             listener.enterPfile_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPfile_name) {
+             listener.exitPfile_name(this);
+        }
+    }
+}
+
+
+export class Comment_on_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMMENT, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public quoted_string(): Quoted_stringContext {
+        return this.getRuleContext(0, Quoted_stringContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_comment_on_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComment_on_table) {
+             listener.enterComment_on_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComment_on_table) {
+             listener.exitComment_on_table(this);
+        }
+    }
+}
+
+
+export class Comment_on_materializedContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMMENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMMENT, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public MATERIALIZED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public quoted_string(): Quoted_stringContext {
+        return this.getRuleContext(0, Quoted_stringContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_comment_on_materialized;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterComment_on_materialized) {
+             listener.enterComment_on_materialized(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitComment_on_materialized) {
+             listener.exitComment_on_materialized(this);
+        }
+    }
+}
+
+
+export class Alter_analytic_viewContext extends antlr.ParserRuleContext {
+    public _av?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public ANALYTIC(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ANALYTIC, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public alter_add_cache_clause(): Alter_add_cache_clauseContext | null {
+        return this.getRuleContext(0, Alter_add_cache_clauseContext);
+    }
+    public alter_drop_cache_clause(): Alter_drop_cache_clauseContext | null {
+        return this.getRuleContext(0, Alter_drop_cache_clauseContext);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_analytic_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_analytic_view) {
+             listener.enterAlter_analytic_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_analytic_view) {
+             listener.exitAlter_analytic_view(this);
+        }
+    }
+}
+
+
+export class Alter_add_cache_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public CACHE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CACHE, 0)!;
+    }
+    public MEASURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURE, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public LEVELS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEVELS, 0)!;
+    }
+    public levels_item(): Levels_itemContext[];
+    public levels_item(i: number): Levels_itemContext | null;
+    public levels_item(i?: number): Levels_itemContext[] | Levels_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Levels_itemContext);
+        }
+
+        return this.getRuleContext(i, Levels_itemContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public measure_list(): Measure_listContext | null {
+        return this.getRuleContext(0, Measure_listContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_add_cache_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_add_cache_clause) {
+             listener.enterAlter_add_cache_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_add_cache_clause) {
+             listener.exitAlter_add_cache_clause(this);
+        }
+    }
+}
+
+
+export class Levels_itemContext extends antlr.ParserRuleContext {
+    public _d?: Id_expressionContext;
+    public _h?: Id_expressionContext;
+    public _l?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_levels_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLevels_item) {
+             listener.enterLevels_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLevels_item) {
+             listener.exitLevels_item(this);
+        }
+    }
+}
+
+
+export class Measure_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_measure_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMeasure_list) {
+             listener.enterMeasure_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMeasure_list) {
+             listener.exitMeasure_list(this);
+        }
+    }
+}
+
+
+export class Alter_drop_cache_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public CACHE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CACHE, 0)!;
+    }
+    public MEASURE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURE, 0)!;
+    }
+    public GROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public LEVELS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEVELS, 0)!;
+    }
+    public levels_item(): Levels_itemContext[];
+    public levels_item(i: number): Levels_itemContext | null;
+    public levels_item(i?: number): Levels_itemContext[] | Levels_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Levels_itemContext);
+        }
+
+        return this.getRuleContext(i, Levels_itemContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public measure_list(): Measure_listContext | null {
+        return this.getRuleContext(0, Measure_listContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_drop_cache_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_drop_cache_clause) {
+             listener.enterAlter_drop_cache_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_drop_cache_clause) {
+             listener.exitAlter_drop_cache_clause(this);
+        }
+    }
+}
+
+
+export class Alter_attribute_dimensionContext extends antlr.ParserRuleContext {
+    public _ad?: Id_expressionContext;
+    public _nad?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public ATTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0)!;
+    }
+    public DIMENSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIMENSION, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_attribute_dimension;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_attribute_dimension) {
+             listener.enterAlter_attribute_dimension(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_attribute_dimension) {
+             listener.exitAlter_attribute_dimension(this);
+        }
+    }
+}
+
+
+export class Alter_audit_policyContext extends antlr.ParserRuleContext {
+    public _p?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public AUDIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUDIT, 0)!;
+    }
+    public POLICY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.POLICY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public DROP(): antlr.TerminalNode[];
+    public DROP(i: number): antlr.TerminalNode | null;
+    public DROP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DROP);
+    	} else {
+    		return this.getToken(PlSqlParser.DROP, i);
+    	}
+    }
+    public CONDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONDITION, 0);
+    }
+    public privilege_audit_clause(): Privilege_audit_clauseContext[];
+    public privilege_audit_clause(i: number): Privilege_audit_clauseContext | null;
+    public privilege_audit_clause(i?: number): Privilege_audit_clauseContext[] | Privilege_audit_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Privilege_audit_clauseContext);
+        }
+
+        return this.getRuleContext(i, Privilege_audit_clauseContext);
+    }
+    public action_audit_clause(): Action_audit_clauseContext[];
+    public action_audit_clause(i: number): Action_audit_clauseContext | null;
+    public action_audit_clause(i?: number): Action_audit_clauseContext[] | Action_audit_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Action_audit_clauseContext);
+        }
+
+        return this.getRuleContext(i, Action_audit_clauseContext);
+    }
+    public role_audit_clause(): Role_audit_clauseContext[];
+    public role_audit_clause(i: number): Role_audit_clauseContext | null;
+    public role_audit_clause(i?: number): Role_audit_clauseContext[] | Role_audit_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Role_audit_clauseContext);
+        }
+
+        return this.getRuleContext(i, Role_audit_clauseContext);
+    }
+    public ONLY(): antlr.TerminalNode[];
+    public ONLY(i: number): antlr.TerminalNode | null;
+    public ONLY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ONLY);
+    	} else {
+    		return this.getToken(PlSqlParser.ONLY, i);
+    	}
+    }
+    public TOPLEVEL(): antlr.TerminalNode[];
+    public TOPLEVEL(i: number): antlr.TerminalNode | null;
+    public TOPLEVEL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TOPLEVEL);
+    	} else {
+    		return this.getToken(PlSqlParser.TOPLEVEL, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public EVALUATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALUATE, 0);
+    }
+    public PER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PER, 0);
+    }
+    public STATEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENT, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public INSTANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_audit_policy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_audit_policy) {
+             listener.enterAlter_audit_policy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_audit_policy) {
+             listener.exitAlter_audit_policy(this);
+        }
+    }
+}
+
+
+export class Alter_clusterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public CLUSTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLUSTER, 0)!;
+    }
+    public cluster_name(): Cluster_nameContext {
+        return this.getRuleContext(0, Cluster_nameContext)!;
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public SIZE(): antlr.TerminalNode[];
+    public SIZE(i: number): antlr.TerminalNode | null;
+    public SIZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SIZE);
+    	} else {
+    		return this.getToken(PlSqlParser.SIZE, i);
+    	}
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext[];
+    public allocate_extent_clause(i: number): Allocate_extent_clauseContext | null;
+    public allocate_extent_clause(i?: number): Allocate_extent_clauseContext[] | Allocate_extent_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allocate_extent_clauseContext);
+        }
+
+        return this.getRuleContext(i, Allocate_extent_clauseContext);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext[];
+    public deallocate_unused_clause(i: number): Deallocate_unused_clauseContext | null;
+    public deallocate_unused_clause(i?: number): Deallocate_unused_clauseContext[] | Deallocate_unused_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Deallocate_unused_clauseContext);
+        }
+
+        return this.getRuleContext(i, Deallocate_unused_clauseContext);
+    }
+    public cache_or_nocache(): Cache_or_nocacheContext[];
+    public cache_or_nocache(i: number): Cache_or_nocacheContext | null;
+    public cache_or_nocache(i?: number): Cache_or_nocacheContext[] | Cache_or_nocacheContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Cache_or_nocacheContext);
+        }
+
+        return this.getRuleContext(i, Cache_or_nocacheContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_cluster;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_cluster) {
+             listener.enterAlter_cluster(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_cluster) {
+             listener.exitAlter_cluster(this);
+        }
+    }
+}
+
+
+export class Drop_analytic_viewContext extends antlr.ParserRuleContext {
+    public _av?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public ANALYTIC(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ANALYTIC, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_analytic_view;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_analytic_view) {
+             listener.enterDrop_analytic_view(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_analytic_view) {
+             listener.exitDrop_analytic_view(this);
+        }
+    }
+}
+
+
+export class Drop_attribute_dimensionContext extends antlr.ParserRuleContext {
+    public _ad?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public ATTRIBUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0)!;
+    }
+    public DIMENSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIMENSION, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public schema_name(): Schema_nameContext | null {
+        return this.getRuleContext(0, Schema_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_attribute_dimension;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_attribute_dimension) {
+             listener.enterDrop_attribute_dimension(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_attribute_dimension) {
+             listener.exitDrop_attribute_dimension(this);
+        }
+    }
+}
+
+
+export class Drop_audit_policyContext extends antlr.ParserRuleContext {
+    public _p?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public AUDIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUDIT, 0)!;
+    }
+    public POLICY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.POLICY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_audit_policy;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_audit_policy) {
+             listener.enterDrop_audit_policy(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_audit_policy) {
+             listener.exitDrop_audit_policy(this);
+        }
+    }
+}
+
+
+export class Drop_flashback_archiveContext extends antlr.ParserRuleContext {
+    public _fa?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public FLASHBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FLASHBACK, 0)!;
+    }
+    public ARCHIVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ARCHIVE, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_flashback_archive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_flashback_archive) {
+             listener.enterDrop_flashback_archive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_flashback_archive) {
+             listener.exitDrop_flashback_archive(this);
+        }
+    }
+}
+
+
+export class Drop_clusterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public CLUSTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLUSTER, 0)!;
+    }
+    public cluster_name(): Cluster_nameContext {
+        return this.getRuleContext(0, Cluster_nameContext)!;
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public TABLES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLES, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_cluster;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_cluster) {
+             listener.enterDrop_cluster(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_cluster) {
+             listener.exitDrop_cluster(this);
+        }
+    }
+}
+
+
+export class Drop_contextContext extends antlr.ParserRuleContext {
+    public _ns?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public CONTEXT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTEXT, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_context;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_context) {
+             listener.enterDrop_context(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_context) {
+             listener.exitDrop_context(this);
+        }
+    }
+}
+
+
+export class Drop_directoryContext extends antlr.ParserRuleContext {
+    public _dn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public DIRECTORY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIRECTORY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_directory;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_directory) {
+             listener.enterDrop_directory(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_directory) {
+             listener.exitDrop_directory(this);
+        }
+    }
+}
+
+
+export class Drop_diskgroupContext extends antlr.ParserRuleContext {
+    public _dgn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public DISKGROUP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DISKGROUP, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public CONTENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTENTS, 0);
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public EXCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDING, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_diskgroup;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_diskgroup) {
+             listener.enterDrop_diskgroup(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_diskgroup) {
+             listener.exitDrop_diskgroup(this);
+        }
+    }
+}
+
+
+export class Drop_editionContext extends antlr.ParserRuleContext {
+    public _e?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public EDITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EDITION, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_edition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_edition) {
+             listener.enterDrop_edition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_edition) {
+             listener.exitDrop_edition(this);
+        }
+    }
+}
+
+
+export class Truncate_clusterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TRUNCATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRUNCATE, 0)!;
+    }
+    public CLUSTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLUSTER, 0)!;
+    }
+    public cluster_name(): Cluster_nameContext {
+        return this.getRuleContext(0, Cluster_nameContext)!;
+    }
+    public STORAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORAGE, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_truncate_cluster;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTruncate_cluster) {
+             listener.enterTruncate_cluster(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTruncate_cluster) {
+             listener.exitTruncate_cluster(this);
+        }
+    }
+}
+
+
+export class Cache_or_nocacheContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cache_or_nocache;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCache_or_nocache) {
+             listener.enterCache_or_nocache(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCache_or_nocache) {
+             listener.exitCache_or_nocache(this);
+        }
+    }
+}
+
+
+export class Database_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_database_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatabase_name) {
+             listener.enterDatabase_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatabase_name) {
+             listener.exitDatabase_name(this);
+        }
+    }
+}
+
+
+export class Alter_databaseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public database_clause(): Database_clauseContext {
+        return this.getRuleContext(0, Database_clauseContext)!;
+    }
+    public startup_clauses(): Startup_clausesContext | null {
+        return this.getRuleContext(0, Startup_clausesContext);
+    }
+    public recovery_clauses(): Recovery_clausesContext | null {
+        return this.getRuleContext(0, Recovery_clausesContext);
+    }
+    public database_file_clauses(): Database_file_clausesContext | null {
+        return this.getRuleContext(0, Database_file_clausesContext);
+    }
+    public logfile_clauses(): Logfile_clausesContext | null {
+        return this.getRuleContext(0, Logfile_clausesContext);
+    }
+    public controlfile_clauses(): Controlfile_clausesContext | null {
+        return this.getRuleContext(0, Controlfile_clausesContext);
+    }
+    public standby_database_clauses(): Standby_database_clausesContext | null {
+        return this.getRuleContext(0, Standby_database_clausesContext);
+    }
+    public default_settings_clause(): Default_settings_clauseContext | null {
+        return this.getRuleContext(0, Default_settings_clauseContext);
+    }
+    public instance_clauses(): Instance_clausesContext | null {
+        return this.getRuleContext(0, Instance_clausesContext);
+    }
+    public security_clause(): Security_clauseContext | null {
+        return this.getRuleContext(0, Security_clauseContext);
+    }
+    public prepare_clause(): Prepare_clauseContext | null {
+        return this.getRuleContext(0, Prepare_clauseContext);
+    }
+    public drop_mirror_clause(): Drop_mirror_clauseContext | null {
+        return this.getRuleContext(0, Drop_mirror_clauseContext);
+    }
+    public lost_write_protection(): Lost_write_protectionContext | null {
+        return this.getRuleContext(0, Lost_write_protectionContext);
+    }
+    public cdb_fleet_clauses(): Cdb_fleet_clausesContext | null {
+        return this.getRuleContext(0, Cdb_fleet_clausesContext);
+    }
+    public property_clauses(): Property_clausesContext | null {
+        return this.getRuleContext(0, Property_clausesContext);
+    }
+    public replay_upgrade_clauses(): Replay_upgrade_clausesContext | null {
+        return this.getRuleContext(0, Replay_upgrade_clausesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_database;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_database) {
+             listener.enterAlter_database(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_database) {
+             listener.exitAlter_database(this);
+        }
+    }
+}
+
+
+export class Database_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public PLUGGABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0);
+    }
+    public database_name(): Database_nameContext | null {
+        return this.getRuleContext(0, Database_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_database_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatabase_clause) {
+             listener.enterDatabase_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatabase_clause) {
+             listener.exitDatabase_clause(this);
+        }
+    }
+}
+
+
+export class Startup_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNT, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public CLONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLONE, 0);
+    }
+    public OPEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPEN, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public resetlogs_or_noresetlogs(): Resetlogs_or_noresetlogsContext | null {
+        return this.getRuleContext(0, Resetlogs_or_noresetlogsContext);
+    }
+    public upgrade_or_downgrade(): Upgrade_or_downgradeContext | null {
+        return this.getRuleContext(0, Upgrade_or_downgradeContext);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_startup_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStartup_clauses) {
+             listener.enterStartup_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStartup_clauses) {
+             listener.exitStartup_clauses(this);
+        }
+    }
+}
+
+
+export class Resetlogs_or_noresetlogsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESETLOGS, 0);
+    }
+    public NORESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORESETLOGS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_resetlogs_or_noresetlogs;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterResetlogs_or_noresetlogs) {
+             listener.enterResetlogs_or_noresetlogs(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitResetlogs_or_noresetlogs) {
+             listener.exitResetlogs_or_noresetlogs(this);
+        }
+    }
+}
+
+
+export class Upgrade_or_downgradeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UPGRADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPGRADE, 0);
+    }
+    public DOWNGRADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOWNGRADE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_upgrade_or_downgrade;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpgrade_or_downgrade) {
+             listener.enterUpgrade_or_downgrade(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpgrade_or_downgrade) {
+             listener.exitUpgrade_or_downgrade(this);
+        }
+    }
+}
+
+
+export class Recovery_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public general_recovery(): General_recoveryContext | null {
+        return this.getRuleContext(0, General_recoveryContext);
+    }
+    public managed_standby_recovery(): Managed_standby_recoveryContext | null {
+        return this.getRuleContext(0, Managed_standby_recoveryContext);
+    }
+    public begin_or_end(): Begin_or_endContext | null {
+        return this.getRuleContext(0, Begin_or_endContext);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_recovery_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRecovery_clauses) {
+             listener.enterRecovery_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRecovery_clauses) {
+             listener.exitRecovery_clauses(this);
+        }
+    }
+}
+
+
+export class Begin_or_endContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BEGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGIN, 0);
+    }
+    public END(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.END, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_begin_or_end;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBegin_or_end) {
+             listener.enterBegin_or_end(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBegin_or_end) {
+             listener.exitBegin_or_end(this);
+        }
+    }
+}
+
+
+export class General_recoveryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RECOVER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RECOVER, 0)!;
+    }
+    public CONTINUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTINUE, 0);
+    }
+    public CANCEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CANCEL, 0);
+    }
+    public AUTOMATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOMATIC, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public full_database_recovery(): Full_database_recoveryContext | null {
+        return this.getRuleContext(0, Full_database_recoveryContext);
+    }
+    public partial_database_recovery(): Partial_database_recoveryContext | null {
+        return this.getRuleContext(0, Partial_database_recoveryContext);
+    }
+    public LOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILE, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public TEST(): antlr.TerminalNode[];
+    public TEST(i: number): antlr.TerminalNode | null;
+    public TEST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TEST);
+    	} else {
+    		return this.getToken(PlSqlParser.TEST, i);
+    	}
+    }
+    public ALLOW(): antlr.TerminalNode[];
+    public ALLOW(i: number): antlr.TerminalNode | null;
+    public ALLOW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ALLOW);
+    	} else {
+    		return this.getToken(PlSqlParser.ALLOW, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public CORRUPTION(): antlr.TerminalNode[];
+    public CORRUPTION(i: number): antlr.TerminalNode | null;
+    public CORRUPTION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CORRUPTION);
+    	} else {
+    		return this.getToken(PlSqlParser.CORRUPTION, i);
+    	}
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_general_recovery;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGeneral_recovery) {
+             listener.enterGeneral_recovery(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGeneral_recovery) {
+             listener.exitGeneral_recovery(this);
+        }
+    }
+}
+
+
+export class Full_database_recoveryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public UNTIL(): antlr.TerminalNode[];
+    public UNTIL(i: number): antlr.TerminalNode | null;
+    public UNTIL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNTIL);
+    	} else {
+    		return this.getToken(PlSqlParser.UNTIL, i);
+    	}
+    }
+    public USING(): antlr.TerminalNode[];
+    public USING(i: number): antlr.TerminalNode | null;
+    public USING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USING);
+    	} else {
+    		return this.getToken(PlSqlParser.USING, i);
+    	}
+    }
+    public BACKUP(): antlr.TerminalNode[];
+    public BACKUP(i: number): antlr.TerminalNode | null;
+    public BACKUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BACKUP);
+    	} else {
+    		return this.getToken(PlSqlParser.BACKUP, i);
+    	}
+    }
+    public CONTROLFILE(): antlr.TerminalNode[];
+    public CONTROLFILE(i: number): antlr.TerminalNode | null;
+    public CONTROLFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONTROLFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.CONTROLFILE, i);
+    	}
+    }
+    public SNAPSHOT(): antlr.TerminalNode[];
+    public SNAPSHOT(i: number): antlr.TerminalNode | null;
+    public SNAPSHOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SNAPSHOT);
+    	} else {
+    		return this.getToken(PlSqlParser.SNAPSHOT, i);
+    	}
+    }
+    public TIME(): antlr.TerminalNode[];
+    public TIME(i: number): antlr.TerminalNode | null;
+    public TIME(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TIME);
+    	} else {
+    		return this.getToken(PlSqlParser.TIME, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public CANCEL(): antlr.TerminalNode[];
+    public CANCEL(i: number): antlr.TerminalNode | null;
+    public CANCEL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CANCEL);
+    	} else {
+    		return this.getToken(PlSqlParser.CANCEL, i);
+    	}
+    }
+    public CHANGE(): antlr.TerminalNode[];
+    public CHANGE(i: number): antlr.TerminalNode | null;
+    public CHANGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHANGE);
+    	} else {
+    		return this.getToken(PlSqlParser.CHANGE, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public CONSISTENT(): antlr.TerminalNode[];
+    public CONSISTENT(i: number): antlr.TerminalNode | null;
+    public CONSISTENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONSISTENT);
+    	} else {
+    		return this.getToken(PlSqlParser.CONSISTENT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_full_database_recovery;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFull_database_recovery) {
+             listener.enterFull_database_recovery(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFull_database_recovery) {
+             listener.exitFull_database_recovery(this);
+        }
+    }
+}
+
+
+export class Partial_database_recoveryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public filenumber(): FilenumberContext[];
+    public filenumber(i: number): FilenumberContext | null;
+    public filenumber(i?: number): FilenumberContext[] | FilenumberContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenumberContext);
+        }
+
+        return this.getRuleContext(i, FilenumberContext);
+    }
+    public partial_database_recovery_10g(): Partial_database_recovery_10gContext | null {
+        return this.getRuleContext(0, Partial_database_recovery_10gContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partial_database_recovery;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartial_database_recovery) {
+             listener.enterPartial_database_recovery(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartial_database_recovery) {
+             listener.exitPartial_database_recovery(this);
+        }
+    }
+}
+
+
+export class Partial_database_recovery_10gContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STANDBY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDBY, 0)!;
+    }
+    public UNTIL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNTIL, 0)!;
+    }
+    public CONTROLFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTROLFILE, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public filenumber(): FilenumberContext[];
+    public filenumber(i: number): FilenumberContext | null;
+    public filenumber(i?: number): FilenumberContext[] | FilenumberContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenumberContext);
+        }
+
+        return this.getRuleContext(i, FilenumberContext);
+    }
+    public CONSISTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSISTENT, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partial_database_recovery_10g;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartial_database_recovery_10g) {
+             listener.enterPartial_database_recovery_10g(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartial_database_recovery_10g) {
+             listener.exitPartial_database_recovery_10g(this);
+        }
+    }
+}
+
+
+export class Managed_standby_recoveryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RECOVER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RECOVER, 0)!;
+    }
+    public MANAGED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGED, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL, 0);
+    }
+    public db_name(): Db_nameContext | null {
+        return this.getRuleContext(0, Db_nameContext);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public IDENTITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTITY, 0);
+    }
+    public FINISH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINISH, 0);
+    }
+    public CANCEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CANCEL, 0);
+    }
+    public USING(): antlr.TerminalNode[];
+    public USING(i: number): antlr.TerminalNode | null;
+    public USING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USING);
+    	} else {
+    		return this.getToken(PlSqlParser.USING, i);
+    	}
+    }
+    public CURRENT(): antlr.TerminalNode[];
+    public CURRENT(i: number): antlr.TerminalNode | null;
+    public CURRENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CURRENT);
+    	} else {
+    		return this.getToken(PlSqlParser.CURRENT, i);
+    	}
+    }
+    public LOGFILE(): antlr.TerminalNode[];
+    public LOGFILE(i: number): antlr.TerminalNode | null;
+    public LOGFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOGFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.LOGFILE, i);
+    	}
+    }
+    public DISCONNECT(): antlr.TerminalNode[];
+    public DISCONNECT(i: number): antlr.TerminalNode | null;
+    public DISCONNECT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISCONNECT);
+    	} else {
+    		return this.getToken(PlSqlParser.DISCONNECT, i);
+    	}
+    }
+    public NODELAY(): antlr.TerminalNode[];
+    public NODELAY(i: number): antlr.TerminalNode | null;
+    public NODELAY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NODELAY);
+    	} else {
+    		return this.getToken(PlSqlParser.NODELAY, i);
+    	}
+    }
+    public UNTIL(): antlr.TerminalNode[];
+    public UNTIL(i: number): antlr.TerminalNode | null;
+    public UNTIL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNTIL);
+    	} else {
+    		return this.getToken(PlSqlParser.UNTIL, i);
+    	}
+    }
+    public CHANGE(): antlr.TerminalNode[];
+    public CHANGE(i: number): antlr.TerminalNode | null;
+    public CHANGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHANGE);
+    	} else {
+    		return this.getToken(PlSqlParser.CHANGE, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public CONSISTENT(): antlr.TerminalNode[];
+    public CONSISTENT(i: number): antlr.TerminalNode | null;
+    public CONSISTENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONSISTENT);
+    	} else {
+    		return this.getToken(PlSqlParser.CONSISTENT, i);
+    	}
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public FROM(): antlr.TerminalNode[];
+    public FROM(i: number): antlr.TerminalNode | null;
+    public FROM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FROM);
+    	} else {
+    		return this.getToken(PlSqlParser.FROM, i);
+    	}
+    }
+    public SESSION(): antlr.TerminalNode[];
+    public SESSION(i: number): antlr.TerminalNode | null;
+    public SESSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SESSION);
+    	} else {
+    		return this.getToken(PlSqlParser.SESSION, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_managed_standby_recovery;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterManaged_standby_recovery) {
+             listener.enterManaged_standby_recovery(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitManaged_standby_recovery) {
+             listener.exitManaged_standby_recovery(this);
+        }
+    }
+}
+
+
+export class Db_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_db_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDb_name) {
+             listener.enterDb_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDb_name) {
+             listener.exitDb_name(this);
+        }
+    }
+}
+
+
+export class Database_file_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public FILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE, 0);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public create_datafile_clause(): Create_datafile_clauseContext | null {
+        return this.getRuleContext(0, Create_datafile_clauseContext);
+    }
+    public alter_datafile_clause(): Alter_datafile_clauseContext | null {
+        return this.getRuleContext(0, Alter_datafile_clauseContext);
+    }
+    public alter_tempfile_clause(): Alter_tempfile_clauseContext | null {
+        return this.getRuleContext(0, Alter_tempfile_clauseContext);
+    }
+    public move_datafile_clause(): Move_datafile_clauseContext | null {
+        return this.getRuleContext(0, Move_datafile_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_database_file_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatabase_file_clauses) {
+             listener.enterDatabase_file_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatabase_file_clauses) {
+             listener.exitDatabase_file_clauses(this);
+        }
+    }
+}
+
+
+export class Create_datafile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public DATAFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATAFILE, 0)!;
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public filenumber(): FilenumberContext[];
+    public filenumber(i: number): FilenumberContext | null;
+    public filenumber(i?: number): FilenumberContext[] | FilenumberContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenumberContext);
+        }
+
+        return this.getRuleContext(i, FilenumberContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public NEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEW, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_datafile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_datafile_clause) {
+             listener.enterCreate_datafile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_datafile_clause) {
+             listener.exitCreate_datafile_clause(this);
+        }
+    }
+}
+
+
+export class Alter_datafile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATAFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATAFILE, 0)!;
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public filenumber(): FilenumberContext[];
+    public filenumber(i: number): FilenumberContext | null;
+    public filenumber(i?: number): FilenumberContext[] | FilenumberContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenumberContext);
+        }
+
+        return this.getRuleContext(i, FilenumberContext);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public END(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.END, 0);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_datafile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_datafile_clause) {
+             listener.enterAlter_datafile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_datafile_clause) {
+             listener.exitAlter_datafile_clause(this);
+        }
+    }
+}
+
+
+export class Alter_tempfile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TEMPFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TEMPFILE, 0)!;
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public filenumber(): FilenumberContext[];
+    public filenumber(i: number): FilenumberContext | null;
+    public filenumber(i?: number): FilenumberContext[] | FilenumberContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenumberContext);
+        }
+
+        return this.getRuleContext(i, FilenumberContext);
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public DATAFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_tempfile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_tempfile_clause) {
+             listener.enterAlter_tempfile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_tempfile_clause) {
+             listener.exitAlter_tempfile_clause(this);
+        }
+    }
+}
+
+
+export class Move_datafile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVE, 0)!;
+    }
+    public DATAFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATAFILE, 0)!;
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public filenumber(): FilenumberContext[];
+    public filenumber(i: number): FilenumberContext | null;
+    public filenumber(i?: number): FilenumberContext[] | FilenumberContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenumberContext);
+        }
+
+        return this.getRuleContext(i, FilenumberContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_move_datafile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMove_datafile_clause) {
+             listener.enterMove_datafile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMove_datafile_clause) {
+             listener.exitMove_datafile_clause(this);
+        }
+    }
+}
+
+
+export class Logfile_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVELOG, 0);
+    }
+    public NOARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOARCHIVELOG, 0);
+    }
+    public MANUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANUAL, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public NOLOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOGGING, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public AVAILABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVAILABILITY, 0);
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public PERFORMANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERFORMANCE, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public FILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE, 0);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public CLEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLEAR, 0);
+    }
+    public LOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILE, 0);
+    }
+    public logfile_descriptor(): Logfile_descriptorContext[];
+    public logfile_descriptor(i: number): Logfile_descriptorContext | null;
+    public logfile_descriptor(i?: number): Logfile_descriptorContext[] | Logfile_descriptorContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logfile_descriptorContext);
+        }
+
+        return this.getRuleContext(i, Logfile_descriptorContext);
+    }
+    public UNARCHIVED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNARCHIVED, 0);
+    }
+    public UNRECOVERABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNRECOVERABLE, 0);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public add_logfile_clauses(): Add_logfile_clausesContext | null {
+        return this.getRuleContext(0, Add_logfile_clausesContext);
+    }
+    public drop_logfile_clauses(): Drop_logfile_clausesContext | null {
+        return this.getRuleContext(0, Drop_logfile_clausesContext);
+    }
+    public switch_logfile_clause(): Switch_logfile_clauseContext | null {
+        return this.getRuleContext(0, Switch_logfile_clauseContext);
+    }
+    public supplemental_db_logging(): Supplemental_db_loggingContext | null {
+        return this.getRuleContext(0, Supplemental_db_loggingContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logfile_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogfile_clauses) {
+             listener.enterLogfile_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogfile_clauses) {
+             listener.exitLogfile_clauses(this);
+        }
+    }
+}
+
+
+export class Add_logfile_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public LOGFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGFILE, 0)!;
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public logfile_descriptor(): Logfile_descriptorContext[];
+    public logfile_descriptor(i: number): Logfile_descriptorContext | null;
+    public logfile_descriptor(i?: number): Logfile_descriptorContext[] | Logfile_descriptorContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logfile_descriptorContext);
+        }
+
+        return this.getRuleContext(i, Logfile_descriptorContext);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public INSTANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANCE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public THREAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THREAD, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public group_redo_logfile(): Group_redo_logfileContext[];
+    public group_redo_logfile(i: number): Group_redo_logfileContext | null;
+    public group_redo_logfile(i?: number): Group_redo_logfileContext[] | Group_redo_logfileContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Group_redo_logfileContext);
+        }
+
+        return this.getRuleContext(i, Group_redo_logfileContext);
+    }
+    public REUSE(): antlr.TerminalNode[];
+    public REUSE(i: number): antlr.TerminalNode | null;
+    public REUSE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.REUSE);
+    	} else {
+    		return this.getToken(PlSqlParser.REUSE, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_logfile_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_logfile_clauses) {
+             listener.enterAdd_logfile_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_logfile_clauses) {
+             listener.exitAdd_logfile_clauses(this);
+        }
+    }
+}
+
+
+export class Group_redo_logfileContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public redo_log_file_spec(): Redo_log_file_specContext {
+        return this.getRuleContext(0, Redo_log_file_specContext)!;
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_group_redo_logfile;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGroup_redo_logfile) {
+             listener.enterGroup_redo_logfile(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGroup_redo_logfile) {
+             listener.exitGroup_redo_logfile(this);
+        }
+    }
+}
+
+
+export class Drop_logfile_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public LOGFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGFILE, 0)!;
+    }
+    public logfile_descriptor(): Logfile_descriptorContext[];
+    public logfile_descriptor(i: number): Logfile_descriptorContext | null;
+    public logfile_descriptor(i?: number): Logfile_descriptorContext[] | Logfile_descriptorContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logfile_descriptorContext);
+        }
+
+        return this.getRuleContext(i, Logfile_descriptorContext);
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_logfile_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_logfile_clauses) {
+             listener.enterDrop_logfile_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_logfile_clauses) {
+             listener.exitDrop_logfile_clauses(this);
+        }
+    }
+}
+
+
+export class Switch_logfile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SWITCH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SWITCH, 0)!;
+    }
+    public ALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALL, 0)!;
+    }
+    public LOGFILES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGFILES, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public BLOCKSIZE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BLOCKSIZE, 0)!;
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_switch_logfile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSwitch_logfile_clause) {
+             listener.enterSwitch_logfile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSwitch_logfile_clause) {
+             listener.exitSwitch_logfile_clause(this);
+        }
+    }
+}
+
+
+export class Supplemental_db_loggingContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_or_drop(): Add_or_dropContext {
+        return this.getRuleContext(0, Add_or_dropContext)!;
+    }
+    public SUPPLEMENTAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUPPLEMENTAL, 0)!;
+    }
+    public LOG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOG, 0)!;
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public supplemental_id_key_clause(): Supplemental_id_key_clauseContext | null {
+        return this.getRuleContext(0, Supplemental_id_key_clauseContext);
+    }
+    public supplemental_plsql_clause(): Supplemental_plsql_clauseContext | null {
+        return this.getRuleContext(0, Supplemental_plsql_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_supplemental_db_logging;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSupplemental_db_logging) {
+             listener.enterSupplemental_db_logging(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSupplemental_db_logging) {
+             listener.exitSupplemental_db_logging(this);
+        }
+    }
+}
+
+
+export class Add_or_dropContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_or_drop;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_or_drop) {
+             listener.enterAdd_or_drop(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_or_drop) {
+             listener.exitAdd_or_drop(this);
+        }
+    }
+}
+
+
+export class Supplemental_plsql_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATA, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public PROCEDURAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROCEDURAL, 0)!;
+    }
+    public REPLICATION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REPLICATION, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_supplemental_plsql_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSupplemental_plsql_clause) {
+             listener.enterSupplemental_plsql_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSupplemental_plsql_clause) {
+             listener.exitSupplemental_plsql_clause(this);
+        }
+    }
+}
+
+
+export class Logfile_descriptorContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public filename(): FilenameContext[];
+    public filename(i: number): FilenameContext | null;
+    public filename(i?: number): FilenameContext[] | FilenameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(FilenameContext);
+        }
+
+        return this.getRuleContext(i, FilenameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logfile_descriptor;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogfile_descriptor) {
+             listener.enterLogfile_descriptor(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogfile_descriptor) {
+             listener.exitLogfile_descriptor(this);
+        }
+    }
+}
+
+
+export class Controlfile_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public CONTROLFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTROLFILE, 0)!;
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL, 0);
+    }
+    public PHYSICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PHYSICAL, 0);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public trace_file_clause(): Trace_file_clauseContext | null {
+        return this.getRuleContext(0, Trace_file_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_controlfile_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterControlfile_clauses) {
+             listener.enterControlfile_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitControlfile_clauses) {
+             listener.exitControlfile_clauses(this);
+        }
+    }
+}
+
+
+export class Trace_file_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TRACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRACE, 0)!;
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public RESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESETLOGS, 0);
+    }
+    public NORESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORESETLOGS, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_trace_file_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTrace_file_clause) {
+             listener.enterTrace_file_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTrace_file_clause) {
+             listener.exitTrace_file_clause(this);
+        }
+    }
+}
+
+
+export class Standby_database_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public activate_standby_db_clause(): Activate_standby_db_clauseContext | null {
+        return this.getRuleContext(0, Activate_standby_db_clauseContext);
+    }
+    public maximize_standby_db_clause(): Maximize_standby_db_clauseContext | null {
+        return this.getRuleContext(0, Maximize_standby_db_clauseContext);
+    }
+    public register_logfile_clause(): Register_logfile_clauseContext | null {
+        return this.getRuleContext(0, Register_logfile_clauseContext);
+    }
+    public commit_switchover_clause(): Commit_switchover_clauseContext | null {
+        return this.getRuleContext(0, Commit_switchover_clauseContext);
+    }
+    public start_standby_clause(): Start_standby_clauseContext | null {
+        return this.getRuleContext(0, Start_standby_clauseContext);
+    }
+    public stop_standby_clause(): Stop_standby_clauseContext | null {
+        return this.getRuleContext(0, Stop_standby_clauseContext);
+    }
+    public convert_database_clause(): Convert_database_clauseContext | null {
+        return this.getRuleContext(0, Convert_database_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_standby_database_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStandby_database_clauses) {
+             listener.enterStandby_database_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStandby_database_clauses) {
+             listener.exitStandby_database_clauses(this);
+        }
+    }
+}
+
+
+export class Activate_standby_db_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACTIVATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ACTIVATE, 0)!;
+    }
+    public STANDBY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDBY, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public FINISH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINISH, 0);
+    }
+    public APPLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPLY, 0);
+    }
+    public PHYSICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PHYSICAL, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_activate_standby_db_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterActivate_standby_db_clause) {
+             listener.enterActivate_standby_db_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitActivate_standby_db_clause) {
+             listener.exitActivate_standby_db_clause(this);
+        }
+    }
+}
+
+
+export class Maximize_standby_db_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public STANDBY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDBY, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public MAXIMIZE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MAXIMIZE, 0)!;
+    }
+    public PROTECTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROTECTION, 0);
+    }
+    public AVAILABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVAILABILITY, 0);
+    }
+    public PERFORMANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERFORMANCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_maximize_standby_db_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMaximize_standby_db_clause) {
+             listener.enterMaximize_standby_db_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMaximize_standby_db_clause) {
+             listener.exitMaximize_standby_db_clause(this);
+        }
+    }
+}
+
+
+export class Register_logfile_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REGISTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REGISTER, 0)!;
+    }
+    public LOGFILE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGFILE, 0)!;
+    }
+    public PHYSICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PHYSICAL, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_register_logfile_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRegister_logfile_clause) {
+             listener.enterRegister_logfile_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRegister_logfile_clause) {
+             listener.exitRegister_logfile_clause(this);
+        }
+    }
+}
+
+
+export class Commit_switchover_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TO(): antlr.TerminalNode[];
+    public TO(i: number): antlr.TerminalNode | null;
+    public TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TO);
+    	} else {
+    		return this.getToken(PlSqlParser.TO, i);
+    	}
+    }
+    public SWITCHOVER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SWITCHOVER, 0)!;
+    }
+    public PREPARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREPARE, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public CANCEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CANCEL, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public SHUTDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHUTDOWN, 0);
+    }
+    public WAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WAIT, 0);
+    }
+    public NOWAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOWAIT, 0);
+    }
+    public PHYSICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PHYSICAL, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_commit_switchover_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCommit_switchover_clause) {
+             listener.enterCommit_switchover_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCommit_switchover_clause) {
+             listener.exitCommit_switchover_clause(this);
+        }
+    }
+}
+
+
+export class Start_standby_clauseContext extends antlr.ParserRuleContext {
+    public _scn_value?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public START(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.START, 0)!;
+    }
+    public LOGICAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGICAL, 0)!;
+    }
+    public STANDBY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDBY, 0)!;
+    }
+    public APPLY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.APPLY, 0)!;
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public NODELAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NODELAY, 0);
+    }
+    public NEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEW, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public INITIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITIAL, 0);
+    }
+    public SKIP_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_, 0);
+    }
+    public FAILED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILED, 0);
+    }
+    public TRANSACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSACTION, 0);
+    }
+    public FINISH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINISH, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_start_standby_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStart_standby_clause) {
+             listener.enterStart_standby_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStart_standby_clause) {
+             listener.exitStart_standby_clause(this);
+        }
+    }
+}
+
+
+export class Stop_standby_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOGICAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOGICAL, 0)!;
+    }
+    public STANDBY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDBY, 0)!;
+    }
+    public APPLY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.APPLY, 0)!;
+    }
+    public STOP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STOP, 0);
+    }
+    public ABORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ABORT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_stop_standby_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStop_standby_clause) {
+             listener.enterStop_standby_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStop_standby_clause) {
+             listener.exitStop_standby_clause(this);
+        }
+    }
+}
+
+
+export class Convert_database_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONVERT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONVERT, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public STANDBY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDBY, 0)!;
+    }
+    public PHYSICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PHYSICAL, 0);
+    }
+    public SNAPSHOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SNAPSHOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_convert_database_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConvert_database_clause) {
+             listener.enterConvert_database_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConvert_database_clause) {
+             listener.exitConvert_database_clause(this);
+        }
+    }
+}
+
+
+export class Default_settings_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public edition_name(): Edition_nameContext | null {
+        return this.getRuleContext(0, Edition_nameContext);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public BIGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIGFILE, 0);
+    }
+    public SMALLFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLFILE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public TEMPORARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPORARY, 0);
+    }
+    public tablespace_group_name(): Tablespace_group_nameContext | null {
+        return this.getRuleContext(0, Tablespace_group_nameContext);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public GLOBAL_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL_NAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public database(): DatabaseContext | null {
+        return this.getRuleContext(0, DatabaseContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public domain(): DomainContext[];
+    public domain(i: number): DomainContext | null;
+    public domain(i?: number): DomainContext[] | DomainContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(DomainContext);
+        }
+
+        return this.getRuleContext(i, DomainContext);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCK, 0);
+    }
+    public CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHANGE, 0);
+    }
+    public TRACKING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRACKING, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public FILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE, 0);
+    }
+    public filename(): FilenameContext | null {
+        return this.getRuleContext(0, FilenameContext);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public flashback_mode_clause(): Flashback_mode_clauseContext | null {
+        return this.getRuleContext(0, Flashback_mode_clauseContext);
+    }
+    public set_time_zone_clause(): Set_time_zone_clauseContext | null {
+        return this.getRuleContext(0, Set_time_zone_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_settings_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_settings_clause) {
+             listener.enterDefault_settings_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_settings_clause) {
+             listener.exitDefault_settings_clause(this);
+        }
+    }
+}
+
+
+export class Set_time_zone_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public TIME_ZONE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TIME_ZONE, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_time_zone_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_time_zone_clause) {
+             listener.enterSet_time_zone_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_time_zone_clause) {
+             listener.exitSet_time_zone_clause(this);
+        }
+    }
+}
+
+
+export class Instance_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public enable_or_disable(): Enable_or_disableContext {
+        return this.getRuleContext(0, Enable_or_disableContext)!;
+    }
+    public INSTANCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INSTANCE, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_instance_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInstance_clauses) {
+             listener.enterInstance_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInstance_clauses) {
+             listener.exitInstance_clauses(this);
+        }
+    }
+}
+
+
+export class Security_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GUARD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GUARD, 0)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_security_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSecurity_clause) {
+             listener.enterSecurity_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSecurity_clause) {
+             listener.exitSecurity_clause(this);
+        }
+    }
+}
+
+
+export class DomainContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_domain;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDomain) {
+             listener.enterDomain(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDomain) {
+             listener.exitDomain(this);
+        }
+    }
+}
+
+
+export class DatabaseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_database;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatabase) {
+             listener.enterDatabase(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatabase) {
+             listener.exitDatabase(this);
+        }
+    }
+}
+
+
+export class Edition_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_edition_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEdition_name) {
+             listener.enterEdition_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEdition_name) {
+             listener.exitEdition_name(this);
+        }
+    }
+}
+
+
+export class FilenumberContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filenumber;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilenumber) {
+             listener.enterFilenumber(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilenumber) {
+             listener.exitFilenumber(this);
+        }
+    }
+}
+
+
+export class FilenameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filename;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilename) {
+             listener.enterFilename(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilename) {
+             listener.exitFilename(this);
+        }
+    }
+}
+
+
+export class Prepare_clauseContext extends antlr.ParserRuleContext {
+    public _c?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PREPARE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PREPARE, 0)!;
+    }
+    public MIRROR(): antlr.TerminalNode[];
+    public MIRROR(i: number): antlr.TerminalNode | null;
+    public MIRROR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MIRROR);
+    	} else {
+    		return this.getToken(PlSqlParser.MIRROR, i);
+    	}
+    }
+    public COPY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COPY, 0)!;
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public REDUNDANCY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDUNDANCY, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public UNPROTECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNPROTECTED, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_prepare_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPrepare_clause) {
+             listener.enterPrepare_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPrepare_clause) {
+             listener.exitPrepare_clause(this);
+        }
+    }
+}
+
+
+export class Drop_mirror_clauseContext extends antlr.ParserRuleContext {
+    public _mn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public MIRROR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MIRROR, 0)!;
+    }
+    public COPY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COPY, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_mirror_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_mirror_clause) {
+             listener.enterDrop_mirror_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_mirror_clause) {
+             listener.exitDrop_mirror_clause(this);
+        }
+    }
+}
+
+
+export class Lost_write_protectionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOST, 0)!;
+    }
+    public WRITE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WRITE, 0)!;
+    }
+    public PROTECTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROTECTION, 0)!;
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public SUSPEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUSPEND, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lost_write_protection;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLost_write_protection) {
+             listener.enterLost_write_protection(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLost_write_protection) {
+             listener.exitLost_write_protection(this);
+        }
+    }
+}
+
+
+export class Cdb_fleet_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public lead_cdb_clause(): Lead_cdb_clauseContext | null {
+        return this.getRuleContext(0, Lead_cdb_clauseContext);
+    }
+    public lead_cdb_uri_clause(): Lead_cdb_uri_clauseContext | null {
+        return this.getRuleContext(0, Lead_cdb_uri_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cdb_fleet_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCdb_fleet_clauses) {
+             listener.enterCdb_fleet_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCdb_fleet_clauses) {
+             listener.exitCdb_fleet_clauses(this);
+        }
+    }
+}
+
+
+export class Lead_cdb_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public LEAD_CDB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEAD_CDB, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public TRUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUE, 0);
+    }
+    public FALSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FALSE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lead_cdb_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLead_cdb_clause) {
+             listener.enterLead_cdb_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLead_cdb_clause) {
+             listener.exitLead_cdb_clause(this);
+        }
+    }
+}
+
+
+export class Lead_cdb_uri_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public LEAD_CDB_URI(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEAD_CDB_URI, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lead_cdb_uri_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLead_cdb_uri_clause) {
+             listener.enterLead_cdb_uri_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLead_cdb_uri_clause) {
+             listener.exitLead_cdb_uri_clause(this);
+        }
+    }
+}
+
+
+export class Property_clausesContext extends antlr.ParserRuleContext {
+    public _qcn?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PROPERTY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PROPERTY, 0)!;
+    }
+    public DEFAULT_CREDENTIAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT_CREDENTIAL, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_property_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProperty_clauses) {
+             listener.enterProperty_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProperty_clauses) {
+             listener.exitProperty_clauses(this);
+        }
+    }
+}
+
+
+export class Replay_upgrade_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UPGRADE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UPGRADE, 0)!;
+    }
+    public SYNC(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SYNC, 0)!;
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public OFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFF, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_replay_upgrade_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReplay_upgrade_clauses) {
+             listener.enterReplay_upgrade_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReplay_upgrade_clauses) {
+             listener.exitReplay_upgrade_clauses(this);
+        }
+    }
+}
+
+
+export class Alter_database_linkContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public LINK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LINK, 0)!;
+    }
+    public local_link_name(): Local_link_nameContext {
+        return this.getRuleContext(0, Local_link_nameContext)!;
+    }
+    public CONNECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public user_object_name(): User_object_nameContext | null {
+        return this.getRuleContext(0, User_object_nameContext);
+    }
+    public IDENTIFIED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public password_value(): Password_valueContext | null {
+        return this.getRuleContext(0, Password_valueContext);
+    }
+    public link_authentication(): Link_authenticationContext | null {
+        return this.getRuleContext(0, Link_authenticationContext);
+    }
+    public SHARED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARED, 0);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_database_link;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_database_link) {
+             listener.enterAlter_database_link(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_database_link) {
+             listener.exitAlter_database_link(this);
+        }
+    }
+}
+
+
+export class Password_valueContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public VALUES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUES, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_password_value;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPassword_value) {
+             listener.enterPassword_value(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPassword_value) {
+             listener.exitPassword_value(this);
+        }
+    }
+}
+
+
+export class Link_authenticationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AUTHENTICATED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUTHENTICATED, 0)!;
+    }
+    public BY(): antlr.TerminalNode[];
+    public BY(i: number): antlr.TerminalNode | null;
+    public BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BY);
+    	} else {
+    		return this.getToken(PlSqlParser.BY, i);
+    	}
+    }
+    public user_object_name(): User_object_nameContext {
+        return this.getRuleContext(0, User_object_nameContext)!;
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public password_value(): Password_valueContext {
+        return this.getRuleContext(0, Password_valueContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_link_authentication;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLink_authentication) {
+             listener.enterLink_authentication(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLink_authentication) {
+             listener.exitLink_authentication(this);
+        }
+    }
+}
+
+
+export class Create_schemaContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public SCHEMA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SCHEMA, 0)!;
+    }
+    public AUTHORIZATION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUTHORIZATION, 0)!;
+    }
+    public schema_name(): Schema_nameContext {
+        return this.getRuleContext(0, Schema_nameContext)!;
+    }
+    public create_table(): Create_tableContext[];
+    public create_table(i: number): Create_tableContext | null;
+    public create_table(i?: number): Create_tableContext[] | Create_tableContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Create_tableContext);
+        }
+
+        return this.getRuleContext(i, Create_tableContext);
+    }
+    public create_view(): Create_viewContext[];
+    public create_view(i: number): Create_viewContext | null;
+    public create_view(i?: number): Create_viewContext[] | Create_viewContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Create_viewContext);
+        }
+
+        return this.getRuleContext(i, Create_viewContext);
+    }
+    public grant_statement(): Grant_statementContext[];
+    public grant_statement(i: number): Grant_statementContext | null;
+    public grant_statement(i?: number): Grant_statementContext[] | Grant_statementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Grant_statementContext);
+        }
+
+        return this.getRuleContext(i, Grant_statementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_schema;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_schema) {
+             listener.enterCreate_schema(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_schema) {
+             listener.exitCreate_schema(this);
+        }
+    }
+}
+
+
+export class Create_databaseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public database_name(): Database_nameContext {
+        return this.getRuleContext(0, Database_nameContext)!;
+    }
+    public USER(): antlr.TerminalNode[];
+    public USER(i: number): antlr.TerminalNode | null;
+    public USER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USER);
+    	} else {
+    		return this.getToken(PlSqlParser.USER, i);
+    	}
+    }
+    public IDENTIFIED(): antlr.TerminalNode[];
+    public IDENTIFIED(i: number): antlr.TerminalNode | null;
+    public IDENTIFIED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IDENTIFIED);
+    	} else {
+    		return this.getToken(PlSqlParser.IDENTIFIED, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode[];
+    public BY(i: number): antlr.TerminalNode | null;
+    public BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BY);
+    	} else {
+    		return this.getToken(PlSqlParser.BY, i);
+    	}
+    }
+    public password_value(): Password_valueContext[];
+    public password_value(i: number): Password_valueContext | null;
+    public password_value(i?: number): Password_valueContext[] | Password_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Password_valueContext);
+        }
+
+        return this.getRuleContext(i, Password_valueContext);
+    }
+    public CONTROLFILE(): antlr.TerminalNode[];
+    public CONTROLFILE(i: number): antlr.TerminalNode | null;
+    public CONTROLFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONTROLFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.CONTROLFILE, i);
+    	}
+    }
+    public REUSE(): antlr.TerminalNode[];
+    public REUSE(i: number): antlr.TerminalNode | null;
+    public REUSE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.REUSE);
+    	} else {
+    		return this.getToken(PlSqlParser.REUSE, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public CHARACTER(): antlr.TerminalNode[];
+    public CHARACTER(i: number): antlr.TerminalNode | null;
+    public CHARACTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHARACTER);
+    	} else {
+    		return this.getToken(PlSqlParser.CHARACTER, i);
+    	}
+    }
+    public SET(): antlr.TerminalNode[];
+    public SET(i: number): antlr.TerminalNode | null;
+    public SET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SET);
+    	} else {
+    		return this.getToken(PlSqlParser.SET, i);
+    	}
+    }
+    public char_set_name(): Char_set_nameContext[];
+    public char_set_name(i: number): Char_set_nameContext | null;
+    public char_set_name(i?: number): Char_set_nameContext[] | Char_set_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Char_set_nameContext);
+        }
+
+        return this.getRuleContext(i, Char_set_nameContext);
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public database_logging_clauses(): Database_logging_clausesContext[];
+    public database_logging_clauses(i: number): Database_logging_clausesContext | null;
+    public database_logging_clauses(i?: number): Database_logging_clausesContext[] | Database_logging_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Database_logging_clausesContext);
+        }
+
+        return this.getRuleContext(i, Database_logging_clausesContext);
+    }
+    public tablespace_clauses(): Tablespace_clausesContext[];
+    public tablespace_clauses(i: number): Tablespace_clausesContext | null;
+    public tablespace_clauses(i?: number): Tablespace_clausesContext[] | Tablespace_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tablespace_clausesContext);
+        }
+
+        return this.getRuleContext(i, Tablespace_clausesContext);
+    }
+    public set_time_zone_clause(): Set_time_zone_clauseContext[];
+    public set_time_zone_clause(i: number): Set_time_zone_clauseContext | null;
+    public set_time_zone_clause(i?: number): Set_time_zone_clauseContext[] | Set_time_zone_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Set_time_zone_clauseContext);
+        }
+
+        return this.getRuleContext(i, Set_time_zone_clauseContext);
+    }
+    public USER_DATA(): antlr.TerminalNode[];
+    public USER_DATA(i: number): antlr.TerminalNode | null;
+    public USER_DATA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.USER_DATA);
+    	} else {
+    		return this.getToken(PlSqlParser.USER_DATA, i);
+    	}
+    }
+    public tablespace_group_name(): Tablespace_group_nameContext[];
+    public tablespace_group_name(i: number): Tablespace_group_nameContext | null;
+    public tablespace_group_name(i?: number): Tablespace_group_nameContext[] | Tablespace_group_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tablespace_group_nameContext);
+        }
+
+        return this.getRuleContext(i, Tablespace_group_nameContext);
+    }
+    public DATAFILE(): antlr.TerminalNode[];
+    public DATAFILE(i: number): antlr.TerminalNode | null;
+    public DATAFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DATAFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.DATAFILE, i);
+    	}
+    }
+    public datafile_tempfile_spec(): Datafile_tempfile_specContext[];
+    public datafile_tempfile_spec(i: number): Datafile_tempfile_specContext | null;
+    public datafile_tempfile_spec(i?: number): Datafile_tempfile_specContext[] | Datafile_tempfile_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Datafile_tempfile_specContext);
+        }
+
+        return this.getRuleContext(i, Datafile_tempfile_specContext);
+    }
+    public enable_pluggable_database(): Enable_pluggable_databaseContext[];
+    public enable_pluggable_database(i: number): Enable_pluggable_databaseContext | null;
+    public enable_pluggable_database(i?: number): Enable_pluggable_databaseContext[] | Enable_pluggable_databaseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Enable_pluggable_databaseContext);
+        }
+
+        return this.getRuleContext(i, Enable_pluggable_databaseContext);
+    }
+    public SYS(): antlr.TerminalNode[];
+    public SYS(i: number): antlr.TerminalNode | null;
+    public SYS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SYS);
+    	} else {
+    		return this.getToken(PlSqlParser.SYS, i);
+    	}
+    }
+    public SYSTEM(): antlr.TerminalNode[];
+    public SYSTEM(i: number): antlr.TerminalNode | null;
+    public SYSTEM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SYSTEM);
+    	} else {
+    		return this.getToken(PlSqlParser.SYSTEM, i);
+    	}
+    }
+    public MAXDATAFILES(): antlr.TerminalNode[];
+    public MAXDATAFILES(i: number): antlr.TerminalNode | null;
+    public MAXDATAFILES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MAXDATAFILES);
+    	} else {
+    		return this.getToken(PlSqlParser.MAXDATAFILES, i);
+    	}
+    }
+    public MAXINSTANCES(): antlr.TerminalNode[];
+    public MAXINSTANCES(i: number): antlr.TerminalNode | null;
+    public MAXINSTANCES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MAXINSTANCES);
+    	} else {
+    		return this.getToken(PlSqlParser.MAXINSTANCES, i);
+    	}
+    }
+    public BIGFILE(): antlr.TerminalNode[];
+    public BIGFILE(i: number): antlr.TerminalNode | null;
+    public BIGFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BIGFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.BIGFILE, i);
+    	}
+    }
+    public SMALLFILE(): antlr.TerminalNode[];
+    public SMALLFILE(i: number): antlr.TerminalNode | null;
+    public SMALLFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SMALLFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.SMALLFILE, i);
+    	}
+    }
+    public NATIONAL(): antlr.TerminalNode[];
+    public NATIONAL(i: number): antlr.TerminalNode | null;
+    public NATIONAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NATIONAL);
+    	} else {
+    		return this.getToken(PlSqlParser.NATIONAL, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_database;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_database) {
+             listener.enterCreate_database(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_database) {
+             listener.exitCreate_database(this);
+        }
+    }
+}
+
+
+export class Database_logging_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILE, 0);
+    }
+    public database_logging_sub_clause(): Database_logging_sub_clauseContext[];
+    public database_logging_sub_clause(i: number): Database_logging_sub_clauseContext | null;
+    public database_logging_sub_clause(i?: number): Database_logging_sub_clauseContext[] | Database_logging_sub_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Database_logging_sub_clauseContext);
+        }
+
+        return this.getRuleContext(i, Database_logging_sub_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public MAXLOGFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGFILES, 0);
+    }
+    public MAXLOGMEMBERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGMEMBERS, 0);
+    }
+    public MAXLOGHISTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGHISTORY, 0);
+    }
+    public ARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVELOG, 0);
+    }
+    public NOARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOARCHIVELOG, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_database_logging_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatabase_logging_clauses) {
+             listener.enterDatabase_logging_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatabase_logging_clauses) {
+             listener.exitDatabase_logging_clauses(this);
+        }
+    }
+}
+
+
+export class Database_logging_sub_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public file_specification(): File_specificationContext {
+        return this.getRuleContext(0, File_specificationContext)!;
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_database_logging_sub_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatabase_logging_sub_clause) {
+             listener.enterDatabase_logging_sub_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatabase_logging_sub_clause) {
+             listener.exitDatabase_logging_sub_clause(this);
+        }
+    }
+}
+
+
+export class Tablespace_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENT, 0);
+    }
+    public MANAGEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGEMENT, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public file_specification(): File_specificationContext[];
+    public file_specification(i: number): File_specificationContext | null;
+    public file_specification(i?: number): File_specificationContext[] | File_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(File_specificationContext);
+        }
+
+        return this.getRuleContext(i, File_specificationContext);
+    }
+    public SYSAUX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSAUX, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public default_tablespace(): Default_tablespaceContext | null {
+        return this.getRuleContext(0, Default_tablespaceContext);
+    }
+    public default_temp_tablespace(): Default_temp_tablespaceContext | null {
+        return this.getRuleContext(0, Default_temp_tablespaceContext);
+    }
+    public undo_tablespace(): Undo_tablespaceContext | null {
+        return this.getRuleContext(0, Undo_tablespaceContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_clauses) {
+             listener.enterTablespace_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_clauses) {
+             listener.exitTablespace_clauses(this);
+        }
+    }
+}
+
+
+export class Enable_pluggable_databaseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ENABLE, 0)!;
+    }
+    public PLUGGABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public SEED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEED, 0);
+    }
+    public undo_mode_clause(): Undo_mode_clauseContext | null {
+        return this.getRuleContext(0, Undo_mode_clauseContext);
+    }
+    public file_name_convert(): File_name_convertContext | null {
+        return this.getRuleContext(0, File_name_convertContext);
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public tablespace_datafile_clauses(): Tablespace_datafile_clausesContext[];
+    public tablespace_datafile_clauses(i: number): Tablespace_datafile_clausesContext | null;
+    public tablespace_datafile_clauses(i?: number): Tablespace_datafile_clausesContext[] | Tablespace_datafile_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Tablespace_datafile_clausesContext);
+        }
+
+        return this.getRuleContext(i, Tablespace_datafile_clausesContext);
+    }
+    public SYSAUX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSAUX, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_enable_pluggable_database;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEnable_pluggable_database) {
+             listener.enterEnable_pluggable_database(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEnable_pluggable_database) {
+             listener.exitEnable_pluggable_database(this);
+        }
+    }
+}
+
+
+export class File_name_convertContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FILE_NAME_CONVERT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILE_NAME_CONVERT, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public filename_convert_sub_clause(): Filename_convert_sub_clauseContext[];
+    public filename_convert_sub_clause(i: number): Filename_convert_sub_clauseContext | null;
+    public filename_convert_sub_clause(i?: number): Filename_convert_sub_clauseContext[] | Filename_convert_sub_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Filename_convert_sub_clauseContext);
+        }
+
+        return this.getRuleContext(i, Filename_convert_sub_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_file_name_convert;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFile_name_convert) {
+             listener.enterFile_name_convert(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFile_name_convert) {
+             listener.exitFile_name_convert(this);
+        }
+    }
+}
+
+
+export class Filename_convert_sub_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filename_convert_sub_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilename_convert_sub_clause) {
+             listener.enterFilename_convert_sub_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilename_convert_sub_clause) {
+             listener.exitFilename_convert_sub_clause(this);
+        }
+    }
+}
+
+
+export class Tablespace_datafile_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DATAFILES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATAFILES, 0)!;
+    }
+    public SIZE(): antlr.TerminalNode[];
+    public SIZE(i: number): antlr.TerminalNode | null;
+    public SIZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SIZE);
+    	} else {
+    		return this.getToken(PlSqlParser.SIZE, i);
+    	}
+    }
+    public size_clause(): Size_clauseContext[];
+    public size_clause(i: number): Size_clauseContext | null;
+    public size_clause(i?: number): Size_clauseContext[] | Size_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Size_clauseContext);
+        }
+
+        return this.getRuleContext(i, Size_clauseContext);
+    }
+    public autoextend_clause(): Autoextend_clauseContext[];
+    public autoextend_clause(i: number): Autoextend_clauseContext | null;
+    public autoextend_clause(i?: number): Autoextend_clauseContext[] | Autoextend_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Autoextend_clauseContext);
+        }
+
+        return this.getRuleContext(i, Autoextend_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace_datafile_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace_datafile_clauses) {
+             listener.enterTablespace_datafile_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace_datafile_clauses) {
+             listener.exitTablespace_datafile_clauses(this);
+        }
+    }
+}
+
+
+export class Undo_mode_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOCAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCAL, 0)!;
+    }
+    public UNDO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNDO, 0)!;
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public OFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFF, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_undo_mode_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUndo_mode_clause) {
+             listener.enterUndo_mode_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUndo_mode_clause) {
+             listener.exitUndo_mode_clause(this);
+        }
+    }
+}
+
+
+export class Default_tablespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public tablespace(): TablespaceContext {
+        return this.getRuleContext(0, TablespaceContext)!;
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public datafile_tempfile_spec(): Datafile_tempfile_specContext | null {
+        return this.getRuleContext(0, Datafile_tempfile_specContext);
+    }
+    public extent_management_clause(): Extent_management_clauseContext | null {
+        return this.getRuleContext(0, Extent_management_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_tablespace) {
+             listener.enterDefault_tablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_tablespace) {
+             listener.exitDefault_tablespace(this);
+        }
+    }
+}
+
+
+export class Default_temp_tablespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public tablespace(): TablespaceContext {
+        return this.getRuleContext(0, TablespaceContext)!;
+    }
+    public TEMPORARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPORARY, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public LEAF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAF, 0);
+    }
+    public TEMPFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPFILE, 0);
+    }
+    public file_specification(): File_specificationContext[];
+    public file_specification(i: number): File_specificationContext | null;
+    public file_specification(i?: number): File_specificationContext[] | File_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(File_specificationContext);
+        }
+
+        return this.getRuleContext(i, File_specificationContext);
+    }
+    public extent_management_clause(): Extent_management_clauseContext | null {
+        return this.getRuleContext(0, Extent_management_clauseContext);
+    }
+    public BIGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIGFILE, 0);
+    }
+    public SMALLFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLFILE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_temp_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_temp_tablespace) {
+             listener.enterDefault_temp_tablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_temp_tablespace) {
+             listener.exitDefault_temp_tablespace(this);
+        }
+    }
+}
+
+
+export class Undo_tablespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNDO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNDO, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public tablespace(): TablespaceContext {
+        return this.getRuleContext(0, TablespaceContext)!;
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public file_specification(): File_specificationContext[];
+    public file_specification(i: number): File_specificationContext | null;
+    public file_specification(i?: number): File_specificationContext[] | File_specificationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(File_specificationContext);
+        }
+
+        return this.getRuleContext(i, File_specificationContext);
+    }
+    public BIGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIGFILE, 0);
+    }
+    public SMALLFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLFILE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_undo_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUndo_tablespace) {
+             listener.enterUndo_tablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUndo_tablespace) {
+             listener.exitUndo_tablespace(this);
+        }
+    }
+}
+
+
+export class Drop_databaseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public BACKUPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUPS, 0);
+    }
+    public NOPROMPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOPROMPT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_database;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_database) {
+             listener.enterDrop_database(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_database) {
+             listener.exitDrop_database(this);
+        }
+    }
+}
+
+
+export class Create_database_linkContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CREATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CREATE, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public LINK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LINK, 0)!;
+    }
+    public link_name(): Link_nameContext {
+        return this.getRuleContext(0, Link_nameContext)!;
+    }
+    public SHARED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARED, 0);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public CONNECT(): antlr.TerminalNode[];
+    public CONNECT(i: number): antlr.TerminalNode | null;
+    public CONNECT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONNECT);
+    	} else {
+    		return this.getToken(PlSqlParser.CONNECT, i);
+    	}
+    }
+    public TO(): antlr.TerminalNode[];
+    public TO(i: number): antlr.TerminalNode | null;
+    public TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TO);
+    	} else {
+    		return this.getToken(PlSqlParser.TO, i);
+    	}
+    }
+    public link_authentication(): Link_authenticationContext[];
+    public link_authentication(i: number): Link_authenticationContext | null;
+    public link_authentication(i?: number): Link_authenticationContext[] | Link_authenticationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Link_authenticationContext);
+        }
+
+        return this.getRuleContext(i, Link_authenticationContext);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public CURRENT_USER(): antlr.TerminalNode[];
+    public CURRENT_USER(i: number): antlr.TerminalNode | null;
+    public CURRENT_USER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CURRENT_USER);
+    	} else {
+    		return this.getToken(PlSqlParser.CURRENT_USER, i);
+    	}
+    }
+    public user_object_name(): User_object_nameContext[];
+    public user_object_name(i: number): User_object_nameContext | null;
+    public user_object_name(i?: number): User_object_nameContext[] | User_object_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_object_nameContext);
+        }
+
+        return this.getRuleContext(i, User_object_nameContext);
+    }
+    public IDENTIFIED(): antlr.TerminalNode[];
+    public IDENTIFIED(i: number): antlr.TerminalNode | null;
+    public IDENTIFIED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IDENTIFIED);
+    	} else {
+    		return this.getToken(PlSqlParser.IDENTIFIED, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode[];
+    public BY(i: number): antlr.TerminalNode | null;
+    public BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BY);
+    	} else {
+    		return this.getToken(PlSqlParser.BY, i);
+    	}
+    }
+    public password_value(): Password_valueContext[];
+    public password_value(i: number): Password_valueContext | null;
+    public password_value(i?: number): Password_valueContext[] | Password_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Password_valueContext);
+        }
+
+        return this.getRuleContext(i, Password_valueContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_create_database_link;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCreate_database_link) {
+             listener.enterCreate_database_link(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCreate_database_link) {
+             listener.exitCreate_database_link(this);
+        }
+    }
+}
+
+
+export class Drop_database_linkContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public DATABASE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DATABASE, 0)!;
+    }
+    public LINK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LINK, 0)!;
+    }
+    public link_name(): Link_nameContext {
+        return this.getRuleContext(0, Link_nameContext)!;
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_database_link;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_database_link) {
+             listener.enterDrop_database_link(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_database_link) {
+             listener.exitDrop_database_link(this);
+        }
+    }
+}
+
+
+export class Alter_tablespace_setContext extends antlr.ParserRuleContext {
+    public _tss?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public TABLESPACE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLESPACE, 0)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public alter_tablespace_attrs(): Alter_tablespace_attrsContext {
+        return this.getRuleContext(0, Alter_tablespace_attrsContext)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_tablespace_set;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_tablespace_set) {
+             listener.enterAlter_tablespace_set(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_tablespace_set) {
+             listener.exitAlter_tablespace_set(this);
+        }
+    }
+}
+
+
+export class Alter_tablespace_attrsContext extends antlr.ParserRuleContext {
+    public _nts?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public default_tablespace_params(): Default_tablespace_paramsContext | null {
+        return this.getRuleContext(0, Default_tablespace_paramsContext);
+    }
+    public MINIMUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINIMUM, 0);
+    }
+    public EXTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENT, 0);
+    }
+    public size_clause(): Size_clauseContext | null {
+        return this.getRuleContext(0, Size_clauseContext);
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public SHRINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHRINK, 0);
+    }
+    public SPACE_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPACE_KEYWORD, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public BEGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGIN, 0);
+    }
+    public END(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.END, 0);
+    }
+    public datafile_tempfile_clauses(): Datafile_tempfile_clausesContext | null {
+        return this.getRuleContext(0, Datafile_tempfile_clausesContext);
+    }
+    public tablespace_logging_clauses(): Tablespace_logging_clausesContext | null {
+        return this.getRuleContext(0, Tablespace_logging_clausesContext);
+    }
+    public tablespace_group_clause(): Tablespace_group_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_group_clauseContext);
+    }
+    public tablespace_state_clauses(): Tablespace_state_clausesContext | null {
+        return this.getRuleContext(0, Tablespace_state_clausesContext);
+    }
+    public autoextend_clause(): Autoextend_clauseContext | null {
+        return this.getRuleContext(0, Autoextend_clauseContext);
+    }
+    public flashback_mode_clause(): Flashback_mode_clauseContext | null {
+        return this.getRuleContext(0, Flashback_mode_clauseContext);
+    }
+    public tablespace_retention_clause(): Tablespace_retention_clauseContext | null {
+        return this.getRuleContext(0, Tablespace_retention_clauseContext);
+    }
+    public alter_tablespace_encryption(): Alter_tablespace_encryptionContext | null {
+        return this.getRuleContext(0, Alter_tablespace_encryptionContext);
+    }
+    public lost_write_protection(): Lost_write_protectionContext | null {
+        return this.getRuleContext(0, Lost_write_protectionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_tablespace_attrs;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_tablespace_attrs) {
+             listener.enterAlter_tablespace_attrs(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_tablespace_attrs) {
+             listener.exitAlter_tablespace_attrs(this);
+        }
+    }
+}
+
+
+export class Alter_tablespace_encryptionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENCRYPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0)!;
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public FINISH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINISH, 0);
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public REKEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REKEY, 0);
+    }
+    public DECRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECRYPT, 0);
+    }
+    public ts_file_name_convert(): Ts_file_name_convertContext | null {
+        return this.getRuleContext(0, Ts_file_name_convertContext);
+    }
+    public tablespace_encryption_spec(): Tablespace_encryption_specContext | null {
+        return this.getRuleContext(0, Tablespace_encryption_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_tablespace_encryption;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_tablespace_encryption) {
+             listener.enterAlter_tablespace_encryption(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_tablespace_encryption) {
+             listener.exitAlter_tablespace_encryption(this);
+        }
+    }
+}
+
+
+export class Ts_file_name_convertContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FILE_NAME_CONVERT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILE_NAME_CONVERT, 0)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ts_file_name_convert;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTs_file_name_convert) {
+             listener.enterTs_file_name_convert(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTs_file_name_convert) {
+             listener.exitTs_file_name_convert(this);
+        }
+    }
+}
+
+
+export class Alter_roleContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public ROLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLE, 0)!;
+    }
+    public role_name(): Role_nameContext {
+        return this.getRuleContext(0, Role_nameContext)!;
+    }
+    public role_identified_clause(): Role_identified_clauseContext {
+        return this.getRuleContext(0, Role_identified_clauseContext)!;
+    }
+    public container_clause(): Container_clauseContext | null {
+        return this.getRuleContext(0, Container_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_role;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_role) {
+             listener.enterAlter_role(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_role) {
+             listener.exitAlter_role(this);
+        }
+    }
+}
+
+
+export class Role_identified_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public IDENTIFIED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0)!;
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public EXTERNALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNALLY, 0);
+    }
+    public GLOBALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBALLY, 0);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_role_identified_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRole_identified_clause) {
+             listener.enterRole_identified_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRole_identified_clause) {
+             listener.exitRole_identified_clause(this);
+        }
+    }
+}
+
+
+export class Alter_tableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALTER, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public alter_table_body(): Alter_table_bodyContext | null {
+        return this.getRuleContext(0, Alter_table_bodyContext);
+    }
+    public memoptimize_read_write_clause(): Memoptimize_read_write_clauseContext[];
+    public memoptimize_read_write_clause(i: number): Memoptimize_read_write_clauseContext | null;
+    public memoptimize_read_write_clause(i?: number): Memoptimize_read_write_clauseContext[] | Memoptimize_read_write_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Memoptimize_read_write_clauseContext);
+        }
+
+        return this.getRuleContext(i, Memoptimize_read_write_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_table;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_table) {
+             listener.enterAlter_table(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_table) {
+             listener.exitAlter_table(this);
+        }
+    }
+}
+
+
+export class Alter_table_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public alter_table_action(): Alter_table_actionContext | null {
+        return this.getRuleContext(0, Alter_table_actionContext);
+    }
+    public enable_disable_clauses(): Enable_disable_clausesContext | null {
+        return this.getRuleContext(0, Enable_disable_clausesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_table_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_table_body) {
+             listener.enterAlter_table_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_table_body) {
+             listener.exitAlter_table_body(this);
+        }
+    }
+}
+
+
+export class Alter_table_actionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public alter_table_properties(): Alter_table_propertiesContext | null {
+        return this.getRuleContext(0, Alter_table_propertiesContext);
+    }
+    public constraint_clauses(): Constraint_clausesContext | null {
+        return this.getRuleContext(0, Constraint_clausesContext);
+    }
+    public column_clauses(): Column_clausesContext | null {
+        return this.getRuleContext(0, Column_clausesContext);
+    }
+    public alter_table_partitioning(): Alter_table_partitioningContext | null {
+        return this.getRuleContext(0, Alter_table_partitioningContext);
+    }
+    public move_table_clause(): Move_table_clauseContext | null {
+        return this.getRuleContext(0, Move_table_clauseContext);
+    }
+    public modify_to_partitioned(): Modify_to_partitionedContext | null {
+        return this.getRuleContext(0, Modify_to_partitionedContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_table_action;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_table_action) {
+             listener.enterAlter_table_action(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_table_action) {
+             listener.exitAlter_table_action(this);
+        }
+    }
+}
+
+
+export class Enable_disable_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public enable_disable_clause(): Enable_disable_clauseContext[];
+    public enable_disable_clause(i: number): Enable_disable_clauseContext | null;
+    public enable_disable_clause(i?: number): Enable_disable_clauseContext[] | Enable_disable_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Enable_disable_clauseContext);
+        }
+
+        return this.getRuleContext(i, Enable_disable_clauseContext);
+    }
+    public enable_or_disable(): Enable_or_disableContext[];
+    public enable_or_disable(i: number): Enable_or_disableContext | null;
+    public enable_or_disable(i?: number): Enable_or_disableContext[] | Enable_or_disableContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Enable_or_disableContext);
+        }
+
+        return this.getRuleContext(i, Enable_or_disableContext);
+    }
+    public TABLE(): antlr.TerminalNode[];
+    public TABLE(i: number): antlr.TerminalNode | null;
+    public TABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLE, i);
+    	}
+    }
+    public LOCK(): antlr.TerminalNode[];
+    public LOCK(i: number): antlr.TerminalNode | null;
+    public LOCK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOCK);
+    	} else {
+    		return this.getToken(PlSqlParser.LOCK, i);
+    	}
+    }
+    public ALL(): antlr.TerminalNode[];
+    public ALL(i: number): antlr.TerminalNode | null;
+    public ALL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ALL);
+    	} else {
+    		return this.getToken(PlSqlParser.ALL, i);
+    	}
+    }
+    public TRIGGERS(): antlr.TerminalNode[];
+    public TRIGGERS(i: number): antlr.TerminalNode | null;
+    public TRIGGERS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TRIGGERS);
+    	} else {
+    		return this.getToken(PlSqlParser.TRIGGERS, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_enable_disable_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEnable_disable_clauses) {
+             listener.enterEnable_disable_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEnable_disable_clauses) {
+             listener.exitEnable_disable_clauses(this);
+        }
+    }
+}
+
+
+export class Memoptimize_read_write_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MEMOPTIMIZE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEMOPTIMIZE, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_memoptimize_read_write_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMemoptimize_read_write_clause) {
+             listener.enterMemoptimize_read_write_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMemoptimize_read_write_clause) {
+             listener.exitMemoptimize_read_write_clause(this);
+        }
+    }
+}
+
+
+export class Alter_table_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public alter_table_properties_1(): Alter_table_properties_1Context | null {
+        return this.getRuleContext(0, Alter_table_properties_1Context);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public shrink_clause(): Shrink_clauseContext | null {
+        return this.getRuleContext(0, Shrink_clauseContext);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public REKEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REKEY, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public ARCHIVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVAL, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public annotations_clause(): Annotations_clauseContext | null {
+        return this.getRuleContext(0, Annotations_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_table_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_table_properties) {
+             listener.enterAlter_table_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_table_properties) {
+             listener.exitAlter_table_properties(this);
+        }
+    }
+}
+
+
+export class Alter_table_partitioningContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_table_partition(): Add_table_partitionContext | null {
+        return this.getRuleContext(0, Add_table_partitionContext);
+    }
+    public drop_table_partition(): Drop_table_partitionContext | null {
+        return this.getRuleContext(0, Drop_table_partitionContext);
+    }
+    public merge_table_partition(): Merge_table_partitionContext | null {
+        return this.getRuleContext(0, Merge_table_partitionContext);
+    }
+    public modify_table_partition(): Modify_table_partitionContext | null {
+        return this.getRuleContext(0, Modify_table_partitionContext);
+    }
+    public split_table_partition(): Split_table_partitionContext | null {
+        return this.getRuleContext(0, Split_table_partitionContext);
+    }
+    public truncate_table_partition(): Truncate_table_partitionContext | null {
+        return this.getRuleContext(0, Truncate_table_partitionContext);
+    }
+    public exchange_table_partition(): Exchange_table_partitionContext | null {
+        return this.getRuleContext(0, Exchange_table_partitionContext);
+    }
+    public coalesce_table_partition(): Coalesce_table_partitionContext | null {
+        return this.getRuleContext(0, Coalesce_table_partitionContext);
+    }
+    public alter_interval_partition(): Alter_interval_partitionContext | null {
+        return this.getRuleContext(0, Alter_interval_partitionContext);
+    }
+    public move_table_partition(): Move_table_partitionContext | null {
+        return this.getRuleContext(0, Move_table_partitionContext);
+    }
+    public rename_table_partition(): Rename_table_partitionContext | null {
+        return this.getRuleContext(0, Rename_table_partitionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_table_partitioning;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_table_partitioning) {
+             listener.enterAlter_table_partitioning(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_table_partitioning) {
+             listener.exitAlter_table_partitioning(this);
+        }
+    }
+}
+
+
+export class Add_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public range_partition_desc(): Range_partition_descContext | null {
+        return this.getRuleContext(0, Range_partition_descContext);
+    }
+    public list_partition_desc(): List_partition_descContext | null {
+        return this.getRuleContext(0, List_partition_descContext);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public partition_name(): Partition_nameContext | null {
+        return this.getRuleContext(0, Partition_nameContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public key_compression(): Key_compressionContext | null {
+        return this.getRuleContext(0, Key_compressionContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_table_partition) {
+             listener.enterAdd_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_table_partition) {
+             listener.exitAdd_table_partition(this);
+        }
+    }
+}
+
+
+export class Drop_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DROP, 0)!;
+    }
+    public partition_extended_names(): Partition_extended_namesContext | null {
+        return this.getRuleContext(0, Partition_extended_namesContext);
+    }
+    public subpartition_extended_names(): Subpartition_extended_namesContext | null {
+        return this.getRuleContext(0, Subpartition_extended_namesContext);
+    }
+    public update_index_clauses(): Update_index_clausesContext | null {
+        return this.getRuleContext(0, Update_index_clausesContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_table_partition) {
+             listener.enterDrop_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_table_partition) {
+             listener.exitDrop_table_partition(this);
+        }
+    }
+}
+
+
+export class Merge_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MERGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MERGE, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public AND(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AND, 0)!;
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_table_partition) {
+             listener.enterMerge_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_table_partition) {
+             listener.exitMerge_table_partition(this);
+        }
+    }
+}
+
+
+export class Modify_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public list_values_clause(): List_values_clauseContext | null {
+        return this.getRuleContext(0, List_values_clauseContext);
+    }
+    public ADD(): antlr.TerminalNode[];
+    public ADD(i: number): antlr.TerminalNode | null;
+    public ADD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ADD);
+    	} else {
+    		return this.getToken(PlSqlParser.ADD, i);
+    	}
+    }
+    public range_subpartition_desc(): Range_subpartition_descContext | null {
+        return this.getRuleContext(0, Range_subpartition_descContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public shrink_clause(): Shrink_clauseContext | null {
+        return this.getRuleContext(0, Shrink_clauseContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public REBUILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REBUILD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_table_partition) {
+             listener.enterModify_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_table_partition) {
+             listener.exitModify_table_partition(this);
+        }
+    }
+}
+
+
+export class Split_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SPLIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SPLIT, 0)!;
+    }
+    public partition_extended_names(): Partition_extended_namesContext {
+        return this.getRuleContext(0, Partition_extended_namesContext)!;
+    }
+    public AT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public literal(): LiteralContext[];
+    public literal(i: number): LiteralContext | null;
+    public literal(i?: number): LiteralContext[] | LiteralContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(LiteralContext);
+        }
+
+        return this.getRuleContext(i, LiteralContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public INTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTO, 0);
+    }
+    public range_partition_desc(): Range_partition_descContext[];
+    public range_partition_desc(i: number): Range_partition_descContext | null;
+    public range_partition_desc(i?: number): Range_partition_descContext[] | Range_partition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Range_partition_descContext);
+        }
+
+        return this.getRuleContext(i, Range_partition_descContext);
+    }
+    public update_global_index_clause(): Update_global_index_clauseContext | null {
+        return this.getRuleContext(0, Update_global_index_clauseContext);
+    }
+    public update_index_clauses(): Update_index_clausesContext | null {
+        return this.getRuleContext(0, Update_index_clausesContext);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public list_partition_desc(): List_partition_descContext[];
+    public list_partition_desc(i: number): List_partition_descContext | null;
+    public list_partition_desc(i?: number): List_partition_descContext[] | List_partition_descContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(List_partition_descContext);
+        }
+
+        return this.getRuleContext(i, List_partition_descContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_split_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSplit_table_partition) {
+             listener.enterSplit_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSplit_table_partition) {
+             listener.exitSplit_table_partition(this);
+        }
+    }
+}
+
+
+export class Truncate_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TRUNCATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRUNCATE, 0)!;
+    }
+    public partition_extended_names(): Partition_extended_namesContext | null {
+        return this.getRuleContext(0, Partition_extended_namesContext);
+    }
+    public subpartition_extended_names(): Subpartition_extended_namesContext | null {
+        return this.getRuleContext(0, Subpartition_extended_namesContext);
+    }
+    public STORAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORAGE, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public update_index_clauses(): Update_index_clausesContext | null {
+        return this.getRuleContext(0, Update_index_clausesContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_truncate_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTruncate_table_partition) {
+             listener.enterTruncate_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTruncate_table_partition) {
+             listener.exitTruncate_table_partition(this);
+        }
+    }
+}
+
+
+export class Exchange_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXCHANGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXCHANGE, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public WITH(): antlr.TerminalNode[];
+    public WITH(i: number): antlr.TerminalNode | null;
+    public WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WITH);
+    	} else {
+    		return this.getToken(PlSqlParser.WITH, i);
+    	}
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public VALIDATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATION, 0);
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public EXCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDING, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_exchange_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExchange_table_partition) {
+             listener.enterExchange_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExchange_table_partition) {
+             listener.exitExchange_table_partition(this);
+        }
+    }
+}
+
+
+export class Coalesce_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COALESCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COALESCE, 0)!;
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public allow_or_disallow(): Allow_or_disallowContext | null {
+        return this.getRuleContext(0, Allow_or_disallowContext);
+    }
+    public CLUSTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTERING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_coalesce_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCoalesce_table_partition) {
+             listener.enterCoalesce_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCoalesce_table_partition) {
+             listener.exitCoalesce_table_partition(this);
+        }
+    }
+}
+
+
+export class Alter_interval_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public INTERVAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTERVAL, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public constant(): ConstantContext | null {
+        return this.getRuleContext(0, ConstantContext);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_interval_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_interval_partition) {
+             listener.enterAlter_interval_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_interval_partition) {
+             listener.exitAlter_interval_partition(this);
+        }
+    }
+}
+
+
+export class Move_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVE, 0)!;
+    }
+    public partition_extended_names(): Partition_extended_namesContext | null {
+        return this.getRuleContext(0, Partition_extended_namesContext);
+    }
+    public table_partition_description(): Table_partition_descriptionContext | null {
+        return this.getRuleContext(0, Table_partition_descriptionContext);
+    }
+    public subpartition_extended_names(): Subpartition_extended_namesContext | null {
+        return this.getRuleContext(0, Subpartition_extended_namesContext);
+    }
+    public filter_condition(): Filter_conditionContext[];
+    public filter_condition(i: number): Filter_conditionContext | null;
+    public filter_condition(i?: number): Filter_conditionContext[] | Filter_conditionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Filter_conditionContext);
+        }
+
+        return this.getRuleContext(i, Filter_conditionContext);
+    }
+    public update_index_clauses(): Update_index_clausesContext[];
+    public update_index_clauses(i: number): Update_index_clausesContext | null;
+    public update_index_clauses(i?: number): Update_index_clausesContext[] | Update_index_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Update_index_clausesContext);
+        }
+
+        return this.getRuleContext(i, Update_index_clausesContext);
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public allow_or_disallow(): Allow_or_disallowContext[];
+    public allow_or_disallow(i: number): Allow_or_disallowContext | null;
+    public allow_or_disallow(i?: number): Allow_or_disallowContext[] | Allow_or_disallowContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allow_or_disallowContext);
+        }
+
+        return this.getRuleContext(i, Allow_or_disallowContext);
+    }
+    public CLUSTERING(): antlr.TerminalNode[];
+    public CLUSTERING(i: number): antlr.TerminalNode | null;
+    public CLUSTERING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CLUSTERING);
+    	} else {
+    		return this.getToken(PlSqlParser.CLUSTERING, i);
+    	}
+    }
+    public ONLINE(): antlr.TerminalNode[];
+    public ONLINE(i: number): antlr.TerminalNode | null;
+    public ONLINE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ONLINE);
+    	} else {
+    		return this.getToken(PlSqlParser.ONLINE, i);
+    	}
+    }
+    public MAPPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAPPING, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public indexing_clause(): Indexing_clauseContext | null {
+        return this.getRuleContext(0, Indexing_clauseContext);
+    }
+    public partitioning_storage_clause(): Partitioning_storage_clauseContext | null {
+        return this.getRuleContext(0, Partitioning_storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_move_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMove_table_partition) {
+             listener.enterMove_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMove_table_partition) {
+             listener.exitMove_table_partition(this);
+        }
+    }
+}
+
+
+export class Filter_conditionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INCLUDING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INCLUDING, 0)!;
+    }
+    public ROWS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROWS, 0)!;
+    }
+    public where_clause(): Where_clauseContext {
+        return this.getRuleContext(0, Where_clauseContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filter_condition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilter_condition) {
+             listener.enterFilter_condition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilter_condition) {
+             listener.exitFilter_condition(this);
+        }
+    }
+}
+
+
+export class Rename_table_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RENAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RENAME, 0)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public partition_name(): Partition_nameContext {
+        return this.getRuleContext(0, Partition_nameContext)!;
+    }
+    public partition_extended_names(): Partition_extended_namesContext | null {
+        return this.getRuleContext(0, Partition_extended_namesContext);
+    }
+    public subpartition_extended_names(): Subpartition_extended_namesContext | null {
+        return this.getRuleContext(0, Subpartition_extended_namesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rename_table_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRename_table_partition) {
+             listener.enterRename_table_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRename_table_partition) {
+             listener.exitRename_table_partition(this);
+        }
+    }
+}
+
+
+export class Partition_extended_namesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public PARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITIONS, 0);
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public partition_key_value(): Partition_key_valueContext[];
+    public partition_key_value(i: number): Partition_key_valueContext | null;
+    public partition_key_value(i?: number): Partition_key_valueContext[] | Partition_key_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_key_valueContext);
+        }
+
+        return this.getRuleContext(i, Partition_key_valueContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_extended_names;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_extended_names) {
+             listener.enterPartition_extended_names(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_extended_names) {
+             listener.exitPartition_extended_names(this);
+        }
+    }
+}
+
+
+export class Subpartition_extended_namesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public SUBPARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITIONS, 0);
+    }
+    public partition_name(): Partition_nameContext[];
+    public partition_name(i: number): Partition_nameContext | null;
+    public partition_name(i?: number): Partition_nameContext[] | Partition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Partition_nameContext);
+        }
+
+        return this.getRuleContext(i, Partition_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public subpartition_key_value(): Subpartition_key_valueContext[];
+    public subpartition_key_value(i: number): Subpartition_key_valueContext | null;
+    public subpartition_key_value(i?: number): Subpartition_key_valueContext[] | Subpartition_key_valueContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Subpartition_key_valueContext);
+        }
+
+        return this.getRuleContext(i, Subpartition_key_valueContext);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subpartition_extended_names;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubpartition_extended_names) {
+             listener.enterSubpartition_extended_names(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubpartition_extended_names) {
+             listener.exitSubpartition_extended_names(this);
+        }
+    }
+}
+
+
+export class Alter_table_properties_1Context extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public table_compression(): Table_compressionContext[];
+    public table_compression(i: number): Table_compressionContext | null;
+    public table_compression(i?: number): Table_compressionContext[] | Table_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_compressionContext);
+        }
+
+        return this.getRuleContext(i, Table_compressionContext);
+    }
+    public inmemory_table_clause(): Inmemory_table_clauseContext[];
+    public inmemory_table_clause(i: number): Inmemory_table_clauseContext | null;
+    public inmemory_table_clause(i?: number): Inmemory_table_clauseContext[] | Inmemory_table_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inmemory_table_clauseContext);
+        }
+
+        return this.getRuleContext(i, Inmemory_table_clauseContext);
+    }
+    public supplemental_table_logging(): Supplemental_table_loggingContext[];
+    public supplemental_table_logging(i: number): Supplemental_table_loggingContext | null;
+    public supplemental_table_logging(i?: number): Supplemental_table_loggingContext[] | Supplemental_table_loggingContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Supplemental_table_loggingContext);
+        }
+
+        return this.getRuleContext(i, Supplemental_table_loggingContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext[];
+    public allocate_extent_clause(i: number): Allocate_extent_clauseContext | null;
+    public allocate_extent_clause(i?: number): Allocate_extent_clauseContext[] | Allocate_extent_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allocate_extent_clauseContext);
+        }
+
+        return this.getRuleContext(i, Allocate_extent_clauseContext);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext[];
+    public deallocate_unused_clause(i: number): Deallocate_unused_clauseContext | null;
+    public deallocate_unused_clause(i?: number): Deallocate_unused_clauseContext[] | Deallocate_unused_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Deallocate_unused_clauseContext);
+        }
+
+        return this.getRuleContext(i, Deallocate_unused_clauseContext);
+    }
+    public RESULT_CACHE(): antlr.TerminalNode[];
+    public RESULT_CACHE(i: number): antlr.TerminalNode | null;
+    public RESULT_CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RESULT_CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.RESULT_CACHE, i);
+    	}
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public MODE(): antlr.TerminalNode[];
+    public MODE(i: number): antlr.TerminalNode | null;
+    public MODE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MODE);
+    	} else {
+    		return this.getToken(PlSqlParser.MODE, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public upgrade_table_clause(): Upgrade_table_clauseContext[];
+    public upgrade_table_clause(i: number): Upgrade_table_clauseContext | null;
+    public upgrade_table_clause(i?: number): Upgrade_table_clauseContext[] | Upgrade_table_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Upgrade_table_clauseContext);
+        }
+
+        return this.getRuleContext(i, Upgrade_table_clauseContext);
+    }
+    public records_per_block_clause(): Records_per_block_clauseContext[];
+    public records_per_block_clause(i: number): Records_per_block_clauseContext | null;
+    public records_per_block_clause(i?: number): Records_per_block_clauseContext[] | Records_per_block_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Records_per_block_clauseContext);
+        }
+
+        return this.getRuleContext(i, Records_per_block_clauseContext);
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public row_movement_clause(): Row_movement_clauseContext[];
+    public row_movement_clause(i: number): Row_movement_clauseContext | null;
+    public row_movement_clause(i?: number): Row_movement_clauseContext[] | Row_movement_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Row_movement_clauseContext);
+        }
+
+        return this.getRuleContext(i, Row_movement_clauseContext);
+    }
+    public logical_replication_clause(): Logical_replication_clauseContext[];
+    public logical_replication_clause(i: number): Logical_replication_clauseContext | null;
+    public logical_replication_clause(i?: number): Logical_replication_clauseContext[] | Logical_replication_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logical_replication_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logical_replication_clauseContext);
+    }
+    public flashback_archive_clause(): Flashback_archive_clauseContext[];
+    public flashback_archive_clause(i: number): Flashback_archive_clauseContext | null;
+    public flashback_archive_clause(i?: number): Flashback_archive_clauseContext[] | Flashback_archive_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Flashback_archive_clauseContext);
+        }
+
+        return this.getRuleContext(i, Flashback_archive_clauseContext);
+    }
+    public alter_iot_clauses(): Alter_iot_clausesContext | null {
+        return this.getRuleContext(0, Alter_iot_clausesContext);
+    }
+    public CACHE(): antlr.TerminalNode[];
+    public CACHE(i: number): antlr.TerminalNode | null;
+    public CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.CACHE, i);
+    	}
+    }
+    public NOCACHE(): antlr.TerminalNode[];
+    public NOCACHE(i: number): antlr.TerminalNode | null;
+    public NOCACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOCACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.NOCACHE, i);
+    	}
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public FORCE(): antlr.TerminalNode[];
+    public FORCE(i: number): antlr.TerminalNode | null;
+    public FORCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FORCE);
+    	} else {
+    		return this.getToken(PlSqlParser.FORCE, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_table_properties_1;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_table_properties_1) {
+             listener.enterAlter_table_properties_1(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_table_properties_1) {
+             listener.exitAlter_table_properties_1(this);
+        }
+    }
+}
+
+
+export class Alter_iot_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public index_org_table_clause(): Index_org_table_clauseContext | null {
+        return this.getRuleContext(0, Index_org_table_clauseContext);
+    }
+    public alter_overflow_clause(): Alter_overflow_clauseContext | null {
+        return this.getRuleContext(0, Alter_overflow_clauseContext);
+    }
+    public alter_mapping_table_clause(): Alter_mapping_table_clauseContext | null {
+        return this.getRuleContext(0, Alter_mapping_table_clauseContext);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_iot_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_iot_clauses) {
+             listener.enterAlter_iot_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_iot_clauses) {
+             listener.exitAlter_iot_clauses(this);
+        }
+    }
+}
+
+
+export class Alter_mapping_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MAPPING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MAPPING, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext | null {
+        return this.getRuleContext(0, Allocate_extent_clauseContext);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext | null {
+        return this.getRuleContext(0, Deallocate_unused_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_mapping_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_mapping_table_clause) {
+             listener.enterAlter_mapping_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_mapping_table_clause) {
+             listener.exitAlter_mapping_table_clause(this);
+        }
+    }
+}
+
+
+export class Alter_overflow_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_overflow_clause(): Add_overflow_clauseContext | null {
+        return this.getRuleContext(0, Add_overflow_clauseContext);
+    }
+    public OVERFLOW_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext[];
+    public segment_attributes_clause(i: number): Segment_attributes_clauseContext | null;
+    public segment_attributes_clause(i?: number): Segment_attributes_clauseContext[] | Segment_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_attributes_clauseContext);
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext[];
+    public allocate_extent_clause(i: number): Allocate_extent_clauseContext | null;
+    public allocate_extent_clause(i?: number): Allocate_extent_clauseContext[] | Allocate_extent_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allocate_extent_clauseContext);
+        }
+
+        return this.getRuleContext(i, Allocate_extent_clauseContext);
+    }
+    public shrink_clause(): Shrink_clauseContext[];
+    public shrink_clause(i: number): Shrink_clauseContext | null;
+    public shrink_clause(i?: number): Shrink_clauseContext[] | Shrink_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Shrink_clauseContext);
+        }
+
+        return this.getRuleContext(i, Shrink_clauseContext);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext[];
+    public deallocate_unused_clause(i: number): Deallocate_unused_clauseContext | null;
+    public deallocate_unused_clause(i?: number): Deallocate_unused_clauseContext[] | Deallocate_unused_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Deallocate_unused_clauseContext);
+        }
+
+        return this.getRuleContext(i, Deallocate_unused_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_alter_overflow_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAlter_overflow_clause) {
+             listener.enterAlter_overflow_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAlter_overflow_clause) {
+             listener.exitAlter_overflow_clause(this);
+        }
+    }
+}
+
+
+export class Add_overflow_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public OVERFLOW_(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0)!;
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext[];
+    public segment_attributes_clause(i: number): Segment_attributes_clauseContext | null;
+    public segment_attributes_clause(i?: number): Segment_attributes_clauseContext[] | Segment_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Segment_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Segment_attributes_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public PARTITION(): antlr.TerminalNode[];
+    public PARTITION(i: number): antlr.TerminalNode | null;
+    public PARTITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PARTITION);
+    	} else {
+    		return this.getToken(PlSqlParser.PARTITION, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_overflow_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_overflow_clause) {
+             listener.enterAdd_overflow_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_overflow_clause) {
+             listener.exitAdd_overflow_clause(this);
+        }
+    }
+}
+
+
+export class Update_index_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public update_global_index_clause(): Update_global_index_clauseContext | null {
+        return this.getRuleContext(0, Update_global_index_clauseContext);
+    }
+    public update_all_indexes_clause(): Update_all_indexes_clauseContext | null {
+        return this.getRuleContext(0, Update_all_indexes_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_index_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_index_clauses) {
+             listener.enterUpdate_index_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_index_clauses) {
+             listener.exitUpdate_index_clauses(this);
+        }
+    }
+}
+
+
+export class Update_global_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GLOBAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GLOBAL, 0)!;
+    }
+    public INDEXES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEXES, 0)!;
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public INVALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVALIDATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_global_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_global_index_clause) {
+             listener.enterUpdate_global_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_global_index_clause) {
+             listener.exitUpdate_global_index_clause(this);
+        }
+    }
+}
+
+
+export class Update_all_indexes_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UPDATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UPDATE, 0)!;
+    }
+    public INDEXES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEXES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public update_all_indexes_index_clause(): Update_all_indexes_index_clauseContext | null {
+        return this.getRuleContext(0, Update_all_indexes_index_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_all_indexes_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_all_indexes_clause) {
+             listener.enterUpdate_all_indexes_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_all_indexes_clause) {
+             listener.exitUpdate_all_indexes_clause(this);
+        }
+    }
+}
+
+
+export class Update_all_indexes_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public index_name(): Index_nameContext {
+        return this.getRuleContext(0, Index_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public update_index_partition(): Update_index_partitionContext | null {
+        return this.getRuleContext(0, Update_index_partitionContext);
+    }
+    public update_index_subpartition(): Update_index_subpartitionContext | null {
+        return this.getRuleContext(0, Update_index_subpartitionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public update_all_indexes_clause(): Update_all_indexes_clauseContext[];
+    public update_all_indexes_clause(i: number): Update_all_indexes_clauseContext | null;
+    public update_all_indexes_clause(i?: number): Update_all_indexes_clauseContext[] | Update_all_indexes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Update_all_indexes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Update_all_indexes_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_all_indexes_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_all_indexes_index_clause) {
+             listener.enterUpdate_all_indexes_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_all_indexes_index_clause) {
+             listener.exitUpdate_all_indexes_index_clause(this);
+        }
+    }
+}
+
+
+export class Update_index_partitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public index_partition_description(): Index_partition_descriptionContext {
+        return this.getRuleContext(0, Index_partition_descriptionContext)!;
+    }
+    public index_subpartition_clause(): Index_subpartition_clauseContext | null {
+        return this.getRuleContext(0, Index_subpartition_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public update_index_partition(): Update_index_partitionContext[];
+    public update_index_partition(i: number): Update_index_partitionContext | null;
+    public update_index_partition(i?: number): Update_index_partitionContext[] | Update_index_partitionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Update_index_partitionContext);
+        }
+
+        return this.getRuleContext(i, Update_index_partitionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_index_partition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_index_partition) {
+             listener.enterUpdate_index_partition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_index_partition) {
+             listener.exitUpdate_index_partition(this);
+        }
+    }
+}
+
+
+export class Update_index_subpartitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBPARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0)!;
+    }
+    public subpartition_name(): Subpartition_nameContext | null {
+        return this.getRuleContext(0, Subpartition_nameContext);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public tablespace(): TablespaceContext | null {
+        return this.getRuleContext(0, TablespaceContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public update_index_subpartition(): Update_index_subpartitionContext[];
+    public update_index_subpartition(i: number): Update_index_subpartitionContext | null;
+    public update_index_subpartition(i?: number): Update_index_subpartitionContext[] | Update_index_subpartitionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Update_index_subpartitionContext);
+        }
+
+        return this.getRuleContext(i, Update_index_subpartitionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_index_subpartition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_index_subpartition) {
+             listener.enterUpdate_index_subpartition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_index_subpartition) {
+             listener.exitUpdate_index_subpartition(this);
+        }
+    }
+}
+
+
+export class Enable_disable_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public using_index_clause(): Using_index_clauseContext | null {
+        return this.getRuleContext(0, Using_index_clauseContext);
+    }
+    public exceptions_clause(): Exceptions_clauseContext | null {
+        return this.getRuleContext(0, Exceptions_clauseContext);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public VALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATE, 0);
+    }
+    public NOVALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOVALIDATE, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_enable_disable_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEnable_disable_clause) {
+             listener.enterEnable_disable_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEnable_disable_clause) {
+             listener.exitEnable_disable_clause(this);
+        }
+    }
+}
+
+
+export class Using_index_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public INDEX(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDEX, 0)!;
+    }
+    public index_name(): Index_nameContext | null {
+        return this.getRuleContext(0, Index_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public create_index(): Create_indexContext | null {
+        return this.getRuleContext(0, Create_indexContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public index_properties(): Index_propertiesContext | null {
+        return this.getRuleContext(0, Index_propertiesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_index_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_index_clause) {
+             listener.enterUsing_index_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_index_clause) {
+             listener.exitUsing_index_clause(this);
+        }
+    }
+}
+
+
+export class Index_attributesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public physical_attributes_clause(): Physical_attributes_clauseContext[];
+    public physical_attributes_clause(i: number): Physical_attributes_clauseContext | null;
+    public physical_attributes_clause(i?: number): Physical_attributes_clauseContext[] | Physical_attributes_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_attributes_clauseContext);
+        }
+
+        return this.getRuleContext(i, Physical_attributes_clauseContext);
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public ONLINE(): antlr.TerminalNode[];
+    public ONLINE(i: number): antlr.TerminalNode | null;
+    public ONLINE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ONLINE);
+    	} else {
+    		return this.getToken(PlSqlParser.ONLINE, i);
+    	}
+    }
+    public TABLESPACE(): antlr.TerminalNode[];
+    public TABLESPACE(i: number): antlr.TerminalNode | null;
+    public TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.TABLESPACE);
+    	} else {
+    		return this.getToken(PlSqlParser.TABLESPACE, i);
+    	}
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public sort_or_nosort(): Sort_or_nosortContext[];
+    public sort_or_nosort(i: number): Sort_or_nosortContext | null;
+    public sort_or_nosort(i?: number): Sort_or_nosortContext[] | Sort_or_nosortContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sort_or_nosortContext);
+        }
+
+        return this.getRuleContext(i, Sort_or_nosortContext);
+    }
+    public REVERSE(): antlr.TerminalNode[];
+    public REVERSE(i: number): antlr.TerminalNode | null;
+    public REVERSE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.REVERSE);
+    	} else {
+    		return this.getToken(PlSqlParser.REVERSE, i);
+    	}
+    }
+    public visible_or_invisible(): Visible_or_invisibleContext[];
+    public visible_or_invisible(i: number): Visible_or_invisibleContext | null;
+    public visible_or_invisible(i?: number): Visible_or_invisibleContext[] | Visible_or_invisibleContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Visible_or_invisibleContext);
+        }
+
+        return this.getRuleContext(i, Visible_or_invisibleContext);
+    }
+    public parallel_clause(): Parallel_clauseContext[];
+    public parallel_clause(i: number): Parallel_clauseContext | null;
+    public parallel_clause(i?: number): Parallel_clauseContext[] | Parallel_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parallel_clauseContext);
+        }
+
+        return this.getRuleContext(i, Parallel_clauseContext);
+    }
+    public tablespace(): TablespaceContext[];
+    public tablespace(i: number): TablespaceContext | null;
+    public tablespace(i?: number): TablespaceContext[] | TablespaceContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(TablespaceContext);
+        }
+
+        return this.getRuleContext(i, TablespaceContext);
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_attributes;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_attributes) {
+             listener.enterIndex_attributes(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_attributes) {
+             listener.exitIndex_attributes(this);
+        }
+    }
+}
+
+
+export class Sort_or_nosortContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SORT, 0);
+    }
+    public NOSORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSORT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sort_or_nosort;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSort_or_nosort) {
+             listener.enterSort_or_nosort(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSort_or_nosort) {
+             listener.exitSort_or_nosort(this);
+        }
+    }
+}
+
+
+export class Exceptions_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXCEPTIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXCEPTIONS, 0)!;
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_exceptions_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExceptions_clause) {
+             listener.enterExceptions_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExceptions_clause) {
+             listener.exitExceptions_clause(this);
+        }
+    }
+}
+
+
+export class Move_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MOVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MOVE, 0)!;
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext | null {
+        return this.getRuleContext(0, Segment_attributes_clauseContext);
+    }
+    public table_compression(): Table_compressionContext | null {
+        return this.getRuleContext(0, Table_compressionContext);
+    }
+    public index_org_table_clause(): Index_org_table_clauseContext | null {
+        return this.getRuleContext(0, Index_org_table_clauseContext);
+    }
+    public lob_storage_clause(): Lob_storage_clauseContext[];
+    public lob_storage_clause(i: number): Lob_storage_clauseContext | null;
+    public lob_storage_clause(i?: number): Lob_storage_clauseContext[] | Lob_storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_storage_clauseContext);
+    }
+    public varray_col_properties(): Varray_col_propertiesContext[];
+    public varray_col_properties(i: number): Varray_col_propertiesContext | null;
+    public varray_col_properties(i?: number): Varray_col_propertiesContext[] | Varray_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Varray_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Varray_col_propertiesContext);
+    }
+    public parallel_clause(): Parallel_clauseContext | null {
+        return this.getRuleContext(0, Parallel_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_move_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMove_table_clause) {
+             listener.enterMove_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMove_table_clause) {
+             listener.exitMove_table_clause(this);
+        }
+    }
+}
+
+
+export class Modify_to_partitionedContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public table_partitioning_clauses(): Table_partitioning_clausesContext | null {
+        return this.getRuleContext(0, Table_partitioning_clausesContext);
+    }
+    public NONPARTITIONED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONPARTITIONED, 0);
+    }
+    public filter_condition(): Filter_conditionContext | null {
+        return this.getRuleContext(0, Filter_conditionContext);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public update_index_clauses(): Update_index_clausesContext | null {
+        return this.getRuleContext(0, Update_index_clausesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_to_partitioned;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_to_partitioned) {
+             listener.enterModify_to_partitioned(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_to_partitioned) {
+             listener.exitModify_to_partitioned(this);
+        }
+    }
+}
+
+
+export class Index_org_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public mapping_table_clause(): Mapping_table_clauseContext[];
+    public mapping_table_clause(i: number): Mapping_table_clauseContext | null;
+    public mapping_table_clause(i?: number): Mapping_table_clauseContext[] | Mapping_table_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Mapping_table_clauseContext);
+        }
+
+        return this.getRuleContext(i, Mapping_table_clauseContext);
+    }
+    public PCTTHRESHOLD(): antlr.TerminalNode[];
+    public PCTTHRESHOLD(i: number): antlr.TerminalNode | null;
+    public PCTTHRESHOLD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTTHRESHOLD);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTTHRESHOLD, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public key_compression(): Key_compressionContext[];
+    public key_compression(i: number): Key_compressionContext | null;
+    public key_compression(i?: number): Key_compressionContext[] | Key_compressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Key_compressionContext);
+        }
+
+        return this.getRuleContext(i, Key_compressionContext);
+    }
+    public index_org_overflow_clause(): Index_org_overflow_clauseContext | null {
+        return this.getRuleContext(0, Index_org_overflow_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_org_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_org_table_clause) {
+             listener.enterIndex_org_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_org_table_clause) {
+             listener.exitIndex_org_table_clause(this);
+        }
+    }
+}
+
+
+export class Mapping_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MAPPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAPPING, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public NOMAPPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMAPPING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_mapping_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMapping_table_clause) {
+             listener.enterMapping_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMapping_table_clause) {
+             listener.exitMapping_table_clause(this);
+        }
+    }
+}
+
+
+export class Key_compressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NOCOMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOMPRESS, 0);
+    }
+    public COMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESS, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_key_compression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterKey_compression) {
+             listener.enterKey_compression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitKey_compression) {
+             listener.exitKey_compression(this);
+        }
+    }
+}
+
+
+export class Index_org_overflow_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OVERFLOW_(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0)!;
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public segment_attributes_clause(): Segment_attributes_clauseContext | null {
+        return this.getRuleContext(0, Segment_attributes_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_org_overflow_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_org_overflow_clause) {
+             listener.enterIndex_org_overflow_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_org_overflow_clause) {
+             listener.exitIndex_org_overflow_clause(this);
+        }
+    }
+}
+
+
+export class Column_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public add_modify_drop_column_clauses(): Add_modify_drop_column_clausesContext | null {
+        return this.getRuleContext(0, Add_modify_drop_column_clausesContext);
+    }
+    public rename_column_clause(): Rename_column_clauseContext | null {
+        return this.getRuleContext(0, Rename_column_clauseContext);
+    }
+    public modify_collection_retrieval(): Modify_collection_retrievalContext | null {
+        return this.getRuleContext(0, Modify_collection_retrievalContext);
+    }
+    public modify_lob_storage_clause(): Modify_lob_storage_clauseContext | null {
+        return this.getRuleContext(0, Modify_lob_storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_clauses) {
+             listener.enterColumn_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_clauses) {
+             listener.exitColumn_clauses(this);
+        }
+    }
+}
+
+
+export class Modify_collection_retrievalContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public NESTED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NESTED, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public collection_item(): Collection_itemContext {
+        return this.getRuleContext(0, Collection_itemContext)!;
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public LOCATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCATOR, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_collection_retrieval;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_collection_retrieval) {
+             listener.enterModify_collection_retrieval(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_collection_retrieval) {
+             listener.exitModify_collection_retrieval(this);
+        }
+    }
+}
+
+
+export class Collection_itemContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_collection_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCollection_item) {
+             listener.enterCollection_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCollection_item) {
+             listener.exitCollection_item(this);
+        }
+    }
+}
+
+
+export class Rename_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RENAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RENAME, 0)!;
+    }
+    public COLUMN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMN, 0)!;
+    }
+    public old_column_name(): Old_column_nameContext {
+        return this.getRuleContext(0, Old_column_nameContext)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public new_column_name(): New_column_nameContext {
+        return this.getRuleContext(0, New_column_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rename_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRename_column_clause) {
+             listener.enterRename_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRename_column_clause) {
+             listener.exitRename_column_clause(this);
+        }
+    }
+}
+
+
+export class Old_column_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_old_column_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOld_column_name) {
+             listener.enterOld_column_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOld_column_name) {
+             listener.exitOld_column_name(this);
+        }
+    }
+}
+
+
+export class New_column_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_new_column_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNew_column_name) {
+             listener.enterNew_column_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNew_column_name) {
+             listener.exitNew_column_name(this);
+        }
+    }
+}
+
+
+export class Add_modify_drop_column_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public constraint_clauses(): Constraint_clausesContext[];
+    public constraint_clauses(i: number): Constraint_clausesContext | null;
+    public constraint_clauses(i?: number): Constraint_clausesContext[] | Constraint_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Constraint_clausesContext);
+        }
+
+        return this.getRuleContext(i, Constraint_clausesContext);
+    }
+    public add_column_clause(): Add_column_clauseContext[];
+    public add_column_clause(i: number): Add_column_clauseContext | null;
+    public add_column_clause(i?: number): Add_column_clauseContext[] | Add_column_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Add_column_clauseContext);
+        }
+
+        return this.getRuleContext(i, Add_column_clauseContext);
+    }
+    public modify_column_clauses(): Modify_column_clausesContext[];
+    public modify_column_clauses(i: number): Modify_column_clausesContext | null;
+    public modify_column_clauses(i?: number): Modify_column_clausesContext[] | Modify_column_clausesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Modify_column_clausesContext);
+        }
+
+        return this.getRuleContext(i, Modify_column_clausesContext);
+    }
+    public drop_column_clause(): Drop_column_clauseContext[];
+    public drop_column_clause(i: number): Drop_column_clauseContext | null;
+    public drop_column_clause(i?: number): Drop_column_clauseContext[] | Drop_column_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Drop_column_clauseContext);
+        }
+
+        return this.getRuleContext(i, Drop_column_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_modify_drop_column_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_modify_drop_column_clauses) {
+             listener.enterAdd_modify_drop_column_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_modify_drop_column_clauses) {
+             listener.exitAdd_modify_drop_column_clauses(this);
+        }
+    }
+}
+
+
+export class Drop_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public UNUSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSED, 0);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public CASCADE(): antlr.TerminalNode[];
+    public CASCADE(i: number): antlr.TerminalNode | null;
+    public CASCADE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CASCADE);
+    	} else {
+    		return this.getToken(PlSqlParser.CASCADE, i);
+    	}
+    }
+    public CONSTRAINTS(): antlr.TerminalNode[];
+    public CONSTRAINTS(i: number): antlr.TerminalNode | null;
+    public CONSTRAINTS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CONSTRAINTS);
+    	} else {
+    		return this.getToken(PlSqlParser.CONSTRAINTS, i);
+    	}
+    }
+    public INVALIDATE(): antlr.TerminalNode[];
+    public INVALIDATE(i: number): antlr.TerminalNode | null;
+    public INVALIDATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INVALIDATE);
+    	} else {
+    		return this.getToken(PlSqlParser.INVALIDATE, i);
+    	}
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public CHECKPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECKPOINT, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMNS, 0);
+    }
+    public CONTINUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTINUE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_column_clause) {
+             listener.enterDrop_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_column_clause) {
+             listener.exitDrop_column_clause(this);
+        }
+    }
+}
+
+
+export class Modify_column_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public modify_col_properties(): Modify_col_propertiesContext[];
+    public modify_col_properties(i: number): Modify_col_propertiesContext | null;
+    public modify_col_properties(i?: number): Modify_col_propertiesContext[] | Modify_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Modify_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Modify_col_propertiesContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public modify_col_visibility(): Modify_col_visibilityContext[];
+    public modify_col_visibility(i: number): Modify_col_visibilityContext | null;
+    public modify_col_visibility(i?: number): Modify_col_visibilityContext[] | Modify_col_visibilityContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Modify_col_visibilityContext);
+        }
+
+        return this.getRuleContext(i, Modify_col_visibilityContext);
+    }
+    public modify_col_substitutable(): Modify_col_substitutableContext | null {
+        return this.getRuleContext(0, Modify_col_substitutableContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_column_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_column_clauses) {
+             listener.enterModify_column_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_column_clauses) {
+             listener.exitModify_column_clauses(this);
+        }
+    }
+}
+
+
+export class Modify_col_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public datatype(): DatatypeContext | null {
+        return this.getRuleContext(0, DatatypeContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public identity_clause(): Identity_clauseContext | null {
+        return this.getRuleContext(0, Identity_clauseContext);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public IDENTITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTITY, 0);
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public encryption_spec(): Encryption_specContext | null {
+        return this.getRuleContext(0, Encryption_specContext);
+    }
+    public DECRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECRYPT, 0);
+    }
+    public inline_constraint(): Inline_constraintContext[];
+    public inline_constraint(i: number): Inline_constraintContext | null;
+    public inline_constraint(i?: number): Inline_constraintContext[] | Inline_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inline_constraintContext);
+        }
+
+        return this.getRuleContext(i, Inline_constraintContext);
+    }
+    public lob_storage_clause(): Lob_storage_clauseContext | null {
+        return this.getRuleContext(0, Lob_storage_clauseContext);
+    }
+    public annotations_clause(): Annotations_clauseContext | null {
+        return this.getRuleContext(0, Annotations_clauseContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_col_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_col_properties) {
+             listener.enterModify_col_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_col_properties) {
+             listener.exitModify_col_properties(this);
+        }
+    }
+}
+
+
+export class Modify_col_visibilityContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public VISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBLE, 0);
+    }
+    public INVISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVISIBLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_col_visibility;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_col_visibility) {
+             listener.enterModify_col_visibility(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_col_visibility) {
+             listener.exitModify_col_visibility(this);
+        }
+    }
+}
+
+
+export class Modify_col_substitutableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COLUMN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public SUBSTITUTABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBSTITUTABLE, 0)!;
+    }
+    public AT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AT, 0)!;
+    }
+    public ALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ALL, 0)!;
+    }
+    public LEVELS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEVELS, 0)!;
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_col_substitutable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_col_substitutable) {
+             listener.enterModify_col_substitutable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_col_substitutable) {
+             listener.exitModify_col_substitutable(this);
+        }
+    }
+}
+
+
+export class Add_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public column_properties(): Column_propertiesContext | null {
+        return this.getRuleContext(0, Column_propertiesContext);
+    }
+    public column_definition(): Column_definitionContext[];
+    public column_definition(i: number): Column_definitionContext | null;
+    public column_definition(i?: number): Column_definitionContext[] | Column_definitionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_definitionContext);
+        }
+
+        return this.getRuleContext(i, Column_definitionContext);
+    }
+    public virtual_column_definition(): Virtual_column_definitionContext[];
+    public virtual_column_definition(i: number): Virtual_column_definitionContext | null;
+    public virtual_column_definition(i?: number): Virtual_column_definitionContext[] | Virtual_column_definitionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Virtual_column_definitionContext);
+        }
+
+        return this.getRuleContext(i, Virtual_column_definitionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_column_clause) {
+             listener.enterAdd_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_column_clause) {
+             listener.exitAdd_column_clause(this);
+        }
+    }
+}
+
+
+export class Varray_col_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VARRAY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VARRAY, 0)!;
+    }
+    public varray_item(): Varray_itemContext {
+        return this.getRuleContext(0, Varray_itemContext)!;
+    }
+    public varray_storage_clause(): Varray_storage_clauseContext | null {
+        return this.getRuleContext(0, Varray_storage_clauseContext);
+    }
+    public substitutable_column_clause(): Substitutable_column_clauseContext | null {
+        return this.getRuleContext(0, Substitutable_column_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_varray_col_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVarray_col_properties) {
+             listener.enterVarray_col_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVarray_col_properties) {
+             listener.exitVarray_col_properties(this);
+        }
+    }
+}
+
+
+export class Varray_storage_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STORE, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public LOB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOB, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public lob_storage_parameters(): Lob_storage_parametersContext | null {
+        return this.getRuleContext(0, Lob_storage_parametersContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public lob_segname(): Lob_segnameContext | null {
+        return this.getRuleContext(0, Lob_segnameContext);
+    }
+    public SECUREFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECUREFILE, 0);
+    }
+    public BASICFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASICFILE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_varray_storage_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVarray_storage_clause) {
+             listener.enterVarray_storage_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVarray_storage_clause) {
+             listener.exitVarray_storage_clause(this);
+        }
+    }
+}
+
+
+export class Lob_segnameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_segname;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_segname) {
+             listener.enterLob_segname(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_segname) {
+             listener.exitLob_segname(this);
+        }
+    }
+}
+
+
+export class Lob_itemContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_item) {
+             listener.enterLob_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_item) {
+             listener.exitLob_item(this);
+        }
+    }
+}
+
+
+export class Lob_storage_parametersContext extends antlr.ParserRuleContext {
+    public _tablespace_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public lob_parameters(): Lob_parametersContext | null {
+        return this.getRuleContext(0, Lob_parametersContext);
+    }
+    public storage_clause(): Storage_clauseContext | null {
+        return this.getRuleContext(0, Storage_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_storage_parameters;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_storage_parameters) {
+             listener.enterLob_storage_parameters(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_storage_parameters) {
+             listener.exitLob_storage_parameters(this);
+        }
+    }
+}
+
+
+export class Lob_storage_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOB, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public lob_item(): Lob_itemContext[];
+    public lob_item(i: number): Lob_itemContext | null;
+    public lob_item(i?: number): Lob_itemContext[] | Lob_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_itemContext);
+        }
+
+        return this.getRuleContext(i, Lob_itemContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public lob_segname(): Lob_segnameContext[];
+    public lob_segname(i: number): Lob_segnameContext | null;
+    public lob_segname(i?: number): Lob_segnameContext[] | Lob_segnameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_segnameContext);
+        }
+
+        return this.getRuleContext(i, Lob_segnameContext);
+    }
+    public SECUREFILE(): antlr.TerminalNode[];
+    public SECUREFILE(i: number): antlr.TerminalNode | null;
+    public SECUREFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SECUREFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.SECUREFILE, i);
+    	}
+    }
+    public BASICFILE(): antlr.TerminalNode[];
+    public BASICFILE(i: number): antlr.TerminalNode | null;
+    public BASICFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BASICFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.BASICFILE, i);
+    	}
+    }
+    public lob_storage_parameters(): Lob_storage_parametersContext[];
+    public lob_storage_parameters(i: number): Lob_storage_parametersContext | null;
+    public lob_storage_parameters(i?: number): Lob_storage_parametersContext[] | Lob_storage_parametersContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_storage_parametersContext);
+        }
+
+        return this.getRuleContext(i, Lob_storage_parametersContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_storage_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_storage_clause) {
+             listener.enterLob_storage_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_storage_clause) {
+             listener.exitLob_storage_clause(this);
+        }
+    }
+}
+
+
+export class Modify_lob_storage_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODIFY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODIFY, 0)!;
+    }
+    public LOB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOB, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public lob_item(): Lob_itemContext {
+        return this.getRuleContext(0, Lob_itemContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public modify_lob_parameters(): Modify_lob_parametersContext {
+        return this.getRuleContext(0, Modify_lob_parametersContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_lob_storage_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_lob_storage_clause) {
+             listener.enterModify_lob_storage_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_lob_storage_clause) {
+             listener.exitModify_lob_storage_clause(this);
+        }
+    }
+}
+
+
+export class Modify_lob_parametersContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public storage_clause(): Storage_clauseContext[];
+    public storage_clause(i: number): Storage_clauseContext | null;
+    public storage_clause(i?: number): Storage_clauseContext[] | Storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Storage_clauseContext);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public REBUILD(): antlr.TerminalNode[];
+    public REBUILD(i: number): antlr.TerminalNode | null;
+    public REBUILD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.REBUILD);
+    	} else {
+    		return this.getToken(PlSqlParser.REBUILD, i);
+    	}
+    }
+    public FREEPOOLS(): antlr.TerminalNode[];
+    public FREEPOOLS(i: number): antlr.TerminalNode | null;
+    public FREEPOOLS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FREEPOOLS);
+    	} else {
+    		return this.getToken(PlSqlParser.FREEPOOLS, i);
+    	}
+    }
+    public lob_retention_clause(): Lob_retention_clauseContext[];
+    public lob_retention_clause(i: number): Lob_retention_clauseContext | null;
+    public lob_retention_clause(i?: number): Lob_retention_clauseContext[] | Lob_retention_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_retention_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_retention_clauseContext);
+    }
+    public lob_deduplicate_clause(): Lob_deduplicate_clauseContext[];
+    public lob_deduplicate_clause(i: number): Lob_deduplicate_clauseContext | null;
+    public lob_deduplicate_clause(i?: number): Lob_deduplicate_clauseContext[] | Lob_deduplicate_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_deduplicate_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_deduplicate_clauseContext);
+    }
+    public lob_compression_clause(): Lob_compression_clauseContext[];
+    public lob_compression_clause(i: number): Lob_compression_clauseContext | null;
+    public lob_compression_clause(i?: number): Lob_compression_clauseContext[] | Lob_compression_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_compression_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_compression_clauseContext);
+    }
+    public ENCRYPT(): antlr.TerminalNode[];
+    public ENCRYPT(i: number): antlr.TerminalNode | null;
+    public ENCRYPT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENCRYPT);
+    	} else {
+    		return this.getToken(PlSqlParser.ENCRYPT, i);
+    	}
+    }
+    public encryption_spec(): Encryption_specContext[];
+    public encryption_spec(i: number): Encryption_specContext | null;
+    public encryption_spec(i?: number): Encryption_specContext[] | Encryption_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Encryption_specContext);
+        }
+
+        return this.getRuleContext(i, Encryption_specContext);
+    }
+    public DECRYPT(): antlr.TerminalNode[];
+    public DECRYPT(i: number): antlr.TerminalNode | null;
+    public DECRYPT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DECRYPT);
+    	} else {
+    		return this.getToken(PlSqlParser.DECRYPT, i);
+    	}
+    }
+    public CACHE(): antlr.TerminalNode[];
+    public CACHE(i: number): antlr.TerminalNode | null;
+    public CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.CACHE, i);
+    	}
+    }
+    public allocate_extent_clause(): Allocate_extent_clauseContext[];
+    public allocate_extent_clause(i: number): Allocate_extent_clauseContext | null;
+    public allocate_extent_clause(i?: number): Allocate_extent_clauseContext[] | Allocate_extent_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Allocate_extent_clauseContext);
+        }
+
+        return this.getRuleContext(i, Allocate_extent_clauseContext);
+    }
+    public shrink_clause(): Shrink_clauseContext[];
+    public shrink_clause(i: number): Shrink_clauseContext | null;
+    public shrink_clause(i?: number): Shrink_clauseContext[] | Shrink_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Shrink_clauseContext);
+        }
+
+        return this.getRuleContext(i, Shrink_clauseContext);
+    }
+    public deallocate_unused_clause(): Deallocate_unused_clauseContext[];
+    public deallocate_unused_clause(i: number): Deallocate_unused_clauseContext | null;
+    public deallocate_unused_clause(i?: number): Deallocate_unused_clauseContext[] | Deallocate_unused_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Deallocate_unused_clauseContext);
+        }
+
+        return this.getRuleContext(i, Deallocate_unused_clauseContext);
+    }
+    public PCTVERSION(): antlr.TerminalNode[];
+    public PCTVERSION(i: number): antlr.TerminalNode | null;
+    public PCTVERSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTVERSION);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTVERSION, i);
+    	}
+    }
+    public NOCACHE(): antlr.TerminalNode[];
+    public NOCACHE(i: number): antlr.TerminalNode | null;
+    public NOCACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOCACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.NOCACHE, i);
+    	}
+    }
+    public READS(): antlr.TerminalNode[];
+    public READS(i: number): antlr.TerminalNode | null;
+    public READS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.READS);
+    	} else {
+    		return this.getToken(PlSqlParser.READS, i);
+    	}
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_modify_lob_parameters;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModify_lob_parameters) {
+             listener.enterModify_lob_parameters(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModify_lob_parameters) {
+             listener.exitModify_lob_parameters(this);
+        }
+    }
+}
+
+
+export class Lob_parametersContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STORAGE(): antlr.TerminalNode[];
+    public STORAGE(i: number): antlr.TerminalNode | null;
+    public STORAGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.STORAGE);
+    	} else {
+    		return this.getToken(PlSqlParser.STORAGE, i);
+    	}
+    }
+    public IN(): antlr.TerminalNode[];
+    public IN(i: number): antlr.TerminalNode | null;
+    public IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IN);
+    	} else {
+    		return this.getToken(PlSqlParser.IN, i);
+    	}
+    }
+    public ROW(): antlr.TerminalNode[];
+    public ROW(i: number): antlr.TerminalNode | null;
+    public ROW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ROW);
+    	} else {
+    		return this.getToken(PlSqlParser.ROW, i);
+    	}
+    }
+    public CHUNK(): antlr.TerminalNode[];
+    public CHUNK(i: number): antlr.TerminalNode | null;
+    public CHUNK(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHUNK);
+    	} else {
+    		return this.getToken(PlSqlParser.CHUNK, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public PCTVERSION(): antlr.TerminalNode[];
+    public PCTVERSION(i: number): antlr.TerminalNode | null;
+    public PCTVERSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PCTVERSION);
+    	} else {
+    		return this.getToken(PlSqlParser.PCTVERSION, i);
+    	}
+    }
+    public FREEPOOLS(): antlr.TerminalNode[];
+    public FREEPOOLS(i: number): antlr.TerminalNode | null;
+    public FREEPOOLS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FREEPOOLS);
+    	} else {
+    		return this.getToken(PlSqlParser.FREEPOOLS, i);
+    	}
+    }
+    public lob_retention_clause(): Lob_retention_clauseContext[];
+    public lob_retention_clause(i: number): Lob_retention_clauseContext | null;
+    public lob_retention_clause(i?: number): Lob_retention_clauseContext[] | Lob_retention_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_retention_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_retention_clauseContext);
+    }
+    public lob_deduplicate_clause(): Lob_deduplicate_clauseContext[];
+    public lob_deduplicate_clause(i: number): Lob_deduplicate_clauseContext | null;
+    public lob_deduplicate_clause(i?: number): Lob_deduplicate_clauseContext[] | Lob_deduplicate_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_deduplicate_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_deduplicate_clauseContext);
+    }
+    public lob_compression_clause(): Lob_compression_clauseContext[];
+    public lob_compression_clause(i: number): Lob_compression_clauseContext | null;
+    public lob_compression_clause(i?: number): Lob_compression_clauseContext[] | Lob_compression_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_compression_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_compression_clauseContext);
+    }
+    public ENCRYPT(): antlr.TerminalNode[];
+    public ENCRYPT(i: number): antlr.TerminalNode | null;
+    public ENCRYPT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENCRYPT);
+    	} else {
+    		return this.getToken(PlSqlParser.ENCRYPT, i);
+    	}
+    }
+    public encryption_spec(): Encryption_specContext[];
+    public encryption_spec(i: number): Encryption_specContext | null;
+    public encryption_spec(i?: number): Encryption_specContext[] | Encryption_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Encryption_specContext);
+        }
+
+        return this.getRuleContext(i, Encryption_specContext);
+    }
+    public DECRYPT(): antlr.TerminalNode[];
+    public DECRYPT(i: number): antlr.TerminalNode | null;
+    public DECRYPT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DECRYPT);
+    	} else {
+    		return this.getToken(PlSqlParser.DECRYPT, i);
+    	}
+    }
+    public ENABLE(): antlr.TerminalNode[];
+    public ENABLE(i: number): antlr.TerminalNode | null;
+    public ENABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ENABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.ENABLE, i);
+    	}
+    }
+    public DISABLE(): antlr.TerminalNode[];
+    public DISABLE(i: number): antlr.TerminalNode | null;
+    public DISABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DISABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.DISABLE, i);
+    	}
+    }
+    public CACHE(): antlr.TerminalNode[];
+    public CACHE(i: number): antlr.TerminalNode | null;
+    public CACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.CACHE, i);
+    	}
+    }
+    public NOCACHE(): antlr.TerminalNode[];
+    public NOCACHE(i: number): antlr.TerminalNode | null;
+    public NOCACHE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOCACHE);
+    	} else {
+    		return this.getToken(PlSqlParser.NOCACHE, i);
+    	}
+    }
+    public READS(): antlr.TerminalNode[];
+    public READS(i: number): antlr.TerminalNode | null;
+    public READS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.READS);
+    	} else {
+    		return this.getToken(PlSqlParser.READS, i);
+    	}
+    }
+    public logging_clause(): Logging_clauseContext[];
+    public logging_clause(i: number): Logging_clauseContext | null;
+    public logging_clause(i?: number): Logging_clauseContext[] | Logging_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logging_clauseContext);
+        }
+
+        return this.getRuleContext(i, Logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_parameters;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_parameters) {
+             listener.enterLob_parameters(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_parameters) {
+             listener.exitLob_parameters(this);
+        }
+    }
+}
+
+
+export class Lob_deduplicate_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEDUPLICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEDUPLICATE, 0);
+    }
+    public KEEP_DUPLICATES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP_DUPLICATES, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_deduplicate_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_deduplicate_clause) {
+             listener.enterLob_deduplicate_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_deduplicate_clause) {
+             listener.exitLob_deduplicate_clause(this);
+        }
+    }
+}
+
+
+export class Lob_compression_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NOCOMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOMPRESS, 0);
+    }
+    public COMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPRESS, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public MEDIUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEDIUM, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_compression_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_compression_clause) {
+             listener.enterLob_compression_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_compression_clause) {
+             listener.exitLob_compression_clause(this);
+        }
+    }
+}
+
+
+export class Lob_retention_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETENTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETENTION, 0)!;
+    }
+    public MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAX, 0);
+    }
+    public MIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public AUTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_retention_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_retention_clause) {
+             listener.enterLob_retention_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_retention_clause) {
+             listener.exitLob_retention_clause(this);
+        }
+    }
+}
+
+
+export class Encryption_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public IDENTIFIED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIED, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public REGULAR_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGULAR_ID, 0);
+    }
+    public SALT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SALT, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_encryption_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEncryption_spec) {
+             listener.enterEncryption_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEncryption_spec) {
+             listener.exitEncryption_spec(this);
+        }
+    }
+}
+
+
+export class TablespaceContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tablespace;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTablespace) {
+             listener.enterTablespace(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTablespace) {
+             listener.exitTablespace(this);
+        }
+    }
+}
+
+
+export class Varray_itemContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_varray_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVarray_item) {
+             listener.enterVarray_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVarray_item) {
+             listener.exitVarray_item(this);
+        }
+    }
+}
+
+
+export class Column_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public object_type_col_properties(): Object_type_col_propertiesContext[];
+    public object_type_col_properties(i: number): Object_type_col_propertiesContext | null;
+    public object_type_col_properties(i?: number): Object_type_col_propertiesContext[] | Object_type_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_type_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Object_type_col_propertiesContext);
+    }
+    public nested_table_col_properties(): Nested_table_col_propertiesContext[];
+    public nested_table_col_properties(i: number): Nested_table_col_propertiesContext | null;
+    public nested_table_col_properties(i?: number): Nested_table_col_propertiesContext[] | Nested_table_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Nested_table_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Nested_table_col_propertiesContext);
+    }
+    public xmltype_column_properties(): Xmltype_column_propertiesContext[];
+    public xmltype_column_properties(i: number): Xmltype_column_propertiesContext | null;
+    public xmltype_column_properties(i?: number): Xmltype_column_propertiesContext[] | Xmltype_column_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Xmltype_column_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Xmltype_column_propertiesContext);
+    }
+    public varray_col_properties(): Varray_col_propertiesContext[];
+    public varray_col_properties(i: number): Varray_col_propertiesContext | null;
+    public varray_col_properties(i?: number): Varray_col_propertiesContext[] | Varray_col_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Varray_col_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Varray_col_propertiesContext);
+    }
+    public lob_storage_clause(): Lob_storage_clauseContext[];
+    public lob_storage_clause(i: number): Lob_storage_clauseContext | null;
+    public lob_storage_clause(i?: number): Lob_storage_clauseContext[] | Lob_storage_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_storage_clauseContext);
+        }
+
+        return this.getRuleContext(i, Lob_storage_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public lob_partition_storage(): Lob_partition_storageContext[];
+    public lob_partition_storage(i: number): Lob_partition_storageContext | null;
+    public lob_partition_storage(i?: number): Lob_partition_storageContext[] | Lob_partition_storageContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_partition_storageContext);
+        }
+
+        return this.getRuleContext(i, Lob_partition_storageContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_properties) {
+             listener.enterColumn_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_properties) {
+             listener.exitColumn_properties(this);
+        }
+    }
+}
+
+
+export class Lob_partition_storageContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOB(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOB, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public lob_item(): Lob_itemContext[];
+    public lob_item(i: number): Lob_itemContext | null;
+    public lob_item(i?: number): Lob_itemContext[] | Lob_itemContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_itemContext);
+        }
+
+        return this.getRuleContext(i, Lob_itemContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public lob_storage_parameters(): Lob_storage_parametersContext[];
+    public lob_storage_parameters(i: number): Lob_storage_parametersContext | null;
+    public lob_storage_parameters(i?: number): Lob_storage_parametersContext[] | Lob_storage_parametersContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_storage_parametersContext);
+        }
+
+        return this.getRuleContext(i, Lob_storage_parametersContext);
+    }
+    public lob_segname(): Lob_segnameContext[];
+    public lob_segname(i: number): Lob_segnameContext | null;
+    public lob_segname(i?: number): Lob_segnameContext[] | Lob_segnameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lob_segnameContext);
+        }
+
+        return this.getRuleContext(i, Lob_segnameContext);
+    }
+    public SECUREFILE(): antlr.TerminalNode[];
+    public SECUREFILE(i: number): antlr.TerminalNode | null;
+    public SECUREFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SECUREFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.SECUREFILE, i);
+    	}
+    }
+    public BASICFILE(): antlr.TerminalNode[];
+    public BASICFILE(i: number): antlr.TerminalNode | null;
+    public BASICFILE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BASICFILE);
+    	} else {
+    		return this.getToken(PlSqlParser.BASICFILE, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lob_partition_storage;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLob_partition_storage) {
+             listener.enterLob_partition_storage(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLob_partition_storage) {
+             listener.exitLob_partition_storage(this);
+        }
+    }
+}
+
+
+export class Period_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PERIOD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PERIOD, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public start_time_column(): Start_time_columnContext | null {
+        return this.getRuleContext(0, Start_time_columnContext);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public end_time_column(): End_time_columnContext | null {
+        return this.getRuleContext(0, End_time_columnContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_period_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPeriod_definition) {
+             listener.enterPeriod_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPeriod_definition) {
+             listener.exitPeriod_definition(this);
+        }
+    }
+}
+
+
+export class Start_time_columnContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_start_time_column;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStart_time_column) {
+             listener.enterStart_time_column(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStart_time_column) {
+             listener.exitStart_time_column(this);
+        }
+    }
+}
+
+
+export class End_time_columnContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_end_time_column;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEnd_time_column) {
+             listener.enterEnd_time_column(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEnd_time_column) {
+             listener.exitEnd_time_column(this);
+        }
+    }
+}
+
+
+export class Column_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public SORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SORT, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public identity_clause(): Identity_clauseContext | null {
+        return this.getRuleContext(0, Identity_clauseContext);
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public encryption_spec(): Encryption_specContext | null {
+        return this.getRuleContext(0, Encryption_specContext);
+    }
+    public inline_ref_constraint(): Inline_ref_constraintContext | null {
+        return this.getRuleContext(0, Inline_ref_constraintContext);
+    }
+    public annotations_clause(): Annotations_clauseContext | null {
+        return this.getRuleContext(0, Annotations_clauseContext);
+    }
+    public VISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBLE, 0);
+    }
+    public INVISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVISIBLE, 0);
+    }
+    public datatype(): DatatypeContext | null {
+        return this.getRuleContext(0, DatatypeContext);
+    }
+    public type_name(): Type_nameContext | null {
+        return this.getRuleContext(0, Type_nameContext);
+    }
+    public COLLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATE, 0);
+    }
+    public column_collation_name(): Column_collation_nameContext | null {
+        return this.getRuleContext(0, Column_collation_nameContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public inline_constraint(): Inline_constraintContext[];
+    public inline_constraint(i: number): Inline_constraintContext | null;
+    public inline_constraint(i?: number): Inline_constraintContext[] | Inline_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inline_constraintContext);
+        }
+
+        return this.getRuleContext(i, Inline_constraintContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_definition) {
+             listener.enterColumn_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_definition) {
+             listener.exitColumn_definition(this);
+        }
+    }
+}
+
+
+export class Column_collation_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_collation_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_collation_name) {
+             listener.enterColumn_collation_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_collation_name) {
+             listener.exitColumn_collation_name(this);
+        }
+    }
+}
+
+
+export class Identity_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GENERATED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GENERATED, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public IDENTITY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTITY, 0)!;
+    }
+    public ALWAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALWAYS, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public identity_options_parentheses(): Identity_options_parenthesesContext | null {
+        return this.getRuleContext(0, Identity_options_parenthesesContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identity_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentity_clause) {
+             listener.enterIdentity_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentity_clause) {
+             listener.exitIdentity_clause(this);
+        }
+    }
+}
+
+
+export class Identity_options_parenthesesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identity_options(): Identity_optionsContext[];
+    public identity_options(i: number): Identity_optionsContext | null;
+    public identity_options(i?: number): Identity_optionsContext[] | Identity_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Identity_optionsContext);
+        }
+
+        return this.getRuleContext(i, Identity_optionsContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identity_options_parentheses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentity_options_parentheses) {
+             listener.enterIdentity_options_parentheses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentity_options_parentheses) {
+             listener.exitIdentity_options_parentheses(this);
+        }
+    }
+}
+
+
+export class Identity_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public START(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.START, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public INCREMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCREMENT, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public MAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXVALUE, 0);
+    }
+    public NOMAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMAXVALUE, 0);
+    }
+    public MINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINVALUE, 0);
+    }
+    public NOMINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMINVALUE, 0);
+    }
+    public CYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CYCLE, 0);
+    }
+    public NOCYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCYCLE, 0);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public NOORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOORDER, 0);
+    }
+    public SCALE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCALE, 0);
+    }
+    public EXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTEND, 0);
+    }
+    public NOEXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOEXTEND, 0);
+    }
+    public NOSCALE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSCALE, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public NOKEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOKEEP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identity_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentity_options) {
+             listener.enterIdentity_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentity_options) {
+             listener.exitIdentity_options(this);
+        }
+    }
+}
+
+
+export class Virtual_column_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public datatype(): DatatypeContext | null {
+        return this.getRuleContext(0, DatatypeContext);
+    }
+    public virtual_column_expression(): Virtual_column_expressionContext | null {
+        return this.getRuleContext(0, Virtual_column_expressionContext);
+    }
+    public VIRTUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIRTUAL, 0);
+    }
+    public evaluation_edition_clause(): Evaluation_edition_clauseContext | null {
+        return this.getRuleContext(0, Evaluation_edition_clauseContext);
+    }
+    public UNUSABLE(): antlr.TerminalNode[];
+    public UNUSABLE(i: number): antlr.TerminalNode | null;
+    public UNUSABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNUSABLE);
+    	} else {
+    		return this.getToken(PlSqlParser.UNUSABLE, i);
+    	}
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public BEGINNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGINNING, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public inline_constraint(): Inline_constraintContext[];
+    public inline_constraint(i: number): Inline_constraintContext | null;
+    public inline_constraint(i?: number): Inline_constraintContext[] | Inline_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Inline_constraintContext);
+        }
+
+        return this.getRuleContext(i, Inline_constraintContext);
+    }
+    public by_user_for_statistics_clause(): By_user_for_statistics_clauseContext | null {
+        return this.getRuleContext(0, By_user_for_statistics_clauseContext);
+    }
+    public VISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBLE, 0);
+    }
+    public INVISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVISIBLE, 0);
+    }
+    public CURRENT(): antlr.TerminalNode[];
+    public CURRENT(i: number): antlr.TerminalNode | null;
+    public CURRENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CURRENT);
+    	} else {
+    		return this.getToken(PlSqlParser.CURRENT, i);
+    	}
+    }
+    public EDITION(): antlr.TerminalNode[];
+    public EDITION(i: number): antlr.TerminalNode | null;
+    public EDITION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EDITION);
+    	} else {
+    		return this.getToken(PlSqlParser.EDITION, i);
+    	}
+    }
+    public edition_name(): Edition_nameContext[];
+    public edition_name(i: number): Edition_nameContext | null;
+    public edition_name(i?: number): Edition_nameContext[] | Edition_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Edition_nameContext);
+        }
+
+        return this.getRuleContext(i, Edition_nameContext);
+    }
+    public COLLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATE, 0);
+    }
+    public column_collation_name(): Column_collation_nameContext | null {
+        return this.getRuleContext(0, Column_collation_nameContext);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_virtual_column_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVirtual_column_definition) {
+             listener.enterVirtual_column_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVirtual_column_definition) {
+             listener.exitVirtual_column_definition(this);
+        }
+    }
+}
+
+
+export class Virtual_column_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public autogenerated_sequence_definition(): Autogenerated_sequence_definitionContext | null {
+        return this.getRuleContext(0, Autogenerated_sequence_definitionContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public GENERATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GENERATED, 0);
+    }
+    public ALWAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALWAYS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_virtual_column_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVirtual_column_expression) {
+             listener.enterVirtual_column_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVirtual_column_expression) {
+             listener.exitVirtual_column_expression(this);
+        }
+    }
+}
+
+
+export class Autogenerated_sequence_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GENERATED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GENERATED, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public IDENTITY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IDENTITY, 0)!;
+    }
+    public ALWAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALWAYS, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public sequence_start_clause(): Sequence_start_clauseContext[];
+    public sequence_start_clause(i: number): Sequence_start_clauseContext | null;
+    public sequence_start_clause(i?: number): Sequence_start_clauseContext[] | Sequence_start_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sequence_start_clauseContext);
+        }
+
+        return this.getRuleContext(i, Sequence_start_clauseContext);
+    }
+    public sequence_spec(): Sequence_specContext[];
+    public sequence_spec(i: number): Sequence_specContext | null;
+    public sequence_spec(i?: number): Sequence_specContext[] | Sequence_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Sequence_specContext);
+        }
+
+        return this.getRuleContext(i, Sequence_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_autogenerated_sequence_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAutogenerated_sequence_definition) {
+             listener.enterAutogenerated_sequence_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAutogenerated_sequence_definition) {
+             listener.exitAutogenerated_sequence_definition(this);
+        }
+    }
+}
+
+
+export class By_user_for_statistics_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public USER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USER, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public STATISTICS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STATISTICS, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_by_user_for_statistics_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBy_user_for_statistics_clause) {
+             listener.enterBy_user_for_statistics_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBy_user_for_statistics_clause) {
+             listener.exitBy_user_for_statistics_clause(this);
+        }
+    }
+}
+
+
+export class Evaluation_edition_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EVALUATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EVALUATE, 0)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public edition_name(): Edition_nameContext | null {
+        return this.getRuleContext(0, Edition_nameContext);
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_evaluation_edition_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterEvaluation_edition_clause) {
+             listener.enterEvaluation_edition_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitEvaluation_edition_clause) {
+             listener.exitEvaluation_edition_clause(this);
+        }
+    }
+}
+
+
+export class Nested_table_col_propertiesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NESTED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NESTED, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public STORE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STORE, 0)!;
+    }
+    public AS(): antlr.TerminalNode[];
+    public AS(i: number): antlr.TerminalNode | null;
+    public AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AS);
+    	} else {
+    		return this.getToken(PlSqlParser.AS, i);
+    	}
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public nested_item(): Nested_itemContext | null {
+        return this.getRuleContext(0, Nested_itemContext);
+    }
+    public COLUMN_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN_VALUE, 0);
+    }
+    public substitutable_column_clause(): Substitutable_column_clauseContext | null {
+        return this.getRuleContext(0, Substitutable_column_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public GLOBAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL, 0);
+    }
+    public LOCATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCATOR, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public object_properties(): Object_propertiesContext[];
+    public object_properties(i: number): Object_propertiesContext | null;
+    public object_properties(i?: number): Object_propertiesContext[] | Object_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Object_propertiesContext);
+    }
+    public physical_properties(): Physical_propertiesContext[];
+    public physical_properties(i: number): Physical_propertiesContext | null;
+    public physical_properties(i?: number): Physical_propertiesContext[] | Physical_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Physical_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Physical_propertiesContext);
+    }
+    public column_properties(): Column_propertiesContext[];
+    public column_properties(i: number): Column_propertiesContext | null;
+    public column_properties(i?: number): Column_propertiesContext[] | Column_propertiesContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_propertiesContext);
+        }
+
+        return this.getRuleContext(i, Column_propertiesContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_nested_table_col_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNested_table_col_properties) {
+             listener.enterNested_table_col_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNested_table_col_properties) {
+             listener.exitNested_table_col_properties(this);
+        }
+    }
+}
+
+
+export class Nested_itemContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_nested_item;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNested_item) {
+             listener.enterNested_item(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNested_item) {
+             listener.exitNested_item(this);
+        }
+    }
+}
+
+
+export class Substitutable_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_name(): Type_nameContext | null {
+        return this.getRuleContext(0, Type_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public ELEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELEMENT, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public SUBSTITUTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTITUTABLE, 0);
+    }
+    public AT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public LEVELS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVELS, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_substitutable_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubstitutable_column_clause) {
+             listener.enterSubstitutable_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubstitutable_column_clause) {
+             listener.exitSubstitutable_column_clause(this);
+        }
+    }
+}
+
+
+export class Partition_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_name) {
+             listener.enterPartition_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_name) {
+             listener.exitPartition_name(this);
+        }
+    }
+}
+
+
+export class Supplemental_logging_propsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUPPLEMENTAL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUPPLEMENTAL, 0)!;
+    }
+    public LOG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOG, 0)!;
+    }
+    public supplemental_log_grp_clause(): Supplemental_log_grp_clauseContext | null {
+        return this.getRuleContext(0, Supplemental_log_grp_clauseContext);
+    }
+    public supplemental_id_key_clause(): Supplemental_id_key_clauseContext | null {
+        return this.getRuleContext(0, Supplemental_id_key_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_supplemental_logging_props;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSupplemental_logging_props) {
+             listener.enterSupplemental_logging_props(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSupplemental_logging_props) {
+             listener.exitSupplemental_logging_props(this);
+        }
+    }
+}
+
+
+export class Object_type_col_propertiesContext extends antlr.ParserRuleContext {
+    public _column?: Regular_idContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COLUMN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMN, 0)!;
+    }
+    public substitutable_column_clause(): Substitutable_column_clauseContext {
+        return this.getRuleContext(0, Substitutable_column_clauseContext)!;
+    }
+    public regular_id(): Regular_idContext {
+        return this.getRuleContext(0, Regular_idContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_type_col_properties;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_type_col_properties) {
+             listener.enterObject_type_col_properties(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_type_col_properties) {
+             listener.exitObject_type_col_properties(this);
+        }
+    }
+}
+
+
+export class Constraint_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public out_of_line_constraint(): Out_of_line_constraintContext[];
+    public out_of_line_constraint(i: number): Out_of_line_constraintContext | null;
+    public out_of_line_constraint(i?: number): Out_of_line_constraintContext[] | Out_of_line_constraintContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Out_of_line_constraintContext);
+        }
+
+        return this.getRuleContext(i, Out_of_line_constraintContext);
+    }
+    public out_of_line_ref_constraint(): Out_of_line_ref_constraintContext | null {
+        return this.getRuleContext(0, Out_of_line_ref_constraintContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public constraint_state(): Constraint_stateContext | null {
+        return this.getRuleContext(0, Constraint_stateContext);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public old_constraint_name(): Old_constraint_nameContext | null {
+        return this.getRuleContext(0, Old_constraint_nameContext);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public new_constraint_name(): New_constraint_nameContext | null {
+        return this.getRuleContext(0, New_constraint_nameContext);
+    }
+    public drop_constraint_clause(): Drop_constraint_clauseContext[];
+    public drop_constraint_clause(i: number): Drop_constraint_clauseContext | null;
+    public drop_constraint_clause(i?: number): Drop_constraint_clauseContext[] | Drop_constraint_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Drop_constraint_clauseContext);
+        }
+
+        return this.getRuleContext(i, Drop_constraint_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_constraint_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConstraint_clauses) {
+             listener.enterConstraint_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConstraint_clauses) {
+             listener.exitConstraint_clauses(this);
+        }
+    }
+}
+
+
+export class Old_constraint_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public constraint_name(): Constraint_nameContext {
+        return this.getRuleContext(0, Constraint_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_old_constraint_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOld_constraint_name) {
+             listener.enterOld_constraint_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOld_constraint_name) {
+             listener.exitOld_constraint_name(this);
+        }
+    }
+}
+
+
+export class New_constraint_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public constraint_name(): Constraint_nameContext {
+        return this.getRuleContext(0, Constraint_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_new_constraint_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNew_constraint_name) {
+             listener.enterNew_constraint_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNew_constraint_name) {
+             listener.exitNew_constraint_name(this);
+        }
+    }
+}
+
+
+export class Drop_constraint_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DROP(): antlr.TerminalNode[];
+    public DROP(i: number): antlr.TerminalNode | null;
+    public DROP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DROP);
+    	} else {
+    		return this.getToken(PlSqlParser.DROP, i);
+    	}
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public KEY(): antlr.TerminalNode[];
+    public KEY(i: number): antlr.TerminalNode | null;
+    public KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.KEY);
+    	} else {
+    		return this.getToken(PlSqlParser.KEY, i);
+    	}
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_drop_constraint_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDrop_constraint_clause) {
+             listener.enterDrop_constraint_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDrop_constraint_clause) {
+             listener.exitDrop_constraint_clause(this);
+        }
+    }
+}
+
+
+export class Check_constraintContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHECK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHECK, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_check_constraint;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCheck_constraint) {
+             listener.enterCheck_constraint(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCheck_constraint) {
+             listener.exitCheck_constraint(this);
+        }
+    }
+}
+
+
+export class Foreign_key_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOREIGN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOREIGN, 0)!;
+    }
+    public KEY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEY, 0)!;
+    }
+    public paren_column_list(): Paren_column_listContext {
+        return this.getRuleContext(0, Paren_column_listContext)!;
+    }
+    public references_clause(): References_clauseContext {
+        return this.getRuleContext(0, References_clauseContext)!;
+    }
+    public on_delete_clause(): On_delete_clauseContext | null {
+        return this.getRuleContext(0, On_delete_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_foreign_key_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterForeign_key_clause) {
+             listener.enterForeign_key_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitForeign_key_clause) {
+             listener.exitForeign_key_clause(this);
+        }
+    }
+}
+
+
+export class References_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REFERENCES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REFERENCES, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_references_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReferences_clause) {
+             listener.enterReferences_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReferences_clause) {
+             listener.exitReferences_clause(this);
+        }
+    }
+}
+
+
+export class On_delete_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_on_delete_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOn_delete_clause) {
+             listener.enterOn_delete_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOn_delete_clause) {
+             listener.exitOn_delete_clause(this);
+        }
+    }
+}
+
+
+export class Anonymous_blockContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BEGIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BEGIN, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public EXCEPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTION, 0);
+    }
+    public seq_of_declare_specs(): Seq_of_declare_specsContext | null {
+        return this.getRuleContext(0, Seq_of_declare_specsContext);
+    }
+    public exception_handler(): Exception_handlerContext[];
+    public exception_handler(i: number): Exception_handlerContext | null;
+    public exception_handler(i?: number): Exception_handlerContext[] | Exception_handlerContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Exception_handlerContext);
+        }
+
+        return this.getRuleContext(i, Exception_handlerContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_anonymous_block;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAnonymous_block) {
+             listener.enterAnonymous_block(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAnonymous_block) {
+             listener.exitAnonymous_block(this);
+        }
+    }
+}
+
+
+export class Invoker_rights_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AUTHID(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AUTHID, 0)!;
+    }
+    public CURRENT_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_USER, 0);
+    }
+    public DEFINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_invoker_rights_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInvoker_rights_clause) {
+             listener.enterInvoker_rights_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInvoker_rights_clause) {
+             listener.exitInvoker_rights_clause(this);
+        }
+    }
+}
+
+
+export class Call_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public java_spec(): Java_specContext | null {
+        return this.getRuleContext(0, Java_specContext);
+    }
+    public c_spec(): C_specContext | null {
+        return this.getRuleContext(0, C_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_call_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCall_spec) {
+             listener.enterCall_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCall_spec) {
+             listener.exitCall_spec(this);
+        }
+    }
+}
+
+
+export class Java_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LANGUAGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LANGUAGE, 0)!;
+    }
+    public JAVA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JAVA, 0)!;
+    }
+    public NAME(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NAME, 0)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_java_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJava_spec) {
+             listener.enterJava_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJava_spec) {
+             listener.exitJava_spec(this);
+        }
+    }
+}
+
+
+export class C_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LANGUAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LANGUAGE, 0);
+    }
+    public C_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.C_LETTER, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public LIBRARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIBRARY, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public c_agent_in_clause(): C_agent_in_clauseContext | null {
+        return this.getRuleContext(0, C_agent_in_clauseContext);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTEXT, 0);
+    }
+    public c_parameters_clause(): C_parameters_clauseContext | null {
+        return this.getRuleContext(0, C_parameters_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_c_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterC_spec) {
+             listener.enterC_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitC_spec) {
+             listener.exitC_spec(this);
+        }
+    }
+}
+
+
+export class C_agent_in_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AGENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AGENT, 0)!;
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expressions_(): Expressions_Context {
+        return this.getRuleContext(0, Expressions_Context)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_c_agent_in_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterC_agent_in_clause) {
+             listener.enterC_agent_in_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitC_agent_in_clause) {
+             listener.exitC_agent_in_clause(this);
+        }
+    }
+}
+
+
+export class C_parameters_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARAMETERS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARAMETERS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public c_external_parameter(): C_external_parameterContext[];
+    public c_external_parameter(i: number): C_external_parameterContext | null;
+    public c_external_parameter(i?: number): C_external_parameterContext[] | C_external_parameterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(C_external_parameterContext);
+        }
+
+        return this.getRuleContext(i, C_external_parameterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_c_parameters_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterC_parameters_clause) {
+             listener.enterC_parameters_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitC_parameters_clause) {
+             listener.exitC_parameters_clause(this);
+        }
+    }
+}
+
+
+export class C_external_parameterContext extends antlr.ParserRuleContext {
+    public _external_datatype?: Regular_idContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTEXT, 0);
+    }
+    public SELF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELF, 0);
+    }
+    public TDO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TDO, 0);
+    }
+    public c_property(): C_propertyContext | null {
+        return this.getRuleContext(0, C_propertyContext);
+    }
+    public parameter_name(): Parameter_nameContext | null {
+        return this.getRuleContext(0, Parameter_nameContext);
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public REFERENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCE, 0);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_c_external_parameter;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterC_external_parameter) {
+             listener.enterC_external_parameter(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitC_external_parameter) {
+             listener.exitC_external_parameter(this);
+        }
+    }
+}
+
+
+export class C_propertyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INDICATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDICATOR, 0);
+    }
+    public STRUCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRUCT, 0);
+    }
+    public TDO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TDO, 0);
+    }
+    public LENGTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LENGTH, 0);
+    }
+    public DURATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DURATION, 0);
+    }
+    public MAXLEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLEN, 0);
+    }
+    public CHARSETID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARSETID, 0);
+    }
+    public CHARSETFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARSETFORM, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_c_property;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterC_property) {
+             listener.enterC_property(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitC_property) {
+             listener.exitC_property(this);
+        }
+    }
+}
+
+
+export class ParameterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public parameter_name(): Parameter_nameContext {
+        return this.getRuleContext(0, Parameter_nameContext)!;
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public default_value_part(): Default_value_partContext | null {
+        return this.getRuleContext(0, Default_value_partContext);
+    }
+    public IN(): antlr.TerminalNode[];
+    public IN(i: number): antlr.TerminalNode | null;
+    public IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IN);
+    	} else {
+    		return this.getToken(PlSqlParser.IN, i);
+    	}
+    }
+    public OUT(): antlr.TerminalNode[];
+    public OUT(i: number): antlr.TerminalNode | null;
+    public OUT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OUT);
+    	} else {
+    		return this.getToken(PlSqlParser.OUT, i);
+    	}
+    }
+    public INOUT(): antlr.TerminalNode[];
+    public INOUT(i: number): antlr.TerminalNode | null;
+    public INOUT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INOUT);
+    	} else {
+    		return this.getToken(PlSqlParser.INOUT, i);
+    	}
+    }
+    public NOCOPY(): antlr.TerminalNode[];
+    public NOCOPY(i: number): antlr.TerminalNode | null;
+    public NOCOPY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOCOPY);
+    	} else {
+    		return this.getToken(PlSqlParser.NOCOPY, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parameter;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParameter) {
+             listener.enterParameter(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParameter) {
+             listener.exitParameter(this);
+        }
+    }
+}
+
+
+export class Default_value_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public ASSIGN_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASSIGN_OP, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_default_value_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDefault_value_part) {
+             listener.enterDefault_value_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDefault_value_part) {
+             listener.exitDefault_value_part(this);
+        }
+    }
+}
+
+
+export class Seq_of_declare_specsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public declare_spec(): Declare_specContext[];
+    public declare_spec(i: number): Declare_specContext | null;
+    public declare_spec(i?: number): Declare_specContext[] | Declare_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Declare_specContext);
+        }
+
+        return this.getRuleContext(i, Declare_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_seq_of_declare_specs;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSeq_of_declare_specs) {
+             listener.enterSeq_of_declare_specs(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSeq_of_declare_specs) {
+             listener.exitSeq_of_declare_specs(this);
+        }
+    }
+}
+
+
+export class Declare_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public pragma_declaration(): Pragma_declarationContext | null {
+        return this.getRuleContext(0, Pragma_declarationContext);
+    }
+    public exception_declaration(): Exception_declarationContext | null {
+        return this.getRuleContext(0, Exception_declarationContext);
+    }
+    public procedure_spec(): Procedure_specContext | null {
+        return this.getRuleContext(0, Procedure_specContext);
+    }
+    public function_spec(): Function_specContext | null {
+        return this.getRuleContext(0, Function_specContext);
+    }
+    public variable_declaration(): Variable_declarationContext | null {
+        return this.getRuleContext(0, Variable_declarationContext);
+    }
+    public subtype_declaration(): Subtype_declarationContext | null {
+        return this.getRuleContext(0, Subtype_declarationContext);
+    }
+    public cursor_declaration(): Cursor_declarationContext | null {
+        return this.getRuleContext(0, Cursor_declarationContext);
+    }
+    public type_declaration(): Type_declarationContext | null {
+        return this.getRuleContext(0, Type_declarationContext);
+    }
+    public procedure_body(): Procedure_bodyContext | null {
+        return this.getRuleContext(0, Procedure_bodyContext);
+    }
+    public function_body(): Function_bodyContext | null {
+        return this.getRuleContext(0, Function_bodyContext);
+    }
+    public selection_directive(): Selection_directiveContext | null {
+        return this.getRuleContext(0, Selection_directiveContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_declare_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDeclare_spec) {
+             listener.enterDeclare_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDeclare_spec) {
+             listener.exitDeclare_spec(this);
+        }
+    }
+}
+
+
+export class Variable_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public CONSTANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTANT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public default_value_part(): Default_value_partContext | null {
+        return this.getRuleContext(0, Default_value_partContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_variable_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVariable_declaration) {
+             listener.enterVariable_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVariable_declaration) {
+             listener.exitVariable_declaration(this);
+        }
+    }
+}
+
+
+export class Subtype_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBTYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SUBTYPE, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANGE, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public DOUBLE_PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE_PERIOD, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subtype_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubtype_declaration) {
+             listener.enterSubtype_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubtype_declaration) {
+             listener.exitSubtype_declaration(this);
+        }
+    }
+}
+
+
+export class Cursor_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CURSOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CURSOR, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public parameter_spec(): Parameter_specContext[];
+    public parameter_spec(i: number): Parameter_specContext | null;
+    public parameter_spec(i?: number): Parameter_specContext[] | Parameter_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Parameter_specContext);
+        }
+
+        return this.getRuleContext(i, Parameter_specContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cursor_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCursor_declaration) {
+             listener.enterCursor_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCursor_declaration) {
+             listener.exitCursor_declaration(this);
+        }
+    }
+}
+
+
+export class Parameter_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public parameter_name(): Parameter_nameContext {
+        return this.getRuleContext(0, Parameter_nameContext)!;
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public default_value_part(): Default_value_partContext | null {
+        return this.getRuleContext(0, Default_value_partContext);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parameter_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParameter_spec) {
+             listener.enterParameter_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParameter_spec) {
+             listener.exitParameter_spec(this);
+        }
+    }
+}
+
+
+export class Exception_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public EXCEPTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXCEPTION, 0)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_exception_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterException_declaration) {
+             listener.enterException_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitException_declaration) {
+             listener.exitException_declaration(this);
+        }
+    }
+}
+
+
+export class Pragma_declarationContext extends antlr.ParserRuleContext {
+    public _id1?: IdentifierContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PRAGMA(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PRAGMA, 0)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public SERIALLY_REUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERIALLY_REUSABLE, 0);
+    }
+    public AUTONOMOUS_TRANSACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTONOMOUS_TRANSACTION, 0);
+    }
+    public EXCEPTION_INIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTION_INIT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public exception_name(): Exception_nameContext | null {
+        return this.getRuleContext(0, Exception_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public numeric_negative(): Numeric_negativeContext | null {
+        return this.getRuleContext(0, Numeric_negativeContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public INLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INLINE, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public RESTRICT_REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICT_REFERENCES, 0);
+    }
+    public DEPRECATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEPRECATE, 0);
+    }
+    public identifier(): IdentifierContext[];
+    public identifier(i: number): IdentifierContext | null;
+    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(IdentifierContext);
+        }
+
+        return this.getRuleContext(i, IdentifierContext);
+    }
+    public UDF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UDF, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pragma_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPragma_declaration) {
+             listener.enterPragma_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPragma_declaration) {
+             listener.exitPragma_declaration(this);
+        }
+    }
+}
+
+
+export class Record_type_defContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RECORD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RECORD, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public field_spec(): Field_specContext[];
+    public field_spec(i: number): Field_specContext | null;
+    public field_spec(i?: number): Field_specContext[] | Field_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Field_specContext);
+        }
+
+        return this.getRuleContext(i, Field_specContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_record_type_def;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRecord_type_def) {
+             listener.enterRecord_type_def(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRecord_type_def) {
+             listener.exitRecord_type_def(this);
+        }
+    }
+}
+
+
+export class Field_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public default_value_part(): Default_value_partContext | null {
+        return this.getRuleContext(0, Default_value_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_field_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterField_spec) {
+             listener.enterField_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitField_spec) {
+             listener.exitField_spec(this);
+        }
+    }
+}
+
+
+export class Ref_cursor_type_defContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REF, 0)!;
+    }
+    public CURSOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CURSOR, 0)!;
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_ref_cursor_type_def;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRef_cursor_type_def) {
+             listener.enterRef_cursor_type_def(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRef_cursor_type_def) {
+             listener.exitRef_cursor_type_def(this);
+        }
+    }
+}
+
+
+export class Type_declarationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TYPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TYPE, 0)!;
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public SEMICOLON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEMICOLON, 0)!;
+    }
+    public table_type_def(): Table_type_defContext | null {
+        return this.getRuleContext(0, Table_type_defContext);
+    }
+    public varray_type_def(): Varray_type_defContext | null {
+        return this.getRuleContext(0, Varray_type_defContext);
+    }
+    public record_type_def(): Record_type_defContext | null {
+        return this.getRuleContext(0, Record_type_defContext);
+    }
+    public ref_cursor_type_def(): Ref_cursor_type_defContext | null {
+        return this.getRuleContext(0, Ref_cursor_type_defContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_declaration) {
+             listener.enterType_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_declaration) {
+             listener.exitType_declaration(this);
+        }
+    }
+}
+
+
+export class Table_type_defContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public table_indexed_by_part(): Table_indexed_by_partContext | null {
+        return this.getRuleContext(0, Table_indexed_by_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_type_def;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_type_def) {
+             listener.enterTable_type_def(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_type_def) {
+             listener.exitTable_type_def(this);
+        }
+    }
+}
+
+
+export class Table_indexed_by_partContext extends antlr.ParserRuleContext {
+    public _idx1?: Token | null;
+    public _idx2?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public INDEXED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXED, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_indexed_by_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_indexed_by_part) {
+             listener.enterTable_indexed_by_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_indexed_by_part) {
+             listener.exitTable_indexed_by_part(this);
+        }
+    }
+}
+
+
+export class Varray_type_defContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public type_spec(): Type_specContext {
+        return this.getRuleContext(0, Type_specContext)!;
+    }
+    public VARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAY, 0);
+    }
+    public ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARRAY, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public VARYING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARYING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_varray_type_def;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVarray_type_def) {
+             listener.enterVarray_type_def(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVarray_type_def) {
+             listener.exitVarray_type_def(this);
+        }
+    }
+}
+
+
+export class Seq_of_statementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public statement(): StatementContext[];
+    public statement(i: number): StatementContext | null;
+    public statement(i?: number): StatementContext[] | StatementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(StatementContext);
+        }
+
+        return this.getRuleContext(i, StatementContext);
+    }
+    public label_declaration(): Label_declarationContext[];
+    public label_declaration(i: number): Label_declarationContext | null;
+    public label_declaration(i?: number): Label_declarationContext[] | Label_declarationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Label_declarationContext);
+        }
+
+        return this.getRuleContext(i, Label_declarationContext);
+    }
+    public selection_directive(): Selection_directiveContext[];
+    public selection_directive(i: number): Selection_directiveContext | null;
+    public selection_directive(i?: number): Selection_directiveContext[] | Selection_directiveContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Selection_directiveContext);
+        }
+
+        return this.getRuleContext(i, Selection_directiveContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode[];
+    public SEMICOLON(i: number): antlr.TerminalNode | null;
+    public SEMICOLON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SEMICOLON);
+    	} else {
+    		return this.getToken(PlSqlParser.SEMICOLON, i);
+    	}
+    }
+    public EOF(): antlr.TerminalNode[];
+    public EOF(i: number): antlr.TerminalNode | null;
+    public EOF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EOF);
+    	} else {
+    		return this.getToken(PlSqlParser.EOF, i);
+    	}
+    }
+    public pragma_declaration(): Pragma_declarationContext[];
+    public pragma_declaration(i: number): Pragma_declarationContext | null;
+    public pragma_declaration(i?: number): Pragma_declarationContext[] | Pragma_declarationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Pragma_declarationContext);
+        }
+
+        return this.getRuleContext(i, Pragma_declarationContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_seq_of_statements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSeq_of_statements) {
+             listener.enterSeq_of_statements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSeq_of_statements) {
+             listener.exitSeq_of_statements(this);
+        }
+    }
+}
+
+
+export class Label_declarationContext extends antlr.ParserRuleContext {
+    public _ltp1?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LESS_THAN_OP(): antlr.TerminalNode[];
+    public LESS_THAN_OP(i: number): antlr.TerminalNode | null;
+    public LESS_THAN_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LESS_THAN_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.LESS_THAN_OP, i);
+    	}
+    }
+    public label_name(): Label_nameContext {
+        return this.getRuleContext(0, Label_nameContext)!;
+    }
+    public GREATER_THAN_OP(): antlr.TerminalNode[];
+    public GREATER_THAN_OP(i: number): antlr.TerminalNode | null;
+    public GREATER_THAN_OP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.GREATER_THAN_OP);
+    	} else {
+    		return this.getToken(PlSqlParser.GREATER_THAN_OP, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_label_declaration;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLabel_declaration) {
+             listener.enterLabel_declaration(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLabel_declaration) {
+             listener.exitLabel_declaration(this);
+        }
+    }
+}
+
+
+export class StatementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public block(): BlockContext | null {
+        return this.getRuleContext(0, BlockContext);
+    }
+    public assignment_statement(): Assignment_statementContext | null {
+        return this.getRuleContext(0, Assignment_statementContext);
+    }
+    public continue_statement(): Continue_statementContext | null {
+        return this.getRuleContext(0, Continue_statementContext);
+    }
+    public exit_statement(): Exit_statementContext | null {
+        return this.getRuleContext(0, Exit_statementContext);
+    }
+    public goto_statement(): Goto_statementContext | null {
+        return this.getRuleContext(0, Goto_statementContext);
+    }
+    public if_statement(): If_statementContext | null {
+        return this.getRuleContext(0, If_statementContext);
+    }
+    public loop_statement(): Loop_statementContext | null {
+        return this.getRuleContext(0, Loop_statementContext);
+    }
+    public forall_statement(): Forall_statementContext | null {
+        return this.getRuleContext(0, Forall_statementContext);
+    }
+    public null_statement(): Null_statementContext | null {
+        return this.getRuleContext(0, Null_statementContext);
+    }
+    public raise_statement(): Raise_statementContext | null {
+        return this.getRuleContext(0, Raise_statementContext);
+    }
+    public return_statement(): Return_statementContext | null {
+        return this.getRuleContext(0, Return_statementContext);
+    }
+    public case_statement(): Case_statementContext | null {
+        return this.getRuleContext(0, Case_statementContext);
+    }
+    public sql_statement(): Sql_statementContext | null {
+        return this.getRuleContext(0, Sql_statementContext);
+    }
+    public call_statement(): Call_statementContext | null {
+        return this.getRuleContext(0, Call_statementContext);
+    }
+    public pipe_row_statement(): Pipe_row_statementContext | null {
+        return this.getRuleContext(0, Pipe_row_statementContext);
+    }
+    public grant_statement(): Grant_statementContext | null {
+        return this.getRuleContext(0, Grant_statementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStatement) {
+             listener.enterStatement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStatement) {
+             listener.exitStatement(this);
+        }
+    }
+}
+
+
+export class Assignment_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ASSIGN_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ASSIGN_OP, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_assignment_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAssignment_statement) {
+             listener.enterAssignment_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAssignment_statement) {
+             listener.exitAssignment_statement(this);
+        }
+    }
+}
+
+
+export class Continue_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONTINUE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONTINUE, 0)!;
+    }
+    public label_name(): Label_nameContext | null {
+        return this.getRuleContext(0, Label_nameContext);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public condition(): ConditionContext | null {
+        return this.getRuleContext(0, ConditionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_continue_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterContinue_statement) {
+             listener.enterContinue_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitContinue_statement) {
+             listener.exitContinue_statement(this);
+        }
+    }
+}
+
+
+export class Exit_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXIT, 0)!;
+    }
+    public label_name(): Label_nameContext | null {
+        return this.getRuleContext(0, Label_nameContext);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public condition(): ConditionContext | null {
+        return this.getRuleContext(0, ConditionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_exit_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExit_statement) {
+             listener.enterExit_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExit_statement) {
+             listener.exitExit_statement(this);
+        }
+    }
+}
+
+
+export class Goto_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GOTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GOTO, 0)!;
+    }
+    public label_name(): Label_nameContext {
+        return this.getRuleContext(0, Label_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_goto_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGoto_statement) {
+             listener.enterGoto_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGoto_statement) {
+             listener.exitGoto_statement(this);
+        }
+    }
+}
+
+
+export class If_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IF(): antlr.TerminalNode[];
+    public IF(i: number): antlr.TerminalNode | null;
+    public IF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IF);
+    	} else {
+    		return this.getToken(PlSqlParser.IF, i);
+    	}
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public elsif_part(): Elsif_partContext[];
+    public elsif_part(i: number): Elsif_partContext | null;
+    public elsif_part(i?: number): Elsif_partContext[] | Elsif_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Elsif_partContext);
+        }
+
+        return this.getRuleContext(i, Elsif_partContext);
+    }
+    public else_part(): Else_partContext | null {
+        return this.getRuleContext(0, Else_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_if_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIf_statement) {
+             listener.enterIf_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIf_statement) {
+             listener.exitIf_statement(this);
+        }
+    }
+}
+
+
+export class Elsif_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELSIF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ELSIF, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_elsif_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterElsif_part) {
+             listener.enterElsif_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitElsif_part) {
+             listener.exitElsif_part(this);
+        }
+    }
+}
+
+
+export class Else_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ELSE, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_else_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterElse_part) {
+             listener.enterElse_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitElse_part) {
+             listener.exitElse_part(this);
+        }
+    }
+}
+
+
+export class Loop_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOOP(): antlr.TerminalNode[];
+    public LOOP(i: number): antlr.TerminalNode | null;
+    public LOOP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LOOP);
+    	} else {
+    		return this.getToken(PlSqlParser.LOOP, i);
+    	}
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public label_declaration(): Label_declarationContext | null {
+        return this.getRuleContext(0, Label_declarationContext);
+    }
+    public WHILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHILE, 0);
+    }
+    public condition(): ConditionContext | null {
+        return this.getRuleContext(0, ConditionContext);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public cursor_loop_param(): Cursor_loop_paramContext | null {
+        return this.getRuleContext(0, Cursor_loop_paramContext);
+    }
+    public label_name(): Label_nameContext | null {
+        return this.getRuleContext(0, Label_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_loop_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLoop_statement) {
+             listener.enterLoop_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLoop_statement) {
+             listener.exitLoop_statement(this);
+        }
+    }
+}
+
+
+export class Cursor_loop_paramContext extends antlr.ParserRuleContext {
+    public _range_separator?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public index_name(): Index_nameContext | null {
+        return this.getRuleContext(0, Index_nameContext);
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public lower_bound(): Lower_boundContext | null {
+        return this.getRuleContext(0, Lower_boundContext);
+    }
+    public upper_bound(): Upper_boundContext | null {
+        return this.getRuleContext(0, Upper_boundContext);
+    }
+    public DOUBLE_PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE_PERIOD, 0);
+    }
+    public REVERSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REVERSE, 0);
+    }
+    public record_name(): Record_nameContext | null {
+        return this.getRuleContext(0, Record_nameContext);
+    }
+    public cursor_name(): Cursor_nameContext | null {
+        return this.getRuleContext(0, Cursor_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cursor_loop_param;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCursor_loop_param) {
+             listener.enterCursor_loop_param(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCursor_loop_param) {
+             listener.exitCursor_loop_param(this);
+        }
+    }
+}
+
+
+export class Forall_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FORALL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FORALL, 0)!;
+    }
+    public index_name(): Index_nameContext {
+        return this.getRuleContext(0, Index_nameContext)!;
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public bounds_clause(): Bounds_clauseContext {
+        return this.getRuleContext(0, Bounds_clauseContext)!;
+    }
+    public data_manipulation_language_statements(): Data_manipulation_language_statementsContext | null {
+        return this.getRuleContext(0, Data_manipulation_language_statementsContext);
+    }
+    public execute_immediate(): Execute_immediateContext | null {
+        return this.getRuleContext(0, Execute_immediateContext);
+    }
+    public SAVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAVE, 0);
+    }
+    public EXCEPTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTIONS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_forall_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterForall_statement) {
+             listener.enterForall_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitForall_statement) {
+             listener.exitForall_statement(this);
+        }
+    }
+}
+
+
+export class Bounds_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public lower_bound(): Lower_boundContext | null {
+        return this.getRuleContext(0, Lower_boundContext);
+    }
+    public DOUBLE_PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE_PERIOD, 0);
+    }
+    public upper_bound(): Upper_boundContext | null {
+        return this.getRuleContext(0, Upper_boundContext);
+    }
+    public INDICES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDICES, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public between_bound(): Between_boundContext | null {
+        return this.getRuleContext(0, Between_boundContext);
+    }
+    public VALUES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUES, 0);
+    }
+    public index_name(): Index_nameContext | null {
+        return this.getRuleContext(0, Index_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_bounds_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBounds_clause) {
+             listener.enterBounds_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBounds_clause) {
+             listener.exitBounds_clause(this);
+        }
+    }
+}
+
+
+export class Between_boundContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BETWEEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BETWEEN, 0)!;
+    }
+    public lower_bound(): Lower_boundContext {
+        return this.getRuleContext(0, Lower_boundContext)!;
+    }
+    public AND(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AND, 0)!;
+    }
+    public upper_bound(): Upper_boundContext {
+        return this.getRuleContext(0, Upper_boundContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_between_bound;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBetween_bound) {
+             listener.enterBetween_bound(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBetween_bound) {
+             listener.exitBetween_bound(this);
+        }
+    }
+}
+
+
+export class Lower_boundContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lower_bound;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLower_bound) {
+             listener.enterLower_bound(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLower_bound) {
+             listener.exitLower_bound(this);
+        }
+    }
+}
+
+
+export class Upper_boundContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_upper_bound;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpper_bound) {
+             listener.enterUpper_bound(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpper_bound) {
+             listener.exitUpper_bound(this);
+        }
+    }
+}
+
+
+export class Null_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NULL_(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NULL_, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_null_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNull_statement) {
+             listener.enterNull_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNull_statement) {
+             listener.exitNull_statement(this);
+        }
+    }
+}
+
+
+export class Raise_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RAISE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RAISE, 0)!;
+    }
+    public exception_name(): Exception_nameContext | null {
+        return this.getRuleContext(0, Exception_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_raise_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRaise_statement) {
+             listener.enterRaise_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRaise_statement) {
+             listener.exitRaise_statement(this);
+        }
+    }
+}
+
+
+export class Return_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_return_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReturn_statement) {
+             listener.enterReturn_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReturn_statement) {
+             listener.exitReturn_statement(this);
+        }
+    }
+}
+
+
+export class Call_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public routine_name(): Routine_nameContext[];
+    public routine_name(i: number): Routine_nameContext | null;
+    public routine_name(i?: number): Routine_nameContext[] | Routine_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Routine_nameContext);
+        }
+
+        return this.getRuleContext(i, Routine_nameContext);
+    }
+    public CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CALL, 0);
+    }
+    public function_argument(): Function_argumentContext[];
+    public function_argument(i: number): Function_argumentContext | null;
+    public function_argument(i?: number): Function_argumentContext[] | Function_argumentContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Function_argumentContext);
+        }
+
+        return this.getRuleContext(i, Function_argumentContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public INTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTO, 0);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_call_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCall_statement) {
+             listener.enterCall_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCall_statement) {
+             listener.exitCall_statement(this);
+        }
+    }
+}
+
+
+export class Pipe_row_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PIPE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PIPE, 0)!;
+    }
+    public ROW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROW, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pipe_row_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPipe_row_statement) {
+             listener.enterPipe_row_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPipe_row_statement) {
+             listener.exitPipe_row_statement(this);
+        }
+    }
+}
+
+
+export class Selection_directiveContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DOLLAR_IF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DOLLAR_IF, 0)!;
+    }
+    public condition(): ConditionContext[];
+    public condition(i: number): ConditionContext | null;
+    public condition(i?: number): ConditionContext[] | ConditionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConditionContext);
+        }
+
+        return this.getRuleContext(i, ConditionContext);
+    }
+    public DOLLAR_THEN(): antlr.TerminalNode[];
+    public DOLLAR_THEN(i: number): antlr.TerminalNode | null;
+    public DOLLAR_THEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DOLLAR_THEN);
+    	} else {
+    		return this.getToken(PlSqlParser.DOLLAR_THEN, i);
+    	}
+    }
+    public DOLLAR_END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DOLLAR_END, 0)!;
+    }
+    public selection_directive_body(): Selection_directive_bodyContext[];
+    public selection_directive_body(i: number): Selection_directive_bodyContext | null;
+    public selection_directive_body(i?: number): Selection_directive_bodyContext[] | Selection_directive_bodyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Selection_directive_bodyContext);
+        }
+
+        return this.getRuleContext(i, Selection_directive_bodyContext);
+    }
+    public DOLLAR_ELSIF(): antlr.TerminalNode[];
+    public DOLLAR_ELSIF(i: number): antlr.TerminalNode | null;
+    public DOLLAR_ELSIF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DOLLAR_ELSIF);
+    	} else {
+    		return this.getToken(PlSqlParser.DOLLAR_ELSIF, i);
+    	}
+    }
+    public DOLLAR_ELSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOLLAR_ELSE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_selection_directive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelection_directive) {
+             listener.enterSelection_directive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelection_directive) {
+             listener.exitSelection_directive(this);
+        }
+    }
+}
+
+
+export class Error_directiveContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DOLLAR_ERROR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DOLLAR_ERROR, 0)!;
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public DOLLAR_END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DOLLAR_END, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_error_directive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterError_directive) {
+             listener.enterError_directive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitError_directive) {
+             listener.exitError_directive(this);
+        }
+    }
+}
+
+
+export class Selection_directive_bodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public statement(): StatementContext[];
+    public statement(i: number): StatementContext | null;
+    public statement(i?: number): StatementContext[] | StatementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(StatementContext);
+        }
+
+        return this.getRuleContext(i, StatementContext);
+    }
+    public SEMICOLON(): antlr.TerminalNode[];
+    public SEMICOLON(i: number): antlr.TerminalNode | null;
+    public SEMICOLON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SEMICOLON);
+    	} else {
+    		return this.getToken(PlSqlParser.SEMICOLON, i);
+    	}
+    }
+    public variable_declaration(): Variable_declarationContext[];
+    public variable_declaration(i: number): Variable_declarationContext | null;
+    public variable_declaration(i?: number): Variable_declarationContext[] | Variable_declarationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Variable_declarationContext);
+        }
+
+        return this.getRuleContext(i, Variable_declarationContext);
+    }
+    public error_directive(): Error_directiveContext[];
+    public error_directive(i: number): Error_directiveContext | null;
+    public error_directive(i?: number): Error_directiveContext[] | Error_directiveContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Error_directiveContext);
+        }
+
+        return this.getRuleContext(i, Error_directiveContext);
+    }
+    public function_body(): Function_bodyContext[];
+    public function_body(i: number): Function_bodyContext | null;
+    public function_body(i?: number): Function_bodyContext[] | Function_bodyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Function_bodyContext);
+        }
+
+        return this.getRuleContext(i, Function_bodyContext);
+    }
+    public procedure_body(): Procedure_bodyContext[];
+    public procedure_body(i: number): Procedure_bodyContext | null;
+    public procedure_body(i?: number): Procedure_bodyContext[] | Procedure_bodyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Procedure_bodyContext);
+        }
+
+        return this.getRuleContext(i, Procedure_bodyContext);
+    }
+    public pragma_declaration(): Pragma_declarationContext[];
+    public pragma_declaration(i: number): Pragma_declarationContext | null;
+    public pragma_declaration(i?: number): Pragma_declarationContext[] | Pragma_declarationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Pragma_declarationContext);
+        }
+
+        return this.getRuleContext(i, Pragma_declarationContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_selection_directive_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelection_directive_body) {
+             listener.enterSelection_directive_body(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelection_directive_body) {
+             listener.exitSelection_directive_body(this);
+        }
+    }
+}
+
+
+export class BodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BEGIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BEGIN, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public EXCEPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTION, 0);
+    }
+    public label_name(): Label_nameContext | null {
+        return this.getRuleContext(0, Label_nameContext);
+    }
+    public exception_handler(): Exception_handlerContext[];
+    public exception_handler(i: number): Exception_handlerContext | null;
+    public exception_handler(i?: number): Exception_handlerContext[] | Exception_handlerContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Exception_handlerContext);
+        }
+
+        return this.getRuleContext(i, Exception_handlerContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_body;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBody) {
+             listener.enterBody(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBody) {
+             listener.exitBody(this);
+        }
+    }
+}
+
+
+export class Exception_handlerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public exception_name(): Exception_nameContext[];
+    public exception_name(i: number): Exception_nameContext | null;
+    public exception_name(i?: number): Exception_nameContext[] | Exception_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Exception_nameContext);
+        }
+
+        return this.getRuleContext(i, Exception_nameContext);
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public OR(): antlr.TerminalNode[];
+    public OR(i: number): antlr.TerminalNode | null;
+    public OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OR);
+    	} else {
+    		return this.getToken(PlSqlParser.OR, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_exception_handler;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterException_handler) {
+             listener.enterException_handler(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitException_handler) {
+             listener.exitException_handler(this);
+        }
+    }
+}
+
+
+export class Trigger_blockContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public body(): BodyContext {
+        return this.getRuleContext(0, BodyContext)!;
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public declare_spec(): Declare_specContext[];
+    public declare_spec(i: number): Declare_specContext | null;
+    public declare_spec(i?: number): Declare_specContext[] | Declare_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Declare_specContext);
+        }
+
+        return this.getRuleContext(i, Declare_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_trigger_block;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTrigger_block) {
+             listener.enterTrigger_block(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTrigger_block) {
+             listener.exitTrigger_block(this);
+        }
+    }
+}
+
+
+export class Tps_blockContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public body(): BodyContext {
+        return this.getRuleContext(0, BodyContext)!;
+    }
+    public declare_spec(): Declare_specContext[];
+    public declare_spec(i: number): Declare_specContext | null;
+    public declare_spec(i?: number): Declare_specContext[] | Declare_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Declare_specContext);
+        }
+
+        return this.getRuleContext(i, Declare_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tps_block;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTps_block) {
+             listener.enterTps_block(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTps_block) {
+             listener.exitTps_block(this);
+        }
+    }
+}
+
+
+export class BlockContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public body(): BodyContext {
+        return this.getRuleContext(0, BodyContext)!;
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public declare_spec(): Declare_specContext[];
+    public declare_spec(i: number): Declare_specContext | null;
+    public declare_spec(i?: number): Declare_specContext[] | Declare_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Declare_specContext);
+        }
+
+        return this.getRuleContext(i, Declare_specContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_block;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBlock) {
+             listener.enterBlock(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBlock) {
+             listener.exitBlock(this);
+        }
+    }
+}
+
+
+export class Sql_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public execute_immediate(): Execute_immediateContext | null {
+        return this.getRuleContext(0, Execute_immediateContext);
+    }
+    public data_manipulation_language_statements(): Data_manipulation_language_statementsContext | null {
+        return this.getRuleContext(0, Data_manipulation_language_statementsContext);
+    }
+    public cursor_manipulation_statements(): Cursor_manipulation_statementsContext | null {
+        return this.getRuleContext(0, Cursor_manipulation_statementsContext);
+    }
+    public transaction_control_statements(): Transaction_control_statementsContext | null {
+        return this.getRuleContext(0, Transaction_control_statementsContext);
+    }
+    public collection_method_call(): Collection_method_callContext | null {
+        return this.getRuleContext(0, Collection_method_callContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_statement) {
+             listener.enterSql_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_statement) {
+             listener.exitSql_statement(this);
+        }
+    }
+}
+
+
+export class Execute_immediateContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXECUTE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXECUTE, 0)!;
+    }
+    public IMMEDIATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public into_clause(): Into_clauseContext | null {
+        return this.getRuleContext(0, Into_clauseContext);
+    }
+    public using_clause(): Using_clauseContext | null {
+        return this.getRuleContext(0, Using_clauseContext);
+    }
+    public dynamic_returning_clause(): Dynamic_returning_clauseContext | null {
+        return this.getRuleContext(0, Dynamic_returning_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_execute_immediate;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExecute_immediate) {
+             listener.enterExecute_immediate(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExecute_immediate) {
+             listener.exitExecute_immediate(this);
+        }
+    }
+}
+
+
+export class Dynamic_returning_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public into_clause(): Into_clauseContext {
+        return this.getRuleContext(0, Into_clauseContext)!;
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dynamic_returning_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDynamic_returning_clause) {
+             listener.enterDynamic_returning_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDynamic_returning_clause) {
+             listener.exitDynamic_returning_clause(this);
+        }
+    }
+}
+
+
+export class Data_manipulation_language_statementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public merge_statement(): Merge_statementContext | null {
+        return this.getRuleContext(0, Merge_statementContext);
+    }
+    public lock_table_statement(): Lock_table_statementContext | null {
+        return this.getRuleContext(0, Lock_table_statementContext);
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public update_statement(): Update_statementContext | null {
+        return this.getRuleContext(0, Update_statementContext);
+    }
+    public delete_statement(): Delete_statementContext | null {
+        return this.getRuleContext(0, Delete_statementContext);
+    }
+    public insert_statement(): Insert_statementContext | null {
+        return this.getRuleContext(0, Insert_statementContext);
+    }
+    public explain_statement(): Explain_statementContext | null {
+        return this.getRuleContext(0, Explain_statementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_data_manipulation_language_statements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterData_manipulation_language_statements) {
+             listener.enterData_manipulation_language_statements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitData_manipulation_language_statements) {
+             listener.exitData_manipulation_language_statements(this);
+        }
+    }
+}
+
+
+export class Cursor_manipulation_statementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public close_statement(): Close_statementContext | null {
+        return this.getRuleContext(0, Close_statementContext);
+    }
+    public open_statement(): Open_statementContext | null {
+        return this.getRuleContext(0, Open_statementContext);
+    }
+    public fetch_statement(): Fetch_statementContext | null {
+        return this.getRuleContext(0, Fetch_statementContext);
+    }
+    public open_for_statement(): Open_for_statementContext | null {
+        return this.getRuleContext(0, Open_for_statementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cursor_manipulation_statements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCursor_manipulation_statements) {
+             listener.enterCursor_manipulation_statements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCursor_manipulation_statements) {
+             listener.exitCursor_manipulation_statements(this);
+        }
+    }
+}
+
+
+export class Close_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CLOSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CLOSE, 0)!;
+    }
+    public cursor_name(): Cursor_nameContext {
+        return this.getRuleContext(0, Cursor_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_close_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClose_statement) {
+             listener.enterClose_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClose_statement) {
+             listener.exitClose_statement(this);
+        }
+    }
+}
+
+
+export class Open_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OPEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPEN, 0)!;
+    }
+    public cursor_name(): Cursor_nameContext {
+        return this.getRuleContext(0, Cursor_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_open_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOpen_statement) {
+             listener.enterOpen_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOpen_statement) {
+             listener.exitOpen_statement(this);
+        }
+    }
+}
+
+
+export class Fetch_statementContext extends antlr.ParserRuleContext {
+    public _it1?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FETCH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FETCH, 0)!;
+    }
+    public cursor_name(): Cursor_nameContext {
+        return this.getRuleContext(0, Cursor_nameContext)!;
+    }
+    public variable_or_collection(): Variable_or_collectionContext[];
+    public variable_or_collection(i: number): Variable_or_collectionContext | null;
+    public variable_or_collection(i?: number): Variable_or_collectionContext[] | Variable_or_collectionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Variable_or_collectionContext);
+        }
+
+        return this.getRuleContext(i, Variable_or_collectionContext);
+    }
+    public BULK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BULK, 0);
+    }
+    public COLLECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLECT, 0);
+    }
+    public INTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTO, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_fetch_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFetch_statement) {
+             listener.enterFetch_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFetch_statement) {
+             listener.exitFetch_statement(this);
+        }
+    }
+}
+
+
+export class Variable_or_collectionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public variable_name(): Variable_nameContext | null {
+        return this.getRuleContext(0, Variable_nameContext);
+    }
+    public collection_expression(): Collection_expressionContext | null {
+        return this.getRuleContext(0, Collection_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_variable_or_collection;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVariable_or_collection) {
+             listener.enterVariable_or_collection(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVariable_or_collection) {
+             listener.exitVariable_or_collection(this);
+        }
+    }
+}
+
+
+export class Open_for_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OPEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OPEN, 0)!;
+    }
+    public variable_name(): Variable_nameContext {
+        return this.getRuleContext(0, Variable_nameContext)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public using_clause(): Using_clauseContext | null {
+        return this.getRuleContext(0, Using_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_open_for_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOpen_for_statement) {
+             listener.enterOpen_for_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOpen_for_statement) {
+             listener.exitOpen_for_statement(this);
+        }
+    }
+}
+
+
+export class Transaction_control_statementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public set_transaction_command(): Set_transaction_commandContext | null {
+        return this.getRuleContext(0, Set_transaction_commandContext);
+    }
+    public set_constraint_command(): Set_constraint_commandContext | null {
+        return this.getRuleContext(0, Set_constraint_commandContext);
+    }
+    public commit_statement(): Commit_statementContext | null {
+        return this.getRuleContext(0, Commit_statementContext);
+    }
+    public rollback_statement(): Rollback_statementContext | null {
+        return this.getRuleContext(0, Rollback_statementContext);
+    }
+    public savepoint_statement(): Savepoint_statementContext | null {
+        return this.getRuleContext(0, Savepoint_statementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_transaction_control_statements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTransaction_control_statements) {
+             listener.enterTransaction_control_statements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTransaction_control_statements) {
+             listener.exitTransaction_control_statements(this);
+        }
+    }
+}
+
+
+export class Set_transaction_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public TRANSACTION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TRANSACTION, 0)!;
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public ISOLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ISOLATION, 0);
+    }
+    public LEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVEL, 0);
+    }
+    public USE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE, 0);
+    }
+    public ROLLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLBACK, 0);
+    }
+    public SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEGMENT, 0);
+    }
+    public rollback_segment_name(): Rollback_segment_nameContext | null {
+        return this.getRuleContext(0, Rollback_segment_nameContext);
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public SERIALIZABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERIALIZABLE, 0);
+    }
+    public COMMITTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMITTED, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_transaction_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_transaction_command) {
+             listener.enterSet_transaction_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_transaction_command) {
+             listener.exitSet_transaction_command(this);
+        }
+    }
+}
+
+
+export class Set_constraint_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public DEFERRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFERRED, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public constraint_name(): Constraint_nameContext[];
+    public constraint_name(i: number): Constraint_nameContext | null;
+    public constraint_name(i?: number): Constraint_nameContext[] | Constraint_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Constraint_nameContext);
+        }
+
+        return this.getRuleContext(i, Constraint_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_constraint_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_constraint_command) {
+             listener.enterSet_constraint_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_constraint_command) {
+             listener.exitSet_constraint_command(this);
+        }
+    }
+}
+
+
+export class Commit_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COMMIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COMMIT, 0)!;
+    }
+    public WORK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WORK, 0);
+    }
+    public write_clause(): Write_clauseContext[];
+    public write_clause(i: number): Write_clauseContext | null;
+    public write_clause(i?: number): Write_clauseContext[] | Write_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Write_clauseContext);
+        }
+
+        return this.getRuleContext(i, Write_clauseContext);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public CORRUPT_XID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORRUPT_XID, 0);
+    }
+    public CORRUPT_XID_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORRUPT_XID_ALL, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_commit_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCommit_statement) {
+             listener.enterCommit_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCommit_statement) {
+             listener.exitCommit_statement(this);
+        }
+    }
+}
+
+
+export class Write_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WRITE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WRITE, 0)!;
+    }
+    public IMMEDIATE(): antlr.TerminalNode[];
+    public IMMEDIATE(i: number): antlr.TerminalNode | null;
+    public IMMEDIATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IMMEDIATE);
+    	} else {
+    		return this.getToken(PlSqlParser.IMMEDIATE, i);
+    	}
+    }
+    public BATCH(): antlr.TerminalNode[];
+    public BATCH(i: number): antlr.TerminalNode | null;
+    public BATCH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BATCH);
+    	} else {
+    		return this.getToken(PlSqlParser.BATCH, i);
+    	}
+    }
+    public WAIT(): antlr.TerminalNode[];
+    public WAIT(i: number): antlr.TerminalNode | null;
+    public WAIT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.WAIT);
+    	} else {
+    		return this.getToken(PlSqlParser.WAIT, i);
+    	}
+    }
+    public NOWAIT(): antlr.TerminalNode[];
+    public NOWAIT(i: number): antlr.TerminalNode | null;
+    public NOWAIT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NOWAIT);
+    	} else {
+    		return this.getToken(PlSqlParser.NOWAIT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_write_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWrite_clause) {
+             listener.enterWrite_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWrite_clause) {
+             listener.exitWrite_clause(this);
+        }
+    }
+}
+
+
+export class Rollback_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ROLLBACK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROLLBACK, 0)!;
+    }
+    public WORK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WORK, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public savepoint_name(): Savepoint_nameContext | null {
+        return this.getRuleContext(0, Savepoint_nameContext);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public SAVEPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAVEPOINT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rollback_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRollback_statement) {
+             listener.enterRollback_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRollback_statement) {
+             listener.exitRollback_statement(this);
+        }
+    }
+}
+
+
+export class Savepoint_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SAVEPOINT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SAVEPOINT, 0)!;
+    }
+    public savepoint_name(): Savepoint_nameContext {
+        return this.getRuleContext(0, Savepoint_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_savepoint_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSavepoint_statement) {
+             listener.enterSavepoint_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSavepoint_statement) {
+             listener.exitSavepoint_statement(this);
+        }
+    }
+}
+
+
+export class Collection_method_callContext extends antlr.ParserRuleContext {
+    public _expression?: ExpressionContext;
+    public _index: ExpressionContext[] = [];
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PERIOD, 0)!;
+    }
+    public TRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIM, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public EXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTEND, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_collection_method_call;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCollection_method_call) {
+             listener.enterCollection_method_call(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCollection_method_call) {
+             listener.exitCollection_method_call(this);
+        }
+    }
+}
+
+
+export class Explain_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXPLAIN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EXPLAIN, 0)!;
+    }
+    public PLAN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PLAN, 0)!;
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public update_statement(): Update_statementContext | null {
+        return this.getRuleContext(0, Update_statementContext);
+    }
+    public delete_statement(): Delete_statementContext | null {
+        return this.getRuleContext(0, Delete_statementContext);
+    }
+    public insert_statement(): Insert_statementContext | null {
+        return this.getRuleContext(0, Insert_statementContext);
+    }
+    public merge_statement(): Merge_statementContext | null {
+        return this.getRuleContext(0, Merge_statementContext);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public STATEMENT_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENT_ID, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public INTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTO, 0);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_explain_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExplain_statement) {
+             listener.enterExplain_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExplain_statement) {
+             listener.exitExplain_statement(this);
+        }
+    }
+}
+
+
+export class Select_only_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public subquery(): SubqueryContext {
+        return this.getRuleContext(0, SubqueryContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_select_only_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelect_only_statement) {
+             listener.enterSelect_only_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelect_only_statement) {
+             listener.exitSelect_only_statement(this);
+        }
+    }
+}
+
+
+export class Select_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public select_only_statement(): Select_only_statementContext {
+        return this.getRuleContext(0, Select_only_statementContext)!;
+    }
+    public for_update_clause(): For_update_clauseContext[];
+    public for_update_clause(i: number): For_update_clauseContext | null;
+    public for_update_clause(i?: number): For_update_clauseContext[] | For_update_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(For_update_clauseContext);
+        }
+
+        return this.getRuleContext(i, For_update_clauseContext);
+    }
+    public order_by_clause(): Order_by_clauseContext[];
+    public order_by_clause(i: number): Order_by_clauseContext | null;
+    public order_by_clause(i?: number): Order_by_clauseContext[] | Order_by_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Order_by_clauseContext);
+        }
+
+        return this.getRuleContext(i, Order_by_clauseContext);
+    }
+    public offset_clause(): Offset_clauseContext[];
+    public offset_clause(i: number): Offset_clauseContext | null;
+    public offset_clause(i?: number): Offset_clauseContext[] | Offset_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Offset_clauseContext);
+        }
+
+        return this.getRuleContext(i, Offset_clauseContext);
+    }
+    public fetch_clause(): Fetch_clauseContext[];
+    public fetch_clause(i: number): Fetch_clauseContext | null;
+    public fetch_clause(i?: number): Fetch_clauseContext[] | Fetch_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Fetch_clauseContext);
+        }
+
+        return this.getRuleContext(i, Fetch_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_select_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelect_statement) {
+             listener.enterSelect_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelect_statement) {
+             listener.exitSelect_statement(this);
+        }
+    }
+}
+
+
+export class With_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public with_factoring_clause(): With_factoring_clauseContext[];
+    public with_factoring_clause(i: number): With_factoring_clauseContext | null;
+    public with_factoring_clause(i?: number): With_factoring_clauseContext[] | With_factoring_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(With_factoring_clauseContext);
+        }
+
+        return this.getRuleContext(i, With_factoring_clauseContext);
+    }
+    public function_body(): Function_bodyContext[];
+    public function_body(i: number): Function_bodyContext | null;
+    public function_body(i?: number): Function_bodyContext[] | Function_bodyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Function_bodyContext);
+        }
+
+        return this.getRuleContext(i, Function_bodyContext);
+    }
+    public procedure_body(): Procedure_bodyContext[];
+    public procedure_body(i: number): Procedure_bodyContext | null;
+    public procedure_body(i?: number): Procedure_bodyContext[] | Procedure_bodyContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Procedure_bodyContext);
+        }
+
+        return this.getRuleContext(i, Procedure_bodyContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_with_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWith_clause) {
+             listener.enterWith_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWith_clause) {
+             listener.exitWith_clause(this);
+        }
+    }
+}
+
+
+export class With_factoring_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public subquery_factoring_clause(): Subquery_factoring_clauseContext | null {
+        return this.getRuleContext(0, Subquery_factoring_clauseContext);
+    }
+    public subav_factoring_clause(): Subav_factoring_clauseContext | null {
+        return this.getRuleContext(0, Subav_factoring_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_with_factoring_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWith_factoring_clause) {
+             listener.enterWith_factoring_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWith_factoring_clause) {
+             listener.exitWith_factoring_clause(this);
+        }
+    }
+}
+
+
+export class Subquery_factoring_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public query_name(): Query_nameContext {
+        return this.getRuleContext(0, Query_nameContext)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public subquery_no_with(): Subquery_no_withContext {
+        return this.getRuleContext(0, Subquery_no_withContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public search_clause(): Search_clauseContext | null {
+        return this.getRuleContext(0, Search_clauseContext);
+    }
+    public cycle_clause(): Cycle_clauseContext | null {
+        return this.getRuleContext(0, Cycle_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subquery_factoring_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubquery_factoring_clause) {
+             listener.enterSubquery_factoring_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubquery_factoring_clause) {
+             listener.exitSubquery_factoring_clause(this);
+        }
+    }
+}
+
+
+export class Search_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SEARCH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEARCH, 0)!;
+    }
+    public FIRST(): antlr.TerminalNode[];
+    public FIRST(i: number): antlr.TerminalNode | null;
+    public FIRST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.FIRST);
+    	} else {
+    		return this.getToken(PlSqlParser.FIRST, i);
+    	}
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public DEPTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEPTH, 0);
+    }
+    public BREADTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BREADTH, 0);
+    }
+    public ASC(): antlr.TerminalNode[];
+    public ASC(i: number): antlr.TerminalNode | null;
+    public ASC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ASC);
+    	} else {
+    		return this.getToken(PlSqlParser.ASC, i);
+    	}
+    }
+    public DESC(): antlr.TerminalNode[];
+    public DESC(i: number): antlr.TerminalNode | null;
+    public DESC(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DESC);
+    	} else {
+    		return this.getToken(PlSqlParser.DESC, i);
+    	}
+    }
+    public NULLS(): antlr.TerminalNode[];
+    public NULLS(i: number): antlr.TerminalNode | null;
+    public NULLS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULLS);
+    	} else {
+    		return this.getToken(PlSqlParser.NULLS, i);
+    	}
+    }
+    public LAST(): antlr.TerminalNode[];
+    public LAST(i: number): antlr.TerminalNode | null;
+    public LAST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LAST);
+    	} else {
+    		return this.getToken(PlSqlParser.LAST, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_search_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSearch_clause) {
+             listener.enterSearch_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSearch_clause) {
+             listener.exitSearch_clause(this);
+        }
+    }
+}
+
+
+export class Cycle_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CYCLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CYCLE, 0)!;
+    }
+    public column_list(): Column_listContext {
+        return this.getRuleContext(0, Column_listContext)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cycle_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCycle_clause) {
+             listener.enterCycle_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCycle_clause) {
+             listener.exitCycle_clause(this);
+        }
+    }
+}
+
+
+export class Subav_factoring_clauseContext extends antlr.ParserRuleContext {
+    public _subav_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ANALYTIC(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ANALYTIC, 0)!;
+    }
+    public VIEW(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VIEW, 0)!;
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public subav_clause(): Subav_clauseContext {
+        return this.getRuleContext(0, Subav_clauseContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subav_factoring_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubav_factoring_clause) {
+             listener.enterSubav_factoring_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubav_factoring_clause) {
+             listener.exitSubav_factoring_clause(this);
+        }
+    }
+}
+
+
+export class Subav_clauseContext extends antlr.ParserRuleContext {
+    public _subav_name?: Object_nameContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public object_name(): Object_nameContext {
+        return this.getRuleContext(0, Object_nameContext)!;
+    }
+    public hierarchies_clause(): Hierarchies_clauseContext | null {
+        return this.getRuleContext(0, Hierarchies_clauseContext);
+    }
+    public filter_clauses(): Filter_clausesContext | null {
+        return this.getRuleContext(0, Filter_clausesContext);
+    }
+    public add_calcs_clause(): Add_calcs_clauseContext | null {
+        return this.getRuleContext(0, Add_calcs_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subav_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubav_clause) {
+             listener.enterSubav_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubav_clause) {
+             listener.exitSubav_clause(this);
+        }
+    }
+}
+
+
+export class Hierarchies_clauseContext extends antlr.ParserRuleContext {
+    public _object_name?: Object_nameContext;
+    public _hier_alias: Object_nameContext[] = [];
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public HIERARCHIES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HIERARCHIES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public object_name(): Object_nameContext[];
+    public object_name(i: number): Object_nameContext | null;
+    public object_name(i?: number): Object_nameContext[] | Object_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Object_nameContext);
+        }
+
+        return this.getRuleContext(i, Object_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hierarchies_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHierarchies_clause) {
+             listener.enterHierarchies_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHierarchies_clause) {
+             listener.exitHierarchies_clause(this);
+        }
+    }
+}
+
+
+export class Filter_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FILTER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FILTER, 0)!;
+    }
+    public FACT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FACT, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public filter_clause(): Filter_clauseContext[];
+    public filter_clause(i: number): Filter_clauseContext | null;
+    public filter_clause(i?: number): Filter_clauseContext[] | Filter_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Filter_clauseContext);
+        }
+
+        return this.getRuleContext(i, Filter_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filter_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilter_clauses) {
+             listener.enterFilter_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilter_clauses) {
+             listener.exitFilter_clauses(this);
+        }
+    }
+}
+
+
+export class Filter_clauseContext extends antlr.ParserRuleContext {
+    public _hier_alias?: Object_nameContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public MEASURES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEASURES, 0);
+    }
+    public object_name(): Object_nameContext | null {
+        return this.getRuleContext(0, Object_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_filter_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFilter_clause) {
+             listener.enterFilter_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFilter_clause) {
+             listener.exitFilter_clause(this);
+        }
+    }
+}
+
+
+export class Add_calcs_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ADD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ADD, 0)!;
+    }
+    public MEASURES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public add_calc_meas_clause(): Add_calc_meas_clauseContext[];
+    public add_calc_meas_clause(i: number): Add_calc_meas_clauseContext | null;
+    public add_calc_meas_clause(i?: number): Add_calc_meas_clauseContext[] | Add_calc_meas_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Add_calc_meas_clauseContext);
+        }
+
+        return this.getRuleContext(i, Add_calc_meas_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_calcs_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_calcs_clause) {
+             listener.enterAdd_calcs_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_calcs_clause) {
+             listener.exitAdd_calcs_clause(this);
+        }
+    }
+}
+
+
+export class Add_calc_meas_clauseContext extends antlr.ParserRuleContext {
+    public _meas_name?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_add_calc_meas_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAdd_calc_meas_clause) {
+             listener.enterAdd_calc_meas_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAdd_calc_meas_clause) {
+             listener.exitAdd_calc_meas_clause(this);
+        }
+    }
+}
+
+
+export class SubqueryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public subquery_basic_elements(): Subquery_basic_elementsContext {
+        return this.getRuleContext(0, Subquery_basic_elementsContext)!;
+    }
+    public with_clause(): With_clauseContext | null {
+        return this.getRuleContext(0, With_clauseContext);
+    }
+    public subquery_operation_part(): Subquery_operation_partContext[];
+    public subquery_operation_part(i: number): Subquery_operation_partContext | null;
+    public subquery_operation_part(i?: number): Subquery_operation_partContext[] | Subquery_operation_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Subquery_operation_partContext);
+        }
+
+        return this.getRuleContext(i, Subquery_operation_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subquery;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubquery) {
+             listener.enterSubquery(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubquery) {
+             listener.exitSubquery(this);
+        }
+    }
+}
+
+
+export class Subquery_no_withContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public subquery_basic_elements(): Subquery_basic_elementsContext {
+        return this.getRuleContext(0, Subquery_basic_elementsContext)!;
+    }
+    public subquery_operation_part(): Subquery_operation_partContext[];
+    public subquery_operation_part(i: number): Subquery_operation_partContext | null;
+    public subquery_operation_part(i?: number): Subquery_operation_partContext[] | Subquery_operation_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Subquery_operation_partContext);
+        }
+
+        return this.getRuleContext(i, Subquery_operation_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subquery_no_with;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubquery_no_with) {
+             listener.enterSubquery_no_with(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubquery_no_with) {
+             listener.exitSubquery_no_with(this);
+        }
+    }
+}
+
+
+export class Subquery_basic_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public query_block(): Query_blockContext | null {
+        return this.getRuleContext(0, Query_blockContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public subquery_no_with(): Subquery_no_withContext | null {
+        return this.getRuleContext(0, Subquery_no_withContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subquery_basic_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubquery_basic_elements) {
+             listener.enterSubquery_basic_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubquery_basic_elements) {
+             listener.exitSubquery_basic_elements(this);
+        }
+    }
+}
+
+
+export class Subquery_operation_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public subquery_basic_elements(): Subquery_basic_elementsContext {
+        return this.getRuleContext(0, Subquery_basic_elementsContext)!;
+    }
+    public UNION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNION, 0);
+    }
+    public INTERSECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERSECT, 0);
+    }
+    public MINUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUS, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subquery_operation_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubquery_operation_part) {
+             listener.enterSubquery_operation_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubquery_operation_part) {
+             listener.exitSubquery_operation_part(this);
+        }
+    }
+}
+
+
+export class Query_blockContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SELECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SELECT, 0)!;
+    }
+    public selected_list(): Selected_listContext {
+        return this.getRuleContext(0, Selected_listContext)!;
+    }
+    public into_clause(): Into_clauseContext | null {
+        return this.getRuleContext(0, Into_clauseContext);
+    }
+    public from_clause(): From_clauseContext | null {
+        return this.getRuleContext(0, From_clauseContext);
+    }
+    public where_clause(): Where_clauseContext | null {
+        return this.getRuleContext(0, Where_clauseContext);
+    }
+    public hierarchical_query_clause(): Hierarchical_query_clauseContext[];
+    public hierarchical_query_clause(i: number): Hierarchical_query_clauseContext | null;
+    public hierarchical_query_clause(i?: number): Hierarchical_query_clauseContext[] | Hierarchical_query_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Hierarchical_query_clauseContext);
+        }
+
+        return this.getRuleContext(i, Hierarchical_query_clauseContext);
+    }
+    public group_by_clause(): Group_by_clauseContext[];
+    public group_by_clause(i: number): Group_by_clauseContext | null;
+    public group_by_clause(i?: number): Group_by_clauseContext[] | Group_by_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Group_by_clauseContext);
+        }
+
+        return this.getRuleContext(i, Group_by_clauseContext);
+    }
+    public model_clause(): Model_clauseContext | null {
+        return this.getRuleContext(0, Model_clauseContext);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public offset_clause(): Offset_clauseContext | null {
+        return this.getRuleContext(0, Offset_clauseContext);
+    }
+    public fetch_clause(): Fetch_clauseContext | null {
+        return this.getRuleContext(0, Fetch_clauseContext);
+    }
+    public DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINCT, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_query_block;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuery_block) {
+             listener.enterQuery_block(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuery_block) {
+             listener.exitQuery_block(this);
+        }
+    }
+}
+
+
+export class Selected_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public select_list_elements(): Select_list_elementsContext[];
+    public select_list_elements(i: number): Select_list_elementsContext | null;
+    public select_list_elements(i?: number): Select_list_elementsContext[] | Select_list_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Select_list_elementsContext);
+        }
+
+        return this.getRuleContext(i, Select_list_elementsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_selected_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelected_list) {
+             listener.enterSelected_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelected_list) {
+             listener.exitSelected_list(this);
+        }
+    }
+}
+
+
+export class From_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FROM(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FROM, 0)!;
+    }
+    public table_ref_list(): Table_ref_listContext {
+        return this.getRuleContext(0, Table_ref_listContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_from_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFrom_clause) {
+             listener.enterFrom_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFrom_clause) {
+             listener.exitFrom_clause(this);
+        }
+    }
+}
+
+
+export class Select_list_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public column_alias(): Column_aliasContext | null {
+        return this.getRuleContext(0, Column_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_select_list_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelect_list_elements) {
+             listener.enterSelect_list_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelect_list_elements) {
+             listener.exitSelect_list_elements(this);
+        }
+    }
+}
+
+
+export class Table_ref_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_ref(): Table_refContext[];
+    public table_ref(i: number): Table_refContext | null;
+    public table_ref(i?: number): Table_refContext[] | Table_refContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Table_refContext);
+        }
+
+        return this.getRuleContext(i, Table_refContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_ref_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_ref_list) {
+             listener.enterTable_ref_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_ref_list) {
+             listener.exitTable_ref_list(this);
+        }
+    }
+}
+
+
+export class Table_refContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_ref_aux(): Table_ref_auxContext {
+        return this.getRuleContext(0, Table_ref_auxContext)!;
+    }
+    public join_clause(): Join_clauseContext[];
+    public join_clause(i: number): Join_clauseContext | null;
+    public join_clause(i?: number): Join_clauseContext[] | Join_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Join_clauseContext);
+        }
+
+        return this.getRuleContext(i, Join_clauseContext);
+    }
+    public pivot_clause(): Pivot_clauseContext | null {
+        return this.getRuleContext(0, Pivot_clauseContext);
+    }
+    public unpivot_clause(): Unpivot_clauseContext | null {
+        return this.getRuleContext(0, Unpivot_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_ref;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_ref) {
+             listener.enterTable_ref(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_ref) {
+             listener.exitTable_ref(this);
+        }
+    }
+}
+
+
+export class Table_ref_auxContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_ref_aux_internal(): Table_ref_aux_internalContext {
+        return this.getRuleContext(0, Table_ref_aux_internalContext)!;
+    }
+    public flashback_query_clause(): Flashback_query_clauseContext[];
+    public flashback_query_clause(i: number): Flashback_query_clauseContext | null;
+    public flashback_query_clause(i?: number): Flashback_query_clauseContext[] | Flashback_query_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Flashback_query_clauseContext);
+        }
+
+        return this.getRuleContext(i, Flashback_query_clauseContext);
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_ref_aux;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_ref_aux) {
+             listener.enterTable_ref_aux(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_ref_aux) {
+             listener.exitTable_ref_aux(this);
+        }
+    }
+}
+
+
+export class Table_ref_aux_internalContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_ref_aux_internal;
+    }
+    public override copyFrom(ctx: Table_ref_aux_internalContext): void {
+        super.copyFrom(ctx);
+    }
+}
+export class Table_ref_aux_internal_oneContext extends Table_ref_aux_internalContext {
+    public constructor(ctx: Table_ref_aux_internalContext) {
+        super(ctx.parent, ctx.invokingState);
+        super.copyFrom(ctx);
+    }
+    public dml_table_expression_clause(): Dml_table_expression_clauseContext {
+        return this.getRuleContext(0, Dml_table_expression_clauseContext)!;
+    }
+    public pivot_clause(): Pivot_clauseContext | null {
+        return this.getRuleContext(0, Pivot_clauseContext);
+    }
+    public unpivot_clause(): Unpivot_clauseContext | null {
+        return this.getRuleContext(0, Unpivot_clauseContext);
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_ref_aux_internal_one) {
+             listener.enterTable_ref_aux_internal_one(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_ref_aux_internal_one) {
+             listener.exitTable_ref_aux_internal_one(this);
+        }
+    }
+}
+export class Table_ref_aux_internal_twoContext extends Table_ref_aux_internalContext {
+    public constructor(ctx: Table_ref_aux_internalContext) {
+        super(ctx.parent, ctx.invokingState);
+        super.copyFrom(ctx);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public table_ref(): Table_refContext {
+        return this.getRuleContext(0, Table_refContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public subquery_operation_part(): Subquery_operation_partContext[];
+    public subquery_operation_part(i: number): Subquery_operation_partContext | null;
+    public subquery_operation_part(i?: number): Subquery_operation_partContext[] | Subquery_operation_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Subquery_operation_partContext);
+        }
+
+        return this.getRuleContext(i, Subquery_operation_partContext);
+    }
+    public pivot_clause(): Pivot_clauseContext | null {
+        return this.getRuleContext(0, Pivot_clauseContext);
+    }
+    public unpivot_clause(): Unpivot_clauseContext | null {
+        return this.getRuleContext(0, Unpivot_clauseContext);
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_ref_aux_internal_two) {
+             listener.enterTable_ref_aux_internal_two(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_ref_aux_internal_two) {
+             listener.exitTable_ref_aux_internal_two(this);
+        }
+    }
+}
+export class Table_ref_aux_internal_threContext extends Table_ref_aux_internalContext {
+    public constructor(ctx: Table_ref_aux_internalContext) {
+        super(ctx.parent, ctx.invokingState);
+        super.copyFrom(ctx);
+    }
+    public ONLY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ONLY, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public dml_table_expression_clause(): Dml_table_expression_clauseContext {
+        return this.getRuleContext(0, Dml_table_expression_clauseContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_ref_aux_internal_thre) {
+             listener.enterTable_ref_aux_internal_thre(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_ref_aux_internal_thre) {
+             listener.exitTable_ref_aux_internal_thre(this);
+        }
+    }
+}
+
+
+export class Join_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JOIN, 0);
+    }
+    public table_ref_aux(): Table_ref_auxContext {
+        return this.getRuleContext(0, Table_ref_auxContext)!;
+    }
+    public query_partition_clause(): Query_partition_clauseContext[];
+    public query_partition_clause(i: number): Query_partition_clauseContext | null;
+    public query_partition_clause(i?: number): Query_partition_clauseContext[] | Query_partition_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Query_partition_clauseContext);
+        }
+
+        return this.getRuleContext(i, Query_partition_clauseContext);
+    }
+    public INNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INNER, 0);
+    }
+    public outer_join_type(): Outer_join_typeContext | null {
+        return this.getRuleContext(0, Outer_join_typeContext);
+    }
+    public join_on_part(): Join_on_partContext[];
+    public join_on_part(i: number): Join_on_partContext | null;
+    public join_on_part(i?: number): Join_on_partContext[] | Join_on_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Join_on_partContext);
+        }
+
+        return this.getRuleContext(i, Join_on_partContext);
+    }
+    public join_using_part(): Join_using_partContext[];
+    public join_using_part(i: number): Join_using_partContext | null;
+    public join_using_part(i?: number): Join_using_partContext[] | Join_using_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Join_using_partContext);
+        }
+
+        return this.getRuleContext(i, Join_using_partContext);
+    }
+    public CROSS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CROSS, 0);
+    }
+    public NATURAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATURAL, 0);
+    }
+    public APPLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPLY, 0);
+    }
+    public OUTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_join_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJoin_clause) {
+             listener.enterJoin_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJoin_clause) {
+             listener.exitJoin_clause(this);
+        }
+    }
+}
+
+
+export class Join_on_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_join_on_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJoin_on_part) {
+             listener.enterJoin_on_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJoin_on_part) {
+             listener.exitJoin_on_part(this);
+        }
+    }
+}
+
+
+export class Join_using_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public paren_column_list(): Paren_column_listContext {
+        return this.getRuleContext(0, Paren_column_listContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_join_using_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJoin_using_part) {
+             listener.enterJoin_using_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJoin_using_part) {
+             listener.exitJoin_using_part(this);
+        }
+    }
+}
+
+
+export class Outer_join_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FULL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FULL, 0);
+    }
+    public LEFT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT, 0);
+    }
+    public RIGHT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT, 0);
+    }
+    public OUTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_outer_join_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOuter_join_type) {
+             listener.enterOuter_join_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOuter_join_type) {
+             listener.exitOuter_join_type(this);
+        }
+    }
+}
+
+
+export class Query_partition_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_query_partition_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuery_partition_clause) {
+             listener.enterQuery_partition_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuery_partition_clause) {
+             listener.exitQuery_partition_clause(this);
+        }
+    }
+}
+
+
+export class Flashback_query_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VERSIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public PERIOD_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD_KEYWORD, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public BETWEEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BETWEEN, 0);
+    }
+    public SCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCN, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public SNAPSHOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SNAPSHOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_flashback_query_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFlashback_query_clause) {
+             listener.enterFlashback_query_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFlashback_query_clause) {
+             listener.exitFlashback_query_clause(this);
+        }
+    }
+}
+
+
+export class Pivot_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PIVOT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PIVOT, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public pivot_element(): Pivot_elementContext[];
+    public pivot_element(i: number): Pivot_elementContext | null;
+    public pivot_element(i?: number): Pivot_elementContext[] | Pivot_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Pivot_elementContext);
+        }
+
+        return this.getRuleContext(i, Pivot_elementContext);
+    }
+    public pivot_for_clause(): Pivot_for_clauseContext {
+        return this.getRuleContext(0, Pivot_for_clauseContext)!;
+    }
+    public pivot_in_clause(): Pivot_in_clauseContext {
+        return this.getRuleContext(0, Pivot_in_clauseContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public XML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XML, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pivot_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPivot_clause) {
+             listener.enterPivot_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPivot_clause) {
+             listener.exitPivot_clause(this);
+        }
+    }
+}
+
+
+export class Pivot_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public numeric_function(): Numeric_functionContext | null {
+        return this.getRuleContext(0, Numeric_functionContext);
+    }
+    public aggregate_function_name(): Aggregate_function_nameContext | null {
+        return this.getRuleContext(0, Aggregate_function_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public column_alias(): Column_aliasContext | null {
+        return this.getRuleContext(0, Column_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pivot_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPivot_element) {
+             listener.enterPivot_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPivot_element) {
+             listener.exitPivot_element(this);
+        }
+    }
+}
+
+
+export class Pivot_for_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pivot_for_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPivot_for_clause) {
+             listener.enterPivot_for_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPivot_for_clause) {
+             listener.exitPivot_for_clause(this);
+        }
+    }
+}
+
+
+export class Pivot_in_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public ANY(): antlr.TerminalNode[];
+    public ANY(i: number): antlr.TerminalNode | null;
+    public ANY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ANY);
+    	} else {
+    		return this.getToken(PlSqlParser.ANY, i);
+    	}
+    }
+    public pivot_in_clause_element(): Pivot_in_clause_elementContext[];
+    public pivot_in_clause_element(i: number): Pivot_in_clause_elementContext | null;
+    public pivot_in_clause_element(i?: number): Pivot_in_clause_elementContext[] | Pivot_in_clause_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Pivot_in_clause_elementContext);
+        }
+
+        return this.getRuleContext(i, Pivot_in_clause_elementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pivot_in_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPivot_in_clause) {
+             listener.enterPivot_in_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPivot_in_clause) {
+             listener.exitPivot_in_clause(this);
+        }
+    }
+}
+
+
+export class Pivot_in_clause_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public pivot_in_clause_elements(): Pivot_in_clause_elementsContext {
+        return this.getRuleContext(0, Pivot_in_clause_elementsContext)!;
+    }
+    public column_alias(): Column_aliasContext | null {
+        return this.getRuleContext(0, Column_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pivot_in_clause_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPivot_in_clause_element) {
+             listener.enterPivot_in_clause_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPivot_in_clause_element) {
+             listener.exitPivot_in_clause_element(this);
+        }
+    }
+}
+
+
+export class Pivot_in_clause_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_pivot_in_clause_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPivot_in_clause_elements) {
+             listener.enterPivot_in_clause_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPivot_in_clause_elements) {
+             listener.exitPivot_in_clause_elements(this);
+        }
+    }
+}
+
+
+export class Unpivot_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNPIVOT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNPIVOT, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public pivot_for_clause(): Pivot_for_clauseContext {
+        return this.getRuleContext(0, Pivot_for_clauseContext)!;
+    }
+    public unpivot_in_clause(): Unpivot_in_clauseContext {
+        return this.getRuleContext(0, Unpivot_in_clauseContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public NULLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLS, 0);
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public INCLUDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDE, 0);
+    }
+    public EXCLUDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unpivot_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnpivot_clause) {
+             listener.enterUnpivot_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnpivot_clause) {
+             listener.exitUnpivot_clause(this);
+        }
+    }
+}
+
+
+export class Unpivot_in_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public unpivot_in_elements(): Unpivot_in_elementsContext[];
+    public unpivot_in_elements(i: number): Unpivot_in_elementsContext | null;
+    public unpivot_in_elements(i?: number): Unpivot_in_elementsContext[] | Unpivot_in_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Unpivot_in_elementsContext);
+        }
+
+        return this.getRuleContext(i, Unpivot_in_elementsContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unpivot_in_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnpivot_in_clause) {
+             listener.enterUnpivot_in_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnpivot_in_clause) {
+             listener.exitUnpivot_in_clause(this);
+        }
+    }
+}
+
+
+export class Unpivot_in_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public constant(): ConstantContext[];
+    public constant(i: number): ConstantContext | null;
+    public constant(i?: number): ConstantContext[] | ConstantContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConstantContext);
+        }
+
+        return this.getRuleContext(i, ConstantContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unpivot_in_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnpivot_in_elements) {
+             listener.enterUnpivot_in_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnpivot_in_elements) {
+             listener.exitUnpivot_in_elements(this);
+        }
+    }
+}
+
+
+export class Hierarchical_query_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CONNECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CONNECT, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public NOCYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCYCLE, 0);
+    }
+    public start_part(): Start_partContext | null {
+        return this.getRuleContext(0, Start_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_hierarchical_query_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHierarchical_query_clause) {
+             listener.enterHierarchical_query_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHierarchical_query_clause) {
+             listener.exitHierarchical_query_clause(this);
+        }
+    }
+}
+
+
+export class Start_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public START(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.START, 0)!;
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_start_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStart_part) {
+             listener.enterStart_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStart_part) {
+             listener.exitStart_part(this);
+        }
+    }
+}
+
+
+export class Group_by_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public group_by_elements(): Group_by_elementsContext[];
+    public group_by_elements(i: number): Group_by_elementsContext | null;
+    public group_by_elements(i?: number): Group_by_elementsContext[] | Group_by_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Group_by_elementsContext);
+        }
+
+        return this.getRuleContext(i, Group_by_elementsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public having_clause(): Having_clauseContext | null {
+        return this.getRuleContext(0, Having_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_group_by_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGroup_by_clause) {
+             listener.enterGroup_by_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGroup_by_clause) {
+             listener.exitGroup_by_clause(this);
+        }
+    }
+}
+
+
+export class Group_by_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public grouping_sets_clause(): Grouping_sets_clauseContext | null {
+        return this.getRuleContext(0, Grouping_sets_clauseContext);
+    }
+    public rollup_cube_clause(): Rollup_cube_clauseContext | null {
+        return this.getRuleContext(0, Rollup_cube_clauseContext);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_group_by_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGroup_by_elements) {
+             listener.enterGroup_by_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGroup_by_elements) {
+             listener.exitGroup_by_elements(this);
+        }
+    }
+}
+
+
+export class Rollup_cube_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public grouping_sets_elements(): Grouping_sets_elementsContext[];
+    public grouping_sets_elements(i: number): Grouping_sets_elementsContext | null;
+    public grouping_sets_elements(i?: number): Grouping_sets_elementsContext[] | Grouping_sets_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Grouping_sets_elementsContext);
+        }
+
+        return this.getRuleContext(i, Grouping_sets_elementsContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public ROLLUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLUP, 0);
+    }
+    public CUBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUBE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rollup_cube_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRollup_cube_clause) {
+             listener.enterRollup_cube_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRollup_cube_clause) {
+             listener.exitRollup_cube_clause(this);
+        }
+    }
+}
+
+
+export class Grouping_sets_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public GROUPING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.GROUPING, 0)!;
+    }
+    public SETS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SETS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public grouping_sets_elements(): Grouping_sets_elementsContext[];
+    public grouping_sets_elements(i: number): Grouping_sets_elementsContext | null;
+    public grouping_sets_elements(i?: number): Grouping_sets_elementsContext[] | Grouping_sets_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Grouping_sets_elementsContext);
+        }
+
+        return this.getRuleContext(i, Grouping_sets_elementsContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_grouping_sets_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGrouping_sets_clause) {
+             listener.enterGrouping_sets_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGrouping_sets_clause) {
+             listener.exitGrouping_sets_clause(this);
+        }
+    }
+}
+
+
+export class Grouping_sets_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public rollup_cube_clause(): Rollup_cube_clauseContext | null {
+        return this.getRuleContext(0, Rollup_cube_clauseContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_grouping_sets_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGrouping_sets_elements) {
+             listener.enterGrouping_sets_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGrouping_sets_elements) {
+             listener.exitGrouping_sets_elements(this);
+        }
+    }
+}
+
+
+export class Having_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public HAVING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.HAVING, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_having_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterHaving_clause) {
+             listener.enterHaving_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitHaving_clause) {
+             listener.exitHaving_clause(this);
+        }
+    }
+}
+
+
+export class Model_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MODEL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODEL, 0)!;
+    }
+    public main_model(): Main_modelContext {
+        return this.getRuleContext(0, Main_modelContext)!;
+    }
+    public cell_reference_options(): Cell_reference_optionsContext[];
+    public cell_reference_options(i: number): Cell_reference_optionsContext | null;
+    public cell_reference_options(i?: number): Cell_reference_optionsContext[] | Cell_reference_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Cell_reference_optionsContext);
+        }
+
+        return this.getRuleContext(i, Cell_reference_optionsContext);
+    }
+    public return_rows_clause(): Return_rows_clauseContext | null {
+        return this.getRuleContext(0, Return_rows_clauseContext);
+    }
+    public reference_model(): Reference_modelContext[];
+    public reference_model(i: number): Reference_modelContext | null;
+    public reference_model(i?: number): Reference_modelContext[] | Reference_modelContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Reference_modelContext);
+        }
+
+        return this.getRuleContext(i, Reference_modelContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_clause) {
+             listener.enterModel_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_clause) {
+             listener.exitModel_clause(this);
+        }
+    }
+}
+
+
+export class Cell_reference_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NAV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAV, 0);
+    }
+    public IGNORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public DIMENSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIMENSION, 0);
+    }
+    public SINGLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SINGLE, 0);
+    }
+    public REFERENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cell_reference_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCell_reference_options) {
+             listener.enterCell_reference_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCell_reference_options) {
+             listener.exitCell_reference_options(this);
+        }
+    }
+}
+
+
+export class Return_rows_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETURN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURN, 0)!;
+    }
+    public ROWS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ROWS, 0)!;
+    }
+    public UPDATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATED, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_return_rows_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReturn_rows_clause) {
+             listener.enterReturn_rows_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReturn_rows_clause) {
+             listener.exitReturn_rows_clause(this);
+        }
+    }
+}
+
+
+export class Reference_modelContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REFERENCE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REFERENCE, 0)!;
+    }
+    public reference_model_name(): Reference_model_nameContext {
+        return this.getRuleContext(0, Reference_model_nameContext)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public subquery(): SubqueryContext {
+        return this.getRuleContext(0, SubqueryContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public model_column_clauses(): Model_column_clausesContext {
+        return this.getRuleContext(0, Model_column_clausesContext)!;
+    }
+    public cell_reference_options(): Cell_reference_optionsContext[];
+    public cell_reference_options(i: number): Cell_reference_optionsContext | null;
+    public cell_reference_options(i?: number): Cell_reference_optionsContext[] | Cell_reference_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Cell_reference_optionsContext);
+        }
+
+        return this.getRuleContext(i, Cell_reference_optionsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_reference_model;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReference_model) {
+             listener.enterReference_model(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReference_model) {
+             listener.exitReference_model(this);
+        }
+    }
+}
+
+
+export class Main_modelContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public model_column_clauses(): Model_column_clausesContext {
+        return this.getRuleContext(0, Model_column_clausesContext)!;
+    }
+    public model_rules_clause(): Model_rules_clauseContext {
+        return this.getRuleContext(0, Model_rules_clauseContext)!;
+    }
+    public MAIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAIN, 0);
+    }
+    public main_model_name(): Main_model_nameContext | null {
+        return this.getRuleContext(0, Main_model_nameContext);
+    }
+    public cell_reference_options(): Cell_reference_optionsContext[];
+    public cell_reference_options(i: number): Cell_reference_optionsContext | null;
+    public cell_reference_options(i?: number): Cell_reference_optionsContext[] | Cell_reference_optionsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Cell_reference_optionsContext);
+        }
+
+        return this.getRuleContext(i, Cell_reference_optionsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_main_model;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMain_model) {
+             listener.enterMain_model(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMain_model) {
+             listener.exitMain_model(this);
+        }
+    }
+}
+
+
+export class Model_column_clausesContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DIMENSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DIMENSION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public model_column_list(): Model_column_listContext[];
+    public model_column_list(i: number): Model_column_listContext | null;
+    public model_column_list(i?: number): Model_column_listContext[] | Model_column_listContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Model_column_listContext);
+        }
+
+        return this.getRuleContext(i, Model_column_listContext);
+    }
+    public MEASURES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MEASURES, 0)!;
+    }
+    public model_column_partition_part(): Model_column_partition_partContext | null {
+        return this.getRuleContext(0, Model_column_partition_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_column_clauses;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_column_clauses) {
+             listener.enterModel_column_clauses(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_column_clauses) {
+             listener.exitModel_column_clauses(this);
+        }
+    }
+}
+
+
+export class Model_column_partition_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PARTITION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PARTITION, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public model_column_list(): Model_column_listContext {
+        return this.getRuleContext(0, Model_column_listContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_column_partition_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_column_partition_part) {
+             listener.enterModel_column_partition_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_column_partition_part) {
+             listener.exitModel_column_partition_part(this);
+        }
+    }
+}
+
+
+export class Model_column_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public model_column(): Model_columnContext[];
+    public model_column(i: number): Model_columnContext | null;
+    public model_column(i?: number): Model_columnContext[] | Model_columnContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Model_columnContext);
+        }
+
+        return this.getRuleContext(i, Model_columnContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_column_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_column_list) {
+             listener.enterModel_column_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_column_list) {
+             listener.exitModel_column_list(this);
+        }
+    }
+}
+
+
+export class Model_columnContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public query_block(): Query_blockContext | null {
+        return this.getRuleContext(0, Query_blockContext);
+    }
+    public column_alias(): Column_aliasContext | null {
+        return this.getRuleContext(0, Column_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_column;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_column) {
+             listener.enterModel_column(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_column) {
+             listener.exitModel_column(this);
+        }
+    }
+}
+
+
+export class Model_rules_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public model_rules_part(): Model_rules_partContext | null {
+        return this.getRuleContext(0, Model_rules_partContext);
+    }
+    public model_rules_element(): Model_rules_elementContext[];
+    public model_rules_element(i: number): Model_rules_elementContext | null;
+    public model_rules_element(i?: number): Model_rules_elementContext[] | Model_rules_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Model_rules_elementContext);
+        }
+
+        return this.getRuleContext(i, Model_rules_elementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_rules_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_rules_clause) {
+             listener.enterModel_rules_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_rules_clause) {
+             listener.exitModel_rules_clause(this);
+        }
+    }
+}
+
+
+export class Model_rules_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RULES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RULES, 0)!;
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public UPSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPSERT, 0);
+    }
+    public ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDER, 0);
+    }
+    public model_iterate_clause(): Model_iterate_clauseContext | null {
+        return this.getRuleContext(0, Model_iterate_clauseContext);
+    }
+    public AUTOMATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOMATIC, 0);
+    }
+    public SEQUENTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENTIAL, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_rules_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_rules_part) {
+             listener.enterModel_rules_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_rules_part) {
+             listener.exitModel_rules_part(this);
+        }
+    }
+}
+
+
+export class Model_rules_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public cell_assignment(): Cell_assignmentContext {
+        return this.getRuleContext(0, Cell_assignmentContext)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public UPSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPSERT, 0);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_rules_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_rules_element) {
+             listener.enterModel_rules_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_rules_element) {
+             listener.exitModel_rules_element(this);
+        }
+    }
+}
+
+
+export class Cell_assignmentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public model_expression(): Model_expressionContext {
+        return this.getRuleContext(0, Model_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cell_assignment;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCell_assignment) {
+             listener.enterCell_assignment(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCell_assignment) {
+             listener.exitCell_assignment(this);
+        }
+    }
+}
+
+
+export class Model_iterate_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ITERATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ITERATE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public until_part(): Until_partContext | null {
+        return this.getRuleContext(0, Until_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_iterate_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_iterate_clause) {
+             listener.enterModel_iterate_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_iterate_clause) {
+             listener.exitModel_iterate_clause(this);
+        }
+    }
+}
+
+
+export class Until_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNTIL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UNTIL, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_until_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUntil_part) {
+             listener.enterUntil_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUntil_part) {
+             listener.exitUntil_part(this);
+        }
+    }
+}
+
+
+export class Order_by_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ORDER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ORDER, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public order_by_elements(): Order_by_elementsContext[];
+    public order_by_elements(i: number): Order_by_elementsContext | null;
+    public order_by_elements(i?: number): Order_by_elementsContext[] | Order_by_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Order_by_elementsContext);
+        }
+
+        return this.getRuleContext(i, Order_by_elementsContext);
+    }
+    public SIBLINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIBLINGS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_order_by_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOrder_by_clause) {
+             listener.enterOrder_by_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOrder_by_clause) {
+             listener.exitOrder_by_clause(this);
+        }
+    }
+}
+
+
+export class Order_by_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public NULLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLS, 0);
+    }
+    public ASC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASC, 0);
+    }
+    public DESC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DESC, 0);
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public LAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_order_by_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOrder_by_elements) {
+             listener.enterOrder_by_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOrder_by_elements) {
+             listener.exitOrder_by_elements(this);
+        }
+    }
+}
+
+
+export class Offset_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OFFSET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OFFSET, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_offset_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOffset_clause) {
+             listener.enterOffset_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOffset_clause) {
+             listener.exitOffset_clause(this);
+        }
+    }
+}
+
+
+export class Fetch_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FETCH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FETCH, 0)!;
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public NEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEXT, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public TIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIES, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public PERCENT_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_KEYWORD, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_fetch_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFetch_clause) {
+             listener.enterFetch_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFetch_clause) {
+             listener.exitFetch_clause(this);
+        }
+    }
+}
+
+
+export class For_update_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public UPDATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UPDATE, 0)!;
+    }
+    public for_update_of_part(): For_update_of_partContext | null {
+        return this.getRuleContext(0, For_update_of_partContext);
+    }
+    public for_update_options(): For_update_optionsContext | null {
+        return this.getRuleContext(0, For_update_optionsContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_for_update_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFor_update_clause) {
+             listener.enterFor_update_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFor_update_clause) {
+             listener.exitFor_update_clause(this);
+        }
+    }
+}
+
+
+export class For_update_of_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OF, 0)!;
+    }
+    public column_list(): Column_listContext {
+        return this.getRuleContext(0, Column_listContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_for_update_of_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFor_update_of_part) {
+             listener.enterFor_update_of_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFor_update_of_part) {
+             listener.exitFor_update_of_part(this);
+        }
+    }
+}
+
+
+export class For_update_optionsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SKIP_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_, 0);
+    }
+    public LOCKED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKED, 0);
+    }
+    public NOWAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOWAIT, 0);
+    }
+    public WAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WAIT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_for_update_options;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFor_update_options) {
+             listener.enterFor_update_options(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFor_update_options) {
+             listener.exitFor_update_options(this);
+        }
+    }
+}
+
+
+export class Update_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UPDATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UPDATE, 0)!;
+    }
+    public general_table_ref(): General_table_refContext {
+        return this.getRuleContext(0, General_table_refContext)!;
+    }
+    public update_set_clause(): Update_set_clauseContext {
+        return this.getRuleContext(0, Update_set_clauseContext)!;
+    }
+    public where_clause(): Where_clauseContext | null {
+        return this.getRuleContext(0, Where_clauseContext);
+    }
+    public static_returning_clause(): Static_returning_clauseContext | null {
+        return this.getRuleContext(0, Static_returning_clauseContext);
+    }
+    public error_logging_clause(): Error_logging_clauseContext | null {
+        return this.getRuleContext(0, Error_logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_statement) {
+             listener.enterUpdate_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_statement) {
+             listener.exitUpdate_statement(this);
+        }
+    }
+}
+
+
+export class Update_set_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public column_based_update_set_clause(): Column_based_update_set_clauseContext[];
+    public column_based_update_set_clause(i: number): Column_based_update_set_clauseContext | null;
+    public column_based_update_set_clause(i?: number): Column_based_update_set_clauseContext[] | Column_based_update_set_clauseContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_based_update_set_clauseContext);
+        }
+
+        return this.getRuleContext(i, Column_based_update_set_clauseContext);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_update_set_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUpdate_set_clause) {
+             listener.enterUpdate_set_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUpdate_set_clause) {
+             listener.exitUpdate_set_clause(this);
+        }
+    }
+}
+
+
+export class Column_based_update_set_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext | null {
+        return this.getRuleContext(0, Column_nameContext);
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_based_update_set_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_based_update_set_clause) {
+             listener.enterColumn_based_update_set_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_based_update_set_clause) {
+             listener.exitColumn_based_update_set_clause(this);
+        }
+    }
+}
+
+
+export class Delete_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public general_table_ref(): General_table_refContext {
+        return this.getRuleContext(0, General_table_refContext)!;
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public where_clause(): Where_clauseContext | null {
+        return this.getRuleContext(0, Where_clauseContext);
+    }
+    public static_returning_clause(): Static_returning_clauseContext | null {
+        return this.getRuleContext(0, Static_returning_clauseContext);
+    }
+    public error_logging_clause(): Error_logging_clauseContext | null {
+        return this.getRuleContext(0, Error_logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_delete_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDelete_statement) {
+             listener.enterDelete_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDelete_statement) {
+             listener.exitDelete_statement(this);
+        }
+    }
+}
+
+
+export class Insert_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INSERT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INSERT, 0)!;
+    }
+    public single_table_insert(): Single_table_insertContext | null {
+        return this.getRuleContext(0, Single_table_insertContext);
+    }
+    public multi_table_insert(): Multi_table_insertContext | null {
+        return this.getRuleContext(0, Multi_table_insertContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_insert_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInsert_statement) {
+             listener.enterInsert_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInsert_statement) {
+             listener.exitInsert_statement(this);
+        }
+    }
+}
+
+
+export class Single_table_insertContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public insert_into_clause(): Insert_into_clauseContext {
+        return this.getRuleContext(0, Insert_into_clauseContext)!;
+    }
+    public values_clause(): Values_clauseContext | null {
+        return this.getRuleContext(0, Values_clauseContext);
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public error_logging_clause(): Error_logging_clauseContext | null {
+        return this.getRuleContext(0, Error_logging_clauseContext);
+    }
+    public static_returning_clause(): Static_returning_clauseContext | null {
+        return this.getRuleContext(0, Static_returning_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_single_table_insert;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSingle_table_insert) {
+             listener.enterSingle_table_insert(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSingle_table_insert) {
+             listener.exitSingle_table_insert(this);
+        }
+    }
+}
+
+
+export class Multi_table_insertContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public select_statement(): Select_statementContext {
+        return this.getRuleContext(0, Select_statementContext)!;
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public conditional_insert_clause(): Conditional_insert_clauseContext | null {
+        return this.getRuleContext(0, Conditional_insert_clauseContext);
+    }
+    public multi_table_element(): Multi_table_elementContext[];
+    public multi_table_element(i: number): Multi_table_elementContext | null;
+    public multi_table_element(i?: number): Multi_table_elementContext[] | Multi_table_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Multi_table_elementContext);
+        }
+
+        return this.getRuleContext(i, Multi_table_elementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_multi_table_insert;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMulti_table_insert) {
+             listener.enterMulti_table_insert(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMulti_table_insert) {
+             listener.exitMulti_table_insert(this);
+        }
+    }
+}
+
+
+export class Multi_table_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public insert_into_clause(): Insert_into_clauseContext {
+        return this.getRuleContext(0, Insert_into_clauseContext)!;
+    }
+    public values_clause(): Values_clauseContext | null {
+        return this.getRuleContext(0, Values_clauseContext);
+    }
+    public error_logging_clause(): Error_logging_clauseContext | null {
+        return this.getRuleContext(0, Error_logging_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_multi_table_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMulti_table_element) {
+             listener.enterMulti_table_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMulti_table_element) {
+             listener.exitMulti_table_element(this);
+        }
+    }
+}
+
+
+export class Conditional_insert_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public conditional_insert_when_part(): Conditional_insert_when_partContext[];
+    public conditional_insert_when_part(i: number): Conditional_insert_when_partContext | null;
+    public conditional_insert_when_part(i?: number): Conditional_insert_when_partContext[] | Conditional_insert_when_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Conditional_insert_when_partContext);
+        }
+
+        return this.getRuleContext(i, Conditional_insert_when_partContext);
+    }
+    public conditional_insert_else_part(): Conditional_insert_else_partContext | null {
+        return this.getRuleContext(0, Conditional_insert_else_partContext);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_conditional_insert_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConditional_insert_clause) {
+             listener.enterConditional_insert_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConditional_insert_clause) {
+             listener.exitConditional_insert_clause(this);
+        }
+    }
+}
+
+
+export class Conditional_insert_when_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public multi_table_element(): Multi_table_elementContext[];
+    public multi_table_element(i: number): Multi_table_elementContext | null;
+    public multi_table_element(i?: number): Multi_table_elementContext[] | Multi_table_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Multi_table_elementContext);
+        }
+
+        return this.getRuleContext(i, Multi_table_elementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_conditional_insert_when_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConditional_insert_when_part) {
+             listener.enterConditional_insert_when_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConditional_insert_when_part) {
+             listener.exitConditional_insert_when_part(this);
+        }
+    }
+}
+
+
+export class Conditional_insert_else_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ELSE, 0)!;
+    }
+    public multi_table_element(): Multi_table_elementContext[];
+    public multi_table_element(i: number): Multi_table_elementContext | null;
+    public multi_table_element(i?: number): Multi_table_elementContext[] | Multi_table_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Multi_table_elementContext);
+        }
+
+        return this.getRuleContext(i, Multi_table_elementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_conditional_insert_else_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConditional_insert_else_part) {
+             listener.enterConditional_insert_else_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConditional_insert_else_part) {
+             listener.exitConditional_insert_else_part(this);
+        }
+    }
+}
+
+
+export class Insert_into_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public general_table_ref(): General_table_refContext {
+        return this.getRuleContext(0, General_table_refContext)!;
+    }
+    public FIELDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIELDS, 0);
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_insert_into_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInsert_into_clause) {
+             listener.enterInsert_into_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInsert_into_clause) {
+             listener.exitInsert_into_clause(this);
+        }
+    }
+}
+
+
+export class Values_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VALUES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VALUES, 0)!;
+    }
+    public REGULAR_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGULAR_ID, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public expressions_(): Expressions_Context[];
+    public expressions_(i: number): Expressions_Context | null;
+    public expressions_(i?: number): Expressions_Context[] | Expressions_Context | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Expressions_Context);
+        }
+
+        return this.getRuleContext(i, Expressions_Context);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public collection_expression(): Collection_expressionContext | null {
+        return this.getRuleContext(0, Collection_expressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_values_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterValues_clause) {
+             listener.enterValues_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitValues_clause) {
+             listener.exitValues_clause(this);
+        }
+    }
+}
+
+
+export class Merge_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MERGE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MERGE, 0)!;
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public selected_tableview(): Selected_tableviewContext[];
+    public selected_tableview(i: number): Selected_tableviewContext | null;
+    public selected_tableview(i?: number): Selected_tableviewContext[] | Selected_tableviewContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Selected_tableviewContext);
+        }
+
+        return this.getRuleContext(i, Selected_tableviewContext);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public condition(): ConditionContext {
+        return this.getRuleContext(0, ConditionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public merge_update_clause(): Merge_update_clauseContext | null {
+        return this.getRuleContext(0, Merge_update_clauseContext);
+    }
+    public merge_insert_clause(): Merge_insert_clauseContext | null {
+        return this.getRuleContext(0, Merge_insert_clauseContext);
+    }
+    public error_logging_clause(): Error_logging_clauseContext | null {
+        return this.getRuleContext(0, Error_logging_clauseContext);
+    }
+    public static_returning_clause(): Static_returning_clauseContext | null {
+        return this.getRuleContext(0, Static_returning_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_statement) {
+             listener.enterMerge_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_statement) {
+             listener.exitMerge_statement(this);
+        }
+    }
+}
+
+
+export class Merge_update_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public MATCHED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATCHED, 0)!;
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public UPDATE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.UPDATE, 0)!;
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public merge_element(): Merge_elementContext[];
+    public merge_element(i: number): Merge_elementContext | null;
+    public merge_element(i?: number): Merge_elementContext[] | Merge_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Merge_elementContext);
+        }
+
+        return this.getRuleContext(i, Merge_elementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public where_clause(): Where_clauseContext | null {
+        return this.getRuleContext(0, Where_clauseContext);
+    }
+    public merge_update_delete_part(): Merge_update_delete_partContext | null {
+        return this.getRuleContext(0, Merge_update_delete_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_update_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_update_clause) {
+             listener.enterMerge_update_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_update_clause) {
+             listener.exitMerge_update_clause(this);
+        }
+    }
+}
+
+
+export class Merge_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public EQUALS_OP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_element) {
+             listener.enterMerge_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_element) {
+             listener.exitMerge_element(this);
+        }
+    }
+}
+
+
+export class Merge_update_delete_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DELETE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DELETE, 0)!;
+    }
+    public where_clause(): Where_clauseContext {
+        return this.getRuleContext(0, Where_clauseContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_update_delete_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_update_delete_part) {
+             listener.enterMerge_update_delete_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_update_delete_part) {
+             listener.exitMerge_update_delete_part(this);
+        }
+    }
+}
+
+
+export class Merge_insert_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public NOT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NOT, 0)!;
+    }
+    public MATCHED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MATCHED, 0)!;
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public INSERT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INSERT, 0)!;
+    }
+    public values_clause(): Values_clauseContext {
+        return this.getRuleContext(0, Values_clauseContext)!;
+    }
+    public paren_column_list(): Paren_column_listContext | null {
+        return this.getRuleContext(0, Paren_column_listContext);
+    }
+    public where_clause(): Where_clauseContext | null {
+        return this.getRuleContext(0, Where_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_merge_insert_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMerge_insert_clause) {
+             listener.enterMerge_insert_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMerge_insert_clause) {
+             listener.exitMerge_insert_clause(this);
+        }
+    }
+}
+
+
+export class Selected_tableviewContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public table_collection_expression(): Table_collection_expressionContext | null {
+        return this.getRuleContext(0, Table_collection_expressionContext);
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_selected_tableview;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelected_tableview) {
+             listener.enterSelected_tableview(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelected_tableview) {
+             listener.exitSelected_tableview(this);
+        }
+    }
+}
+
+
+export class Lock_table_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOCK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOCK, 0)!;
+    }
+    public TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TABLE, 0)!;
+    }
+    public lock_table_element(): Lock_table_elementContext[];
+    public lock_table_element(i: number): Lock_table_elementContext | null;
+    public lock_table_element(i?: number): Lock_table_elementContext[] | Lock_table_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Lock_table_elementContext);
+        }
+
+        return this.getRuleContext(i, Lock_table_elementContext);
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public lock_mode(): Lock_modeContext {
+        return this.getRuleContext(0, Lock_modeContext)!;
+    }
+    public MODE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MODE, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public wait_nowait_part(): Wait_nowait_partContext | null {
+        return this.getRuleContext(0, Wait_nowait_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lock_table_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLock_table_statement) {
+             listener.enterLock_table_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLock_table_statement) {
+             listener.exitLock_table_statement(this);
+        }
+    }
+}
+
+
+export class Wait_nowait_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WAIT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public NOWAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOWAIT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_wait_nowait_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWait_nowait_part) {
+             listener.enterWait_nowait_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWait_nowait_part) {
+             listener.exitWait_nowait_part(this);
+        }
+    }
+}
+
+
+export class Lock_table_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public partition_extension_clause(): Partition_extension_clauseContext | null {
+        return this.getRuleContext(0, Partition_extension_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lock_table_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLock_table_element) {
+             listener.enterLock_table_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLock_table_element) {
+             listener.exitLock_table_element(this);
+        }
+    }
+}
+
+
+export class Lock_modeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public SHARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARE, 0);
+    }
+    public EXCLUSIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUSIVE, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_lock_mode;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLock_mode) {
+             listener.enterLock_mode(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLock_mode) {
+             listener.exitLock_mode(this);
+        }
+    }
+}
+
+
+export class General_table_refContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public dml_table_expression_clause(): Dml_table_expression_clauseContext | null {
+        return this.getRuleContext(0, Dml_table_expression_clauseContext);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public table_alias(): Table_aliasContext | null {
+        return this.getRuleContext(0, Table_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_general_table_ref;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGeneral_table_ref) {
+             listener.enterGeneral_table_ref(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGeneral_table_ref) {
+             listener.exitGeneral_table_ref(this);
+        }
+    }
+}
+
+
+export class Static_returning_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expressions_(): Expressions_Context {
+        return this.getRuleContext(0, Expressions_Context)!;
+    }
+    public into_clause(): Into_clauseContext {
+        return this.getRuleContext(0, Into_clauseContext)!;
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_static_returning_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStatic_returning_clause) {
+             listener.enterStatic_returning_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStatic_returning_clause) {
+             listener.exitStatic_returning_clause(this);
+        }
+    }
+}
+
+
+export class Error_logging_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LOG(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LOG, 0)!;
+    }
+    public ERRORS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ERRORS, 0)!;
+    }
+    public error_logging_into_part(): Error_logging_into_partContext | null {
+        return this.getRuleContext(0, Error_logging_into_partContext);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public error_logging_reject_part(): Error_logging_reject_partContext | null {
+        return this.getRuleContext(0, Error_logging_reject_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_error_logging_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterError_logging_clause) {
+             listener.enterError_logging_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitError_logging_clause) {
+             listener.exitError_logging_clause(this);
+        }
+    }
+}
+
+
+export class Error_logging_into_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext {
+        return this.getRuleContext(0, Tableview_nameContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_error_logging_into_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterError_logging_into_part) {
+             listener.enterError_logging_into_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitError_logging_into_part) {
+             listener.exitError_logging_into_part(this);
+        }
+    }
+}
+
+
+export class Error_logging_reject_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REJECT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.REJECT, 0)!;
+    }
+    public LIMIT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LIMIT, 0)!;
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_error_logging_reject_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterError_logging_reject_part) {
+             listener.enterError_logging_reject_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitError_logging_reject_part) {
+             listener.exitError_logging_reject_part(this);
+        }
+    }
+}
+
+
+export class Dml_table_expression_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public table_collection_expression(): Table_collection_expressionContext | null {
+        return this.getRuleContext(0, Table_collection_expressionContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public select_statement(): Select_statementContext | null {
+        return this.getRuleContext(0, Select_statementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public subquery_restriction_clause(): Subquery_restriction_clauseContext | null {
+        return this.getRuleContext(0, Subquery_restriction_clauseContext);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public hierarchies_clause(): Hierarchies_clauseContext | null {
+        return this.getRuleContext(0, Hierarchies_clauseContext);
+    }
+    public sample_clause(): Sample_clauseContext | null {
+        return this.getRuleContext(0, Sample_clauseContext);
+    }
+    public json_table_clause(): Json_table_clauseContext | null {
+        return this.getRuleContext(0, Json_table_clauseContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public LATERAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LATERAL, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public RELATIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELATIONAL, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public XMLTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTYPE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dml_table_expression_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDml_table_expression_clause) {
+             listener.enterDml_table_expression_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDml_table_expression_clause) {
+             listener.exitDml_table_expression_clause(this);
+        }
+    }
+}
+
+
+export class Table_collection_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public THE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THE, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public outer_join_sign(): Outer_join_signContext | null {
+        return this.getRuleContext(0, Outer_join_signContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_collection_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_collection_expression) {
+             listener.enterTable_collection_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_collection_expression) {
+             listener.exitTable_collection_expression(this);
+        }
+    }
+}
+
+
+export class Subquery_restriction_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WITH, 0)!;
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECK, 0);
+    }
+    public OPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTION, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public constraint_name(): Constraint_nameContext | null {
+        return this.getRuleContext(0, Constraint_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_subquery_restriction_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSubquery_restriction_clause) {
+             listener.enterSubquery_restriction_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSubquery_restriction_clause) {
+             listener.exitSubquery_restriction_clause(this);
+        }
+    }
+}
+
+
+export class Sample_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SAMPLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SAMPLE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCK, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public seed_part(): Seed_partContext | null {
+        return this.getRuleContext(0, Seed_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sample_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSample_clause) {
+             listener.enterSample_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSample_clause) {
+             listener.exitSample_clause(this);
+        }
+    }
+}
+
+
+export class Seed_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SEED(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SEED, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_seed_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSeed_part) {
+             listener.enterSeed_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSeed_part) {
+             listener.exitSeed_part(this);
+        }
+    }
+}
+
+
+export class ConditionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public JSON_EQUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_EQUAL, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_condition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCondition) {
+             listener.enterCondition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCondition) {
+             listener.exitCondition(this);
+        }
+    }
+}
+
+
+export class Expressions_Context extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_expressions_;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExpressions_) {
+             listener.enterExpressions_(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExpressions_) {
+             listener.exitExpressions_(this);
+        }
+    }
+}
+
+
+export class ExpressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public cursor_expression(): Cursor_expressionContext | null {
+        return this.getRuleContext(0, Cursor_expressionContext);
+    }
+    public logical_expression(): Logical_expressionContext | null {
+        return this.getRuleContext(0, Logical_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExpression) {
+             listener.enterExpression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExpression) {
+             listener.exitExpression(this);
+        }
+    }
+}
+
+
+export class Cursor_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CURSOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.CURSOR, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public subquery(): SubqueryContext {
+        return this.getRuleContext(0, SubqueryContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cursor_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCursor_expression) {
+             listener.enterCursor_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCursor_expression) {
+             listener.exitCursor_expression(this);
+        }
+    }
+}
+
+
+export class Logical_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public unary_logical_expression(): Unary_logical_expressionContext | null {
+        return this.getRuleContext(0, Unary_logical_expressionContext);
+    }
+    public logical_expression(): Logical_expressionContext[];
+    public logical_expression(i: number): Logical_expressionContext | null;
+    public logical_expression(i?: number): Logical_expressionContext[] | Logical_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Logical_expressionContext);
+        }
+
+        return this.getRuleContext(i, Logical_expressionContext);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logical_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogical_expression) {
+             listener.enterLogical_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogical_expression) {
+             listener.exitLogical_expression(this);
+        }
+    }
+}
+
+
+export class Unary_logical_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public multiset_expression(): Multiset_expressionContext {
+        return this.getRuleContext(0, Multiset_expressionContext)!;
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public unary_logical_operation(): Unary_logical_operationContext | null {
+        return this.getRuleContext(0, Unary_logical_operationContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unary_logical_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnary_logical_expression) {
+             listener.enterUnary_logical_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnary_logical_expression) {
+             listener.exitUnary_logical_expression(this);
+        }
+    }
+}
+
+
+export class Unary_logical_operationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IS, 0)!;
+    }
+    public logical_operation(): Logical_operationContext {
+        return this.getRuleContext(0, Logical_operationContext)!;
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unary_logical_operation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnary_logical_operation) {
+             listener.enterUnary_logical_operation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnary_logical_operation) {
+             listener.exitUnary_logical_operation(this);
+        }
+    }
+}
+
+
+export class Logical_operationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public NAN_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAN_, 0);
+    }
+    public PRESENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESENT, 0);
+    }
+    public INFINITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INFINITE, 0);
+    }
+    public A_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.A_LETTER, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public EMPTY_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public type_spec(): Type_specContext[];
+    public type_spec(i: number): Type_specContext | null;
+    public type_spec(i?: number): Type_specContext[] | Type_specContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Type_specContext);
+        }
+
+        return this.getRuleContext(i, Type_specContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public JSON(): antlr.TerminalNode[];
+    public JSON(i: number): antlr.TerminalNode | null;
+    public JSON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.JSON);
+    	} else {
+    		return this.getToken(PlSqlParser.JSON, i);
+    	}
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYS, 0);
+    }
+    public STRICT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRICT, 0);
+    }
+    public LAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAX, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_logical_operation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLogical_operation) {
+             listener.enterLogical_operation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLogical_operation) {
+             listener.exitLogical_operation(this);
+        }
+    }
+}
+
+
+export class Multiset_expressionContext extends antlr.ParserRuleContext {
+    public _multiset_type?: Token | null;
+    public _multiset_operator?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public relational_expression(): Relational_expressionContext {
+        return this.getRuleContext(0, Relational_expressionContext)!;
+    }
+    public concatenation(): ConcatenationContext | null {
+        return this.getRuleContext(0, ConcatenationContext);
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public SUBMULTISET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBMULTISET, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public multiset_expression(): Multiset_expressionContext | null {
+        return this.getRuleContext(0, Multiset_expressionContext);
+    }
+    public MULTISET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MULTISET, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public INTERSECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERSECT, 0);
+    }
+    public UNION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNION, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINCT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_multiset_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMultiset_expression) {
+             listener.enterMultiset_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMultiset_expression) {
+             listener.exitMultiset_expression(this);
+        }
+    }
+}
+
+
+export class Relational_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public compound_expression(): Compound_expressionContext | null {
+        return this.getRuleContext(0, Compound_expressionContext);
+    }
+    public relational_expression(): Relational_expressionContext[];
+    public relational_expression(i: number): Relational_expressionContext | null;
+    public relational_expression(i?: number): Relational_expressionContext[] | Relational_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Relational_expressionContext);
+        }
+
+        return this.getRuleContext(i, Relational_expressionContext);
+    }
+    public relational_operator(): Relational_operatorContext | null {
+        return this.getRuleContext(0, Relational_operatorContext);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public in_elements(): In_elementsContext | null {
+        return this.getRuleContext(0, In_elementsContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relational_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelational_expression) {
+             listener.enterRelational_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelational_expression) {
+             listener.exitRelational_expression(this);
+        }
+    }
+}
+
+
+export class Compound_expressionContext extends antlr.ParserRuleContext {
+    public _like_type?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public in_elements(): In_elementsContext | null {
+        return this.getRuleContext(0, In_elementsContext);
+    }
+    public BETWEEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BETWEEN, 0);
+    }
+    public between_elements(): Between_elementsContext | null {
+        return this.getRuleContext(0, Between_elementsContext);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public LIKE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE, 0);
+    }
+    public LIKEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKEC, 0);
+    }
+    public LIKE2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE2, 0);
+    }
+    public LIKE4(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE4, 0);
+    }
+    public ESCAPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ESCAPE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_compound_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCompound_expression) {
+             listener.enterCompound_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCompound_expression) {
+             listener.exitCompound_expression(this);
+        }
+    }
+}
+
+
+export class Relational_operatorContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public NOT_EQUAL_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT_EQUAL_OP, 0);
+    }
+    public LESS_THAN_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LESS_THAN_OP, 0);
+    }
+    public GREATER_THAN_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GREATER_THAN_OP, 0);
+    }
+    public EXCLAMATION_OPERATOR_PART(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLAMATION_OPERATOR_PART, 0);
+    }
+    public CARRET_OPERATOR_PART(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CARRET_OPERATOR_PART, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_relational_operator;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRelational_operator) {
+             listener.enterRelational_operator(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRelational_operator) {
+             listener.exitRelational_operator(this);
+        }
+    }
+}
+
+
+export class In_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public constant(): ConstantContext | null {
+        return this.getRuleContext(0, ConstantContext);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_in_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIn_elements) {
+             listener.enterIn_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIn_elements) {
+             listener.exitIn_elements(this);
+        }
+    }
+}
+
+
+export class Between_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public AND(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.AND, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_between_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBetween_elements) {
+             listener.enterBetween_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBetween_elements) {
+             listener.exitBetween_elements(this);
+        }
+    }
+}
+
+
+export class ConcatenationContext extends antlr.ParserRuleContext {
+    public _op?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public model_expression(): Model_expressionContext | null {
+        return this.getRuleContext(0, Model_expressionContext);
+    }
+    public AT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT, 0);
+    }
+    public interval_expression(): Interval_expressionContext | null {
+        return this.getRuleContext(0, Interval_expressionContext);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public OVERFLOW_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONE, 0);
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public DOUBLE_ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE_ASTERISK, 0);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public SOLIDUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOLIDUS, 0);
+    }
+    public MOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOD, 0);
+    }
+    public PLUS_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUS_SIGN, 0);
+    }
+    public MINUS_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUS_SIGN, 0);
+    }
+    public BAR(): antlr.TerminalNode[];
+    public BAR(i: number): antlr.TerminalNode | null;
+    public BAR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BAR);
+    	} else {
+    		return this.getToken(PlSqlParser.BAR, i);
+    	}
+    }
+    public COLLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATE, 0);
+    }
+    public column_collation_name(): Column_collation_nameContext | null {
+        return this.getRuleContext(0, Column_collation_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_concatenation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConcatenation) {
+             listener.enterConcatenation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConcatenation) {
+             listener.exitConcatenation(this);
+        }
+    }
+}
+
+
+export class Interval_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY, 0);
+    }
+    public TO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TO, 0)!;
+    }
+    public SECOND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECOND, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTH, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_interval_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInterval_expression) {
+             listener.enterInterval_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInterval_expression) {
+             listener.exitInterval_expression(this);
+        }
+    }
+}
+
+
+export class Model_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public unary_expression(): Unary_expressionContext {
+        return this.getRuleContext(0, Unary_expressionContext)!;
+    }
+    public LEFT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_BRACKET, 0);
+    }
+    public model_expression_element(): Model_expression_elementContext | null {
+        return this.getRuleContext(0, Model_expression_elementContext);
+    }
+    public RIGHT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_BRACKET, 0);
+    }
+    public MINUS_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUS_SIGN, 0);
+    }
+    public PLUS_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUS_SIGN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_expression) {
+             listener.enterModel_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_expression) {
+             listener.exitModel_expression(this);
+        }
+    }
+}
+
+
+export class Model_expression_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ANY(): antlr.TerminalNode[];
+    public ANY(i: number): antlr.TerminalNode | null;
+    public ANY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ANY);
+    	} else {
+    		return this.getToken(PlSqlParser.ANY, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public single_column_for_loop(): Single_column_for_loopContext[];
+    public single_column_for_loop(i: number): Single_column_for_loopContext | null;
+    public single_column_for_loop(i?: number): Single_column_for_loopContext[] | Single_column_for_loopContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Single_column_for_loopContext);
+        }
+
+        return this.getRuleContext(i, Single_column_for_loopContext);
+    }
+    public multi_column_for_loop(): Multi_column_for_loopContext | null {
+        return this.getRuleContext(0, Multi_column_for_loopContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_model_expression_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterModel_expression_element) {
+             listener.enterModel_expression_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitModel_expression_element) {
+             listener.exitModel_expression_element(this);
+        }
+    }
+}
+
+
+export class Single_column_for_loopContext extends antlr.ParserRuleContext {
+    public _fromExpr?: ExpressionContext;
+    public _toExpr?: ExpressionContext;
+    public _action_type?: Token | null;
+    public _action_expr?: ExpressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public INCREMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCREMENT, 0);
+    }
+    public DECREMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECREMENT, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public LIKE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_single_column_for_loop;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSingle_column_for_loop) {
+             listener.enterSingle_column_for_loop(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSingle_column_for_loop) {
+             listener.exitSingle_column_for_loop(this);
+        }
+    }
+}
+
+
+export class Multi_column_for_loopContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public FOR(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.FOR, 0)!;
+    }
+    public paren_column_list(): Paren_column_listContext {
+        return this.getRuleContext(0, Paren_column_listContext)!;
+    }
+    public IN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.IN, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_multi_column_for_loop;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMulti_column_for_loop) {
+             listener.enterMulti_column_for_loop(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMulti_column_for_loop) {
+             listener.exitMulti_column_for_loop(this);
+        }
+    }
+}
+
+
+export class Unary_expressionContext extends antlr.ParserRuleContext {
+    public _expression?: ExpressionContext;
+    public _index: ExpressionContext[] = [];
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PRIOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIOR, 0);
+    }
+    public unary_expression_core(): Unary_expression_coreContext {
+        return this.getRuleContext(0, Unary_expression_coreContext)!;
+    }
+    public CONNECT_BY_ROOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_ROOT, 0);
+    }
+    public NEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEW, 0);
+    }
+    public OLD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLD, 0);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNT, 0);
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public LAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST, 0);
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public NEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEXT, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unary_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnary_expression) {
+             listener.enterUnary_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnary_expression) {
+             listener.exitUnary_expression(this);
+        }
+    }
+}
+
+
+export class Unary_expression_coreContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public case_expression(): Case_expressionContext | null {
+        return this.getRuleContext(0, Case_expressionContext);
+    }
+    public quantified_expression(): Quantified_expressionContext | null {
+        return this.getRuleContext(0, Quantified_expressionContext);
+    }
+    public standard_function(): Standard_functionContext | null {
+        return this.getRuleContext(0, Standard_functionContext);
+    }
+    public atom(): AtomContext | null {
+        return this.getRuleContext(0, AtomContext);
+    }
+    public implicit_cursor_expression(): Implicit_cursor_expressionContext | null {
+        return this.getRuleContext(0, Implicit_cursor_expressionContext);
+    }
+    public selection_directive_expression(): Selection_directive_expressionContext | null {
+        return this.getRuleContext(0, Selection_directive_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_unary_expression_core;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUnary_expression_core) {
+             listener.enterUnary_expression_core(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUnary_expression_core) {
+             listener.exitUnary_expression_core(this);
+        }
+    }
+}
+
+
+export class Selection_directive_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DOLLAR_IF(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DOLLAR_IF, 0)!;
+    }
+    public condition(): ConditionContext[];
+    public condition(i: number): ConditionContext | null;
+    public condition(i?: number): ConditionContext[] | ConditionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConditionContext);
+        }
+
+        return this.getRuleContext(i, ConditionContext);
+    }
+    public DOLLAR_THEN(): antlr.TerminalNode[];
+    public DOLLAR_THEN(i: number): antlr.TerminalNode | null;
+    public DOLLAR_THEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DOLLAR_THEN);
+    	} else {
+    		return this.getToken(PlSqlParser.DOLLAR_THEN, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public DOLLAR_END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DOLLAR_END, 0)!;
+    }
+    public DOLLAR_ELSIF(): antlr.TerminalNode[];
+    public DOLLAR_ELSIF(i: number): antlr.TerminalNode | null;
+    public DOLLAR_ELSIF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DOLLAR_ELSIF);
+    	} else {
+    		return this.getToken(PlSqlParser.DOLLAR_ELSIF, i);
+    	}
+    }
+    public DOLLAR_ELSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOLLAR_ELSE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_selection_directive_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSelection_directive_expression) {
+             listener.enterSelection_directive_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSelection_directive_expression) {
+             listener.exitSelection_directive_expression(this);
+        }
+    }
+}
+
+
+export class Implicit_cursor_expressionContext extends antlr.ParserRuleContext {
+    public _index?: ExpressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SQL(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SQL, 0)!;
+    }
+    public PERCENT_BULK_ROWCOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_BULK_ROWCOUNT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public PERCENT_BULK_EXCEPTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_BULK_EXCEPTIONS, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNT, 0);
+    }
+    public ERROR_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR_INDEX, 0);
+    }
+    public ERROR_CODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR_CODE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_implicit_cursor_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImplicit_cursor_expression) {
+             listener.enterImplicit_cursor_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImplicit_cursor_expression) {
+             listener.exitImplicit_cursor_expression(this);
+        }
+    }
+}
+
+
+export class Collection_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public collation_name(): Collation_nameContext {
+        return this.getRuleContext(0, Collation_nameContext)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public general_element_part(): General_element_partContext[];
+    public general_element_part(i: number): General_element_partContext | null;
+    public general_element_part(i?: number): General_element_partContext[] | General_element_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(General_element_partContext);
+        }
+
+        return this.getRuleContext(i, General_element_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_collection_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCollection_expression) {
+             listener.enterCollection_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCollection_expression) {
+             listener.exitCollection_expression(this);
+        }
+    }
+}
+
+
+export class Case_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public searched_case_statement(): Searched_case_statementContext | null {
+        return this.getRuleContext(0, Searched_case_statementContext);
+    }
+    public simple_case_statement(): Simple_case_statementContext | null {
+        return this.getRuleContext(0, Simple_case_statementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_case_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCase_statement) {
+             listener.enterCase_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCase_statement) {
+             listener.exitCase_statement(this);
+        }
+    }
+}
+
+
+export class Simple_case_statementContext extends antlr.ParserRuleContext {
+    public _ck1?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public CASE(): antlr.TerminalNode[];
+    public CASE(i: number): antlr.TerminalNode | null;
+    public CASE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CASE);
+    	} else {
+    		return this.getToken(PlSqlParser.CASE, i);
+    	}
+    }
+    public label_declaration(): Label_declarationContext | null {
+        return this.getRuleContext(0, Label_declarationContext);
+    }
+    public case_when_part_statement(): Case_when_part_statementContext[];
+    public case_when_part_statement(i: number): Case_when_part_statementContext | null;
+    public case_when_part_statement(i?: number): Case_when_part_statementContext[] | Case_when_part_statementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Case_when_part_statementContext);
+        }
+
+        return this.getRuleContext(i, Case_when_part_statementContext);
+    }
+    public case_else_part_statement(): Case_else_part_statementContext | null {
+        return this.getRuleContext(0, Case_else_part_statementContext);
+    }
+    public label_name(): Label_nameContext | null {
+        return this.getRuleContext(0, Label_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_simple_case_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSimple_case_statement) {
+             listener.enterSimple_case_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSimple_case_statement) {
+             listener.exitSimple_case_statement(this);
+        }
+    }
+}
+
+
+export class Searched_case_statementContext extends antlr.ParserRuleContext {
+    public _ck1?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public CASE(): antlr.TerminalNode[];
+    public CASE(i: number): antlr.TerminalNode | null;
+    public CASE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CASE);
+    	} else {
+    		return this.getToken(PlSqlParser.CASE, i);
+    	}
+    }
+    public label_declaration(): Label_declarationContext | null {
+        return this.getRuleContext(0, Label_declarationContext);
+    }
+    public case_when_part_statement(): Case_when_part_statementContext[];
+    public case_when_part_statement(i: number): Case_when_part_statementContext | null;
+    public case_when_part_statement(i?: number): Case_when_part_statementContext[] | Case_when_part_statementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Case_when_part_statementContext);
+        }
+
+        return this.getRuleContext(i, Case_when_part_statementContext);
+    }
+    public case_else_part_statement(): Case_else_part_statementContext | null {
+        return this.getRuleContext(0, Case_else_part_statementContext);
+    }
+    public label_name(): Label_nameContext | null {
+        return this.getRuleContext(0, Label_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_searched_case_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSearched_case_statement) {
+             listener.enterSearched_case_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSearched_case_statement) {
+             listener.exitSearched_case_statement(this);
+        }
+    }
+}
+
+
+export class Case_when_part_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_case_when_part_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCase_when_part_statement) {
+             listener.enterCase_when_part_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCase_when_part_statement) {
+             listener.exitCase_when_part_statement(this);
+        }
+    }
+}
+
+
+export class Case_else_part_statementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ELSE, 0)!;
+    }
+    public seq_of_statements(): Seq_of_statementsContext {
+        return this.getRuleContext(0, Seq_of_statementsContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_case_else_part_statement;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCase_else_part_statement) {
+             listener.enterCase_else_part_statement(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCase_else_part_statement) {
+             listener.exitCase_else_part_statement(this);
+        }
+    }
+}
+
+
+export class Case_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public searched_case_expression(): Searched_case_expressionContext | null {
+        return this.getRuleContext(0, Searched_case_expressionContext);
+    }
+    public simple_case_expression(): Simple_case_expressionContext | null {
+        return this.getRuleContext(0, Simple_case_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_case_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCase_expression) {
+             listener.enterCase_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCase_expression) {
+             listener.exitCase_expression(this);
+        }
+    }
+}
+
+
+export class Simple_case_expressionContext extends antlr.ParserRuleContext {
+    public _ck1?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public CASE(): antlr.TerminalNode[];
+    public CASE(i: number): antlr.TerminalNode | null;
+    public CASE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CASE);
+    	} else {
+    		return this.getToken(PlSqlParser.CASE, i);
+    	}
+    }
+    public case_when_part_expression(): Case_when_part_expressionContext[];
+    public case_when_part_expression(i: number): Case_when_part_expressionContext | null;
+    public case_when_part_expression(i?: number): Case_when_part_expressionContext[] | Case_when_part_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Case_when_part_expressionContext);
+        }
+
+        return this.getRuleContext(i, Case_when_part_expressionContext);
+    }
+    public case_else_part_expression(): Case_else_part_expressionContext | null {
+        return this.getRuleContext(0, Case_else_part_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_simple_case_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSimple_case_expression) {
+             listener.enterSimple_case_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSimple_case_expression) {
+             listener.exitSimple_case_expression(this);
+        }
+    }
+}
+
+
+export class Searched_case_expressionContext extends antlr.ParserRuleContext {
+    public _ck1?: Token | null;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public END(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.END, 0)!;
+    }
+    public CASE(): antlr.TerminalNode[];
+    public CASE(i: number): antlr.TerminalNode | null;
+    public CASE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CASE);
+    	} else {
+    		return this.getToken(PlSqlParser.CASE, i);
+    	}
+    }
+    public case_when_part_expression(): Case_when_part_expressionContext[];
+    public case_when_part_expression(i: number): Case_when_part_expressionContext | null;
+    public case_when_part_expression(i?: number): Case_when_part_expressionContext[] | Case_when_part_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Case_when_part_expressionContext);
+        }
+
+        return this.getRuleContext(i, Case_when_part_expressionContext);
+    }
+    public case_else_part_expression(): Case_else_part_expressionContext | null {
+        return this.getRuleContext(0, Case_else_part_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_searched_case_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSearched_case_expression) {
+             listener.enterSearched_case_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSearched_case_expression) {
+             listener.exitSearched_case_expression(this);
+        }
+    }
+}
+
+
+export class Case_when_part_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHEN, 0)!;
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public THEN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.THEN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_case_when_part_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCase_when_part_expression) {
+             listener.enterCase_when_part_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCase_when_part_expression) {
+             listener.exitCase_when_part_expression(this);
+        }
+    }
+}
+
+
+export class Case_else_part_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ELSE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ELSE, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_case_else_part_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCase_else_part_expression) {
+             listener.enterCase_else_part_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCase_else_part_expression) {
+             listener.exitCase_else_part_expression(this);
+        }
+    }
+}
+
+
+export class AtomContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public constant(): ConstantContext | null {
+        return this.getRuleContext(0, ConstantContext);
+    }
+    public inquiry_directive(): Inquiry_directiveContext | null {
+        return this.getRuleContext(0, Inquiry_directiveContext);
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public outer_join_sign(): Outer_join_signContext | null {
+        return this.getRuleContext(0, Outer_join_signContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public subquery_operation_part(): Subquery_operation_partContext[];
+    public subquery_operation_part(i: number): Subquery_operation_partContext | null;
+    public subquery_operation_part(i?: number): Subquery_operation_partContext[] | Subquery_operation_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Subquery_operation_partContext);
+        }
+
+        return this.getRuleContext(i, Subquery_operation_partContext);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public general_element_part(): General_element_partContext[];
+    public general_element_part(i: number): General_element_partContext | null;
+    public general_element_part(i?: number): General_element_partContext[] | General_element_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(General_element_partContext);
+        }
+
+        return this.getRuleContext(i, General_element_partContext);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_atom;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAtom) {
+             listener.enterAtom(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAtom) {
+             listener.exitAtom(this);
+        }
+    }
+}
+
+
+export class Quantified_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SOME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOME, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public ANY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANY, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public select_only_statement(): Select_only_statementContext | null {
+        return this.getRuleContext(0, Select_only_statementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_quantified_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuantified_expression) {
+             listener.enterQuantified_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuantified_expression) {
+             listener.exitQuantified_expression(this);
+        }
+    }
+}
+
+
+export class String_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUBSTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTR, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public TO_CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_CHAR, 0);
+    }
+    public table_element(): Table_elementContext | null {
+        return this.getRuleContext(0, Table_elementContext);
+    }
+    public standard_function(): Standard_functionContext | null {
+        return this.getRuleContext(0, Standard_functionContext);
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public DECODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECODE, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public CHR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHR, 0);
+    }
+    public concatenation(): ConcatenationContext | null {
+        return this.getRuleContext(0, ConcatenationContext);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public NCHAR_CS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCHAR_CS, 0);
+    }
+    public NVL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NVL, 0);
+    }
+    public TRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIM, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public LEADING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEADING, 0);
+    }
+    public TRAILING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRAILING, 0);
+    }
+    public BOTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BOTH, 0);
+    }
+    public TO_DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_DATE, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public CONVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONVERSION, 0);
+    }
+    public ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_string_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterString_function) {
+             listener.enterString_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitString_function) {
+             listener.exitString_function(this);
+        }
+    }
+}
+
+
+export class Standard_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public string_function(): String_functionContext | null {
+        return this.getRuleContext(0, String_functionContext);
+    }
+    public numeric_function_wrapper(): Numeric_function_wrapperContext | null {
+        return this.getRuleContext(0, Numeric_function_wrapperContext);
+    }
+    public json_function(): Json_functionContext | null {
+        return this.getRuleContext(0, Json_functionContext);
+    }
+    public other_function(): Other_functionContext | null {
+        return this.getRuleContext(0, Other_functionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_standard_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStandard_function) {
+             listener.enterStandard_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStandard_function) {
+             listener.exitStandard_function(this);
+        }
+    }
+}
+
+
+export class Json_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public JSON_ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_ARRAY, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public json_array_element(): Json_array_elementContext[];
+    public json_array_element(i: number): Json_array_elementContext | null;
+    public json_array_element(i?: number): Json_array_elementContext[] | Json_array_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Json_array_elementContext);
+        }
+
+        return this.getRuleContext(i, Json_array_elementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public json_on_null_clause(): Json_on_null_clauseContext | null {
+        return this.getRuleContext(0, Json_on_null_clauseContext);
+    }
+    public json_return_clause(): Json_return_clauseContext | null {
+        return this.getRuleContext(0, Json_return_clauseContext);
+    }
+    public STRICT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRICT, 0);
+    }
+    public JSON_ARRAYAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_ARRAYAGG, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public JSON_OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_OBJECT, 0);
+    }
+    public json_object_content(): Json_object_contentContext | null {
+        return this.getRuleContext(0, Json_object_contentContext);
+    }
+    public JSON_OBJECTAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_OBJECTAGG, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYS, 0);
+    }
+    public ABSENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ABSENT, 0);
+    }
+    public VARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR2, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTE, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public JSON_QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_QUERY, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public json_query_returning_clause(): Json_query_returning_clauseContext | null {
+        return this.getRuleContext(0, Json_query_returning_clauseContext);
+    }
+    public json_query_wrapper_clause(): Json_query_wrapper_clauseContext | null {
+        return this.getRuleContext(0, Json_query_wrapper_clauseContext);
+    }
+    public json_query_on_error_clause(): Json_query_on_error_clauseContext | null {
+        return this.getRuleContext(0, Json_query_on_error_clauseContext);
+    }
+    public json_query_on_empty_clause(): Json_query_on_empty_clauseContext | null {
+        return this.getRuleContext(0, Json_query_on_empty_clauseContext);
+    }
+    public JSON_SERIALIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_SERIALIZE, 0);
+    }
+    public json_query_return_type(): Json_query_return_typeContext | null {
+        return this.getRuleContext(0, Json_query_return_typeContext);
+    }
+    public PRETTY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRETTY, 0);
+    }
+    public ASCII(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASCII, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public ERROR(): antlr.TerminalNode[];
+    public ERROR(i: number): antlr.TerminalNode | null;
+    public ERROR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ERROR);
+    	} else {
+    		return this.getToken(PlSqlParser.ERROR, i);
+    	}
+    }
+    public EMPTY_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_, 0);
+    }
+    public ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARRAY, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public JSON_TRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_TRANSFORM, 0);
+    }
+    public json_transform_op(): Json_transform_opContext[];
+    public json_transform_op(i: number): Json_transform_opContext | null;
+    public json_transform_op(i?: number): Json_transform_opContext[] | Json_transform_opContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Json_transform_opContext);
+        }
+
+        return this.getRuleContext(i, Json_transform_opContext);
+    }
+    public JSON_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_VALUE, 0);
+    }
+    public json_value_return_clause(): Json_value_return_clauseContext | null {
+        return this.getRuleContext(0, Json_value_return_clauseContext);
+    }
+    public json_value_on_mismatch_clause(): Json_value_on_mismatch_clauseContext | null {
+        return this.getRuleContext(0, Json_value_on_mismatch_clauseContext);
+    }
+    public DEFAULT(): antlr.TerminalNode[];
+    public DEFAULT(i: number): antlr.TerminalNode | null;
+    public DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DEFAULT);
+    	} else {
+    		return this.getToken(PlSqlParser.DEFAULT, i);
+    	}
+    }
+    public literal(): LiteralContext[];
+    public literal(i: number): LiteralContext | null;
+    public literal(i?: number): LiteralContext[] | LiteralContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(LiteralContext);
+        }
+
+        return this.getRuleContext(i, LiteralContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_function) {
+             listener.enterJson_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_function) {
+             listener.exitJson_function(this);
+        }
+    }
+}
+
+
+export class Json_object_contentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public json_object_entry(): Json_object_entryContext[];
+    public json_object_entry(i: number): Json_object_entryContext | null;
+    public json_object_entry(i?: number): Json_object_entryContext[] | Json_object_entryContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Json_object_entryContext);
+        }
+
+        return this.getRuleContext(i, Json_object_entryContext);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public json_on_null_clause(): Json_on_null_clauseContext | null {
+        return this.getRuleContext(0, Json_on_null_clauseContext);
+    }
+    public json_return_clause(): Json_return_clauseContext | null {
+        return this.getRuleContext(0, Json_return_clauseContext);
+    }
+    public STRICT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRICT, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYS, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_object_content;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_object_content) {
+             listener.enterJson_object_content(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_object_content) {
+             listener.exitJson_object_content(this);
+        }
+    }
+}
+
+
+export class Json_object_entryContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public IS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_object_entry;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_object_entry) {
+             listener.enterJson_object_entry(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_object_entry) {
+             listener.exitJson_object_entry(this);
+        }
+    }
+}
+
+
+export class Json_table_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public JSON_TABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.JSON_TABLE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public ERROR(): antlr.TerminalNode[];
+    public ERROR(i: number): antlr.TerminalNode | null;
+    public ERROR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ERROR);
+    	} else {
+    		return this.getToken(PlSqlParser.ERROR, i);
+    	}
+    }
+    public EMPTY_(): antlr.TerminalNode[];
+    public EMPTY_(i: number): antlr.TerminalNode | null;
+    public EMPTY_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EMPTY_);
+    	} else {
+    		return this.getToken(PlSqlParser.EMPTY_, i);
+    	}
+    }
+    public json_column_clause(): Json_column_clauseContext | null {
+        return this.getRuleContext(0, Json_column_clauseContext);
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_table_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_table_clause) {
+             listener.enterJson_table_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_table_clause) {
+             listener.exitJson_table_clause(this);
+        }
+    }
+}
+
+
+export class Json_array_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public json_function(): Json_functionContext | null {
+        return this.getRuleContext(0, Json_functionContext);
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_array_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_array_element) {
+             listener.enterJson_array_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_array_element) {
+             listener.exitJson_array_element(this);
+        }
+    }
+}
+
+
+export class Json_on_null_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public ABSENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ABSENT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_on_null_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_on_null_clause) {
+             listener.enterJson_on_null_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_on_null_clause) {
+             listener.exitJson_on_null_clause(this);
+        }
+    }
+}
+
+
+export class Json_return_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETURNING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURNING, 0)!;
+    }
+    public VARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR2, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTE, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_return_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_return_clause) {
+             listener.enterJson_return_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_return_clause) {
+             listener.exitJson_return_clause(this);
+        }
+    }
+}
+
+
+export class Json_transform_opContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode[];
+    public CHAR_STRING(i: number): antlr.TerminalNode | null;
+    public CHAR_STRING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.CHAR_STRING);
+    	} else {
+    		return this.getToken(PlSqlParser.CHAR_STRING, i);
+    	}
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public MISSING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MISSING, 0);
+    }
+    public IGNORE(): antlr.TerminalNode[];
+    public IGNORE(i: number): antlr.TerminalNode | null;
+    public IGNORE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.IGNORE);
+    	} else {
+    		return this.getToken(PlSqlParser.IGNORE, i);
+    	}
+    }
+    public ERROR(): antlr.TerminalNode[];
+    public ERROR(i: number): antlr.TerminalNode | null;
+    public ERROR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ERROR);
+    	} else {
+    		return this.getToken(PlSqlParser.ERROR, i);
+    	}
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public EXISTING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTING, 0);
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public CREATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public APPEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPEND, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_transform_op;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_transform_op) {
+             listener.enterJson_transform_op(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_transform_op) {
+             listener.exitJson_transform_op(this);
+        }
+    }
+}
+
+
+export class Json_column_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COLUMNS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COLUMNS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public json_column_definition(): Json_column_definitionContext[];
+    public json_column_definition(i: number): Json_column_definitionContext | null;
+    public json_column_definition(i?: number): Json_column_definitionContext[] | Json_column_definitionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Json_column_definitionContext);
+        }
+
+        return this.getRuleContext(i, Json_column_definitionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_column_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_column_clause) {
+             listener.enterJson_column_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_column_clause) {
+             listener.exitJson_column_clause(this);
+        }
+    }
+}
+
+
+export class Json_column_definitionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public json_value_return_type(): Json_value_return_typeContext | null {
+        return this.getRuleContext(0, Json_value_return_typeContext);
+    }
+    public PATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATH, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public json_query_on_error_clause(): Json_query_on_error_clauseContext | null {
+        return this.getRuleContext(0, Json_query_on_error_clauseContext);
+    }
+    public json_query_on_empty_clause(): Json_query_on_empty_clauseContext | null {
+        return this.getRuleContext(0, Json_query_on_empty_clauseContext);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public json_query_return_type(): Json_query_return_typeContext | null {
+        return this.getRuleContext(0, Json_query_return_typeContext);
+    }
+    public json_query_wrapper_clause(): Json_query_wrapper_clauseContext | null {
+        return this.getRuleContext(0, Json_query_wrapper_clauseContext);
+    }
+    public NESTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED, 0);
+    }
+    public json_column_clause(): Json_column_clauseContext | null {
+        return this.getRuleContext(0, Json_column_clauseContext);
+    }
+    public LEFT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_BRACKET, 0);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public RIGHT_BRACKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_BRACKET, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public ORDINALITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDINALITY, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_column_definition;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_column_definition) {
+             listener.enterJson_column_definition(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_column_definition) {
+             listener.exitJson_column_definition(this);
+        }
+    }
+}
+
+
+export class Json_query_returning_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public json_query_return_type(): Json_query_return_typeContext | null {
+        return this.getRuleContext(0, Json_query_return_typeContext);
+    }
+    public PRETTY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRETTY, 0);
+    }
+    public ASCII(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASCII, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_query_returning_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_query_returning_clause) {
+             listener.enterJson_query_returning_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_query_returning_clause) {
+             listener.exitJson_query_returning_clause(this);
+        }
+    }
+}
+
+
+export class Json_query_return_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR2, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTE, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_query_return_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_query_return_type) {
+             listener.enterJson_query_return_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_query_return_type) {
+             listener.exitJson_query_return_type(this);
+        }
+    }
+}
+
+
+export class Json_query_wrapper_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public WRAPPER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRAPPER, 0);
+    }
+    public ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARRAY, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public UNCONDITIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNCONDITIONAL, 0);
+    }
+    public CONDITIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONDITIONAL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_query_wrapper_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_query_wrapper_clause) {
+             listener.enterJson_query_wrapper_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_query_wrapper_clause) {
+             listener.exitJson_query_wrapper_clause(this);
+        }
+    }
+}
+
+
+export class Json_query_on_error_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public ERROR(): antlr.TerminalNode[];
+    public ERROR(i: number): antlr.TerminalNode | null;
+    public ERROR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ERROR);
+    	} else {
+    		return this.getToken(PlSqlParser.ERROR, i);
+    	}
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public EMPTY_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_, 0);
+    }
+    public ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARRAY, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_query_on_error_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_query_on_error_clause) {
+             listener.enterJson_query_on_error_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_query_on_error_clause) {
+             listener.exitJson_query_on_error_clause(this);
+        }
+    }
+}
+
+
+export class Json_query_on_empty_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public EMPTY_(): antlr.TerminalNode[];
+    public EMPTY_(i: number): antlr.TerminalNode | null;
+    public EMPTY_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.EMPTY_);
+    	} else {
+    		return this.getToken(PlSqlParser.EMPTY_, i);
+    	}
+    }
+    public ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARRAY, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_query_on_empty_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_query_on_empty_clause) {
+             listener.enterJson_query_on_empty_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_query_on_empty_clause) {
+             listener.exitJson_query_on_empty_clause(this);
+        }
+    }
+}
+
+
+export class Json_value_return_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public RETURNING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RETURNING, 0)!;
+    }
+    public json_value_return_type(): Json_value_return_typeContext | null {
+        return this.getRuleContext(0, Json_value_return_typeContext);
+    }
+    public ASCII(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASCII, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_value_return_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_value_return_clause) {
+             listener.enterJson_value_return_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_value_return_clause) {
+             listener.exitJson_value_return_clause(this);
+        }
+    }
+}
+
+
+export class Json_value_return_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR2, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTE, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMBER, 0);
+    }
+    public INTEGER(): antlr.TerminalNode[];
+    public INTEGER(i: number): antlr.TerminalNode | null;
+    public INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.INTEGER, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONE, 0);
+    }
+    public SDO_GEOMETRY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SDO_GEOMETRY, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public CASESENSITIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASESENSITIVE, 0);
+    }
+    public MAPPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAPPING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_value_return_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_value_return_type) {
+             listener.enterJson_value_return_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_value_return_type) {
+             listener.exitJson_value_return_type(this);
+        }
+    }
+}
+
+
+export class Json_value_on_mismatch_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public MISMATCH(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MISMATCH, 0)!;
+    }
+    public IGNORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE, 0);
+    }
+    public ERROR(): antlr.TerminalNode[];
+    public ERROR(i: number): antlr.TerminalNode | null;
+    public ERROR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ERROR);
+    	} else {
+    		return this.getToken(PlSqlParser.ERROR, i);
+    	}
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public MISSING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MISSING, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public EXTRA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTRA, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_json_value_on_mismatch_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterJson_value_on_mismatch_clause) {
+             listener.enterJson_value_on_mismatch_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitJson_value_on_mismatch_clause) {
+             listener.exitJson_value_on_mismatch_clause(this);
+        }
+    }
+}
+
+
+export class LiteralContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public string_function(): String_functionContext | null {
+        return this.getRuleContext(0, String_functionContext);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public numeric_negative(): Numeric_negativeContext | null {
+        return this.getRuleContext(0, Numeric_negativeContext);
+    }
+    public MAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXVALUE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_literal;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLiteral) {
+             listener.enterLiteral(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLiteral) {
+             listener.exitLiteral(this);
+        }
+    }
+}
+
+
+export class Numeric_function_wrapperContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public numeric_function(): Numeric_functionContext {
+        return this.getRuleContext(0, Numeric_functionContext)!;
+    }
+    public single_column_for_loop(): Single_column_for_loopContext | null {
+        return this.getRuleContext(0, Single_column_for_loopContext);
+    }
+    public multi_column_for_loop(): Multi_column_for_loopContext | null {
+        return this.getRuleContext(0, Multi_column_for_loopContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_numeric_function_wrapper;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNumeric_function_wrapper) {
+             listener.enterNumeric_function_wrapper(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNumeric_function_wrapper) {
+             listener.exitNumeric_function_wrapper(this);
+        }
+    }
+}
+
+
+export class Numeric_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUM, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public over_clause(): Over_clauseContext | null {
+        return this.getRuleContext(0, Over_clauseContext);
+    }
+    public keep_clause(): Keep_clauseContext | null {
+        return this.getRuleContext(0, Keep_clauseContext);
+    }
+    public DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINCT, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNT, 0);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public concatenation(): ConcatenationContext | null {
+        return this.getRuleContext(0, ConcatenationContext);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public ROUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROUND, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public AVG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVG, 0);
+    }
+    public MIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIN, 0);
+    }
+    public MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAX, 0);
+    }
+    public LEAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAST, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public GREATEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GREATEST, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_numeric_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNumeric_function) {
+             listener.enterNumeric_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNumeric_function) {
+             listener.exitNumeric_function(this);
+        }
+    }
+}
+
+
+export class Listagg_overflow_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ON(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ON, 0)!;
+    }
+    public OVERFLOW_(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0)!;
+    }
+    public ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNT, 0);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_listagg_overflow_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterListagg_overflow_clause) {
+             listener.enterListagg_overflow_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitListagg_overflow_clause) {
+             listener.exitListagg_overflow_clause(this);
+        }
+    }
+}
+
+
+export class Other_functionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public over_clause_keyword(): Over_clause_keywordContext | null {
+        return this.getRuleContext(0, Over_clause_keywordContext);
+    }
+    public function_argument_analytic(): Function_argument_analyticContext | null {
+        return this.getRuleContext(0, Function_argument_analyticContext);
+    }
+    public over_clause(): Over_clauseContext | null {
+        return this.getRuleContext(0, Over_clauseContext);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public function_argument_modeling(): Function_argument_modelingContext | null {
+        return this.getRuleContext(0, Function_argument_modelingContext);
+    }
+    public using_clause(): Using_clauseContext | null {
+        return this.getRuleContext(0, Using_clauseContext);
+    }
+    public COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNT, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINCT, 0);
+    }
+    public UNIQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIQUE, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public CAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAST, 0);
+    }
+    public XMLCAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCAST, 0);
+    }
+    public MULTISET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MULTISET, 0);
+    }
+    public subquery(): SubqueryContext | null {
+        return this.getRuleContext(0, SubqueryContext);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public CONVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONVERSION, 0);
+    }
+    public ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public table_element(): Table_elementContext | null {
+        return this.getRuleContext(0, Table_elementContext);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public COLLECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLECT, 0);
+    }
+    public collect_order_by_part(): Collect_order_by_partContext | null {
+        return this.getRuleContext(0, Collect_order_by_partContext);
+    }
+    public within_or_over_clause_keyword(): Within_or_over_clause_keywordContext | null {
+        return this.getRuleContext(0, Within_or_over_clause_keywordContext);
+    }
+    public function_argument(): Function_argumentContext | null {
+        return this.getRuleContext(0, Function_argumentContext);
+    }
+    public within_or_over_part(): Within_or_over_partContext[];
+    public within_or_over_part(i: number): Within_or_over_partContext | null;
+    public within_or_over_part(i?: number): Within_or_over_partContext[] | Within_or_over_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Within_or_over_partContext);
+        }
+
+        return this.getRuleContext(i, Within_or_over_partContext);
+    }
+    public LISTAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LISTAGG, 0);
+    }
+    public argument(): ArgumentContext | null {
+        return this.getRuleContext(0, ArgumentContext);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public listagg_overflow_clause(): Listagg_overflow_clauseContext | null {
+        return this.getRuleContext(0, Listagg_overflow_clauseContext);
+    }
+    public WITHIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHIN, 0);
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public cursor_name(): Cursor_nameContext | null {
+        return this.getRuleContext(0, Cursor_nameContext);
+    }
+    public PERCENT_ISOPEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_ISOPEN, 0);
+    }
+    public PERCENT_FOUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_FOUND, 0);
+    }
+    public PERCENT_NOTFOUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_NOTFOUND, 0);
+    }
+    public PERCENT_ROWCOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_ROWCOUNT, 0);
+    }
+    public DECOMPOSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECOMPOSE, 0);
+    }
+    public CANONICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CANONICAL, 0);
+    }
+    public COMPATIBILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPATIBILITY, 0);
+    }
+    public EXTRACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTRACT, 0);
+    }
+    public FROM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM, 0);
+    }
+    public FIRST_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST_VALUE, 0);
+    }
+    public LAST_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST_VALUE, 0);
+    }
+    public respect_or_ignore_nulls(): Respect_or_ignore_nullsContext | null {
+        return this.getRuleContext(0, Respect_or_ignore_nullsContext);
+    }
+    public LEAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAD, 0);
+    }
+    public LAG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAG, 0);
+    }
+    public standard_prediction_function_keyword(): Standard_prediction_function_keywordContext | null {
+        return this.getRuleContext(0, Standard_prediction_function_keywordContext);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public cost_matrix_clause(): Cost_matrix_clauseContext | null {
+        return this.getRuleContext(0, Cost_matrix_clauseContext);
+    }
+    public TO_BINARY_DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_BINARY_DOUBLE, 0);
+    }
+    public TO_BINARY_FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_BINARY_FLOAT, 0);
+    }
+    public TO_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_NUMBER, 0);
+    }
+    public TO_TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_TIMESTAMP, 0);
+    }
+    public TO_TIMESTAMP_TZ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_TIMESTAMP_TZ, 0);
+    }
+    public TO_DSINTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_DSINTERVAL, 0);
+    }
+    public TO_YMINTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_YMINTERVAL, 0);
+    }
+    public TRANSLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATE, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public CHAR_CS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_CS, 0);
+    }
+    public NCHAR_CS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCHAR_CS, 0);
+    }
+    public TREAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TREAT, 0);
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public general_element_part(): General_element_partContext[];
+    public general_element_part(i: number): General_element_partContext | null;
+    public general_element_part(i?: number): General_element_partContext[] | General_element_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(General_element_partContext);
+        }
+
+        return this.getRuleContext(i, General_element_partContext);
+    }
+    public TRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIM, 0);
+    }
+    public LEADING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEADING, 0);
+    }
+    public TRAILING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRAILING, 0);
+    }
+    public BOTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BOTH, 0);
+    }
+    public VALIDATE_CONVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATE_CONVERSION, 0);
+    }
+    public XMLAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLAGG, 0);
+    }
+    public xml_multiuse_expression_element(): Xml_multiuse_expression_elementContext[];
+    public xml_multiuse_expression_element(i: number): Xml_multiuse_expression_elementContext | null;
+    public xml_multiuse_expression_element(i?: number): Xml_multiuse_expression_elementContext[] | Xml_multiuse_expression_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Xml_multiuse_expression_elementContext);
+        }
+
+        return this.getRuleContext(i, Xml_multiuse_expression_elementContext);
+    }
+    public XMLCOLATTVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCOLATTVAL, 0);
+    }
+    public XMLFOREST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLFOREST, 0);
+    }
+    public XMLELEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLELEMENT, 0);
+    }
+    public xml_attributes_clause(): Xml_attributes_clauseContext | null {
+        return this.getRuleContext(0, Xml_attributes_clauseContext);
+    }
+    public ENTITYESCAPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENTITYESCAPING, 0);
+    }
+    public NOENTITYESCAPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOENTITYESCAPING, 0);
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public EVALNAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALNAME, 0);
+    }
+    public column_alias(): Column_aliasContext[];
+    public column_alias(i: number): Column_aliasContext | null;
+    public column_alias(i?: number): Column_aliasContext[] | Column_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_aliasContext);
+        }
+
+        return this.getRuleContext(i, Column_aliasContext);
+    }
+    public XMLEXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLEXISTS, 0);
+    }
+    public xml_passing_clause(): Xml_passing_clauseContext | null {
+        return this.getRuleContext(0, Xml_passing_clauseContext);
+    }
+    public XMLPARSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLPARSE, 0);
+    }
+    public DOCUMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOCUMENT, 0);
+    }
+    public CONTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTENT, 0);
+    }
+    public WELLFORMED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WELLFORMED, 0);
+    }
+    public XMLPI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLPI, 0);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public XMLQUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLQUERY, 0);
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public EMPTY_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_, 0);
+    }
+    public XMLROOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLROOT, 0);
+    }
+    public xmlroot_param_version_part(): Xmlroot_param_version_partContext | null {
+        return this.getRuleContext(0, Xmlroot_param_version_partContext);
+    }
+    public xmlroot_param_standalone_part(): Xmlroot_param_standalone_partContext | null {
+        return this.getRuleContext(0, Xmlroot_param_standalone_partContext);
+    }
+    public XMLSERIALIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLSERIALIZE, 0);
+    }
+    public xmlserialize_param_enconding_part(): Xmlserialize_param_enconding_partContext | null {
+        return this.getRuleContext(0, Xmlserialize_param_enconding_partContext);
+    }
+    public xmlserialize_param_version_part(): Xmlserialize_param_version_partContext | null {
+        return this.getRuleContext(0, Xmlserialize_param_version_partContext);
+    }
+    public xmlserialize_param_ident_part(): Xmlserialize_param_ident_partContext | null {
+        return this.getRuleContext(0, Xmlserialize_param_ident_partContext);
+    }
+    public DEFAULTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULTS, 0);
+    }
+    public HIDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIDE, 0);
+    }
+    public SHOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHOW, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public xmltable(): XmltableContext | null {
+        return this.getRuleContext(0, XmltableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_other_function;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOther_function) {
+             listener.enterOther_function(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOther_function) {
+             listener.exitOther_function(this);
+        }
+    }
+}
+
+
+export class Over_clause_keywordContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public AVG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVG, 0);
+    }
+    public CORR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORR, 0);
+    }
+    public LAG_DIFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAG_DIFF, 0);
+    }
+    public LAG_DIFF_PERCENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAG_DIFF_PERCENT, 0);
+    }
+    public MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAX, 0);
+    }
+    public MEDIAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEDIAN, 0);
+    }
+    public MIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIN, 0);
+    }
+    public NTH_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NTH_VALUE, 0);
+    }
+    public NTILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NTILE, 0);
+    }
+    public RATIO_TO_REPORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RATIO_TO_REPORT, 0);
+    }
+    public ROW_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW_NUMBER, 0);
+    }
+    public SUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUM, 0);
+    }
+    public VARIANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARIANCE, 0);
+    }
+    public REGR_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_, 0);
+    }
+    public STDDEV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STDDEV, 0);
+    }
+    public VAR_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VAR_, 0);
+    }
+    public VAR_POP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VAR_POP, 0);
+    }
+    public COVAR_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COVAR_, 0);
+    }
+    public WM_CONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WM_CONCAT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_over_clause_keyword;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOver_clause_keyword) {
+             listener.enterOver_clause_keyword(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOver_clause_keyword) {
+             listener.exitOver_clause_keyword(this);
+        }
+    }
+}
+
+
+export class Within_or_over_clause_keywordContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CUME_DIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUME_DIST, 0);
+    }
+    public DENSE_RANK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DENSE_RANK, 0);
+    }
+    public PERCENT_RANK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_RANK, 0);
+    }
+    public PERCENTILE_CONT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENTILE_CONT, 0);
+    }
+    public PERCENTILE_DISC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENTILE_DISC, 0);
+    }
+    public RANK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANK, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_within_or_over_clause_keyword;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWithin_or_over_clause_keyword) {
+             listener.enterWithin_or_over_clause_keyword(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWithin_or_over_clause_keyword) {
+             listener.exitWithin_or_over_clause_keyword(this);
+        }
+    }
+}
+
+
+export class Standard_prediction_function_keywordContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PREDICTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION, 0);
+    }
+    public PREDICTION_BOUNDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_BOUNDS, 0);
+    }
+    public PREDICTION_COST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_COST, 0);
+    }
+    public PREDICTION_DETAILS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_DETAILS, 0);
+    }
+    public PREDICTION_PROBABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_PROBABILITY, 0);
+    }
+    public PREDICTION_SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_SET, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_standard_prediction_function_keyword;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStandard_prediction_function_keyword) {
+             listener.enterStandard_prediction_function_keyword(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStandard_prediction_function_keyword) {
+             listener.exitStandard_prediction_function_keyword(this);
+        }
+    }
+}
+
+
+export class Over_clauseContext extends antlr.ParserRuleContext {
+    public _th?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OVER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.OVER, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public HIERARCHY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIERARCHY, 0);
+    }
+    public OFFSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFSET, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public query_partition_clause(): Query_partition_clauseContext | null {
+        return this.getRuleContext(0, Query_partition_clauseContext);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public ACROSS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACROSS, 0);
+    }
+    public ANCESTOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANCESTOR, 0);
+    }
+    public AT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT, 0);
+    }
+    public LEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVEL, 0);
+    }
+    public windowing_clause(): Windowing_clauseContext | null {
+        return this.getRuleContext(0, Windowing_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_over_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOver_clause) {
+             listener.enterOver_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOver_clause) {
+             listener.exitOver_clause(this);
+        }
+    }
+}
+
+
+export class Windowing_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public windowing_type(): Windowing_typeContext {
+        return this.getRuleContext(0, Windowing_typeContext)!;
+    }
+    public BETWEEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BETWEEN, 0);
+    }
+    public windowing_elements(): Windowing_elementsContext[];
+    public windowing_elements(i: number): Windowing_elementsContext | null;
+    public windowing_elements(i?: number): Windowing_elementsContext[] | Windowing_elementsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Windowing_elementsContext);
+        }
+
+        return this.getRuleContext(i, Windowing_elementsContext);
+    }
+    public AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_windowing_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWindowing_clause) {
+             listener.enterWindowing_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWindowing_clause) {
+             listener.exitWindowing_clause(this);
+        }
+    }
+}
+
+
+export class Windowing_typeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANGE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_windowing_type;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWindowing_type) {
+             listener.enterWindowing_type(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWindowing_type) {
+             listener.exitWindowing_type(this);
+        }
+    }
+}
+
+
+export class Windowing_elementsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNBOUNDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNBOUNDED, 0);
+    }
+    public PRECEDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECEDING, 0);
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public concatenation(): ConcatenationContext | null {
+        return this.getRuleContext(0, ConcatenationContext);
+    }
+    public FOLLOWING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOLLOWING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_windowing_elements;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWindowing_elements) {
+             listener.enterWindowing_elements(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWindowing_elements) {
+             listener.exitWindowing_elements(this);
+        }
+    }
+}
+
+
+export class Using_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public using_element(): Using_elementContext[];
+    public using_element(i: number): Using_elementContext | null;
+    public using_element(i?: number): Using_elementContext[] | Using_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Using_elementContext);
+        }
+
+        return this.getRuleContext(i, Using_elementContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_clause) {
+             listener.enterUsing_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_clause) {
+             listener.exitUsing_clause(this);
+        }
+    }
+}
+
+
+export class Using_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public IN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public OUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUT, 0);
+    }
+    public assignable_element(): Assignable_elementContext | null {
+        return this.getRuleContext(0, Assignable_elementContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_using_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUsing_element) {
+             listener.enterUsing_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUsing_element) {
+             listener.exitUsing_element(this);
+        }
+    }
+}
+
+
+export class Assignable_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_assignable_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAssignable_element) {
+             listener.enterAssignable_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAssignable_element) {
+             listener.exitAssignable_element(this);
+        }
+    }
+}
+
+
+export class Collect_order_by_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ORDER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ORDER, 0)!;
+    }
+    public BY(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.BY, 0)!;
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_collect_order_by_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCollect_order_by_part) {
+             listener.enterCollect_order_by_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCollect_order_by_part) {
+             listener.exitCollect_order_by_part(this);
+        }
+    }
+}
+
+
+export class Within_or_over_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WITHIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHIN, 0);
+    }
+    public GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public over_clause(): Over_clauseContext | null {
+        return this.getRuleContext(0, Over_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_within_or_over_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWithin_or_over_part) {
+             listener.enterWithin_or_over_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWithin_or_over_part) {
+             listener.exitWithin_or_over_part(this);
+        }
+    }
+}
+
+
+export class String_delimiterContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public string_function(): String_functionContext | null {
+        return this.getRuleContext(0, String_functionContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public string_delimiter(): String_delimiterContext[];
+    public string_delimiter(i: number): String_delimiterContext | null;
+    public string_delimiter(i?: number): String_delimiterContext[] | String_delimiterContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(String_delimiterContext);
+        }
+
+        return this.getRuleContext(i, String_delimiterContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public BAR(): antlr.TerminalNode[];
+    public BAR(i: number): antlr.TerminalNode | null;
+    public BAR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BAR);
+    	} else {
+    		return this.getToken(PlSqlParser.BAR, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_string_delimiter;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterString_delimiter) {
+             listener.enterString_delimiter(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitString_delimiter) {
+             listener.exitString_delimiter(this);
+        }
+    }
+}
+
+
+export class Cost_matrix_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public COST(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.COST, 0)!;
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public cost_class_name(): Cost_class_nameContext[];
+    public cost_class_name(i: number): Cost_class_nameContext | null;
+    public cost_class_name(i?: number): Cost_class_nameContext[] | Cost_class_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Cost_class_nameContext);
+        }
+
+        return this.getRuleContext(i, Cost_class_nameContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public VALUES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUES, 0);
+    }
+    public AUTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cost_matrix_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCost_matrix_clause) {
+             listener.enterCost_matrix_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCost_matrix_clause) {
+             listener.exitCost_matrix_clause(this);
+        }
+    }
+}
+
+
+export class Xml_passing_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PASSING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PASSING, 0)!;
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public column_alias(): Column_aliasContext[];
+    public column_alias(i: number): Column_aliasContext | null;
+    public column_alias(i?: number): Column_aliasContext[] | Column_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_aliasContext);
+        }
+
+        return this.getRuleContext(i, Column_aliasContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_passing_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_passing_clause) {
+             listener.enterXml_passing_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_passing_clause) {
+             listener.exitXml_passing_clause(this);
+        }
+    }
+}
+
+
+export class Xml_attributes_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public XMLATTRIBUTES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.XMLATTRIBUTES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public xml_multiuse_expression_element(): Xml_multiuse_expression_elementContext[];
+    public xml_multiuse_expression_element(i: number): Xml_multiuse_expression_elementContext | null;
+    public xml_multiuse_expression_element(i?: number): Xml_multiuse_expression_elementContext[] | Xml_multiuse_expression_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Xml_multiuse_expression_elementContext);
+        }
+
+        return this.getRuleContext(i, Xml_multiuse_expression_elementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public ENTITYESCAPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENTITYESCAPING, 0);
+    }
+    public NOENTITYESCAPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOENTITYESCAPING, 0);
+    }
+    public SCHEMACHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEMACHECK, 0);
+    }
+    public NOSCHEMACHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSCHEMACHECK, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_attributes_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_attributes_clause) {
+             listener.enterXml_attributes_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_attributes_clause) {
+             listener.exitXml_attributes_clause(this);
+        }
+    }
+}
+
+
+export class Xml_namespaces_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public XMLNAMESPACES(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.XMLNAMESPACES, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public concatenation(): ConcatenationContext[];
+    public concatenation(i: number): ConcatenationContext | null;
+    public concatenation(i?: number): ConcatenationContext[] | ConcatenationContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ConcatenationContext);
+        }
+
+        return this.getRuleContext(i, ConcatenationContext);
+    }
+    public column_alias(): Column_aliasContext[];
+    public column_alias(i: number): Column_aliasContext | null;
+    public column_alias(i?: number): Column_aliasContext[] | Column_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_aliasContext);
+        }
+
+        return this.getRuleContext(i, Column_aliasContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public xml_general_default_part(): Xml_general_default_partContext | null {
+        return this.getRuleContext(0, Xml_general_default_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_namespaces_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_namespaces_clause) {
+             listener.enterXml_namespaces_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_namespaces_clause) {
+             listener.exitXml_namespaces_clause(this);
+        }
+    }
+}
+
+
+export class Xml_table_columnContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public xml_column_name(): Xml_column_nameContext {
+        return this.getRuleContext(0, Xml_column_nameContext)!;
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public ORDINALITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDINALITY, 0);
+    }
+    public type_spec(): Type_specContext | null {
+        return this.getRuleContext(0, Type_specContext);
+    }
+    public PATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATH, 0);
+    }
+    public concatenation(): ConcatenationContext | null {
+        return this.getRuleContext(0, ConcatenationContext);
+    }
+    public xml_general_default_part(): Xml_general_default_partContext | null {
+        return this.getRuleContext(0, Xml_general_default_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_table_column;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_table_column) {
+             listener.enterXml_table_column(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_table_column) {
+             listener.exitXml_table_column(this);
+        }
+    }
+}
+
+
+export class Xml_general_default_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public DEFAULT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DEFAULT, 0)!;
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_general_default_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_general_default_part) {
+             listener.enterXml_general_default_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_general_default_part) {
+             listener.exitXml_general_default_part(this);
+        }
+    }
+}
+
+
+export class Xml_multiuse_expression_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public EVALNAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALNAME, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_multiuse_expression_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_multiuse_expression_element) {
+             listener.enterXml_multiuse_expression_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_multiuse_expression_element) {
+             listener.exitXml_multiuse_expression_element(this);
+        }
+    }
+}
+
+
+export class Xmlroot_param_version_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VERSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VERSION, 0)!;
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public expression(): ExpressionContext | null {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlroot_param_version_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlroot_param_version_part) {
+             listener.enterXmlroot_param_version_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlroot_param_version_part) {
+             listener.exitXmlroot_param_version_part(this);
+        }
+    }
+}
+
+
+export class Xmlroot_param_standalone_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public STANDALONE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.STANDALONE, 0)!;
+    }
+    public YES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YES, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlroot_param_standalone_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlroot_param_standalone_part) {
+             listener.enterXmlroot_param_standalone_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlroot_param_standalone_part) {
+             listener.exitXmlroot_param_standalone_part(this);
+        }
+    }
+}
+
+
+export class Xmlserialize_param_enconding_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ENCODING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ENCODING, 0)!;
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlserialize_param_enconding_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlserialize_param_enconding_part) {
+             listener.enterXmlserialize_param_enconding_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlserialize_param_enconding_part) {
+             listener.exitXmlserialize_param_enconding_part(this);
+        }
+    }
+}
+
+
+export class Xmlserialize_param_version_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public VERSION(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.VERSION, 0)!;
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlserialize_param_version_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlserialize_param_version_part) {
+             listener.enterXmlserialize_param_version_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlserialize_param_version_part) {
+             listener.exitXmlserialize_param_version_part(this);
+        }
+    }
+}
+
+
+export class Xmlserialize_param_ident_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public INDENT(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INDENT, 0)!;
+    }
+    public SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIZE, 0);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public concatenation(): ConcatenationContext | null {
+        return this.getRuleContext(0, ConcatenationContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmlserialize_param_ident_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmlserialize_param_ident_part) {
+             listener.enterXmlserialize_param_ident_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmlserialize_param_ident_part) {
+             listener.exitXmlserialize_param_ident_part(this);
+        }
+    }
+}
+
+
+export class Annotations_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ANNOTATIONS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.ANNOTATIONS, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public annotations_list(): Annotations_listContext {
+        return this.getRuleContext(0, Annotations_listContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_annotations_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAnnotations_clause) {
+             listener.enterAnnotations_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAnnotations_clause) {
+             listener.exitAnnotations_clause(this);
+        }
+    }
+}
+
+
+export class Annotations_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public annotation(): AnnotationContext {
+        return this.getRuleContext(0, AnnotationContext)!;
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public annotations_list(): Annotations_listContext[];
+    public annotations_list(i: number): Annotations_listContext | null;
+    public annotations_list(i?: number): Annotations_listContext[] | Annotations_listContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Annotations_listContext);
+        }
+
+        return this.getRuleContext(i, Annotations_listContext);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public NOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOT, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public OR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_annotations_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAnnotations_list) {
+             listener.enterAnnotations_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAnnotations_list) {
+             listener.exitAnnotations_list(this);
+        }
+    }
+}
+
+
+export class AnnotationContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_annotation;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAnnotation) {
+             listener.enterAnnotation(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAnnotation) {
+             listener.exitAnnotation(this);
+        }
+    }
+}
+
+
+export class Sql_plus_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EXIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXIT, 0);
+    }
+    public PROMPT_MESSAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROMPT_MESSAGE, 0);
+    }
+    public SHOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHOW, 0);
+    }
+    public ERR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERR, 0);
+    }
+    public ERRORS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERRORS, 0);
+    }
+    public whenever_command(): Whenever_commandContext | null {
+        return this.getRuleContext(0, Whenever_commandContext);
+    }
+    public timing_command(): Timing_commandContext | null {
+        return this.getRuleContext(0, Timing_commandContext);
+    }
+    public start_command(): Start_commandContext | null {
+        return this.getRuleContext(0, Start_commandContext);
+    }
+    public set_command(): Set_commandContext | null {
+        return this.getRuleContext(0, Set_commandContext);
+    }
+    public clear_command(): Clear_commandContext | null {
+        return this.getRuleContext(0, Clear_commandContext);
+    }
+    public execute_command(): Execute_commandContext | null {
+        return this.getRuleContext(0, Execute_commandContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_plus_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_plus_command) {
+             listener.enterSql_plus_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_plus_command) {
+             listener.exitSql_plus_command(this);
+        }
+    }
+}
+
+
+export class Execute_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public statement(): StatementContext {
+        return this.getRuleContext(0, StatementContext)!;
+    }
+    public EXEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXEC, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_execute_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterExecute_command) {
+             listener.enterExecute_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitExecute_command) {
+             listener.exitExecute_command(this);
+        }
+    }
+}
+
+
+export class Start_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public sql_plus_filepath(): Sql_plus_filepathContext {
+        return this.getRuleContext(0, Sql_plus_filepathContext)!;
+    }
+    public START(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.START, 0);
+    }
+    public AT_SIGN(): antlr.TerminalNode[];
+    public AT_SIGN(i: number): antlr.TerminalNode | null;
+    public AT_SIGN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.AT_SIGN);
+    	} else {
+    		return this.getToken(PlSqlParser.AT_SIGN, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_start_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterStart_command) {
+             listener.enterStart_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitStart_command) {
+             listener.exitStart_command(this);
+        }
+    }
+}
+
+
+export class Sql_plus_filepathContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PERIOD, 0)!;
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public FILE_EXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE_EXT, 0);
+    }
+    public COLON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLON, 0);
+    }
+    public SOLIDUS(): antlr.TerminalNode[];
+    public SOLIDUS(i: number): antlr.TerminalNode | null;
+    public SOLIDUS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SOLIDUS);
+    	} else {
+    		return this.getToken(PlSqlParser.SOLIDUS, i);
+    	}
+    }
+    public RSOLIDUS(): antlr.TerminalNode[];
+    public RSOLIDUS(i: number): antlr.TerminalNode | null;
+    public RSOLIDUS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RSOLIDUS);
+    	} else {
+    		return this.getToken(PlSqlParser.RSOLIDUS, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sql_plus_filepath;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSql_plus_filepath) {
+             listener.enterSql_plus_filepath(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSql_plus_filepath) {
+             listener.exitSql_plus_filepath(this);
+        }
+    }
+}
+
+
+export class Whenever_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHENEVER(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHENEVER, 0)!;
+    }
+    public SQLERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQLERROR, 0);
+    }
+    public OSERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OSERROR, 0);
+    }
+    public EXIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXIT, 0);
+    }
+    public CONTINUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTINUE, 0);
+    }
+    public SUCCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUCCESS, 0);
+    }
+    public FAILURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILURE, 0);
+    }
+    public WARNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WARNING, 0);
+    }
+    public variable_name(): Variable_nameContext | null {
+        return this.getRuleContext(0, Variable_nameContext);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public ROLLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLBACK, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_whenever_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWhenever_command) {
+             listener.enterWhenever_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWhenever_command) {
+             listener.exitWhenever_command(this);
+        }
+    }
+}
+
+
+export class Set_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public SET(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.SET, 0)!;
+    }
+    public regular_id(): Regular_idContext[];
+    public regular_id(i: number): Regular_idContext | null;
+    public regular_id(i?: number): Regular_idContext[] | Regular_idContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Regular_idContext);
+        }
+
+        return this.getRuleContext(i, Regular_idContext);
+    }
+    public ON(): antlr.TerminalNode[];
+    public ON(i: number): antlr.TerminalNode | null;
+    public ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.ON);
+    	} else {
+    		return this.getToken(PlSqlParser.ON, i);
+    	}
+    }
+    public OFF(): antlr.TerminalNode[];
+    public OFF(i: number): antlr.TerminalNode | null;
+    public OFF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.OFF);
+    	} else {
+    		return this.getToken(PlSqlParser.OFF, i);
+    	}
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_set_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSet_command) {
+             listener.enterSet_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSet_command) {
+             listener.exitSet_command(this);
+        }
+    }
+}
+
+
+export class Timing_commandContext extends antlr.ParserRuleContext {
+    public _timing_text?: Id_expressionContext;
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TIMING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.TIMING, 0)!;
+    }
+    public START(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.START, 0);
+    }
+    public SHOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHOW, 0);
+    }
+    public STOP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STOP, 0);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_timing_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTiming_command) {
+             listener.enterTiming_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTiming_command) {
+             listener.exitTiming_command(this);
+        }
+    }
+}
+
+
+export class Clear_commandContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CLEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLEAR, 0);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_clear_command;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterClear_command) {
+             listener.enterClear_command(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitClear_command) {
+             listener.exitClear_command(this);
+        }
+    }
+}
+
+
+export class Partition_extension_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public FOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOR, 0);
+    }
+    public expressions_(): Expressions_Context | null {
+        return this.getRuleContext(0, Expressions_Context);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_partition_extension_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPartition_extension_clause) {
+             listener.enterPartition_extension_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPartition_extension_clause) {
+             listener.exitPartition_extension_clause(this);
+        }
+    }
+}
+
+
+export class Column_aliasContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public AS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AS, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_alias;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_alias) {
+             listener.enterColumn_alias(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_alias) {
+             listener.exitColumn_alias(this);
+        }
+    }
+}
+
+
+export class Table_aliasContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_alias;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_alias) {
+             listener.enterTable_alias(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_alias) {
+             listener.exitTable_alias(this);
+        }
+    }
+}
+
+
+export class Where_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public WHERE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.WHERE, 0)!;
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public OF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OF, 0);
+    }
+    public cursor_name(): Cursor_nameContext | null {
+        return this.getRuleContext(0, Cursor_nameContext);
+    }
+    public condition(): ConditionContext | null {
+        return this.getRuleContext(0, ConditionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_where_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterWhere_clause) {
+             listener.enterWhere_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitWhere_clause) {
+             listener.exitWhere_clause(this);
+        }
+    }
+}
+
+
+export class Into_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INTO(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INTO, 0)!;
+    }
+    public general_element(): General_elementContext[];
+    public general_element(i: number): General_elementContext | null;
+    public general_element(i?: number): General_elementContext[] | General_elementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(General_elementContext);
+        }
+
+        return this.getRuleContext(i, General_elementContext);
+    }
+    public bind_variable(): Bind_variableContext[];
+    public bind_variable(i: number): Bind_variableContext | null;
+    public bind_variable(i?: number): Bind_variableContext[] | Bind_variableContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Bind_variableContext);
+        }
+
+        return this.getRuleContext(i, Bind_variableContext);
+    }
+    public BULK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BULK, 0);
+    }
+    public COLLECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLECT, 0);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_into_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInto_clause) {
+             listener.enterInto_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInto_clause) {
+             listener.exitInto_clause(this);
+        }
+    }
+}
+
+
+export class Xml_column_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public quoted_string(): Quoted_stringContext | null {
+        return this.getRuleContext(0, Quoted_stringContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xml_column_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXml_column_name) {
+             listener.enterXml_column_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXml_column_name) {
+             listener.exitXml_column_name(this);
+        }
+    }
+}
+
+
+export class Cost_class_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cost_class_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCost_class_name) {
+             listener.enterCost_class_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCost_class_name) {
+             listener.exitCost_class_name(this);
+        }
+    }
+}
+
+
+export class Attribute_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_attribute_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAttribute_name) {
+             listener.enterAttribute_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAttribute_name) {
+             listener.exitAttribute_name(this);
+        }
+    }
+}
+
+
+export class Savepoint_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_savepoint_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSavepoint_name) {
+             listener.enterSavepoint_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSavepoint_name) {
+             listener.exitSavepoint_name(this);
+        }
+    }
+}
+
+
+export class Rollback_segment_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_rollback_segment_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRollback_segment_name) {
+             listener.enterRollback_segment_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRollback_segment_name) {
+             listener.exitRollback_segment_name(this);
+        }
+    }
+}
+
+
+export class Schema_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_schema_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSchema_name) {
+             listener.enterSchema_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSchema_name) {
+             listener.exitSchema_name(this);
+        }
+    }
+}
+
+
+export class Routine_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public AT_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT_SIGN, 0);
+    }
+    public link_name(): Link_nameContext | null {
+        return this.getRuleContext(0, Link_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_routine_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRoutine_name) {
+             listener.enterRoutine_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRoutine_name) {
+             listener.exitRoutine_name(this);
+        }
+    }
+}
+
+
+export class Package_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_package_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPackage_name) {
+             listener.enterPackage_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPackage_name) {
+             listener.exitPackage_name(this);
+        }
+    }
+}
+
+
+export class Implementation_type_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_implementation_type_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterImplementation_type_name) {
+             listener.enterImplementation_type_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitImplementation_type_name) {
+             listener.exitImplementation_type_name(this);
+        }
+    }
+}
+
+
+export class Parameter_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_parameter_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParameter_name) {
+             listener.enterParameter_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParameter_name) {
+             listener.exitParameter_name(this);
+        }
+    }
+}
+
+
+export class Reference_model_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_reference_model_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterReference_model_name) {
+             listener.enterReference_model_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitReference_model_name) {
+             listener.exitReference_model_name(this);
+        }
+    }
+}
+
+
+export class Main_model_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_main_model_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterMain_model_name) {
+             listener.enterMain_model_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitMain_model_name) {
+             listener.exitMain_model_name(this);
+        }
+    }
+}
+
+
+export class Container_tableview_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_container_tableview_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterContainer_tableview_name) {
+             listener.enterContainer_tableview_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitContainer_tableview_name) {
+             listener.exitContainer_tableview_name(this);
+        }
+    }
+}
+
+
+export class Aggregate_function_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_aggregate_function_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterAggregate_function_name) {
+             listener.enterAggregate_function_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitAggregate_function_name) {
+             listener.exitAggregate_function_name(this);
+        }
+    }
+}
+
+
+export class Query_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_query_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuery_name) {
+             listener.enterQuery_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuery_name) {
+             listener.exitQuery_name(this);
+        }
+    }
+}
+
+
+export class Grantee_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public identified_by(): Identified_byContext | null {
+        return this.getRuleContext(0, Identified_byContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_grantee_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGrantee_name) {
+             listener.enterGrantee_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGrantee_name) {
+             listener.exitGrantee_name(this);
+        }
+    }
+}
+
+
+export class Role_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public CONNECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_role_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRole_name) {
+             listener.enterRole_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRole_name) {
+             listener.exitRole_name(this);
+        }
+    }
+}
+
+
+export class Constraint_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public AT_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT_SIGN, 0);
+    }
+    public link_name(): Link_nameContext | null {
+        return this.getRuleContext(0, Link_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_constraint_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConstraint_name) {
+             listener.enterConstraint_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConstraint_name) {
+             listener.exitConstraint_name(this);
+        }
+    }
+}
+
+
+export class Label_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_label_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLabel_name) {
+             listener.enterLabel_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLabel_name) {
+             listener.exitLabel_name(this);
+        }
+    }
+}
+
+
+export class Type_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_name) {
+             listener.enterType_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_name) {
+             listener.exitType_name(this);
+        }
+    }
+}
+
+
+export class Sequence_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_sequence_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSequence_name) {
+             listener.enterSequence_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSequence_name) {
+             listener.exitSequence_name(this);
+        }
+    }
+}
+
+
+export class Exception_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_exception_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterException_name) {
+             listener.enterException_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitException_name) {
+             listener.exitException_name(this);
+        }
+    }
+}
+
+
+export class Function_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_name) {
+             listener.enterFunction_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_name) {
+             listener.exitFunction_name(this);
+        }
+    }
+}
+
+
+export class Procedure_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_procedure_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterProcedure_name) {
+             listener.enterProcedure_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitProcedure_name) {
+             listener.exitProcedure_name(this);
+        }
+    }
+}
+
+
+export class Trigger_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_trigger_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTrigger_name) {
+             listener.enterTrigger_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTrigger_name) {
+             listener.exitTrigger_name(this);
+        }
+    }
+}
+
+
+export class Variable_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public INTRODUCER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTRODUCER, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_variable_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterVariable_name) {
+             listener.enterVariable_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitVariable_name) {
+             listener.exitVariable_name(this);
+        }
+    }
+}
+
+
+export class Index_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_index_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIndex_name) {
+             listener.enterIndex_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIndex_name) {
+             listener.exitIndex_name(this);
+        }
+    }
+}
+
+
+export class Cursor_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_cursor_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterCursor_name) {
+             listener.enterCursor_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitCursor_name) {
+             listener.exitCursor_name(this);
+        }
+    }
+}
+
+
+export class Record_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public bind_variable(): Bind_variableContext | null {
+        return this.getRuleContext(0, Bind_variableContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_record_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRecord_name) {
+             listener.enterRecord_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRecord_name) {
+             listener.exitRecord_name(this);
+        }
+    }
+}
+
+
+export class Link_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public database(): DatabaseContext {
+        return this.getRuleContext(0, DatabaseContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public domain(): DomainContext[];
+    public domain(i: number): DomainContext | null;
+    public domain(i?: number): DomainContext[] | DomainContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(DomainContext);
+        }
+
+        return this.getRuleContext(i, DomainContext);
+    }
+    public AT_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT_SIGN, 0);
+    }
+    public connection_qualifier(): Connection_qualifierContext | null {
+        return this.getRuleContext(0, Connection_qualifierContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_link_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLink_name) {
+             listener.enterLink_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLink_name) {
+             listener.exitLink_name(this);
+        }
+    }
+}
+
+
+export class Local_link_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_local_link_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterLocal_link_name) {
+             listener.enterLocal_link_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitLocal_link_name) {
+             listener.exitLocal_link_name(this);
+        }
+    }
+}
+
+
+export class Connection_qualifierContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_connection_qualifier;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConnection_qualifier) {
+             listener.enterConnection_qualifier(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConnection_qualifier) {
+             listener.exitConnection_qualifier(this);
+        }
+    }
+}
+
+
+export class Column_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_name) {
+             listener.enterColumn_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_name) {
+             listener.exitColumn_name(this);
+        }
+    }
+}
+
+
+export class Tableview_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public id_expression(): Id_expressionContext | null {
+        return this.getRuleContext(0, Id_expressionContext);
+    }
+    public AT_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT_SIGN, 0);
+    }
+    public link_name(): Link_nameContext | null {
+        return this.getRuleContext(0, Link_nameContext);
+    }
+    public partition_extension_clause(): Partition_extension_clauseContext | null {
+        return this.getRuleContext(0, Partition_extension_clauseContext);
+    }
+    public xmltable(): XmltableContext | null {
+        return this.getRuleContext(0, XmltableContext);
+    }
+    public outer_join_sign(): Outer_join_signContext | null {
+        return this.getRuleContext(0, Outer_join_signContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_tableview_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTableview_name) {
+             listener.enterTableview_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTableview_name) {
+             listener.exitTableview_name(this);
+        }
+    }
+}
+
+
+export class XmltableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public XMLTABLE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.XMLTABLE, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public concatenation(): ConcatenationContext {
+        return this.getRuleContext(0, ConcatenationContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public xml_namespaces_clause(): Xml_namespaces_clauseContext | null {
+        return this.getRuleContext(0, Xml_namespaces_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public xml_passing_clause(): Xml_passing_clauseContext | null {
+        return this.getRuleContext(0, Xml_passing_clauseContext);
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public SEQUENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCE, 0);
+    }
+    public BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BY, 0);
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMNS, 0);
+    }
+    public xml_table_column(): Xml_table_columnContext[];
+    public xml_table_column(i: number): Xml_table_columnContext | null;
+    public xml_table_column(i?: number): Xml_table_columnContext[] | Xml_table_columnContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Xml_table_columnContext);
+        }
+
+        return this.getRuleContext(i, Xml_table_columnContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public general_element_part(): General_element_partContext | null {
+        return this.getRuleContext(0, General_element_partContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_xmltable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterXmltable) {
+             listener.enterXmltable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitXmltable) {
+             listener.exitXmltable(this);
+        }
+    }
+}
+
+
+export class Char_set_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_char_set_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterChar_set_name) {
+             listener.enterChar_set_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitChar_set_name) {
+             listener.exitChar_set_name(this);
+        }
+    }
+}
+
+
+export class Synonym_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public identifier(): IdentifierContext {
+        return this.getRuleContext(0, IdentifierContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_synonym_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSynonym_name) {
+             listener.enterSynonym_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSynonym_name) {
+             listener.exitSynonym_name(this);
+        }
+    }
+}
+
+
+export class Schema_object_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_schema_object_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSchema_object_name) {
+             listener.enterSchema_object_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSchema_object_name) {
+             listener.exitSchema_object_name(this);
+        }
+    }
+}
+
+
+export class Dir_object_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_dir_object_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDir_object_name) {
+             listener.enterDir_object_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDir_object_name) {
+             listener.exitDir_object_name(this);
+        }
+    }
+}
+
+
+export class User_object_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_user_object_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterUser_object_name) {
+             listener.enterUser_object_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitUser_object_name) {
+             listener.exitUser_object_name(this);
+        }
+    }
+}
+
+
+export class Grant_object_nameContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public user_object_name(): User_object_nameContext[];
+    public user_object_name(i: number): User_object_nameContext | null;
+    public user_object_name(i?: number): User_object_nameContext[] | User_object_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(User_object_nameContext);
+        }
+
+        return this.getRuleContext(i, User_object_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public dir_object_name(): Dir_object_nameContext | null {
+        return this.getRuleContext(0, Dir_object_nameContext);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public schema_object_name(): Schema_object_nameContext | null {
+        return this.getRuleContext(0, Schema_object_nameContext);
+    }
+    public MINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINING, 0);
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public JAVA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JAVA, 0);
+    }
+    public SOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE, 0);
+    }
+    public RESOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOURCE, 0);
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public TRANSLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATION, 0);
+    }
+    public PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROFILE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_grant_object_name;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGrant_object_name) {
+             listener.enterGrant_object_name(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGrant_object_name) {
+             listener.exitGrant_object_name(this);
+        }
+    }
+}
+
+
+export class Column_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public column_name(): Column_nameContext[];
+    public column_name(i: number): Column_nameContext | null;
+    public column_name(i?: number): Column_nameContext[] | Column_nameContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_nameContext);
+        }
+
+        return this.getRuleContext(i, Column_nameContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_column_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterColumn_list) {
+             listener.enterColumn_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitColumn_list) {
+             listener.exitColumn_list(this);
+        }
+    }
+}
+
+
+export class Paren_column_listContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_list(): Column_listContext {
+        return this.getRuleContext(0, Column_listContext)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_paren_column_list;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterParen_column_list) {
+             listener.enterParen_column_list(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitParen_column_list) {
+             listener.exitParen_column_list(this);
+        }
+    }
+}
+
+
+export class Keep_clauseContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public KEEP(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.KEEP, 0)!;
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public DENSE_RANK(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.DENSE_RANK, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public LAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST, 0);
+    }
+    public query_partition_clause(): Query_partition_clauseContext | null {
+        return this.getRuleContext(0, Query_partition_clauseContext);
+    }
+    public order_by_clause(): Order_by_clauseContext | null {
+        return this.getRuleContext(0, Order_by_clauseContext);
+    }
+    public over_clause(): Over_clauseContext | null {
+        return this.getRuleContext(0, Over_clauseContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_keep_clause;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterKeep_clause) {
+             listener.enterKeep_clause(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitKeep_clause) {
+             listener.exitKeep_clause(this);
+        }
+    }
+}
+
+
+export class Function_argumentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public argument(): ArgumentContext[];
+    public argument(i: number): ArgumentContext | null;
+    public argument(i?: number): ArgumentContext[] | ArgumentContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ArgumentContext);
+        }
+
+        return this.getRuleContext(i, ArgumentContext);
+    }
+    public keep_clause(): Keep_clauseContext | null {
+        return this.getRuleContext(0, Keep_clauseContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_argument;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_argument) {
+             listener.enterFunction_argument(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_argument) {
+             listener.exitFunction_argument(this);
+        }
+    }
+}
+
+
+export class Function_argument_analyticContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public argument(): ArgumentContext[];
+    public argument(i: number): ArgumentContext | null;
+    public argument(i?: number): ArgumentContext[] | ArgumentContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ArgumentContext);
+        }
+
+        return this.getRuleContext(i, ArgumentContext);
+    }
+    public keep_clause(): Keep_clauseContext | null {
+        return this.getRuleContext(0, Keep_clauseContext);
+    }
+    public respect_or_ignore_nulls(): Respect_or_ignore_nullsContext[];
+    public respect_or_ignore_nulls(i: number): Respect_or_ignore_nullsContext | null;
+    public respect_or_ignore_nulls(i?: number): Respect_or_ignore_nullsContext[] | Respect_or_ignore_nullsContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Respect_or_ignore_nullsContext);
+        }
+
+        return this.getRuleContext(i, Respect_or_ignore_nullsContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_argument_analytic;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_argument_analytic) {
+             listener.enterFunction_argument_analytic(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_argument_analytic) {
+             listener.exitFunction_argument_analytic(this);
+        }
+    }
+}
+
+
+export class Function_argument_modelingContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public column_name(): Column_nameContext {
+        return this.getRuleContext(0, Column_nameContext)!;
+    }
+    public USING(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.USING, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public tableview_name(): Tableview_nameContext | null {
+        return this.getRuleContext(0, Tableview_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public COMMA(): antlr.TerminalNode[];
+    public COMMA(i: number): antlr.TerminalNode | null;
+    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COMMA);
+    	} else {
+    		return this.getToken(PlSqlParser.COMMA, i);
+    	}
+    }
+    public keep_clause(): Keep_clauseContext | null {
+        return this.getRuleContext(0, Keep_clauseContext);
+    }
+    public numeric(): NumericContext[];
+    public numeric(i: number): NumericContext | null;
+    public numeric(i?: number): NumericContext[] | NumericContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(NumericContext);
+        }
+
+        return this.getRuleContext(i, NumericContext);
+    }
+    public NULL_(): antlr.TerminalNode[];
+    public NULL_(i: number): antlr.TerminalNode | null;
+    public NULL_(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.NULL_);
+    	} else {
+    		return this.getToken(PlSqlParser.NULL_, i);
+    	}
+    }
+    public column_alias(): Column_aliasContext[];
+    public column_alias(i: number): Column_aliasContext | null;
+    public column_alias(i?: number): Column_aliasContext[] | Column_aliasContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Column_aliasContext);
+        }
+
+        return this.getRuleContext(i, Column_aliasContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_function_argument_modeling;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterFunction_argument_modeling) {
+             listener.enterFunction_argument_modeling(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitFunction_argument_modeling) {
+             listener.exitFunction_argument_modeling(this);
+        }
+    }
+}
+
+
+export class Respect_or_ignore_nullsContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public NULLS(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.NULLS, 0)!;
+    }
+    public RESPECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESPECT, 0);
+    }
+    public IGNORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_respect_or_ignore_nulls;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRespect_or_ignore_nulls) {
+             listener.enterRespect_or_ignore_nulls(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRespect_or_ignore_nulls) {
+             listener.exitRespect_or_ignore_nulls(this);
+        }
+    }
+}
+
+
+export class ArgumentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public expression(): ExpressionContext {
+        return this.getRuleContext(0, ExpressionContext)!;
+    }
+    public identifier(): IdentifierContext | null {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    public EQUALS_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUALS_OP, 0);
+    }
+    public GREATER_THAN_OP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GREATER_THAN_OP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_argument;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterArgument) {
+             listener.enterArgument(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitArgument) {
+             listener.exitArgument(this);
+        }
+    }
+}
+
+
+export class Type_specContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public datatype(): DatatypeContext | null {
+        return this.getRuleContext(0, DatatypeContext);
+    }
+    public type_name(): Type_nameContext | null {
+        return this.getRuleContext(0, Type_nameContext);
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public PERCENT_ROWTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_ROWTYPE, 0);
+    }
+    public PERCENT_TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_TYPE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_type_spec;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterType_spec) {
+             listener.enterType_spec(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitType_spec) {
+             listener.exitType_spec(this);
+        }
+    }
+}
+
+
+export class DatatypeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public native_datatype_element(): Native_datatype_elementContext | null {
+        return this.getRuleContext(0, Native_datatype_elementContext);
+    }
+    public precision_part(): Precision_partContext | null {
+        return this.getRuleContext(0, Precision_partContext);
+    }
+    public WITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONE, 0);
+    }
+    public CHARACTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTER, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERVAL, 0);
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY, 0);
+    }
+    public MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTH, 0);
+    }
+    public SECOND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECOND, 0);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public expression(): ExpressionContext[];
+    public expression(i: number): ExpressionContext | null;
+    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+
+        return this.getRuleContext(i, ExpressionContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_datatype;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterDatatype) {
+             listener.enterDatatype(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitDatatype) {
+             listener.exitDatatype(this);
+        }
+    }
+}
+
+
+export class Precision_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public numeric(): NumericContext[];
+    public numeric(i: number): NumericContext | null;
+    public numeric(i?: number): NumericContext[] | NumericContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(NumericContext);
+        }
+
+        return this.getRuleContext(i, NumericContext);
+    }
+    public ASTERISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASTERISK, 0);
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTE, 0);
+    }
+    public numeric_negative(): Numeric_negativeContext | null {
+        return this.getRuleContext(0, Numeric_negativeContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_precision_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterPrecision_part) {
+             listener.enterPrecision_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitPrecision_part) {
+             listener.exitPrecision_part(this);
+        }
+    }
+}
+
+
+export class Native_datatype_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BINARY_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_INTEGER, 0);
+    }
+    public PLS_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLS_INTEGER, 0);
+    }
+    public NATURAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATURAL, 0);
+    }
+    public BINARY_FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_FLOAT, 0);
+    }
+    public BINARY_DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_DOUBLE, 0);
+    }
+    public NATURALN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATURALN, 0);
+    }
+    public POSITIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POSITIVE, 0);
+    }
+    public POSITIVEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POSITIVEN, 0);
+    }
+    public SIGNTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIGNTYPE, 0);
+    }
+    public SIMPLE_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIMPLE_INTEGER, 0);
+    }
+    public NVARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NVARCHAR2, 0);
+    }
+    public DEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEC, 0);
+    }
+    public INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTEGER, 0);
+    }
+    public INT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INT, 0);
+    }
+    public NUMERIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMERIC, 0);
+    }
+    public SMALLINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLINT, 0);
+    }
+    public NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMBER, 0);
+    }
+    public DECIMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECIMAL, 0);
+    }
+    public DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE, 0);
+    }
+    public PRECISION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECISION, 0);
+    }
+    public FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLOAT, 0);
+    }
+    public REAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REAL, 0);
+    }
+    public NCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCHAR, 0);
+    }
+    public LONG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LONG, 0);
+    }
+    public RAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAW, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public CHARACTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTER, 0);
+    }
+    public VARYING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARYING, 0);
+    }
+    public VARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR2, 0);
+    }
+    public VARCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR, 0);
+    }
+    public STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRING, 0);
+    }
+    public BOOLEAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BOOLEAN, 0);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID, 0);
+    }
+    public UROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UROWID, 0);
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTH, 0);
+    }
+    public DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY, 0);
+    }
+    public HOUR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HOUR, 0);
+    }
+    public MINUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUTE, 0);
+    }
+    public SECOND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECOND, 0);
+    }
+    public SDO_GEOMETRY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SDO_GEOMETRY, 0);
+    }
+    public TIMEZONE_HOUR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_HOUR, 0);
+    }
+    public TIMEZONE_MINUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_MINUTE, 0);
+    }
+    public TIMEZONE_REGION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_REGION, 0);
+    }
+    public TIMEZONE_ABBR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_ABBR, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public TIMESTAMP_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP_UNCONSTRAINED, 0);
+    }
+    public TIMESTAMP_TZ_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED, 0);
+    }
+    public TIMESTAMP_LTZ_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED, 0);
+    }
+    public YMINTERVAL_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YMINTERVAL_UNCONSTRAINED, 0);
+    }
+    public DSINTERVAL_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DSINTERVAL_UNCONSTRAINED, 0);
+    }
+    public BFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BFILE, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public NCLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCLOB, 0);
+    }
+    public MLSLABEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MLSLABEL, 0);
+    }
+    public XMLTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTYPE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_native_datatype_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNative_datatype_element) {
+             listener.enterNative_datatype_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNative_datatype_element) {
+             listener.exitNative_datatype_element(this);
+        }
+    }
+}
+
+
+export class Bind_variableContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BINDVAR(): antlr.TerminalNode[];
+    public BINDVAR(i: number): antlr.TerminalNode | null;
+    public BINDVAR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.BINDVAR);
+    	} else {
+    		return this.getToken(PlSqlParser.BINDVAR, i);
+    	}
+    }
+    public COLON(): antlr.TerminalNode[];
+    public COLON(i: number): antlr.TerminalNode | null;
+    public COLON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.COLON);
+    	} else {
+    		return this.getToken(PlSqlParser.COLON, i);
+    	}
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public general_element_part(): General_element_partContext[];
+    public general_element_part(i: number): General_element_partContext | null;
+    public general_element_part(i?: number): General_element_partContext[] | General_element_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(General_element_partContext);
+        }
+
+        return this.getRuleContext(i, General_element_partContext);
+    }
+    public INDICATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDICATOR, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_bind_variable;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterBind_variable) {
+             listener.enterBind_variable(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitBind_variable) {
+             listener.exitBind_variable(this);
+        }
+    }
+}
+
+
+export class General_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public general_element_part(): General_element_partContext[];
+    public general_element_part(i: number): General_element_partContext | null;
+    public general_element_part(i?: number): General_element_partContext[] | General_element_partContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(General_element_partContext);
+        }
+
+        return this.getRuleContext(i, General_element_partContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0);
+    }
+    public general_element(): General_elementContext | null {
+        return this.getRuleContext(0, General_elementContext);
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_general_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGeneral_element) {
+             listener.enterGeneral_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGeneral_element) {
+             listener.exitGeneral_element(this);
+        }
+    }
+}
+
+
+export class General_element_partContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public INTRODUCER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTRODUCER, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public AT_SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT_SIGN, 0);
+    }
+    public link_name(): Link_nameContext | null {
+        return this.getRuleContext(0, Link_nameContext);
+    }
+    public function_argument(): Function_argumentContext[];
+    public function_argument(i: number): Function_argumentContext | null;
+    public function_argument(i?: number): Function_argumentContext[] | Function_argumentContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Function_argumentContext);
+        }
+
+        return this.getRuleContext(i, Function_argumentContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_general_element_part;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterGeneral_element_part) {
+             listener.enterGeneral_element_part(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitGeneral_element_part) {
+             listener.exitGeneral_element_part(this);
+        }
+    }
+}
+
+
+export class Table_elementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext[];
+    public id_expression(i: number): Id_expressionContext | null;
+    public id_expression(i?: number): Id_expressionContext[] | Id_expressionContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Id_expressionContext);
+        }
+
+        return this.getRuleContext(i, Id_expressionContext);
+    }
+    public INTRODUCER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTRODUCER, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public PERIOD(): antlr.TerminalNode[];
+    public PERIOD(i: number): antlr.TerminalNode | null;
+    public PERIOD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.PERIOD);
+    	} else {
+    		return this.getToken(PlSqlParser.PERIOD, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_table_element;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterTable_element) {
+             listener.enterTable_element(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitTable_element) {
+             listener.exitTable_element(this);
+        }
+    }
+}
+
+
+export class Object_privilegeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public PRIVILEGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGES, 0);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public FLASHBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASHBACK, 0);
+    }
+    public ARCHIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVE, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public INHERIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INHERIT, 0);
+    }
+    public REMOTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOTE, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public SEQUENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCE, 0);
+    }
+    public MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGE, 0);
+    }
+    public VIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIEW, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public REFRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFRESH, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REWRITE, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCES, 0);
+    }
+    public SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELECT, 0);
+    }
+    public TRANSLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATE, 0);
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public UNDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNDER, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public USE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_object_privilege;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterObject_privilege) {
+             listener.enterObject_privilege(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitObject_privilege) {
+             listener.exitObject_privilege(this);
+        }
+    }
+}
+
+
+export class System_privilegeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL, 0);
+    }
+    public PRIVILEGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGES, 0);
+    }
+    public ADVISOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVISOR, 0);
+    }
+    public ADMINISTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADMINISTER, 0);
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public TUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TUNING, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public ANY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANY, 0);
+    }
+    public PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROFILE, 0);
+    }
+    public ALTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTER, 0);
+    }
+    public CREATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE, 0);
+    }
+    public DROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP, 0);
+    }
+    public MANAGEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGEMENT, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTEXT, 0);
+    }
+    public EXEMPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXEMPT, 0);
+    }
+    public REDACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDACTION, 0);
+    }
+    public POLICY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POLICY, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public LINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINK, 0);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public CONNECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public PROCEDURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURE, 0);
+    }
+    public ANALYZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANALYZE, 0);
+    }
+    public DICTIONARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DICTIONARY, 0);
+    }
+    public DIMENSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIMENSION, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public FLASHBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASHBACK, 0);
+    }
+    public ARCHIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVE, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX, 0);
+    }
+    public INDEXTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXTYPE, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public JOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JOB, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public CLASS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASS, 0);
+    }
+    public PROGRAM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROGRAM, 0);
+    }
+    public MANAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGE, 0);
+    }
+    public SCHEDULER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEDULER, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public LIBRARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIBRARY, 0);
+    }
+    public LOGMINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGMINING, 0);
+    }
+    public MATERIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0);
+    }
+    public VIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIEW, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REWRITE, 0);
+    }
+    public GLOBAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL, 0);
+    }
+    public ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ON, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public REFRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFRESH, 0);
+    }
+    public MINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINING, 0);
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELECT, 0);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public CUBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUBE, 0);
+    }
+    public UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATE, 0);
+    }
+    public MEASURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEASURE, 0);
+    }
+    public FOLDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOLDER, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERT, 0);
+    }
+    public BUILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BUILD, 0);
+    }
+    public PROCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCESS, 0);
+    }
+    public OPERATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPERATOR, 0);
+    }
+    public OUTLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTLINE, 0);
+    }
+    public PLUGGABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0);
+    }
+    public CONTAINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER, 0);
+    }
+    public ROLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLE, 0);
+    }
+    public GRANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GRANT, 0);
+    }
+    public ROLLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLBACK, 0);
+    }
+    public SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEGMENT, 0);
+    }
+    public SEQUENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCE, 0);
+    }
+    public RESTRICTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICTED, 0);
+    }
+    public RESOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOURCE, 0);
+    }
+    public COST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COST, 0);
+    }
+    public TRANSLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATION, 0);
+    }
+    public USE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE, 0);
+    }
+    public TRANSLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATE, 0);
+    }
+    public SYNONYM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYNONYM, 0);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public LOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCK, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public TRIGGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIGGER, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public UNDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNDER, 0);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGE, 0);
+    }
+    public AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUDIT, 0);
+    }
+    public BECOME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BECOME, 0);
+    }
+    public CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHANGE, 0);
+    }
+    public NOTIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOTIFICATION, 0);
+    }
+    public ACCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESS, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public TRANSACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSACTION, 0);
+    }
+    public PRIVILEGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGE, 0);
+    }
+    public INHERIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INHERIT, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public SYSGUID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSGUID, 0);
+    }
+    public PURGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PURGE, 0);
+    }
+    public DBA_RECYCLEBIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBA_RECYCLEBIN, 0);
+    }
+    public RESUMABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESUMABLE, 0);
+    }
+    public SYSBACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSBACKUP, 0);
+    }
+    public SYSDBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSDBA, 0);
+    }
+    public SYSDG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSDG, 0);
+    }
+    public SYSKM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSKM, 0);
+    }
+    public SYSOPER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSOPER, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_system_privilege;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterSystem_privilege) {
+             listener.enterSystem_privilege(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitSystem_privilege) {
+             listener.exitSystem_privilege(this);
+        }
+    }
+}
+
+
+export class ConstantContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public quoted_string(): Quoted_stringContext[];
+    public quoted_string(i: number): Quoted_stringContext | null;
+    public quoted_string(i?: number): Quoted_stringContext[] | Quoted_stringContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Quoted_stringContext);
+        }
+
+        return this.getRuleContext(i, Quoted_stringContext);
+    }
+    public bind_variable(): Bind_variableContext[];
+    public bind_variable(i: number): Bind_variableContext | null;
+    public bind_variable(i?: number): Bind_variableContext[] | Bind_variableContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(Bind_variableContext);
+        }
+
+        return this.getRuleContext(i, Bind_variableContext);
+    }
+    public AT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONE, 0);
+    }
+    public INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERVAL, 0);
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public MONTH(): antlr.TerminalNode[];
+    public MONTH(i: number): antlr.TerminalNode | null;
+    public MONTH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MONTH);
+    	} else {
+    		return this.getToken(PlSqlParser.MONTH, i);
+    	}
+    }
+    public DAY(): antlr.TerminalNode[];
+    public DAY(i: number): antlr.TerminalNode | null;
+    public DAY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.DAY);
+    	} else {
+    		return this.getToken(PlSqlParser.DAY, i);
+    	}
+    }
+    public HOUR(): antlr.TerminalNode[];
+    public HOUR(i: number): antlr.TerminalNode | null;
+    public HOUR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.HOUR);
+    	} else {
+    		return this.getToken(PlSqlParser.HOUR, i);
+    	}
+    }
+    public MINUTE(): antlr.TerminalNode[];
+    public MINUTE(i: number): antlr.TerminalNode | null;
+    public MINUTE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.MINUTE);
+    	} else {
+    		return this.getToken(PlSqlParser.MINUTE, i);
+    	}
+    }
+    public SECOND(): antlr.TerminalNode[];
+    public SECOND(i: number): antlr.TerminalNode | null;
+    public SECOND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.SECOND);
+    	} else {
+    		return this.getToken(PlSqlParser.SECOND, i);
+    	}
+    }
+    public general_element_part(): General_element_partContext | null {
+        return this.getRuleContext(0, General_element_partContext);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode[];
+    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
+    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.LEFT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.LEFT_PAREN, i);
+    	}
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode[];
+    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
+    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.RIGHT_PAREN);
+    	} else {
+    		return this.getToken(PlSqlParser.RIGHT_PAREN, i);
+    	}
+    }
+    public TO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO, 0);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode[];
+    public UNSIGNED_INTEGER(i: number): antlr.TerminalNode | null;
+    public UNSIGNED_INTEGER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(PlSqlParser.UNSIGNED_INTEGER);
+    	} else {
+    		return this.getToken(PlSqlParser.UNSIGNED_INTEGER, i);
+    	}
+    }
+    public COMMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMA, 0);
+    }
+    public numeric(): NumericContext | null {
+        return this.getRuleContext(0, NumericContext);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public NULL_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULL_, 0);
+    }
+    public TRUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUE, 0);
+    }
+    public FALSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FALSE, 0);
+    }
+    public DBTIMEZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBTIMEZONE, 0);
+    }
+    public SESSIONTIMEZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSIONTIMEZONE, 0);
+    }
+    public MINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINVALUE, 0);
+    }
+    public MAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXVALUE, 0);
+    }
+    public DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_constant;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterConstant) {
+             listener.enterConstant(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitConstant) {
+             listener.exitConstant(this);
+        }
+    }
+}
+
+
+export class NumericContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public UNSIGNED_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSIGNED_INTEGER, 0);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public APPROXIMATE_NUM_LIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPROXIMATE_NUM_LIT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_numeric;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNumeric) {
+             listener.enterNumeric(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNumeric) {
+             listener.exitNumeric(this);
+        }
+    }
+}
+
+
+export class Numeric_negativeContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public MINUS_SIGN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.MINUS_SIGN, 0)!;
+    }
+    public numeric(): NumericContext {
+        return this.getRuleContext(0, NumericContext)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_numeric_negative;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNumeric_negative) {
+             listener.enterNumeric_negative(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNumeric_negative) {
+             listener.exitNumeric_negative(this);
+        }
+    }
+}
+
+
+export class Quoted_stringContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public CHAR_STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_STRING, 0);
+    }
+    public NATIONAL_CHAR_STRING_LIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATIONAL_CHAR_STRING_LIT, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_quoted_string;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterQuoted_string) {
+             listener.enterQuoted_string(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitQuoted_string) {
+             listener.exitQuoted_string(this);
+        }
+    }
+}
+
+
+export class IdentifierContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public id_expression(): Id_expressionContext {
+        return this.getRuleContext(0, Id_expressionContext)!;
+    }
+    public INTRODUCER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTRODUCER, 0);
+    }
+    public char_set_name(): Char_set_nameContext | null {
+        return this.getRuleContext(0, Char_set_nameContext);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_identifier;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterIdentifier) {
+             listener.enterIdentifier(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitIdentifier) {
+             listener.exitIdentifier(this);
+        }
+    }
+}
+
+
+export class Id_expressionContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public regular_id(): Regular_idContext | null {
+        return this.getRuleContext(0, Regular_idContext);
+    }
+    public DELIMITED_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELIMITED_ID, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_id_expression;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterId_expression) {
+             listener.enterId_expression(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitId_expression) {
+             listener.exitId_expression(this);
+        }
+    }
+}
+
+
+export class Inquiry_directiveContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public INQUIRY_DIRECTIVE(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.INQUIRY_DIRECTIVE, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_inquiry_directive;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterInquiry_directive) {
+             listener.enterInquiry_directive(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitInquiry_directive) {
+             listener.exitInquiry_directive(this);
+        }
+    }
+}
+
+
+export class Outer_join_signContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LEFT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.LEFT_PAREN, 0)!;
+    }
+    public PLUS_SIGN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.PLUS_SIGN, 0)!;
+    }
+    public RIGHT_PAREN(): antlr.TerminalNode {
+        return this.getToken(PlSqlParser.RIGHT_PAREN, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_outer_join_sign;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterOuter_join_sign) {
+             listener.enterOuter_join_sign(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitOuter_join_sign) {
+             listener.exitOuter_join_sign(this);
+        }
+    }
+}
+
+
+export class Regular_idContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public non_reserved_keywords_pre12c(): Non_reserved_keywords_pre12cContext | null {
+        return this.getRuleContext(0, Non_reserved_keywords_pre12cContext);
+    }
+    public non_reserved_keywords_in_12c(): Non_reserved_keywords_in_12cContext | null {
+        return this.getRuleContext(0, Non_reserved_keywords_in_12cContext);
+    }
+    public non_reserved_keywords_in_18c(): Non_reserved_keywords_in_18cContext | null {
+        return this.getRuleContext(0, Non_reserved_keywords_in_18cContext);
+    }
+    public REGULAR_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGULAR_ID, 0);
+    }
+    public AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUDIT, 0);
+    }
+    public ITEMS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ITEMS, 0);
+    }
+    public BYTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTES, 0);
+    }
+    public LINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINES, 0);
+    }
+    public RECORDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECORDS, 0);
+    }
+    public NEWLINE_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEWLINE_, 0);
+    }
+    public FIELD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIELD, 0);
+    }
+    public MASK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MASK, 0);
+    }
+    public ABSENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ABSENT, 0);
+    }
+    public A_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.A_LETTER, 0);
+    }
+    public AGENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AGENT, 0);
+    }
+    public AGGREGATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AGGREGATE, 0);
+    }
+    public ANALYZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANALYZE, 0);
+    }
+    public AUTONOMOUS_TRANSACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTONOMOUS_TRANSACTION, 0);
+    }
+    public BACKINGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKINGFILE, 0);
+    }
+    public BATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BATCH, 0);
+    }
+    public BINARY_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_INTEGER, 0);
+    }
+    public BOOLEAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BOOLEAN, 0);
+    }
+    public C_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.C_LETTER, 0);
+    }
+    public CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR, 0);
+    }
+    public CHARSETID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARSETID, 0);
+    }
+    public CHARSETFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARSETFORM, 0);
+    }
+    public CLUSTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER, 0);
+    }
+    public CONSTRUCTOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRUCTOR, 0);
+    }
+    public CUSTOMDATUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUSTOMDATUM, 0);
+    }
+    public CASESENSITIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASESENSITIVE, 0);
+    }
+    public COUNTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNTED, 0);
+    }
+    public DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE, 0);
+    }
+    public DECIMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECIMAL, 0);
+    }
+    public DELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE, 0);
+    }
+    public DEPRECATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEPRECATE, 0);
+    }
+    public DETECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DETECTED, 0);
+    }
+    public DETERMINISTIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DETERMINISTIC, 0);
+    }
+    public DISABLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLED, 0);
+    }
+    public DSINTERVAL_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DSINTERVAL_UNCONSTRAINED, 0);
+    }
+    public DURATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DURATION, 0);
+    }
+    public E_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.E_LETTER, 0);
+    }
+    public ENABLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLED, 0);
+    }
+    public ENCLOSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCLOSED, 0);
+    }
+    public ERROR_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR_INDEX, 0);
+    }
+    public ERROR_CODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR_CODE, 0);
+    }
+    public ERR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERR, 0);
+    }
+    public EXCEPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTION, 0);
+    }
+    public EXCEPTION_INIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTION_INIT, 0);
+    }
+    public EXCEPTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTIONS, 0);
+    }
+    public EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTS, 0);
+    }
+    public EXEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXEC, 0);
+    }
+    public EXIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXIT, 0);
+    }
+    public EXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTEND, 0);
+    }
+    public FIELDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIELDS, 0);
+    }
+    public FILE_EXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE_EXT, 0);
+    }
+    public FILESTORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILESTORE, 0);
+    }
+    public FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLOAT, 0);
+    }
+    public FORALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORALL, 0);
+    }
+    public G_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.G_LETTER, 0);
+    }
+    public INDICES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDICES, 0);
+    }
+    public INOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INOUT, 0);
+    }
+    public INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTEGER, 0);
+    }
+    public INTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERNAL, 0);
+    }
+    public JSON_TRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_TRANSFORM, 0);
+    }
+    public K_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.K_LETTER, 0);
+    }
+    public LANGUAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LANGUAGE, 0);
+    }
+    public LONG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LONG, 0);
+    }
+    public LOOP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOOP, 0);
+    }
+    public MAXLEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLEN, 0);
+    }
+    public MOUNTPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNTPOINT, 0);
+    }
+    public M_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.M_LETTER, 0);
+    }
+    public MISSING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MISSING, 0);
+    }
+    public MISMATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MISMATCH, 0);
+    }
+    public NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMBER, 0);
+    }
+    public ORADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORADATA, 0);
+    }
+    public ORC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORC, 0);
+    }
+    public OSERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OSERROR, 0);
+    }
+    public OUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUT, 0);
+    }
+    public OVERRIDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERRIDING, 0);
+    }
+    public P_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.P_LETTER, 0);
+    }
+    public PARALLEL_ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARALLEL_ENABLE, 0);
+    }
+    public PIPELINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PIPELINED, 0);
+    }
+    public PLS_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLS_INTEGER, 0);
+    }
+    public PMEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PMEM, 0);
+    }
+    public POSITIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POSITIVE, 0);
+    }
+    public POSITIVEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POSITIVEN, 0);
+    }
+    public PRAGMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRAGMA, 0);
+    }
+    public PUBLIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUBLIC, 0);
+    }
+    public RAISE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAISE, 0);
+    }
+    public RAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAW, 0);
+    }
+    public RECORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECORD, 0);
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public RENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RENAME, 0);
+    }
+    public RESTRICT_REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICT_REFERENCES, 0);
+    }
+    public RESULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESULT, 0);
+    }
+    public SDO_GEOMETRY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SDO_GEOMETRY, 0);
+    }
+    public SELF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELF, 0);
+    }
+    public SERIALLY_REUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERIALLY_REUSABLE, 0);
+    }
+    public SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET, 0);
+    }
+    public SEQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQ, 0);
+    }
+    public SHARDSPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARDSPACE, 0);
+    }
+    public SIGNTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIGNTYPE, 0);
+    }
+    public SIMPLE_INTEGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIMPLE_INTEGER, 0);
+    }
+    public SMALLINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLINT, 0);
+    }
+    public STRUCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRUCT, 0);
+    }
+    public SQLDATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQLDATA, 0);
+    }
+    public SQLERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQLERROR, 0);
+    }
+    public SUBTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBTYPE, 0);
+    }
+    public T_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.T_LETTER, 0);
+    }
+    public TDO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TDO, 0);
+    }
+    public TIMESTAMP_LTZ_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP_LTZ_UNCONSTRAINED, 0);
+    }
+    public TIMESTAMP_TZ_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP_TZ_UNCONSTRAINED, 0);
+    }
+    public TIMESTAMP_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP_UNCONSTRAINED, 0);
+    }
+    public TIMEZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE, 0);
+    }
+    public TRIGGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIGGER, 0);
+    }
+    public UDF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UDF, 0);
+    }
+    public VARCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR, 0);
+    }
+    public VARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARCHAR2, 0);
+    }
+    public VARIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARIABLE, 0);
+    }
+    public WARNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WARNING, 0);
+    }
+    public WHILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHILE, 0);
+    }
+    public WM_CONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WM_CONCAT, 0);
+    }
+    public XMLAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLAGG, 0);
+    }
+    public YMINTERVAL_UNCONSTRAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YMINTERVAL_UNCONSTRAINED, 0);
+    }
+    public REGR_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_, 0);
+    }
+    public VAR_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VAR_, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public COVAR_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COVAR_, 0);
+    }
+    public DATE_FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE_FORMAT, 0);
+    }
+    public CSV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CSV, 0);
+    }
+    public CHARACTERSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTERSET, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_regular_id;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterRegular_id) {
+             listener.enterRegular_id(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitRegular_id) {
+             listener.exitRegular_id(this);
+        }
+    }
+}
+
+
+export class Non_reserved_keywords_in_18cContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public PERSISTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERSISTABLE, 0);
+    }
+    public POLYMORPHIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POLYMORPHIC, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_non_reserved_keywords_in_18c;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNon_reserved_keywords_in_18c) {
+             listener.enterNon_reserved_keywords_in_18c(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNon_reserved_keywords_in_18c) {
+             listener.exitNon_reserved_keywords_in_18c(this);
+        }
+    }
+}
+
+
+export class Non_reserved_keywords_in_12cContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ACL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACL, 0);
+    }
+    public ACCESSIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESSIBLE, 0);
+    }
+    public ACROSS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACROSS, 0);
+    }
+    public ACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTION, 0);
+    }
+    public ACTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIONS, 0);
+    }
+    public ACTIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVE, 0);
+    }
+    public ACTIVE_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVE_DATA, 0);
+    }
+    public ACTIVITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVITY, 0);
+    }
+    public ADAPTIVE_PLAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADAPTIVE_PLAN, 0);
+    }
+    public ADVANCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVANCED, 0);
+    }
+    public AFD_DISKSTRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFD_DISKSTRING, 0);
+    }
+    public ALTERNATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALTERNATE, 0);
+    }
+    public ALGORITHM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALGORITHM, 0);
+    }
+    public ANALYTIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANALYTIC, 0);
+    }
+    public ANCESTOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANCESTOR, 0);
+    }
+    public ANOMALY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANOMALY, 0);
+    }
+    public ANSI_REARCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANSI_REARCH, 0);
+    }
+    public APPLICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPLICATION, 0);
+    }
+    public APPROX_COUNT_DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPROX_COUNT_DISTINCT, 0);
+    }
+    public ARCHIVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVAL, 0);
+    }
+    public ARCHIVED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVED, 0);
+    }
+    public ASIS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASIS, 0);
+    }
+    public ASSIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASSIGN, 0);
+    }
+    public AUTO_LOGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO_LOGIN, 0);
+    }
+    public AUTO_REOPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO_REOPTIMIZE, 0);
+    }
+    public AVRO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVRO, 0);
+    }
+    public BACKGROUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKGROUND, 0);
+    }
+    public BACKUPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUPS, 0);
+    }
+    public BATCHSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BATCHSIZE, 0);
+    }
+    public BATCH_TABLE_ACCESS_BY_ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BATCH_TABLE_ACCESS_BY_ROWID, 0);
+    }
+    public BEGINNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGINNING, 0);
+    }
+    public BEQUEATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEQUEATH, 0);
+    }
+    public BITMAP_AND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITMAP_AND, 0);
+    }
+    public BLOCKCHAIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKCHAIN, 0);
+    }
+    public BSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BSON, 0);
+    }
+    public CACHING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHING, 0);
+    }
+    public CALCULATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CALCULATED, 0);
+    }
+    public CALLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CALLBACK, 0);
+    }
+    public CAPACITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAPACITY, 0);
+    }
+    public CAPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAPTION, 0);
+    }
+    public CDBDEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CDBDEFAULT, 0);
+    }
+    public CLASSIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASSIFICATION, 0);
+    }
+    public CLASSIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASSIFIER, 0);
+    }
+    public CLAUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLAUSE, 0);
+    }
+    public CLEAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLEAN, 0);
+    }
+    public CLEANUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLEANUP, 0);
+    }
+    public CLIENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLIENT, 0);
+    }
+    public CLUSTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTERING, 0);
+    }
+    public CLUSTER_DETAILS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER_DETAILS, 0);
+    }
+    public CLUSTER_DISTANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER_DISTANCE, 0);
+    }
+    public COLLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATE, 0);
+    }
+    public COLLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLATION, 0);
+    }
+    public COMMON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMON, 0);
+    }
+    public COMMON_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMON_DATA, 0);
+    }
+    public COMPONENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPONENT, 0);
+    }
+    public COMPONENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPONENTS, 0);
+    }
+    public CONDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONDITION, 0);
+    }
+    public CONDITIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONDITIONAL, 0);
+    }
+    public CONTAINERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINERS, 0);
+    }
+    public CONTAINERS_DEFAULT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINERS_DEFAULT, 0);
+    }
+    public CONTAINER_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER_DATA, 0);
+    }
+    public CONTAINER_MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER_MAP, 0);
+    }
+    public CONVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONVERSION, 0);
+    }
+    public CON_DBID_TO_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CON_DBID_TO_ID, 0);
+    }
+    public CON_GUID_TO_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CON_GUID_TO_ID, 0);
+    }
+    public CON_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CON_ID, 0);
+    }
+    public CON_NAME_TO_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CON_NAME_TO_ID, 0);
+    }
+    public CON_UID_TO_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CON_UID_TO_ID, 0);
+    }
+    public COOKIE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COOKIE, 0);
+    }
+    public COPY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COPY, 0);
+    }
+    public CREATE_FILE_DEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE_FILE_DEST, 0);
+    }
+    public CREDENTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREDENTIAL, 0);
+    }
+    public CRITICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CRITICAL, 0);
+    }
+    public CUBE_AJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUBE_AJ, 0);
+    }
+    public CUBE_SJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUBE_SJ, 0);
+    }
+    public DATAMOVEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAMOVEMENT, 0);
+    }
+    public DATAOBJ_TO_MAT_PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAOBJ_TO_MAT_PARTITION, 0);
+    }
+    public DATAPUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAPUMP, 0);
+    }
+    public DATA_SECURITY_REWRITE_LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA_SECURITY_REWRITE_LIMIT, 0);
+    }
+    public DAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAYS, 0);
+    }
+    public DB_UNIQUE_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DB_UNIQUE_NAME, 0);
+    }
+    public DECORRELATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECORRELATE, 0);
+    }
+    public DEFAULT_CREDENTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT_CREDENTIAL, 0);
+    }
+    public DEFAULT_COLLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULT_COLLATION, 0);
+    }
+    public DEFINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINE, 0);
+    }
+    public DEFINITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINITION, 0);
+    }
+    public DELEGATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELEGATE, 0);
+    }
+    public DELETE_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETE_ALL, 0);
+    }
+    public DESCRIPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DESCRIPTION, 0);
+    }
+    public DESTROY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DESTROY, 0);
+    }
+    public DIMENSIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIMENSIONS, 0);
+    }
+    public DISABLE_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE_ALL, 0);
+    }
+    public DISABLE_PARALLEL_DML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE_PARALLEL_DML, 0);
+    }
+    public DISCARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISCARD, 0);
+    }
+    public DISTRIBUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTRIBUTE, 0);
+    }
+    public DUPLICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DUPLICATE, 0);
+    }
+    public DUPLICATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DUPLICATED, 0);
+    }
+    public DV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DV, 0);
+    }
+    public EDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONABLE, 0);
+    }
+    public ELIM_GROUPBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELIM_GROUPBY, 0);
+    }
+    public EM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EM, 0);
+    }
+    public ENABLE_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE_ALL, 0);
+    }
+    public ENABLE_PARALLEL_DML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE_PARALLEL_DML, 0);
+    }
+    public EQUIPART(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EQUIPART, 0);
+    }
+    public EVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVAL, 0);
+    }
+    public EVALUATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALUATE, 0);
+    }
+    public EXISTING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTING, 0);
+    }
+    public EXPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPRESS, 0);
+    }
+    public EXTENDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENDED, 0);
+    }
+    public EXTRACTCLOBXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTRACTCLOBXML, 0);
+    }
+    public FACTOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FACTOR, 0);
+    }
+    public FAILOVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILOVER, 0);
+    }
+    public FAILURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILURE, 0);
+    }
+    public FAMILY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAMILY, 0);
+    }
+    public FAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAR, 0);
+    }
+    public FASTSTART(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FASTSTART, 0);
+    }
+    public FEATURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FEATURE, 0);
+    }
+    public FEATURE_DETAILS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FEATURE_DETAILS, 0);
+    }
+    public FETCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FETCH, 0);
+    }
+    public FILE_NAME_CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE_NAME_CONVERT, 0);
+    }
+    public FILEGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILEGROUP, 0);
+    }
+    public FIXED_VIEW_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIXED_VIEW_DATA, 0);
+    }
+    public FLEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLEX, 0);
+    }
+    public FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORMAT, 0);
+    }
+    public FTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FTP, 0);
+    }
+    public GATHER_OPTIMIZER_STATISTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GATHER_OPTIMIZER_STATISTICS, 0);
+    }
+    public GET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GET, 0);
+    }
+    public HALF_YEARS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HALF_YEARS, 0);
+    }
+    public HASHING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASHING, 0);
+    }
+    public HIER_ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIER_ORDER, 0);
+    }
+    public HIERARCHICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIERARCHICAL, 0);
+    }
+    public HOURS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HOURS, 0);
+    }
+    public HTTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HTTP, 0);
+    }
+    public H_LETTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.H_LETTER, 0);
+    }
+    public IDLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDLE, 0);
+    }
+    public ILM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ILM, 0);
+    }
+    public IMMUTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMUTABLE, 0);
+    }
+    public INACTIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INACTIVE, 0);
+    }
+    public INACTIVE_ACCOUNT_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INACTIVE_ACCOUNT_TIME, 0);
+    }
+    public INDEXING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXING, 0);
+    }
+    public INHERIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INHERIT, 0);
+    }
+    public INMEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INMEMORY, 0);
+    }
+    public INMEMORY_PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INMEMORY_PRUNING, 0);
+    }
+    public INPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INPLACE, 0);
+    }
+    public INTERLEAVED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERLEAVED, 0);
+    }
+    public INVALIDATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVALIDATION, 0);
+    }
+    public ISOLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ISOLATE, 0);
+    }
+    public IS_LEAF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IS_LEAF, 0);
+    }
+    public JSON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON, 0);
+    }
+    public JSONGET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSONGET, 0);
+    }
+    public JSONPARSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSONPARSE, 0);
+    }
+    public JSON_ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_ARRAY, 0);
+    }
+    public JSON_ARRAYAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_ARRAYAGG, 0);
+    }
+    public JSON_EQUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_EQUAL, 0);
+    }
+    public JSON_EXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_EXISTS, 0);
+    }
+    public JSON_EXISTS2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_EXISTS2, 0);
+    }
+    public JSON_OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_OBJECT, 0);
+    }
+    public JSON_OBJECTAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_OBJECTAGG, 0);
+    }
+    public JSON_QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_QUERY, 0);
+    }
+    public JSON_SERIALIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_SERIALIZE, 0);
+    }
+    public JSON_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_TABLE, 0);
+    }
+    public JSON_TEXTCONTAINS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_TEXTCONTAINS, 0);
+    }
+    public JSON_TEXTCONTAINS2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_TEXTCONTAINS2, 0);
+    }
+    public JSON_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JSON_VALUE, 0);
+    }
+    public KEYSTORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYSTORE, 0);
+    }
+    public LABEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LABEL, 0);
+    }
+    public LAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAX, 0);
+    }
+    public LEAD_CDB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAD_CDB, 0);
+    }
+    public LEAD_CDB_URI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAD_CDB_URI, 0);
+    }
+    public LEVEL_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVEL_NAME, 0);
+    }
+    public LIFECYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIFECYCLE, 0);
+    }
+    public LINEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINEAR, 0);
+    }
+    public LOCKDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKDOWN, 0);
+    }
+    public LOCKING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKING, 0);
+    }
+    public LOGMINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGMINING, 0);
+    }
+    public LOST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOST, 0);
+    }
+    public MANDATORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANDATORY, 0);
+    }
+    public MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAP, 0);
+    }
+    public MATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATCH, 0);
+    }
+    public MATCHES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATCHES, 0);
+    }
+    public MATCH_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATCH_NUMBER, 0);
+    }
+    public MATCH_RECOGNIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATCH_RECOGNIZE, 0);
+    }
+    public MAX_SHARED_TEMP_SIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAX_SHARED_TEMP_SIZE, 0);
+    }
+    public MEMCOMPRESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMCOMPRESS, 0);
+    }
+    public METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METADATA, 0);
+    }
+    public MEMBER_CAPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_CAPTION, 0);
+    }
+    public MEMBER_DESCRIPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_DESCRIPTION, 0);
+    }
+    public MEMBER_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_NAME, 0);
+    }
+    public MEMBER_UNIQUE_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER_UNIQUE_NAME, 0);
+    }
+    public MEMOPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMOPTIMIZE, 0);
+    }
+    public MINUTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUTES, 0);
+    }
+    public MODEL_NB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_NB, 0);
+    }
+    public MODEL_SV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_SV, 0);
+    }
+    public MODIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFICATION, 0);
+    }
+    public MODULE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODULE, 0);
+    }
+    public MONTHS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTHS, 0);
+    }
+    public MULTIDIMENSIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MULTIDIMENSIONAL, 0);
+    }
+    public NEG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEG, 0);
+    }
+    public NOCOPY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCOPY, 0);
+    }
+    public NOKEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOKEEP, 0);
+    }
+    public NONEDITIONABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONEDITIONABLE, 0);
+    }
+    public NONPARTITIONED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONPARTITIONED, 0);
+    }
+    public NOPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOPARTITION, 0);
+    }
+    public NORELOCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORELOCATE, 0);
+    }
+    public NOREPLAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREPLAY, 0);
+    }
+    public NO_ADAPTIVE_PLAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ADAPTIVE_PLAN, 0);
+    }
+    public NO_ANSI_REARCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ANSI_REARCH, 0);
+    }
+    public NO_AUTO_REOPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_AUTO_REOPTIMIZE, 0);
+    }
+    public NO_BATCH_TABLE_ACCESS_BY_ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_BATCH_TABLE_ACCESS_BY_ROWID, 0);
+    }
+    public NO_CLUSTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CLUSTERING, 0);
+    }
+    public NO_COMMON_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_COMMON_DATA, 0);
+    }
+    public NO_DATA_SECURITY_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_DATA_SECURITY_REWRITE, 0);
+    }
+    public NO_DECORRELATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_DECORRELATE, 0);
+    }
+    public NO_ELIM_GROUPBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ELIM_GROUPBY, 0);
+    }
+    public NO_GATHER_OPTIMIZER_STATISTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_GATHER_OPTIMIZER_STATISTICS, 0);
+    }
+    public NO_INMEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_INMEMORY, 0);
+    }
+    public NO_INMEMORY_PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_INMEMORY_PRUNING, 0);
+    }
+    public NO_OBJECT_LINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_OBJECT_LINK, 0);
+    }
+    public NO_PARTIAL_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PARTIAL_JOIN, 0);
+    }
+    public NO_PARTIAL_ROLLUP_PUSHDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PARTIAL_ROLLUP_PUSHDOWN, 0);
+    }
+    public NO_PQ_CONCURRENT_UNION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PQ_CONCURRENT_UNION, 0);
+    }
+    public NO_PQ_REPLICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PQ_REPLICATE, 0);
+    }
+    public NO_PQ_SKEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PQ_SKEW, 0);
+    }
+    public NOPROMPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOPROMPT, 0);
+    }
+    public NO_PX_FAULT_TOLERANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PX_FAULT_TOLERANCE, 0);
+    }
+    public NO_ROOT_SW_FOR_LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ROOT_SW_FOR_LOCAL, 0);
+    }
+    public NO_SQL_TRANSLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SQL_TRANSLATION, 0);
+    }
+    public NO_USE_CUBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_CUBE, 0);
+    }
+    public NO_USE_VECTOR_AGGREGATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_VECTOR_AGGREGATION, 0);
+    }
+    public NO_VECTOR_TRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_VECTOR_TRANSFORM, 0);
+    }
+    public NO_VECTOR_TRANSFORM_DIMS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_VECTOR_TRANSFORM_DIMS, 0);
+    }
+    public NO_VECTOR_TRANSFORM_FACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_VECTOR_TRANSFORM_FACT, 0);
+    }
+    public NO_ZONEMAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ZONEMAP, 0);
+    }
+    public OBJ_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJ_ID, 0);
+    }
+    public OFFSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFSET, 0);
+    }
+    public OLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLS, 0);
+    }
+    public OMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OMIT, 0);
+    }
+    public ONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONE, 0);
+    }
+    public ORACLE_DATAPUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_DATAPUMP, 0);
+    }
+    public ORACLE_HDFS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_HDFS, 0);
+    }
+    public ORACLE_HIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_HIVE, 0);
+    }
+    public ORACLE_LOADER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORACLE_LOADER, 0);
+    }
+    public ORA_CHECK_ACL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_CHECK_ACL, 0);
+    }
+    public ORA_CHECK_PRIVILEGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_CHECK_PRIVILEGE, 0);
+    }
+    public ORA_CLUSTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_CLUSTERING, 0);
+    }
+    public ORA_INVOKING_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_INVOKING_USER, 0);
+    }
+    public ORA_INVOKING_USERID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_INVOKING_USERID, 0);
+    }
+    public ORA_INVOKING_XS_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_INVOKING_XS_USER, 0);
+    }
+    public ORA_INVOKING_XS_USER_GUID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_INVOKING_XS_USER_GUID, 0);
+    }
+    public ORA_RAWCOMPARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_RAWCOMPARE, 0);
+    }
+    public ORA_RAWCONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_RAWCONCAT, 0);
+    }
+    public ORA_WRITE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_WRITE_TIME, 0);
+    }
+    public PARENT_LEVEL_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT_LEVEL_NAME, 0);
+    }
+    public PARENT_UNIQUE_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT_UNIQUE_NAME, 0);
+    }
+    public PASSWORD_ROLLOVER_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_ROLLOVER_TIME, 0);
+    }
+    public PARTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTIAL, 0);
+    }
+    public PARTIAL_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTIAL_JOIN, 0);
+    }
+    public PARTIAL_ROLLUP_PUSHDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTIAL_ROLLUP_PUSHDOWN, 0);
+    }
+    public PAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PAST, 0);
+    }
+    public PATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATCH, 0);
+    }
+    public PATH_PREFIX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATH_PREFIX, 0);
+    }
+    public PATTERN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATTERN, 0);
+    }
+    public PER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PER, 0);
+    }
+    public PERIOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD, 0);
+    }
+    public PERIOD_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERIOD_KEYWORD, 0);
+    }
+    public PERMUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERMUTE, 0);
+    }
+    public PLUGGABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLUGGABLE, 0);
+    }
+    public POOL_16K(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POOL_16K, 0);
+    }
+    public POOL_2K(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POOL_2K, 0);
+    }
+    public POOL_32K(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POOL_32K, 0);
+    }
+    public POOL_4K(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POOL_4K, 0);
+    }
+    public POOL_8K(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POOL_8K, 0);
+    }
+    public PQ_CONCURRENT_UNION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_CONCURRENT_UNION, 0);
+    }
+    public PQ_DISTRIBUTE_WINDOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_DISTRIBUTE_WINDOW, 0);
+    }
+    public PQ_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_FILTER, 0);
+    }
+    public PQ_REPLICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_REPLICATE, 0);
+    }
+    public PQ_SKEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_SKEW, 0);
+    }
+    public PRELOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRELOAD, 0);
+    }
+    public PRETTY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRETTY, 0);
+    }
+    public PREV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREV, 0);
+    }
+    public PRINTBLOBTOCLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRINTBLOBTOCLOB, 0);
+    }
+    public PRIORITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIORITY, 0);
+    }
+    public PRIVILEGED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGED, 0);
+    }
+    public PROPERTY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROPERTY, 0);
+    }
+    public PROTOCOL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROTOCOL, 0);
+    }
+    public PROXY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROXY, 0);
+    }
+    public PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRUNING, 0);
+    }
+    public PX_FAULT_TOLERANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PX_FAULT_TOLERANCE, 0);
+    }
+    public QUARTERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUARTERS, 0);
+    }
+    public QUOTAGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUOTAGROUP, 0);
+    }
+    public REALM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REALM, 0);
+    }
+    public REDEFINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDEFINE, 0);
+    }
+    public RELOCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELOCATE, 0);
+    }
+    public REMOTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOTE, 0);
+    }
+    public RESTART(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTART, 0);
+    }
+    public ROLESET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLESET, 0);
+    }
+    public ROWID_MAPPING_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID_MAPPING_TABLE, 0);
+    }
+    public RUNNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RUNNING, 0);
+    }
+    public SAVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAVE, 0);
+    }
+    public SCRUB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCRUB, 0);
+    }
+    public SDO_GEOM_MBR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SDO_GEOM_MBR, 0);
+    }
+    public SECONDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECONDS, 0);
+    }
+    public SECRET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECRET, 0);
+    }
+    public SERIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERIAL, 0);
+    }
+    public SERVICES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVICES, 0);
+    }
+    public SERVICE_NAME_CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVICE_NAME_CONVERT, 0);
+    }
+    public SHARDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARDED, 0);
+    }
+    public SHARING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARING, 0);
+    }
+    public SHELFLIFE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHELFLIFE, 0);
+    }
+    public SITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SITE, 0);
+    }
+    public SOURCE_FILE_DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE_FILE_DIRECTORY, 0);
+    }
+    public SOURCE_FILE_NAME_CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE_FILE_NAME_CONVERT, 0);
+    }
+    public SQL_TRANSLATION_PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL_TRANSLATION_PROFILE, 0);
+    }
+    public STANDARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDARD, 0);
+    }
+    public STANDARD_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDARD_HASH, 0);
+    }
+    public STANDBYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBYS, 0);
+    }
+    public STATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATE, 0);
+    }
+    public STATEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENT, 0);
+    }
+    public STREAM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STREAM, 0);
+    }
+    public SUBSCRIBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSCRIBE, 0);
+    }
+    public SUBSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSET, 0);
+    }
+    public SUCCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUCCESS, 0);
+    }
+    public SYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS, 0);
+    }
+    public SYSBACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSBACKUP, 0);
+    }
+    public SYSDG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSDG, 0);
+    }
+    public SYSGUID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSGUID, 0);
+    }
+    public SYSKM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSKM, 0);
+    }
+    public SYSOBJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSOBJ, 0);
+    }
+    public SYS_CHECK_PRIVILEGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_CHECK_PRIVILEGE, 0);
+    }
+    public SYS_GET_COL_ACLIDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_GET_COL_ACLIDS, 0);
+    }
+    public SYS_MKXTI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_MKXTI, 0);
+    }
+    public SYS_OP_CYCLED_SEQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CYCLED_SEQ, 0);
+    }
+    public SYS_OP_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_HASH, 0);
+    }
+    public SYS_OP_KEY_VECTOR_CREATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_KEY_VECTOR_CREATE, 0);
+    }
+    public SYS_OP_KEY_VECTOR_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_KEY_VECTOR_FILTER, 0);
+    }
+    public SYS_OP_KEY_VECTOR_FILTER_LIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_KEY_VECTOR_FILTER_LIST, 0);
+    }
+    public SYS_OP_KEY_VECTOR_SUCCEEDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_KEY_VECTOR_SUCCEEDED, 0);
+    }
+    public SYS_OP_KEY_VECTOR_USE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_KEY_VECTOR_USE, 0);
+    }
+    public SYS_OP_PART_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_PART_ID, 0);
+    }
+    public SYS_OP_ZONE_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ZONE_ID, 0);
+    }
+    public SYS_RAW_TO_XSID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_RAW_TO_XSID, 0);
+    }
+    public SYS_XSID_TO_RAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XSID_TO_RAW, 0);
+    }
+    public SYS_ZMAP_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ZMAP_FILTER, 0);
+    }
+    public SYS_ZMAP_REFRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ZMAP_REFRESH, 0);
+    }
+    public TAG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TAG, 0);
+    }
+    public TEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEXT, 0);
+    }
+    public TIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIER, 0);
+    }
+    public TIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIES, 0);
+    }
+    public TO_ACLID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_ACLID, 0);
+    }
+    public TRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSFORM, 0);
+    }
+    public TRANSLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATION, 0);
+    }
+    public TRUST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUST, 0);
+    }
+    public UCS2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UCS2, 0);
+    }
+    public UNCONDITIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNCONDITIONAL, 0);
+    }
+    public UNITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNITE, 0);
+    }
+    public UNMATCHED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNMATCHED, 0);
+    }
+    public UNPLUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNPLUG, 0);
+    }
+    public UNSUBSCRIBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNSUBSCRIBE, 0);
+    }
+    public USABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USABLE, 0);
+    }
+    public USER_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER_DATA, 0);
+    }
+    public USER_TABLESPACES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER_TABLESPACES, 0);
+    }
+    public USE_CUBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_CUBE, 0);
+    }
+    public USE_HIDDEN_PARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_HIDDEN_PARTITIONS, 0);
+    }
+    public USE_VECTOR_AGGREGATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_VECTOR_AGGREGATION, 0);
+    }
+    public USING_NO_EXPAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING_NO_EXPAND, 0);
+    }
+    public USING_NLS_COMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING_NLS_COMP, 0);
+    }
+    public UTF16BE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UTF16BE, 0);
+    }
+    public UTF16LE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UTF16LE, 0);
+    }
+    public UTF32(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UTF32, 0);
+    }
+    public UTF8(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UTF8, 0);
+    }
+    public V1(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.V1, 0);
+    }
+    public V2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.V2, 0);
+    }
+    public VALIDATE_CONVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATE_CONVERSION, 0);
+    }
+    public VALID_TIME_END(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALID_TIME_END, 0);
+    }
+    public VECTOR_TRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VECTOR_TRANSFORM, 0);
+    }
+    public VECTOR_TRANSFORM_DIMS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VECTOR_TRANSFORM_DIMS, 0);
+    }
+    public VECTOR_TRANSFORM_FACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VECTOR_TRANSFORM_FACT, 0);
+    }
+    public VERIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERIFIER, 0);
+    }
+    public VIOLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIOLATION, 0);
+    }
+    public VISIBILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBILITY, 0);
+    }
+    public WEEK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WEEK, 0);
+    }
+    public WEEKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WEEKS, 0);
+    }
+    public WITH_PLSQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITH_PLSQL, 0);
+    }
+    public WRAPPER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRAPPER, 0);
+    }
+    public XS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XS, 0);
+    }
+    public YEARS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEARS, 0);
+    }
+    public ZONEMAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONEMAP, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_non_reserved_keywords_in_12c;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNon_reserved_keywords_in_12c) {
+             listener.enterNon_reserved_keywords_in_12c(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNon_reserved_keywords_in_12c) {
+             listener.exitNon_reserved_keywords_in_12c(this);
+        }
+    }
+}
+
+
+export class Non_reserved_keywords_pre12cContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public ABORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ABORT, 0);
+    }
+    public ABS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ABS, 0);
+    }
+    public ACCESSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESSED, 0);
+    }
+    public ACCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCESS, 0);
+    }
+    public ACCOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACCOUNT, 0);
+    }
+    public ACOS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACOS, 0);
+    }
+    public ACTIVATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVATE, 0);
+    }
+    public ACTIVE_COMPONENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVE_COMPONENT, 0);
+    }
+    public ACTIVE_FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVE_FUNCTION, 0);
+    }
+    public ACTIVE_TAG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ACTIVE_TAG, 0);
+    }
+    public ADD_COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD_COLUMN, 0);
+    }
+    public ADD_GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD_GROUP, 0);
+    }
+    public ADD_MONTHS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD_MONTHS, 0);
+    }
+    public ADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADD, 0);
+    }
+    public ADJ_DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADJ_DATE, 0);
+    }
+    public ADMINISTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADMINISTER, 0);
+    }
+    public ADMINISTRATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADMINISTRATOR, 0);
+    }
+    public ADMIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADMIN, 0);
+    }
+    public ADVISE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVISE, 0);
+    }
+    public ADVISOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ADVISOR, 0);
+    }
+    public AFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AFTER, 0);
+    }
+    public ALIAS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALIAS, 0);
+    }
+    public ALLOCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALLOCATE, 0);
+    }
+    public ALLOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALLOW, 0);
+    }
+    public ALL_ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALL_ROWS, 0);
+    }
+    public ALWAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ALWAYS, 0);
+    }
+    public ANALYZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANALYZE, 0);
+    }
+    public ANCILLARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANCILLARY, 0);
+    }
+    public AND_EQUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AND_EQUAL, 0);
+    }
+    public ANTIJOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANTIJOIN, 0);
+    }
+    public ANYSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ANYSCHEMA, 0);
+    }
+    public APPENDCHILDXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPENDCHILDXML, 0);
+    }
+    public APPEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPEND, 0);
+    }
+    public APPEND_VALUES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPEND_VALUES, 0);
+    }
+    public APPLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.APPLY, 0);
+    }
+    public ARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVELOG, 0);
+    }
+    public ARCHIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARCHIVE, 0);
+    }
+    public ARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ARRAY, 0);
+    }
+    public ASCII(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASCII, 0);
+    }
+    public ASCIISTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASCIISTR, 0);
+    }
+    public ASIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASIN, 0);
+    }
+    public ASSEMBLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASSEMBLY, 0);
+    }
+    public ASSOCIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASSOCIATE, 0);
+    }
+    public ASYNCHRONOUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASYNCHRONOUS, 0);
+    }
+    public ASYNC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ASYNC, 0);
+    }
+    public ATAN2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATAN2, 0);
+    }
+    public ATAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATAN, 0);
+    }
+    public AT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AT, 0);
+    }
+    public ATTRIBUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATTRIBUTE, 0);
+    }
+    public ATTRIBUTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ATTRIBUTES, 0);
+    }
+    public AUTHENTICATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHENTICATED, 0);
+    }
+    public AUTHENTICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHENTICATION, 0);
+    }
+    public AUTHID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHID, 0);
+    }
+    public AUTHORIZATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTHORIZATION, 0);
+    }
+    public AUTOALLOCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOALLOCATE, 0);
+    }
+    public AUTOEXTEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOEXTEND, 0);
+    }
+    public AUTOMATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTOMATIC, 0);
+    }
+    public AUTO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AUTO, 0);
+    }
+    public AVAILABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVAILABILITY, 0);
+    }
+    public AVG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.AVG, 0);
+    }
+    public BACKUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BACKUP, 0);
+    }
+    public BASICFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASICFILE, 0);
+    }
+    public BASIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BASIC, 0);
+    }
+    public BATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BATCH, 0);
+    }
+    public BECOME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BECOME, 0);
+    }
+    public BEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEFORE, 0);
+    }
+    public BEGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGIN, 0);
+    }
+    public BEGIN_OUTLINE_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEGIN_OUTLINE_DATA, 0);
+    }
+    public BEHALF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BEHALF, 0);
+    }
+    public BFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BFILE, 0);
+    }
+    public BFILENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BFILENAME, 0);
+    }
+    public BIGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIGFILE, 0);
+    }
+    public BINARY_DOUBLE_INFINITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_DOUBLE_INFINITY, 0);
+    }
+    public BINARY_DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_DOUBLE, 0);
+    }
+    public BINARY_DOUBLE_NAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_DOUBLE_NAN, 0);
+    }
+    public BINARY_FLOAT_INFINITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_FLOAT_INFINITY, 0);
+    }
+    public BINARY_FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_FLOAT, 0);
+    }
+    public BINARY_FLOAT_NAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY_FLOAT_NAN, 0);
+    }
+    public BINARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINARY, 0);
+    }
+    public BIND_AWARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIND_AWARE, 0);
+    }
+    public BINDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BINDING, 0);
+    }
+    public BIN_TO_NUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BIN_TO_NUM, 0);
+    }
+    public BITAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITAND, 0);
+    }
+    public BITMAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITMAP, 0);
+    }
+    public BITMAPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITMAPS, 0);
+    }
+    public BITMAP_TREE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITMAP_TREE, 0);
+    }
+    public BITS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BITS, 0);
+    }
+    public BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOB, 0);
+    }
+    public BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCK, 0);
+    }
+    public BLOCK_RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCK_RANGE, 0);
+    }
+    public BLOCKSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKSIZE, 0);
+    }
+    public BLOCKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BLOCKS, 0);
+    }
+    public BODY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BODY, 0);
+    }
+    public BOTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BOTH, 0);
+    }
+    public BOUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BOUND, 0);
+    }
+    public BRANCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BRANCH, 0);
+    }
+    public BREADTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BREADTH, 0);
+    }
+    public BROADCAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BROADCAST, 0);
+    }
+    public BUFFER_CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BUFFER_CACHE, 0);
+    }
+    public BUFFER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BUFFER, 0);
+    }
+    public BUFFER_POOL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BUFFER_POOL, 0);
+    }
+    public BUILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BUILD, 0);
+    }
+    public BULK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BULK, 0);
+    }
+    public BYPASS_RECURSIVE_CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYPASS_RECURSIVE_CHECK, 0);
+    }
+    public BYPASS_UJVC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYPASS_UJVC, 0);
+    }
+    public BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.BYTE, 0);
+    }
+    public CACHE_CB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE_CB, 0);
+    }
+    public CACHE_INSTANCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE_INSTANCES, 0);
+    }
+    public CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE, 0);
+    }
+    public CACHE_TEMP_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CACHE_TEMP_TABLE, 0);
+    }
+    public CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CALL, 0);
+    }
+    public CANCEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CANCEL, 0);
+    }
+    public CARDINALITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CARDINALITY, 0);
+    }
+    public CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASCADE, 0);
+    }
+    public CASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CASE, 0);
+    }
+    public CAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CAST, 0);
+    }
+    public CATEGORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CATEGORY, 0);
+    }
+    public CEIL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CEIL, 0);
+    }
+    public CELL_FLASH_CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CELL_FLASH_CACHE, 0);
+    }
+    public CERTIFICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CERTIFICATE, 0);
+    }
+    public CFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CFILE, 0);
+    }
+    public CHAINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAINED, 0);
+    }
+    public CHANGE_DUPKEY_ERROR_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHANGE_DUPKEY_ERROR_INDEX, 0);
+    }
+    public CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHANGE, 0);
+    }
+    public CHARACTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARACTER, 0);
+    }
+    public CHAR_CS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHAR_CS, 0);
+    }
+    public CHARTOROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHARTOROWID, 0);
+    }
+    public CHECK_ACL_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECK_ACL_REWRITE, 0);
+    }
+    public CHECKPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHECKPOINT, 0);
+    }
+    public CHILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHILD, 0);
+    }
+    public CHOOSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHOOSE, 0);
+    }
+    public CHR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHR, 0);
+    }
+    public CHUNK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CHUNK, 0);
+    }
+    public CLASS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLASS, 0);
+    }
+    public CLEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLEAR, 0);
+    }
+    public CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOB, 0);
+    }
+    public CLONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLONE, 0);
+    }
+    public CLOSE_CACHED_OPEN_CURSORS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOSE_CACHED_OPEN_CURSORS, 0);
+    }
+    public CLOSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLOSE, 0);
+    }
+    public CLUSTER_BY_ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER_BY_ROWID, 0);
+    }
+    public CLUSTER_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER_ID, 0);
+    }
+    public CLUSTERING_FACTOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTERING_FACTOR, 0);
+    }
+    public CLUSTER_PROBABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER_PROBABILITY, 0);
+    }
+    public CLUSTER_SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CLUSTER_SET, 0);
+    }
+    public COALESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE, 0);
+    }
+    public COALESCE_SQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COALESCE_SQ, 0);
+    }
+    public COARSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COARSE, 0);
+    }
+    public CO_AUTH_IND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CO_AUTH_IND, 0);
+    }
+    public COLD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLD, 0);
+    }
+    public COLLECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLLECT, 0);
+    }
+    public COLUMNAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMNAR, 0);
+    }
+    public COLUMN_AUTH_INDICATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN_AUTH_INDICATOR, 0);
+    }
+    public COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN, 0);
+    }
+    public COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMNS, 0);
+    }
+    public COLUMN_STATS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN_STATS, 0);
+    }
+    public COLUMN_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COLUMN_VALUE, 0);
+    }
+    public COMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMENT, 0);
+    }
+    public COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMIT, 0);
+    }
+    public COMMITTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMMITTED, 0);
+    }
+    public COMPACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPACT, 0);
+    }
+    public COMPATIBILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPATIBILITY, 0);
+    }
+    public COMPILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPILE, 0);
+    }
+    public COMPLETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPLETE, 0);
+    }
+    public COMPLIANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPLIANCE, 0);
+    }
+    public COMPOSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPOSE, 0);
+    }
+    public COMPOSITE_LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPOSITE_LIMIT, 0);
+    }
+    public COMPOSITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPOSITE, 0);
+    }
+    public COMPOUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPOUND, 0);
+    }
+    public COMPUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COMPUTE, 0);
+    }
+    public CONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONCAT, 0);
+    }
+    public CONFIRM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONFIRM, 0);
+    }
+    public CONFORMING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONFORMING, 0);
+    }
+    public CONNECT_BY_CB_WHR_ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_CB_WHR_ONLY, 0);
+    }
+    public CONNECT_BY_COMBINE_SW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_COMBINE_SW, 0);
+    }
+    public CONNECT_BY_COST_BASED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_COST_BASED, 0);
+    }
+    public CONNECT_BY_ELIM_DUPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_ELIM_DUPS, 0);
+    }
+    public CONNECT_BY_FILTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_FILTERING, 0);
+    }
+    public CONNECT_BY_ISCYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_ISCYCLE, 0);
+    }
+    public CONNECT_BY_ISLEAF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_ISLEAF, 0);
+    }
+    public CONNECT_BY_ROOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_BY_ROOT, 0);
+    }
+    public CONNECT_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONNECT_TIME, 0);
+    }
+    public CONSIDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSIDER, 0);
+    }
+    public CONSISTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSISTENT, 0);
+    }
+    public CONSTANT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTANT, 0);
+    }
+    public CONST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONST, 0);
+    }
+    public CONSTRAINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINT, 0);
+    }
+    public CONSTRAINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONSTRAINTS, 0);
+    }
+    public CONTAINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTAINER, 0);
+    }
+    public CONTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTENT, 0);
+    }
+    public CONTENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTENTS, 0);
+    }
+    public CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTEXT, 0);
+    }
+    public CONTINUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTINUE, 0);
+    }
+    public CONTROLFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONTROLFILE, 0);
+    }
+    public CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CONVERT, 0);
+    }
+    public CORR_K(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORR_K, 0);
+    }
+    public CORR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORR, 0);
+    }
+    public CORR_S(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORR_S, 0);
+    }
+    public CORRUPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORRUPTION, 0);
+    }
+    public CORRUPT_XID_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORRUPT_XID_ALL, 0);
+    }
+    public CORRUPT_XID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CORRUPT_XID, 0);
+    }
+    public COSH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COSH, 0);
+    }
+    public COS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COS, 0);
+    }
+    public COST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COST, 0);
+    }
+    public COST_XML_QUERY_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COST_XML_QUERY_REWRITE, 0);
+    }
+    public COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COUNT, 0);
+    }
+    public COVAR_POP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COVAR_POP, 0);
+    }
+    public COVAR_SAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.COVAR_SAMP, 0);
+    }
+    public CPU_COSTING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CPU_COSTING, 0);
+    }
+    public CPU_PER_CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CPU_PER_CALL, 0);
+    }
+    public CPU_PER_SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CPU_PER_SESSION, 0);
+    }
+    public CRASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CRASH, 0);
+    }
+    public CREATE_STORED_OUTLINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATE_STORED_OUTLINES, 0);
+    }
+    public CREATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CREATION, 0);
+    }
+    public CROSSEDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CROSSEDITION, 0);
+    }
+    public CROSS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CROSS, 0);
+    }
+    public CSCONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CSCONVERT, 0);
+    }
+    public CUBE_GB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUBE_GB, 0);
+    }
+    public CUBE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUBE, 0);
+    }
+    public CUME_DISTM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUME_DISTM, 0);
+    }
+    public CUME_DIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CUME_DIST, 0);
+    }
+    public CURRENT_DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_DATE, 0);
+    }
+    public CURRENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT, 0);
+    }
+    public CURRENT_SCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_SCHEMA, 0);
+    }
+    public CURRENT_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_TIME, 0);
+    }
+    public CURRENT_TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_TIMESTAMP, 0);
+    }
+    public CURRENT_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENT_USER, 0);
+    }
+    public CURRENTV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURRENTV, 0);
+    }
+    public CURSOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURSOR, 0);
+    }
+    public CURSOR_SHARING_EXACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURSOR_SHARING_EXACT, 0);
+    }
+    public CURSOR_SPECIFIC_SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CURSOR_SPECIFIC_SEGMENT, 0);
+    }
+    public CV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CV, 0);
+    }
+    public CYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.CYCLE, 0);
+    }
+    public DANGLING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DANGLING, 0);
+    }
+    public DATABASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATABASE, 0);
+    }
+    public DATAFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILE, 0);
+    }
+    public DATAFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAFILES, 0);
+    }
+    public DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATA, 0);
+    }
+    public DATAOBJNO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAOBJNO, 0);
+    }
+    public DATAOBJ_TO_PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATAOBJ_TO_PARTITION, 0);
+    }
+    public DATE_MODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DATE_MODE, 0);
+    }
+    public DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DAY, 0);
+    }
+    public DBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBA, 0);
+    }
+    public DBA_RECYCLEBIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBA_RECYCLEBIN, 0);
+    }
+    public DBLINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBLINK, 0);
+    }
+    public DBMS_STATS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBMS_STATS, 0);
+    }
+    public DB_ROLE_CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DB_ROLE_CHANGE, 0);
+    }
+    public DBTIMEZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DBTIMEZONE, 0);
+    }
+    public DB_VERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DB_VERSION, 0);
+    }
+    public DDL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DDL, 0);
+    }
+    public DEALLOCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEALLOCATE, 0);
+    }
+    public DEBUGGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUGGER, 0);
+    }
+    public DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEBUG, 0);
+    }
+    public DECLARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECLARE, 0);
+    }
+    public DEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEC, 0);
+    }
+    public DECOMPOSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECOMPOSE, 0);
+    }
+    public DECREMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECREMENT, 0);
+    }
+    public DECR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECR, 0);
+    }
+    public DECRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DECRYPT, 0);
+    }
+    public DEDUPLICATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEDUPLICATE, 0);
+    }
+    public DEFAULTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFAULTS, 0);
+    }
+    public DEFERRABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFERRABLE, 0);
+    }
+    public DEFERRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFERRED, 0);
+    }
+    public DEFINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINED, 0);
+    }
+    public DEFINER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEFINER, 0);
+    }
+    public DEGREE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEGREE, 0);
+    }
+    public DELAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELAY, 0);
+    }
+    public DELETEXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DELETEXML, 0);
+    }
+    public DEMAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEMAND, 0);
+    }
+    public DENSE_RANKM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DENSE_RANKM, 0);
+    }
+    public DENSE_RANK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DENSE_RANK, 0);
+    }
+    public DEPENDENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEPENDENT, 0);
+    }
+    public DEPTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEPTH, 0);
+    }
+    public DEQUEUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEQUEUE, 0);
+    }
+    public DEREF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEREF, 0);
+    }
+    public DEREF_NO_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DEREF_NO_REWRITE, 0);
+    }
+    public DETACHED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DETACHED, 0);
+    }
+    public DETERMINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DETERMINES, 0);
+    }
+    public DICTIONARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DICTIONARY, 0);
+    }
+    public DIMENSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIMENSION, 0);
+    }
+    public DIRECT_LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECT_LOAD, 0);
+    }
+    public DIRECTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECTORY, 0);
+    }
+    public DIRECT_PATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DIRECT_PATH, 0);
+    }
+    public DISABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE, 0);
+    }
+    public DISABLE_PRESET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE_PRESET, 0);
+    }
+    public DISABLE_RPKE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISABLE_RPKE, 0);
+    }
+    public DISALLOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISALLOW, 0);
+    }
+    public DISASSOCIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISASSOCIATE, 0);
+    }
+    public DISCONNECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISCONNECT, 0);
+    }
+    public DISKGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISKGROUP, 0);
+    }
+    public DISK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISK, 0);
+    }
+    public DISKS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISKS, 0);
+    }
+    public DISMOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISMOUNT, 0);
+    }
+    public DISTINGUISHED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTINGUISHED, 0);
+    }
+    public DISTRIBUTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DISTRIBUTED, 0);
+    }
+    public DML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DML, 0);
+    }
+    public DML_UPDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DML_UPDATE, 0);
+    }
+    public DOCFIDELITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOCFIDELITY, 0);
+    }
+    public DOCUMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOCUMENT, 0);
+    }
+    public DOMAIN_INDEX_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOMAIN_INDEX_FILTER, 0);
+    }
+    public DOMAIN_INDEX_NO_SORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOMAIN_INDEX_NO_SORT, 0);
+    }
+    public DOMAIN_INDEX_SORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOMAIN_INDEX_SORT, 0);
+    }
+    public DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOUBLE, 0);
+    }
+    public DOWNGRADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DOWNGRADE, 0);
+    }
+    public DRIVING_SITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DRIVING_SITE, 0);
+    }
+    public DROP_COLUMN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP_COLUMN, 0);
+    }
+    public DROP_GROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DROP_GROUP, 0);
+    }
+    public DST_UPGRADE_INSERT_CONV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DST_UPGRADE_INSERT_CONV, 0);
+    }
+    public DUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DUMP, 0);
+    }
+    public DYNAMIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DYNAMIC, 0);
+    }
+    public DYNAMIC_SAMPLING_EST_CDN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DYNAMIC_SAMPLING_EST_CDN, 0);
+    }
+    public DYNAMIC_SAMPLING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.DYNAMIC_SAMPLING, 0);
+    }
+    public EACH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EACH, 0);
+    }
+    public EDITIONING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONING, 0);
+    }
+    public EDITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITION, 0);
+    }
+    public EDITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EDITIONS, 0);
+    }
+    public ELEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELEMENT, 0);
+    }
+    public ELIMINATE_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELIMINATE_JOIN, 0);
+    }
+    public ELIMINATE_OBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELIMINATE_OBY, 0);
+    }
+    public ELIMINATE_OUTER_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ELIMINATE_OUTER_JOIN, 0);
+    }
+    public EMPTY_BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_BLOB, 0);
+    }
+    public EMPTY_CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_CLOB, 0);
+    }
+    public EMPTY_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EMPTY_, 0);
+    }
+    public ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE, 0);
+    }
+    public ENABLE_PRESET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENABLE_PRESET, 0);
+    }
+    public ENCODING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCODING, 0);
+    }
+    public ENCRYPTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPTION, 0);
+    }
+    public ENCRYPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENCRYPT, 0);
+    }
+    public END_OUTLINE_DATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.END_OUTLINE_DATA, 0);
+    }
+    public ENFORCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENFORCED, 0);
+    }
+    public ENFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENFORCE, 0);
+    }
+    public ENQUEUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENQUEUE, 0);
+    }
+    public ENTERPRISE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENTERPRISE, 0);
+    }
+    public ENTITYESCAPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENTITYESCAPING, 0);
+    }
+    public ENTRY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ENTRY, 0);
+    }
+    public ERROR_ARGUMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR_ARGUMENT, 0);
+    }
+    public ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR, 0);
+    }
+    public ERROR_ON_OVERLAP_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERROR_ON_OVERLAP_TIME, 0);
+    }
+    public ERRORS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ERRORS, 0);
+    }
+    public ESCAPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ESCAPE, 0);
+    }
+    public ESTIMATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ESTIMATE, 0);
+    }
+    public EVALNAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALNAME, 0);
+    }
+    public EVALUATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVALUATION, 0);
+    }
+    public EVENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVENTS, 0);
+    }
+    public EVERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EVERY, 0);
+    }
+    public EXCEPTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPTIONS, 0);
+    }
+    public EXCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCEPT, 0);
+    }
+    public EXCHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCHANGE, 0);
+    }
+    public EXCLUDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDE, 0);
+    }
+    public EXCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXCLUDING, 0);
+    }
+    public EXECUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXECUTE, 0);
+    }
+    public EXEMPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXEMPT, 0);
+    }
+    public EXISTSNODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXISTSNODE, 0);
+    }
+    public EXPAND_GSET_TO_UNION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPAND_GSET_TO_UNION, 0);
+    }
+    public EXPAND_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPAND_TABLE, 0);
+    }
+    public EXPIRE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPIRE, 0);
+    }
+    public EXPLAIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPLAIN, 0);
+    }
+    public EXPLOSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPLOSION, 0);
+    }
+    public EXP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXP, 0);
+    }
+    public EXPORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPORT, 0);
+    }
+    public EXPR_CORR_CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXPR_CORR_CHECK, 0);
+    }
+    public EXTENDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENDS, 0);
+    }
+    public EXTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENT, 0);
+    }
+    public EXTENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTENTS, 0);
+    }
+    public EXTERNALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNALLY, 0);
+    }
+    public EXTERNAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTERNAL, 0);
+    }
+    public EXTRACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTRACT, 0);
+    }
+    public EXTRACTVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTRACTVALUE, 0);
+    }
+    public EXTRA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.EXTRA, 0);
+    }
+    public FACILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FACILITY, 0);
+    }
+    public FACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FACT, 0);
+    }
+    public FACTORIZE_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FACTORIZE_JOIN, 0);
+    }
+    public FAILED_LOGIN_ATTEMPTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILED_LOGIN_ATTEMPTS, 0);
+    }
+    public FAILED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILED, 0);
+    }
+    public FAILGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAILGROUP, 0);
+    }
+    public FALSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FALSE, 0);
+    }
+    public FAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FAST, 0);
+    }
+    public FBTSCAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FBTSCAN, 0);
+    }
+    public FEATURE_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FEATURE_ID, 0);
+    }
+    public FEATURE_SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FEATURE_SET, 0);
+    }
+    public FEATURE_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FEATURE_VALUE, 0);
+    }
+    public FILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILE, 0);
+    }
+    public FILESYSTEM_LIKE_LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILESYSTEM_LIKE_LOGGING, 0);
+    }
+    public FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FILTER, 0);
+    }
+    public FINAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINAL, 0);
+    }
+    public FINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINE, 0);
+    }
+    public FINISH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FINISH, 0);
+    }
+    public FIRSTM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRSTM, 0);
+    }
+    public FIRST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST, 0);
+    }
+    public FIRST_ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST_ROWS, 0);
+    }
+    public FIRST_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FIRST_VALUE, 0);
+    }
+    public FLAGGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLAGGER, 0);
+    }
+    public FLASHBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASHBACK, 0);
+    }
+    public FLASH_CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLASH_CACHE, 0);
+    }
+    public FLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLOB, 0);
+    }
+    public FLOOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLOOR, 0);
+    }
+    public FLUSH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FLUSH, 0);
+    }
+    public FOLDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOLDER, 0);
+    }
+    public FOLLOWING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOLLOWING, 0);
+    }
+    public FOLLOWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOLLOWS, 0);
+    }
+    public FORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE, 0);
+    }
+    public FORCE_XML_QUERY_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORCE_XML_QUERY_REWRITE, 0);
+    }
+    public FOREIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOREIGN, 0);
+    }
+    public FOREVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FOREVER, 0);
+    }
+    public FORWARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FORWARD, 0);
+    }
+    public FRAGMENT_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FRAGMENT_NUMBER, 0);
+    }
+    public FREELIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FREELIST, 0);
+    }
+    public FREELISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FREELISTS, 0);
+    }
+    public FREEPOOLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FREEPOOLS, 0);
+    }
+    public FRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FRESH, 0);
+    }
+    public FROM_TZ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FROM_TZ, 0);
+    }
+    public FULL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FULL, 0);
+    }
+    public FULL_OUTER_JOIN_TO_OUTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FULL_OUTER_JOIN_TO_OUTER, 0);
+    }
+    public FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FUNCTION, 0);
+    }
+    public FUNCTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.FUNCTIONS, 0);
+    }
+    public GATHER_PLAN_STATISTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GATHER_PLAN_STATISTICS, 0);
+    }
+    public GBY_CONC_ROLLUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GBY_CONC_ROLLUP, 0);
+    }
+    public GBY_PUSHDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GBY_PUSHDOWN, 0);
+    }
+    public GENERATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GENERATED, 0);
+    }
+    public GLOBALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBALLY, 0);
+    }
+    public GLOBAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL, 0);
+    }
+    public GLOBAL_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL_NAME, 0);
+    }
+    public GLOBAL_TOPIC_ENABLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GLOBAL_TOPIC_ENABLED, 0);
+    }
+    public GREATEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GREATEST, 0);
+    }
+    public GROUP_BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP_BY, 0);
+    }
+    public GROUP_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUP_ID, 0);
+    }
+    public GROUPING_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUPING_ID, 0);
+    }
+    public GROUPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUPING, 0);
+    }
+    public GROUPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GROUPS, 0);
+    }
+    public GUARANTEED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GUARANTEED, 0);
+    }
+    public GUARANTEE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GUARANTEE, 0);
+    }
+    public GUARD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.GUARD, 0);
+    }
+    public HASH_AJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASH_AJ, 0);
+    }
+    public HASHKEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASHKEYS, 0);
+    }
+    public HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASH, 0);
+    }
+    public HASH_SJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HASH_SJ, 0);
+    }
+    public HEADER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEADER, 0);
+    }
+    public HEAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEAP, 0);
+    }
+    public HELP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HELP, 0);
+    }
+    public HEXTORAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEXTORAW, 0);
+    }
+    public HEXTOREF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HEXTOREF, 0);
+    }
+    public HIDDEN_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIDDEN_KEYWORD, 0);
+    }
+    public HIDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIDE, 0);
+    }
+    public HIERARCHY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIERARCHY, 0);
+    }
+    public HIGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HIGH, 0);
+    }
+    public HINTSET_BEGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HINTSET_BEGIN, 0);
+    }
+    public HINTSET_END(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HINTSET_END, 0);
+    }
+    public HOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HOT, 0);
+    }
+    public HOUR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HOUR, 0);
+    }
+    public HWM_BROKERED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HWM_BROKERED, 0);
+    }
+    public HYBRID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.HYBRID, 0);
+    }
+    public IDENTIFIER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTIFIER, 0);
+    }
+    public IDENTITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDENTITY, 0);
+    }
+    public IDGENERATORS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDGENERATORS, 0);
+    }
+    public IDLE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IDLE_TIME, 0);
+    }
+    public ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ID, 0);
+    }
+    public IF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IF, 0);
+    }
+    public IGNORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE, 0);
+    }
+    public IGNORE_OPTIM_EMBEDDED_HINTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE_OPTIM_EMBEDDED_HINTS, 0);
+    }
+    public IGNORE_ROW_ON_DUPKEY_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE_ROW_ON_DUPKEY_INDEX, 0);
+    }
+    public IGNORE_WHERE_CLAUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IGNORE_WHERE_CLAUSE, 0);
+    }
+    public IMMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMMEDIATE, 0);
+    }
+    public IMPACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMPACT, 0);
+    }
+    public IMPORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IMPORT, 0);
+    }
+    public INCLUDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDE, 0);
+    }
+    public INCLUDE_VERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDE_VERSION, 0);
+    }
+    public INCLUDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCLUDING, 0);
+    }
+    public INCREMENTAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCREMENTAL, 0);
+    }
+    public INCREMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCREMENT, 0);
+    }
+    public INCR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INCR, 0);
+    }
+    public INDENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDENT, 0);
+    }
+    public INDEX_ASC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_ASC, 0);
+    }
+    public INDEX_COMBINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_COMBINE, 0);
+    }
+    public INDEX_DESC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_DESC, 0);
+    }
+    public INDEXED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXED, 0);
+    }
+    public INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXES, 0);
+    }
+    public INDEX_FFS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_FFS, 0);
+    }
+    public INDEX_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_FILTER, 0);
+    }
+    public INDEX_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_JOIN, 0);
+    }
+    public INDEX_ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_ROWS, 0);
+    }
+    public INDEX_RRS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_RRS, 0);
+    }
+    public INDEX_RS_ASC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_RS_ASC, 0);
+    }
+    public INDEX_RS_DESC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_RS_DESC, 0);
+    }
+    public INDEX_RS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_RS, 0);
+    }
+    public INDEX_SCAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_SCAN, 0);
+    }
+    public INDEX_SKIP_SCAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_SKIP_SCAN, 0);
+    }
+    public INDEX_SS_ASC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_SS_ASC, 0);
+    }
+    public INDEX_SS_DESC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_SS_DESC, 0);
+    }
+    public INDEX_SS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_SS, 0);
+    }
+    public INDEX_STATS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEX_STATS, 0);
+    }
+    public INDEXTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXTYPE, 0);
+    }
+    public INDEXTYPES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDEXTYPES, 0);
+    }
+    public INDICATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INDICATOR, 0);
+    }
+    public INFINITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INFINITE, 0);
+    }
+    public INFORMATIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INFORMATIONAL, 0);
+    }
+    public INITCAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITCAP, 0);
+    }
+    public INITIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITIALIZED, 0);
+    }
+    public INITIALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITIALLY, 0);
+    }
+    public INITIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITIAL, 0);
+    }
+    public INITRANS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INITRANS, 0);
+    }
+    public INLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INLINE, 0);
+    }
+    public INLINE_XMLTYPE_NT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INLINE_XMLTYPE_NT, 0);
+    }
+    public IN_MEMORY_METADATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN_MEMORY_METADATA, 0);
+    }
+    public INNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INNER, 0);
+    }
+    public INSERTCHILDXMLAFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERTCHILDXMLAFTER, 0);
+    }
+    public INSERTCHILDXMLBEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERTCHILDXMLBEFORE, 0);
+    }
+    public INSERTCHILDXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERTCHILDXML, 0);
+    }
+    public INSERTXMLAFTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERTXMLAFTER, 0);
+    }
+    public INSERTXMLBEFORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSERTXMLBEFORE, 0);
+    }
+    public INSTANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANCE, 0);
+    }
+    public INSTANCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANCES, 0);
+    }
+    public INSTANTIABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANTIABLE, 0);
+    }
+    public INSTANTLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTANTLY, 0);
+    }
+    public INSTEAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTEAD, 0);
+    }
+    public INSTR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTR2, 0);
+    }
+    public INSTR4(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTR4, 0);
+    }
+    public INSTRB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTRB, 0);
+    }
+    public INSTRC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTRC, 0);
+    }
+    public INSTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INSTR, 0);
+    }
+    public INTERMEDIATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERMEDIATE, 0);
+    }
+    public INTERNAL_CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERNAL_CONVERT, 0);
+    }
+    public INTERNAL_USE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERNAL_USE, 0);
+    }
+    public INTERPRETED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERPRETED, 0);
+    }
+    public INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INTERVAL, 0);
+    }
+    public INT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INT, 0);
+    }
+    public INVALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVALIDATE, 0);
+    }
+    public INVISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.INVISIBLE, 0);
+    }
+    public IN_XQUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.IN_XQUERY, 0);
+    }
+    public ISOLATION_LEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ISOLATION_LEVEL, 0);
+    }
+    public ISOLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ISOLATION, 0);
+    }
+    public ITERATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ITERATE, 0);
+    }
+    public ITERATION_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ITERATION_NUMBER, 0);
+    }
+    public JAVA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JAVA, 0);
+    }
+    public JOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JOB, 0);
+    }
+    public JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.JOIN, 0);
+    }
+    public KEEP_DUPLICATES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP_DUPLICATES, 0);
+    }
+    public KEEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEEP, 0);
+    }
+    public KERBEROS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KERBEROS, 0);
+    }
+    public KEY_LENGTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY_LENGTH, 0);
+    }
+    public KEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEY, 0);
+    }
+    public KEYSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYSIZE, 0);
+    }
+    public KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KEYS, 0);
+    }
+    public KILL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.KILL, 0);
+    }
+    public LAG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAG, 0);
+    }
+    public LAST_DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST_DAY, 0);
+    }
+    public LAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST, 0);
+    }
+    public LAST_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAST_VALUE, 0);
+    }
+    public LATERAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LATERAL, 0);
+    }
+    public LAYER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LAYER, 0);
+    }
+    public LDAP_REGISTRATION_ENABLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LDAP_REGISTRATION_ENABLED, 0);
+    }
+    public LDAP_REGISTRATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LDAP_REGISTRATION, 0);
+    }
+    public LDAP_REG_SYNC_INTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LDAP_REG_SYNC_INTERVAL, 0);
+    }
+    public LEADING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEADING, 0);
+    }
+    public LEAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAD, 0);
+    }
+    public LEAF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAF, 0);
+    }
+    public LEAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEAST, 0);
+    }
+    public LEFT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEFT, 0);
+    }
+    public LENGTH2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LENGTH2, 0);
+    }
+    public LENGTH4(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LENGTH4, 0);
+    }
+    public LENGTHB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LENGTHB, 0);
+    }
+    public LENGTHC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LENGTHC, 0);
+    }
+    public LENGTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LENGTH, 0);
+    }
+    public LESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LESS, 0);
+    }
+    public LEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVEL, 0);
+    }
+    public LEVELS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LEVELS, 0);
+    }
+    public LIBRARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIBRARY, 0);
+    }
+    public LIFE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIFE, 0);
+    }
+    public LIFETIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIFETIME, 0);
+    }
+    public LIKE2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE2, 0);
+    }
+    public LIKE4(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE4, 0);
+    }
+    public LIKEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKEC, 0);
+    }
+    public LIKE_EXPAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIKE_EXPAND, 0);
+    }
+    public LIMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIMIT, 0);
+    }
+    public LINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LINK, 0);
+    }
+    public LISTAGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LISTAGG, 0);
+    }
+    public LIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LIST, 0);
+    }
+    public LN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LN, 0);
+    }
+    public LNNVL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LNNVL, 0);
+    }
+    public LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOAD, 0);
+    }
+    public LOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOB, 0);
+    }
+    public LOBNVL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOBNVL, 0);
+    }
+    public LOBS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOBS, 0);
+    }
+    public LOCAL_INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL_INDEXES, 0);
+    }
+    public LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCAL, 0);
+    }
+    public LOCALTIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCALTIME, 0);
+    }
+    public LOCALTIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCALTIMESTAMP, 0);
+    }
+    public LOCATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCATION, 0);
+    }
+    public LOCATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCATOR, 0);
+    }
+    public LOCKED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOCKED, 0);
+    }
+    public LOGFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILE, 0);
+    }
+    public LOGFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGFILES, 0);
+    }
+    public LOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGGING, 0);
+    }
+    public LOGICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL, 0);
+    }
+    public LOGICAL_READS_PER_CALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL_READS_PER_CALL, 0);
+    }
+    public LOGICAL_READS_PER_SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGICAL_READS_PER_SESSION, 0);
+    }
+    public LOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOG, 0);
+    }
+    public LOGOFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGOFF, 0);
+    }
+    public LOGON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOGON, 0);
+    }
+    public LOG_READ_ONLY_VIOLATIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOG_READ_ONLY_VIOLATIONS, 0);
+    }
+    public LOWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOWER, 0);
+    }
+    public LOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LOW, 0);
+    }
+    public LPAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LPAD, 0);
+    }
+    public LTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.LTRIM, 0);
+    }
+    public MAIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAIN, 0);
+    }
+    public MAKE_REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAKE_REF, 0);
+    }
+    public MANAGED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGED, 0);
+    }
+    public MANAGEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGEMENT, 0);
+    }
+    public MANAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGE, 0);
+    }
+    public MANAGER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANAGER, 0);
+    }
+    public MANUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MANUAL, 0);
+    }
+    public MAPPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAPPING, 0);
+    }
+    public MASTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MASTER, 0);
+    }
+    public MATCHED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATCHED, 0);
+    }
+    public MATERIALIZED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATERIALIZED, 0);
+    }
+    public MATERIALIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MATERIALIZE, 0);
+    }
+    public MAXARCHLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXARCHLOGS, 0);
+    }
+    public MAXDATAFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXDATAFILES, 0);
+    }
+    public MAXEXTENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXEXTENTS, 0);
+    }
+    public MAXIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXIMIZE, 0);
+    }
+    public MAXINSTANCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXINSTANCES, 0);
+    }
+    public MAXLOGFILES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGFILES, 0);
+    }
+    public MAXLOGHISTORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGHISTORY, 0);
+    }
+    public MAXLOGMEMBERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXLOGMEMBERS, 0);
+    }
+    public MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAX, 0);
+    }
+    public MAXSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXSIZE, 0);
+    }
+    public MAXTRANS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXTRANS, 0);
+    }
+    public MAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MAXVALUE, 0);
+    }
+    public MEASURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEASURE, 0);
+    }
+    public MEASURES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEASURES, 0);
+    }
+    public MEDIAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEDIAN, 0);
+    }
+    public MEDIUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEDIUM, 0);
+    }
+    public MEMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMBER, 0);
+    }
+    public MEMOPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMOPTIMIZE, 0);
+    }
+    public MEMORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MEMORY, 0);
+    }
+    public MERGEACTIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGEACTIONS, 0);
+    }
+    public MERGE_AJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGE_AJ, 0);
+    }
+    public MERGE_CONST_ON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGE_CONST_ON, 0);
+    }
+    public MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGE, 0);
+    }
+    public MERGE_SJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MERGE_SJ, 0);
+    }
+    public METHOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.METHOD, 0);
+    }
+    public MIGRATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIGRATE, 0);
+    }
+    public MIGRATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIGRATION, 0);
+    }
+    public MINEXTENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINEXTENTS, 0);
+    }
+    public MINIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINIMIZE, 0);
+    }
+    public MINIMUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINIMUM, 0);
+    }
+    public MINING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINING, 0);
+    }
+    public MIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIN, 0);
+    }
+    public MINUS_NULL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUS_NULL, 0);
+    }
+    public MINUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINUTE, 0);
+    }
+    public MINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MINVALUE, 0);
+    }
+    public MIRRORCOLD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIRRORCOLD, 0);
+    }
+    public MIRRORHOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIRRORHOT, 0);
+    }
+    public MIRROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MIRROR, 0);
+    }
+    public MLSLABEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MLSLABEL, 0);
+    }
+    public MODEL_COMPILE_SUBQUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_COMPILE_SUBQUERY, 0);
+    }
+    public MODEL_DONTVERIFY_UNIQUENESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_DONTVERIFY_UNIQUENESS, 0);
+    }
+    public MODEL_DYNAMIC_SUBQUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_DYNAMIC_SUBQUERY, 0);
+    }
+    public MODEL_MIN_ANALYSIS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_MIN_ANALYSIS, 0);
+    }
+    public MODEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL, 0);
+    }
+    public MODEL_NO_ANALYSIS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_NO_ANALYSIS, 0);
+    }
+    public MODEL_PBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_PBY, 0);
+    }
+    public MODEL_PUSH_REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODEL_PUSH_REF, 0);
+    }
+    public MODIFY_COLUMN_TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY_COLUMN_TYPE, 0);
+    }
+    public MODIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MODIFY, 0);
+    }
+    public MOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOD, 0);
+    }
+    public MONITORING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONITORING, 0);
+    }
+    public MONITOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONITOR, 0);
+    }
+    public MONTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTH, 0);
+    }
+    public MONTHS_BETWEEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MONTHS_BETWEEN, 0);
+    }
+    public MOUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNT, 0);
+    }
+    public MOUNTPATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOUNTPATH, 0);
+    }
+    public MOVEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOVEMENT, 0);
+    }
+    public MOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MOVE, 0);
+    }
+    public MULTISET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MULTISET, 0);
+    }
+    public MV_MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.MV_MERGE, 0);
+    }
+    public NAMED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAMED, 0);
+    }
+    public NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAME, 0);
+    }
+    public NAMESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAMESPACE, 0);
+    }
+    public NAN_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAN_, 0);
+    }
+    public NANVL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NANVL, 0);
+    }
+    public NATIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATIONAL, 0);
+    }
+    public NATIVE_FULL_OUTER_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATIVE_FULL_OUTER_JOIN, 0);
+    }
+    public NATIVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATIVE, 0);
+    }
+    public NATURAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NATURAL, 0);
+    }
+    public NAV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NAV, 0);
+    }
+    public NCHAR_CS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCHAR_CS, 0);
+    }
+    public NCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCHAR, 0);
+    }
+    public NCHR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCHR, 0);
+    }
+    public NCLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NCLOB, 0);
+    }
+    public NEEDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEEDED, 0);
+    }
+    public NESTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED, 0);
+    }
+    public NESTED_TABLE_FAST_INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED_TABLE_FAST_INSERT, 0);
+    }
+    public NESTED_TABLE_GET_REFS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED_TABLE_GET_REFS, 0);
+    }
+    public NESTED_TABLE_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED_TABLE_ID, 0);
+    }
+    public NESTED_TABLE_SET_REFS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED_TABLE_SET_REFS, 0);
+    }
+    public NESTED_TABLE_SET_SETID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NESTED_TABLE_SET_SETID, 0);
+    }
+    public NETWORK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NETWORK, 0);
+    }
+    public NEVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEVER, 0);
+    }
+    public NEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEW, 0);
+    }
+    public NEW_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEW_TIME, 0);
+    }
+    public NEXT_DAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEXT_DAY, 0);
+    }
+    public NEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NEXT, 0);
+    }
+    public NL_AJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NL_AJ, 0);
+    }
+    public NLJ_BATCHING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLJ_BATCHING, 0);
+    }
+    public NLJ_INDEX_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLJ_INDEX_FILTER, 0);
+    }
+    public NLJ_INDEX_SCAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLJ_INDEX_SCAN, 0);
+    }
+    public NLJ_PREFETCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLJ_PREFETCH, 0);
+    }
+    public NLS_CALENDAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_CALENDAR, 0);
+    }
+    public NLS_CHARACTERSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_CHARACTERSET, 0);
+    }
+    public NLS_CHARSET_DECL_LEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_CHARSET_DECL_LEN, 0);
+    }
+    public NLS_CHARSET_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_CHARSET_ID, 0);
+    }
+    public NLS_CHARSET_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_CHARSET_NAME, 0);
+    }
+    public NLS_COMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_COMP, 0);
+    }
+    public NLS_CURRENCY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_CURRENCY, 0);
+    }
+    public NLS_DATE_FORMAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_DATE_FORMAT, 0);
+    }
+    public NLS_DATE_LANGUAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_DATE_LANGUAGE, 0);
+    }
+    public NLS_INITCAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_INITCAP, 0);
+    }
+    public NLS_ISO_CURRENCY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_ISO_CURRENCY, 0);
+    }
+    public NL_SJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NL_SJ, 0);
+    }
+    public NLS_LANG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_LANG, 0);
+    }
+    public NLS_LANGUAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_LANGUAGE, 0);
+    }
+    public NLS_LENGTH_SEMANTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_LENGTH_SEMANTICS, 0);
+    }
+    public NLS_LOWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_LOWER, 0);
+    }
+    public NLS_NCHAR_CONV_EXCP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_NCHAR_CONV_EXCP, 0);
+    }
+    public NLS_NUMERIC_CHARACTERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_NUMERIC_CHARACTERS, 0);
+    }
+    public NLS_SORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_SORT, 0);
+    }
+    public NLSSORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLSSORT, 0);
+    }
+    public NLS_SPECIAL_CHARS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_SPECIAL_CHARS, 0);
+    }
+    public NLS_TERRITORY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_TERRITORY, 0);
+    }
+    public NLS_UPPER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NLS_UPPER, 0);
+    }
+    public NO_ACCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ACCESS, 0);
+    }
+    public NOAPPEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOAPPEND, 0);
+    }
+    public NOARCHIVELOG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOARCHIVELOG, 0);
+    }
+    public NOAUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOAUDIT, 0);
+    }
+    public NO_BASETABLE_MULTIMV_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_BASETABLE_MULTIMV_REWRITE, 0);
+    }
+    public NO_BIND_AWARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_BIND_AWARE, 0);
+    }
+    public NO_BUFFER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_BUFFER, 0);
+    }
+    public NOCACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCACHE, 0);
+    }
+    public NO_CARTESIAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CARTESIAN, 0);
+    }
+    public NO_CHECK_ACL_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CHECK_ACL_REWRITE, 0);
+    }
+    public NO_CLUSTER_BY_ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CLUSTER_BY_ROWID, 0);
+    }
+    public NO_COALESCE_SQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_COALESCE_SQ, 0);
+    }
+    public NO_CONNECT_BY_CB_WHR_ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CONNECT_BY_CB_WHR_ONLY, 0);
+    }
+    public NO_CONNECT_BY_COMBINE_SW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CONNECT_BY_COMBINE_SW, 0);
+    }
+    public NO_CONNECT_BY_COST_BASED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CONNECT_BY_COST_BASED, 0);
+    }
+    public NO_CONNECT_BY_ELIM_DUPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CONNECT_BY_ELIM_DUPS, 0);
+    }
+    public NO_CONNECT_BY_FILTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CONNECT_BY_FILTERING, 0);
+    }
+    public NO_COST_XML_QUERY_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_COST_XML_QUERY_REWRITE, 0);
+    }
+    public NO_CPU_COSTING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_CPU_COSTING, 0);
+    }
+    public NOCPU_COSTING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCPU_COSTING, 0);
+    }
+    public NOCYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOCYCLE, 0);
+    }
+    public NODELAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NODELAY, 0);
+    }
+    public NO_DOMAIN_INDEX_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_DOMAIN_INDEX_FILTER, 0);
+    }
+    public NO_DST_UPGRADE_INSERT_CONV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_DST_UPGRADE_INSERT_CONV, 0);
+    }
+    public NO_ELIMINATE_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ELIMINATE_JOIN, 0);
+    }
+    public NO_ELIMINATE_OBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ELIMINATE_OBY, 0);
+    }
+    public NO_ELIMINATE_OUTER_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ELIMINATE_OUTER_JOIN, 0);
+    }
+    public NOENTITYESCAPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOENTITYESCAPING, 0);
+    }
+    public NO_EXPAND_GSET_TO_UNION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_EXPAND_GSET_TO_UNION, 0);
+    }
+    public NO_EXPAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_EXPAND, 0);
+    }
+    public NO_EXPAND_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_EXPAND_TABLE, 0);
+    }
+    public NO_FACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_FACT, 0);
+    }
+    public NO_FACTORIZE_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_FACTORIZE_JOIN, 0);
+    }
+    public NO_FILTERING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_FILTERING, 0);
+    }
+    public NOFORCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOFORCE, 0);
+    }
+    public NO_FULL_OUTER_JOIN_TO_OUTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_FULL_OUTER_JOIN_TO_OUTER, 0);
+    }
+    public NO_GBY_PUSHDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_GBY_PUSHDOWN, 0);
+    }
+    public NOGUARANTEE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOGUARANTEE, 0);
+    }
+    public NO_INDEX_FFS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_INDEX_FFS, 0);
+    }
+    public NO_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_INDEX, 0);
+    }
+    public NO_INDEX_SS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_INDEX_SS, 0);
+    }
+    public NO_LOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_LOAD, 0);
+    }
+    public NOLOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOCAL, 0);
+    }
+    public NOLOGGING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOLOGGING, 0);
+    }
+    public NOMAPPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMAPPING, 0);
+    }
+    public NOMAXVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMAXVALUE, 0);
+    }
+    public NO_MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_MERGE, 0);
+    }
+    public NOMINIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMINIMIZE, 0);
+    }
+    public NOMINVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMINVALUE, 0);
+    }
+    public NO_MODEL_PUSH_REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_MODEL_PUSH_REF, 0);
+    }
+    public NO_MONITORING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_MONITORING, 0);
+    }
+    public NOMONITORING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOMONITORING, 0);
+    }
+    public NO_MONITOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_MONITOR, 0);
+    }
+    public NO_MULTIMV_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_MULTIMV_REWRITE, 0);
+    }
+    public NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO, 0);
+    }
+    public NO_NATIVE_FULL_OUTER_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_NATIVE_FULL_OUTER_JOIN, 0);
+    }
+    public NONBLOCKING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONBLOCKING, 0);
+    }
+    public NONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONE, 0);
+    }
+    public NO_NLJ_BATCHING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_NLJ_BATCHING, 0);
+    }
+    public NO_NLJ_PREFETCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_NLJ_PREFETCH, 0);
+    }
+    public NONSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NONSCHEMA, 0);
+    }
+    public NOORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOORDER, 0);
+    }
+    public NO_ORDER_ROLLUPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_ORDER_ROLLUPS, 0);
+    }
+    public NO_OUTER_JOIN_TO_ANTI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_OUTER_JOIN_TO_ANTI, 0);
+    }
+    public NO_OUTER_JOIN_TO_INNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_OUTER_JOIN_TO_INNER, 0);
+    }
+    public NOOVERRIDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOOVERRIDE, 0);
+    }
+    public NO_PARALLEL_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PARALLEL_INDEX, 0);
+    }
+    public NOPARALLEL_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOPARALLEL_INDEX, 0);
+    }
+    public NO_PARALLEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PARALLEL, 0);
+    }
+    public NOPARALLEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOPARALLEL, 0);
+    }
+    public NO_PARTIAL_COMMIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PARTIAL_COMMIT, 0);
+    }
+    public NO_PLACE_DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PLACE_DISTINCT, 0);
+    }
+    public NO_PLACE_GROUP_BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PLACE_GROUP_BY, 0);
+    }
+    public NO_PQ_MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PQ_MAP, 0);
+    }
+    public NO_PRUNE_GSETS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PRUNE_GSETS, 0);
+    }
+    public NO_PULL_PRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PULL_PRED, 0);
+    }
+    public NO_PUSH_PRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PUSH_PRED, 0);
+    }
+    public NO_PUSH_SUBQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PUSH_SUBQ, 0);
+    }
+    public NO_PX_JOIN_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_PX_JOIN_FILTER, 0);
+    }
+    public NO_QKN_BUFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_QKN_BUFF, 0);
+    }
+    public NO_QUERY_TRANSFORMATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_QUERY_TRANSFORMATION, 0);
+    }
+    public NO_REF_CASCADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_REF_CASCADE, 0);
+    }
+    public NORELY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORELY, 0);
+    }
+    public NOREPAIR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREPAIR, 0);
+    }
+    public NORESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORESETLOGS, 0);
+    }
+    public NO_RESULT_CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_RESULT_CACHE, 0);
+    }
+    public NOREVERSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREVERSE, 0);
+    }
+    public NO_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_REWRITE, 0);
+    }
+    public NOREWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOREWRITE, 0);
+    }
+    public NORMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NORMAL, 0);
+    }
+    public NOROWDEPENDENCIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOROWDEPENDENCIES, 0);
+    }
+    public NOSCHEMACHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSCHEMACHECK, 0);
+    }
+    public NOSEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSEGMENT, 0);
+    }
+    public NO_SEMIJOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SEMIJOIN, 0);
+    }
+    public NO_SEMI_TO_INNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SEMI_TO_INNER, 0);
+    }
+    public NO_SET_TO_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SET_TO_JOIN, 0);
+    }
+    public NOSORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSORT, 0);
+    }
+    public NO_SQL_TUNE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SQL_TUNE, 0);
+    }
+    public NO_STAR_TRANSFORMATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_STAR_TRANSFORMATION, 0);
+    }
+    public NO_STATEMENT_QUEUING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_STATEMENT_QUEUING, 0);
+    }
+    public NO_STATS_GSETS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_STATS_GSETS, 0);
+    }
+    public NOSTRICT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSTRICT, 0);
+    }
+    public NO_SUBQUERY_PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SUBQUERY_PRUNING, 0);
+    }
+    public NO_SUBSTRB_PAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SUBSTRB_PAD, 0);
+    }
+    public NO_SWAP_JOIN_INPUTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_SWAP_JOIN_INPUTS, 0);
+    }
+    public NOSWITCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOSWITCH, 0);
+    }
+    public NO_TABLE_LOOKUP_BY_NL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_TABLE_LOOKUP_BY_NL, 0);
+    }
+    public NO_TEMP_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_TEMP_TABLE, 0);
+    }
+    public NOTHING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOTHING, 0);
+    }
+    public NOTIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOTIFICATION, 0);
+    }
+    public NO_TRANSFORM_DISTINCT_AGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_TRANSFORM_DISTINCT_AGG, 0);
+    }
+    public NO_UNNEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_UNNEST, 0);
+    }
+    public NO_USE_HASH_AGGREGATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_HASH_AGGREGATION, 0);
+    }
+    public NO_USE_HASH_GBY_FOR_PUSHDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_HASH_GBY_FOR_PUSHDOWN, 0);
+    }
+    public NO_USE_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_HASH, 0);
+    }
+    public NO_USE_INVISIBLE_INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_INVISIBLE_INDEXES, 0);
+    }
+    public NO_USE_MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_MERGE, 0);
+    }
+    public NO_USE_NL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_USE_NL, 0);
+    }
+    public NOVALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NOVALIDATE, 0);
+    }
+    public NO_XDB_FASTPATH_INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_XDB_FASTPATH_INSERT, 0);
+    }
+    public NO_XML_DML_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_XML_DML_REWRITE, 0);
+    }
+    public NO_XMLINDEX_REWRITE_IN_SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_XMLINDEX_REWRITE_IN_SELECT, 0);
+    }
+    public NO_XMLINDEX_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_XMLINDEX_REWRITE, 0);
+    }
+    public NO_XML_QUERY_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NO_XML_QUERY_REWRITE, 0);
+    }
+    public NTH_VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NTH_VALUE, 0);
+    }
+    public NTILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NTILE, 0);
+    }
+    public NULLIF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLIF, 0);
+    }
+    public NULLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NULLS, 0);
+    }
+    public NUMERIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMERIC, 0);
+    }
+    public NUM_INDEX_KEYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUM_INDEX_KEYS, 0);
+    }
+    public NUMTODSINTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMTODSINTERVAL, 0);
+    }
+    public NUMTOYMINTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NUMTOYMINTERVAL, 0);
+    }
+    public NVARCHAR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NVARCHAR2, 0);
+    }
+    public NVL2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NVL2, 0);
+    }
+    public NVL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.NVL, 0);
+    }
+    public OBJECT2XML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT2XML, 0);
+    }
+    public OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJECT, 0);
+    }
+    public OBJNO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJNO, 0);
+    }
+    public OBJNO_REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OBJNO_REUSE, 0);
+    }
+    public OCCURENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OCCURENCES, 0);
+    }
+    public OFFLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFFLINE, 0);
+    }
+    public OFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OFF, 0);
+    }
+    public OIDINDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OIDINDEX, 0);
+    }
+    public OID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OID, 0);
+    }
+    public OLAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLAP, 0);
+    }
+    public OLD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLD, 0);
+    }
+    public OLD_PUSH_PRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLD_PUSH_PRED, 0);
+    }
+    public OLTP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OLTP, 0);
+    }
+    public ONLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLINE, 0);
+    }
+    public ONLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ONLY, 0);
+    }
+    public OPAQUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPAQUE, 0);
+    }
+    public OPAQUE_TRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPAQUE_TRANSFORM, 0);
+    }
+    public OPAQUE_XCANONICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPAQUE_XCANONICAL, 0);
+    }
+    public OPCODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPCODE, 0);
+    }
+    public OPEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPEN, 0);
+    }
+    public OPERATIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPERATIONS, 0);
+    }
+    public OPERATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPERATOR, 0);
+    }
+    public OPT_ESTIMATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPT_ESTIMATE, 0);
+    }
+    public OPTIMAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIMAL, 0);
+    }
+    public OPTIMIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIMIZE, 0);
+    }
+    public OPTIMIZER_FEATURES_ENABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIMIZER_FEATURES_ENABLE, 0);
+    }
+    public OPTIMIZER_GOAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPTIMIZER_GOAL, 0);
+    }
+    public OPT_PARAM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OPT_PARAM, 0);
+    }
+    public ORA_BRANCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_BRANCH, 0);
+    }
+    public ORADEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORADEBUG, 0);
+    }
+    public ORA_DST_AFFECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_DST_AFFECTED, 0);
+    }
+    public ORA_DST_CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_DST_CONVERT, 0);
+    }
+    public ORA_DST_ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_DST_ERROR, 0);
+    }
+    public ORA_GET_ACLIDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_GET_ACLIDS, 0);
+    }
+    public ORA_GET_PRIVILEGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_GET_PRIVILEGES, 0);
+    }
+    public ORA_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_HASH, 0);
+    }
+    public ORA_ROWSCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_ROWSCN, 0);
+    }
+    public ORA_ROWSCN_RAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_ROWSCN_RAW, 0);
+    }
+    public ORA_ROWVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_ROWVERSION, 0);
+    }
+    public ORA_TABVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORA_TABVERSION, 0);
+    }
+    public ORDERED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDERED, 0);
+    }
+    public ORDERED_PREDICATES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDERED_PREDICATES, 0);
+    }
+    public ORDINALITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORDINALITY, 0);
+    }
+    public OR_EXPAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR_EXPAND, 0);
+    }
+    public ORGANIZATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ORGANIZATION, 0);
+    }
+    public OR_PREDICATES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OR_PREDICATES, 0);
+    }
+    public OTHER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OTHER, 0);
+    }
+    public OUTER_JOIN_TO_ANTI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTER_JOIN_TO_ANTI, 0);
+    }
+    public OUTER_JOIN_TO_INNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTER_JOIN_TO_INNER, 0);
+    }
+    public OUTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTER, 0);
+    }
+    public OUTLINE_LEAF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTLINE_LEAF, 0);
+    }
+    public OUTLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUTLINE, 0);
+    }
+    public OUT_OF_LINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OUT_OF_LINE, 0);
+    }
+    public OVERFLOW_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERFLOW_, 0);
+    }
+    public OVERFLOW_NOMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERFLOW_NOMOVE, 0);
+    }
+    public OVERLAPS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERLAPS, 0);
+    }
+    public OVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVER, 0);
+    }
+    public OVERRIDE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OVERRIDE, 0);
+    }
+    public OWNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OWNER, 0);
+    }
+    public OWNERSHIP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OWNERSHIP, 0);
+    }
+    public OWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.OWN, 0);
+    }
+    public PACKAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PACKAGE, 0);
+    }
+    public PACKAGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PACKAGES, 0);
+    }
+    public PARALLEL_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARALLEL_INDEX, 0);
+    }
+    public PARALLEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARALLEL, 0);
+    }
+    public PARAMETERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAMETERS, 0);
+    }
+    public PARAM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARAM, 0);
+    }
+    public PARENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARENT, 0);
+    }
+    public PARITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARITY, 0);
+    }
+    public PARTIALLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTIALLY, 0);
+    }
+    public PARTITION_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION_HASH, 0);
+    }
+    public PARTITION_LIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION_LIST, 0);
+    }
+    public PARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION, 0);
+    }
+    public PARTITION_RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITION_RANGE, 0);
+    }
+    public PARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTITIONS, 0);
+    }
+    public PARTNUMINST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PARTNUMINST, 0);
+    }
+    public PASSING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSING, 0);
+    }
+    public PASSWORD_GRACE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_GRACE_TIME, 0);
+    }
+    public PASSWORD_LIFE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_LIFE_TIME, 0);
+    }
+    public PASSWORD_LOCK_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_LOCK_TIME, 0);
+    }
+    public PASSWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD, 0);
+    }
+    public PASSWORD_REUSE_MAX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_REUSE_MAX, 0);
+    }
+    public PASSWORD_REUSE_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_REUSE_TIME, 0);
+    }
+    public PASSWORD_VERIFY_FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PASSWORD_VERIFY_FUNCTION, 0);
+    }
+    public PATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATH, 0);
+    }
+    public PATHS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PATHS, 0);
+    }
+    public PBL_HS_BEGIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PBL_HS_BEGIN, 0);
+    }
+    public PBL_HS_END(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PBL_HS_END, 0);
+    }
+    public PCTINCREASE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PCTINCREASE, 0);
+    }
+    public PCTTHRESHOLD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PCTTHRESHOLD, 0);
+    }
+    public PCTUSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PCTUSED, 0);
+    }
+    public PCTVERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PCTVERSION, 0);
+    }
+    public PENDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PENDING, 0);
+    }
+    public PERCENTILE_CONT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENTILE_CONT, 0);
+    }
+    public PERCENTILE_DISC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENTILE_DISC, 0);
+    }
+    public PERCENT_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_KEYWORD, 0);
+    }
+    public PERCENT_RANKM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_RANKM, 0);
+    }
+    public PERCENT_RANK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERCENT_RANK, 0);
+    }
+    public PERFORMANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERFORMANCE, 0);
+    }
+    public PERMANENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERMANENT, 0);
+    }
+    public PERMISSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PERMISSION, 0);
+    }
+    public PFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PFILE, 0);
+    }
+    public PHYSICAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PHYSICAL, 0);
+    }
+    public PIKEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PIKEY, 0);
+    }
+    public PIV_GB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PIV_GB, 0);
+    }
+    public PIVOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PIVOT, 0);
+    }
+    public PIV_SSF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PIV_SSF, 0);
+    }
+    public PLACE_DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLACE_DISTINCT, 0);
+    }
+    public PLACE_GROUP_BY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLACE_GROUP_BY, 0);
+    }
+    public PLAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLAN, 0);
+    }
+    public PLSCOPE_SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLSCOPE_SETTINGS, 0);
+    }
+    public PLSQL_CCFLAGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLSQL_CCFLAGS, 0);
+    }
+    public PLSQL_CODE_TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLSQL_CODE_TYPE, 0);
+    }
+    public PLSQL_DEBUG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLSQL_DEBUG, 0);
+    }
+    public PLSQL_OPTIMIZE_LEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLSQL_OPTIMIZE_LEVEL, 0);
+    }
+    public PLSQL_WARNINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PLSQL_WARNINGS, 0);
+    }
+    public POINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POINT, 0);
+    }
+    public POLICY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POLICY, 0);
+    }
+    public POST_TRANSACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POST_TRANSACTION, 0);
+    }
+    public POWERMULTISET_BY_CARDINALITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWERMULTISET_BY_CARDINALITY, 0);
+    }
+    public POWERMULTISET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWERMULTISET, 0);
+    }
+    public POWER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POWER, 0);
+    }
+    public POSITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.POSITION, 0);
+    }
+    public PQ_DISTRIBUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_DISTRIBUTE, 0);
+    }
+    public PQ_MAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_MAP, 0);
+    }
+    public PQ_NOMAP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PQ_NOMAP, 0);
+    }
+    public PREBUILT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREBUILT, 0);
+    }
+    public PRECEDES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECEDES, 0);
+    }
+    public PRECEDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECEDING, 0);
+    }
+    public PRECISION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECISION, 0);
+    }
+    public PRECOMPUTE_SUBQUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRECOMPUTE_SUBQUERY, 0);
+    }
+    public PREDICATE_REORDERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICATE_REORDERS, 0);
+    }
+    public PREDICTION_BOUNDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_BOUNDS, 0);
+    }
+    public PREDICTION_COST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_COST, 0);
+    }
+    public PREDICTION_DETAILS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_DETAILS, 0);
+    }
+    public PREDICTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION, 0);
+    }
+    public PREDICTION_PROBABILITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_PROBABILITY, 0);
+    }
+    public PREDICTION_SET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREDICTION_SET, 0);
+    }
+    public PREPARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREPARE, 0);
+    }
+    public PRESENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESENT, 0);
+    }
+    public PRESENTNNV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESENTNNV, 0);
+    }
+    public PRESENTV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESENTV, 0);
+    }
+    public PRESERVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE, 0);
+    }
+    public PRESERVE_OID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRESERVE_OID, 0);
+    }
+    public PREVIOUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PREVIOUS, 0);
+    }
+    public PRIMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIMARY, 0);
+    }
+    public PRIVATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVATE, 0);
+    }
+    public PRIVATE_SGA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVATE_SGA, 0);
+    }
+    public PRIVILEGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGE, 0);
+    }
+    public PRIVILEGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PRIVILEGES, 0);
+    }
+    public PROCEDURAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURAL, 0);
+    }
+    public PROCEDURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCEDURE, 0);
+    }
+    public PROCESS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROCESS, 0);
+    }
+    public PROFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROFILE, 0);
+    }
+    public PROGRAM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROGRAM, 0);
+    }
+    public PROJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROJECT, 0);
+    }
+    public PROPAGATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROPAGATE, 0);
+    }
+    public PROTECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROTECTED, 0);
+    }
+    public PROTECTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PROTECTION, 0);
+    }
+    public PULL_PRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PULL_PRED, 0);
+    }
+    public PURGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PURGE, 0);
+    }
+    public PUSH_PRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUSH_PRED, 0);
+    }
+    public PUSH_SUBQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PUSH_SUBQ, 0);
+    }
+    public PX_GRANULE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PX_GRANULE, 0);
+    }
+    public PX_JOIN_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.PX_JOIN_FILTER, 0);
+    }
+    public QB_NAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QB_NAME, 0);
+    }
+    public QUERY_BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY_BLOCK, 0);
+    }
+    public QUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUERY, 0);
+    }
+    public QUEUE_CURR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUEUE_CURR, 0);
+    }
+    public QUEUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUEUE, 0);
+    }
+    public QUEUE_ROWP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUEUE_ROWP, 0);
+    }
+    public QUIESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUIESCE, 0);
+    }
+    public QUORUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUORUM, 0);
+    }
+    public QUOTA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.QUOTA, 0);
+    }
+    public RANDOM_LOCAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANDOM_LOCAL, 0);
+    }
+    public RANDOM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANDOM, 0);
+    }
+    public RANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANGE, 0);
+    }
+    public RANKM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANKM, 0);
+    }
+    public RANK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RANK, 0);
+    }
+    public RAPIDLY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAPIDLY, 0);
+    }
+    public RATIO_TO_REPORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RATIO_TO_REPORT, 0);
+    }
+    public RAWTOHEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAWTOHEX, 0);
+    }
+    public RAWTONHEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RAWTONHEX, 0);
+    }
+    public RBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RBA, 0);
+    }
+    public RBO_OUTLINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RBO_OUTLINE, 0);
+    }
+    public RDBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RDBA, 0);
+    }
+    public READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READ, 0);
+    }
+    public READS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.READS, 0);
+    }
+    public REAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REAL, 0);
+    }
+    public REBALANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REBALANCE, 0);
+    }
+    public REBUILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REBUILD, 0);
+    }
+    public RECORDS_PER_BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECORDS_PER_BLOCK, 0);
+    }
+    public RECOVERABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECOVERABLE, 0);
+    }
+    public RECOVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECOVER, 0);
+    }
+    public RECOVERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECOVERY, 0);
+    }
+    public RECYCLEBIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECYCLEBIN, 0);
+    }
+    public RECYCLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RECYCLE, 0);
+    }
+    public REDACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDACTION, 0);
+    }
+    public REDO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDO, 0);
+    }
+    public REDUCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDUCED, 0);
+    }
+    public REDUNDANCY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REDUNDANCY, 0);
+    }
+    public REF_CASCADE_CURSOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF_CASCADE_CURSOR, 0);
+    }
+    public REFERENCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCED, 0);
+    }
+    public REFERENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCE, 0);
+    }
+    public REFERENCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCES, 0);
+    }
+    public REFERENCING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFERENCING, 0);
+    }
+    public REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REF, 0);
+    }
+    public REFRESH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFRESH, 0);
+    }
+    public REFTOHEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REFTOHEX, 0);
+    }
+    public REGEXP_COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGEXP_COUNT, 0);
+    }
+    public REGEXP_INSTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGEXP_INSTR, 0);
+    }
+    public REGEXP_LIKE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGEXP_LIKE, 0);
+    }
+    public REGEXP_REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGEXP_REPLACE, 0);
+    }
+    public REGEXP_SUBSTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGEXP_SUBSTR, 0);
+    }
+    public REGISTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGISTER, 0);
+    }
+    public REGR_AVGX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_AVGX, 0);
+    }
+    public REGR_AVGY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_AVGY, 0);
+    }
+    public REGR_COUNT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_COUNT, 0);
+    }
+    public REGR_INTERCEPT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_INTERCEPT, 0);
+    }
+    public REGR_R2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_R2, 0);
+    }
+    public REGR_SLOPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_SLOPE, 0);
+    }
+    public REGR_SXX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_SXX, 0);
+    }
+    public REGR_SXY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_SXY, 0);
+    }
+    public REGR_SYY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGR_SYY, 0);
+    }
+    public REGULAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REGULAR, 0);
+    }
+    public REJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REJECT, 0);
+    }
+    public REKEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REKEY, 0);
+    }
+    public RELATIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELATIONAL, 0);
+    }
+    public RELY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RELY, 0);
+    }
+    public REMAINDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMAINDER, 0);
+    }
+    public REMOTE_MAPPED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOTE_MAPPED, 0);
+    }
+    public REMOVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REMOVE, 0);
+    }
+    public REPAIR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPAIR, 0);
+    }
+    public REPEAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPEAT, 0);
+    }
+    public REPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLACE, 0);
+    }
+    public REPLICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REPLICATION, 0);
+    }
+    public REQUIRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REQUIRED, 0);
+    }
+    public RESETLOGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESETLOGS, 0);
+    }
+    public RESET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESET, 0);
+    }
+    public RESIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESIZE, 0);
+    }
+    public RESOLVE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOLVE, 0);
+    }
+    public RESOLVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESOLVER, 0);
+    }
+    public RESPECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESPECT, 0);
+    }
+    public RESTORE_AS_INTERVALS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTORE_AS_INTERVALS, 0);
+    }
+    public RESTORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTORE, 0);
+    }
+    public RESTRICT_ALL_REF_CONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICT_ALL_REF_CONS, 0);
+    }
+    public RESTRICTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICTED, 0);
+    }
+    public RESTRICT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESTRICT, 0);
+    }
+    public RESULT_CACHE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESULT_CACHE, 0);
+    }
+    public RESUMABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESUMABLE, 0);
+    }
+    public RESUME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RESUME, 0);
+    }
+    public RETENTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETENTION, 0);
+    }
+    public RETRY_ON_ROW_CHANGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETRY_ON_ROW_CHANGE, 0);
+    }
+    public RETURNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURNING, 0);
+    }
+    public RETURN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RETURN, 0);
+    }
+    public REUSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REUSE, 0);
+    }
+    public REVERSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REVERSE, 0);
+    }
+    public REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REWRITE, 0);
+    }
+    public REWRITE_OR_ERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.REWRITE_OR_ERROR, 0);
+    }
+    public RIGHT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RIGHT, 0);
+    }
+    public ROLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLE, 0);
+    }
+    public ROLES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLES, 0);
+    }
+    public ROLLBACK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLBACK, 0);
+    }
+    public ROLLING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLING, 0);
+    }
+    public ROLLUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROLLUP, 0);
+    }
+    public ROOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROOT, 0);
+    }
+    public ROUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROUND, 0);
+    }
+    public ROWDEPENDENCIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWDEPENDENCIES, 0);
+    }
+    public ROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWID, 0);
+    }
+    public ROWIDTOCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWIDTOCHAR, 0);
+    }
+    public ROWIDTONCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWIDTONCHAR, 0);
+    }
+    public ROW_LENGTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW_LENGTH, 0);
+    }
+    public ROW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW, 0);
+    }
+    public ROW_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROW_NUMBER, 0);
+    }
+    public ROWNUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWNUM, 0);
+    }
+    public ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ROWS, 0);
+    }
+    public RPAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RPAD, 0);
+    }
+    public RTRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RTRIM, 0);
+    }
+    public RULE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RULE, 0);
+    }
+    public RULES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.RULES, 0);
+    }
+    public SALT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SALT, 0);
+    }
+    public SAMPLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAMPLE, 0);
+    }
+    public SAVE_AS_INTERVALS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAVE_AS_INTERVALS, 0);
+    }
+    public SAVEPOINT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SAVEPOINT, 0);
+    }
+    public SB4(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SB4, 0);
+    }
+    public SCALE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCALE, 0);
+    }
+    public SCALE_ROWS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCALE_ROWS, 0);
+    }
+    public SCAN_INSTANCES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCAN_INSTANCES, 0);
+    }
+    public SCAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCAN, 0);
+    }
+    public SCHEDULER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEDULER, 0);
+    }
+    public SCHEMACHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEMACHECK, 0);
+    }
+    public SCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCHEMA, 0);
+    }
+    public SCN_ASCENDING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCN_ASCENDING, 0);
+    }
+    public SCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCN, 0);
+    }
+    public SCOPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SCOPE, 0);
+    }
+    public SD_ALL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SD_ALL, 0);
+    }
+    public SD_INHIBIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SD_INHIBIT, 0);
+    }
+    public SD_SHOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SD_SHOW, 0);
+    }
+    public SEARCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEARCH, 0);
+    }
+    public SECOND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECOND, 0);
+    }
+    public SECUREFILE_DBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECUREFILE_DBA, 0);
+    }
+    public SECUREFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECUREFILE, 0);
+    }
+    public SECURITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SECURITY, 0);
+    }
+    public SEED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEED, 0);
+    }
+    public SEG_BLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEG_BLOCK, 0);
+    }
+    public SEG_FILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEG_FILE, 0);
+    }
+    public SEGMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEGMENT, 0);
+    }
+    public SELECTIVITY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SELECTIVITY, 0);
+    }
+    public SEMIJOIN_DRIVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMIJOIN_DRIVER, 0);
+    }
+    public SEMIJOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMIJOIN, 0);
+    }
+    public SEMI_TO_INNER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEMI_TO_INNER, 0);
+    }
+    public SEQUENCED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCED, 0);
+    }
+    public SEQUENCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENCE, 0);
+    }
+    public SEQUENTIAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEQUENTIAL, 0);
+    }
+    public SERIALIZABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERIALIZABLE, 0);
+    }
+    public SERVERERROR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVERERROR, 0);
+    }
+    public SERVICE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SERVICE, 0);
+    }
+    public SESSION_CACHED_CURSORS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION_CACHED_CURSORS, 0);
+    }
+    public SESSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSION, 0);
+    }
+    public SESSIONS_PER_USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSIONS_PER_USER, 0);
+    }
+    public SESSIONTIMEZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSIONTIMEZONE, 0);
+    }
+    public SESSIONTZNAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SESSIONTZNAME, 0);
+    }
+    public SETS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETS, 0);
+    }
+    public SETTINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SETTINGS, 0);
+    }
+    public SET_TO_JOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SET_TO_JOIN, 0);
+    }
+    public SEVERE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SEVERE, 0);
+    }
+    public SHARED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARED, 0);
+    }
+    public SHARED_POOL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHARED_POOL, 0);
+    }
+    public SHOW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHOW, 0);
+    }
+    public SHRINK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHRINK, 0);
+    }
+    public SHUTDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SHUTDOWN, 0);
+    }
+    public SIBLINGS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIBLINGS, 0);
+    }
+    public SID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SID, 0);
+    }
+    public SIGNAL_COMPONENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIGNAL_COMPONENT, 0);
+    }
+    public SIGNAL_FUNCTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIGNAL_FUNCTION, 0);
+    }
+    public SIGN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIGN, 0);
+    }
+    public SIMPLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIMPLE, 0);
+    }
+    public SINGLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SINGLE, 0);
+    }
+    public SINGLETASK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SINGLETASK, 0);
+    }
+    public SINH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SINH, 0);
+    }
+    public SIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SIN, 0);
+    }
+    public SKIP_EXT_OPTIMIZER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_EXT_OPTIMIZER, 0);
+    }
+    public SKIP_(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_, 0);
+    }
+    public SKIP_UNQ_UNUSABLE_IDX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_UNQ_UNUSABLE_IDX, 0);
+    }
+    public SKIP_UNUSABLE_INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SKIP_UNUSABLE_INDEXES, 0);
+    }
+    public SMALLFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SMALLFILE, 0);
+    }
+    public SNAPSHOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SNAPSHOT, 0);
+    }
+    public SOME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOME, 0);
+    }
+    public SORT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SORT, 0);
+    }
+    public SOUNDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOUNDEX, 0);
+    }
+    public SOURCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SOURCE, 0);
+    }
+    public SPACE_KEYWORD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPACE_KEYWORD, 0);
+    }
+    public SPECIFICATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPECIFICATION, 0);
+    }
+    public SPFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPFILE, 0);
+    }
+    public SPLIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPLIT, 0);
+    }
+    public SPREADSHEET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SPREADSHEET, 0);
+    }
+    public SQLLDR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQLLDR, 0);
+    }
+    public SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL, 0);
+    }
+    public SQL_TRACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL_TRACE, 0);
+    }
+    public SQL_MACRO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQL_MACRO, 0);
+    }
+    public SQRT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SQRT, 0);
+    }
+    public STALE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STALE, 0);
+    }
+    public STANDALONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDALONE, 0);
+    }
+    public STANDBY_MAX_DATA_DELAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY_MAX_DATA_DELAY, 0);
+    }
+    public STANDBY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STANDBY, 0);
+    }
+    public STAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STAR, 0);
+    }
+    public STAR_TRANSFORMATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STAR_TRANSFORMATION, 0);
+    }
+    public STARTUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STARTUP, 0);
+    }
+    public STATEMENT_ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENT_ID, 0);
+    }
+    public STATEMENT_QUEUING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENT_QUEUING, 0);
+    }
+    public STATEMENTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATEMENTS, 0);
+    }
+    public STATIC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATIC, 0);
+    }
+    public STATISTICS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATISTICS, 0);
+    }
+    public STATS_BINOMIAL_TEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_BINOMIAL_TEST, 0);
+    }
+    public STATS_CROSSTAB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_CROSSTAB, 0);
+    }
+    public STATS_F_TEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_F_TEST, 0);
+    }
+    public STATS_KS_TEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_KS_TEST, 0);
+    }
+    public STATS_MODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_MODE, 0);
+    }
+    public STATS_MW_TEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_MW_TEST, 0);
+    }
+    public STATS_ONE_WAY_ANOVA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_ONE_WAY_ANOVA, 0);
+    }
+    public STATS_T_TEST_INDEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_T_TEST_INDEP, 0);
+    }
+    public STATS_T_TEST_INDEPU(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_T_TEST_INDEPU, 0);
+    }
+    public STATS_T_TEST_ONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_T_TEST_ONE, 0);
+    }
+    public STATS_T_TEST_PAIRED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_T_TEST_PAIRED, 0);
+    }
+    public STATS_WSR_TEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STATS_WSR_TEST, 0);
+    }
+    public STDDEV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STDDEV, 0);
+    }
+    public STDDEV_POP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STDDEV_POP, 0);
+    }
+    public STDDEV_SAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STDDEV_SAMP, 0);
+    }
+    public STOP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STOP, 0);
+    }
+    public STORAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORAGE, 0);
+    }
+    public STORE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STORE, 0);
+    }
+    public STREAMS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STREAMS, 0);
+    }
+    public STRICT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRICT, 0);
+    }
+    public STRING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRING, 0);
+    }
+    public STRIPE_COLUMNS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRIPE_COLUMNS, 0);
+    }
+    public STRIPE_WIDTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRIPE_WIDTH, 0);
+    }
+    public STRIP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRIP, 0);
+    }
+    public STRUCTURE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.STRUCTURE, 0);
+    }
+    public SUBMULTISET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBMULTISET, 0);
+    }
+    public SUBPARTITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION, 0);
+    }
+    public SUBPARTITION_REL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITION_REL, 0);
+    }
+    public SUBPARTITIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBPARTITIONS, 0);
+    }
+    public SUBQUERIES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBQUERIES, 0);
+    }
+    public SUBQUERY_PRUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBQUERY_PRUNING, 0);
+    }
+    public SUBSTITUTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTITUTABLE, 0);
+    }
+    public SUBSTR2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTR2, 0);
+    }
+    public SUBSTR4(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTR4, 0);
+    }
+    public SUBSTRB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTRB, 0);
+    }
+    public SUBSTRC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTRC, 0);
+    }
+    public SUBSTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUBSTR, 0);
+    }
+    public SUCCESSFUL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUCCESSFUL, 0);
+    }
+    public SUMMARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUMMARY, 0);
+    }
+    public SUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUM, 0);
+    }
+    public SUPPLEMENTAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUPPLEMENTAL, 0);
+    }
+    public SUSPEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SUSPEND, 0);
+    }
+    public SWAP_JOIN_INPUTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SWAP_JOIN_INPUTS, 0);
+    }
+    public SWITCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SWITCH, 0);
+    }
+    public SWITCHOVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SWITCHOVER, 0);
+    }
+    public SYNCHRONOUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYNCHRONOUS, 0);
+    }
+    public SYNC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYNC, 0);
+    }
+    public SYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS, 0);
+    }
+    public SYSASM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSASM, 0);
+    }
+    public SYS_AUDIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_AUDIT, 0);
+    }
+    public SYSAUX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSAUX, 0);
+    }
+    public SYS_CHECKACL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_CHECKACL, 0);
+    }
+    public SYS_CONNECT_BY_PATH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_CONNECT_BY_PATH, 0);
+    }
+    public SYS_CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_CONTEXT, 0);
+    }
+    public SYSDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSDATE, 0);
+    }
+    public SYSDBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSDBA, 0);
+    }
+    public SYS_DBURIGEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DBURIGEN, 0);
+    }
+    public SYS_DL_CURSOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DL_CURSOR, 0);
+    }
+    public SYS_DM_RXFORM_CHR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DM_RXFORM_CHR, 0);
+    }
+    public SYS_DM_RXFORM_NUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DM_RXFORM_NUM, 0);
+    }
+    public SYS_DOM_COMPARE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DOM_COMPARE, 0);
+    }
+    public SYS_DST_PRIM2SEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DST_PRIM2SEC, 0);
+    }
+    public SYS_DST_SEC2PRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_DST_SEC2PRIM, 0);
+    }
+    public SYS_ET_BFILE_TO_RAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ET_BFILE_TO_RAW, 0);
+    }
+    public SYS_ET_BLOB_TO_IMAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ET_BLOB_TO_IMAGE, 0);
+    }
+    public SYS_ET_IMAGE_TO_BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ET_IMAGE_TO_BLOB, 0);
+    }
+    public SYS_ET_RAW_TO_BFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ET_RAW_TO_BFILE, 0);
+    }
+    public SYS_EXTPDTXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_EXTPDTXT, 0);
+    }
+    public SYS_EXTRACT_UTC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_EXTRACT_UTC, 0);
+    }
+    public SYS_FBT_INSDEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_FBT_INSDEL, 0);
+    }
+    public SYS_FILTER_ACLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_FILTER_ACLS, 0);
+    }
+    public SYS_FNMATCHES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_FNMATCHES, 0);
+    }
+    public SYS_FNREPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_FNREPLACE, 0);
+    }
+    public SYS_GET_ACLIDS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_GET_ACLIDS, 0);
+    }
+    public SYS_GET_PRIVILEGES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_GET_PRIVILEGES, 0);
+    }
+    public SYS_GETTOKENID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_GETTOKENID, 0);
+    }
+    public SYS_GETXTIVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_GETXTIVAL, 0);
+    }
+    public SYS_GUID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_GUID, 0);
+    }
+    public SYS_MAKEXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_MAKEXML, 0);
+    }
+    public SYS_MAKE_XMLNODEID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_MAKE_XMLNODEID, 0);
+    }
+    public SYS_MKXMLATTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_MKXMLATTR, 0);
+    }
+    public SYS_OP_ADT2BIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ADT2BIN, 0);
+    }
+    public SYS_OP_ADTCONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ADTCONS, 0);
+    }
+    public SYS_OP_ALSCRVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ALSCRVAL, 0);
+    }
+    public SYS_OP_ATG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ATG, 0);
+    }
+    public SYS_OP_BIN2ADT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_BIN2ADT, 0);
+    }
+    public SYS_OP_BITVEC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_BITVEC, 0);
+    }
+    public SYS_OP_BL2R(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_BL2R, 0);
+    }
+    public SYS_OP_BLOOM_FILTER_LIST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_BLOOM_FILTER_LIST, 0);
+    }
+    public SYS_OP_BLOOM_FILTER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_BLOOM_FILTER, 0);
+    }
+    public SYS_OP_C2C(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_C2C, 0);
+    }
+    public SYS_OP_CAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CAST, 0);
+    }
+    public SYS_OP_CEG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CEG, 0);
+    }
+    public SYS_OP_CL2C(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CL2C, 0);
+    }
+    public SYS_OP_COMBINED_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_COMBINED_HASH, 0);
+    }
+    public SYS_OP_COMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_COMP, 0);
+    }
+    public SYS_OP_CONVERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CONVERT, 0);
+    }
+    public SYS_OP_COUNTCHG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_COUNTCHG, 0);
+    }
+    public SYS_OP_CSCONV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CSCONV, 0);
+    }
+    public SYS_OP_CSCONVTEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CSCONVTEST, 0);
+    }
+    public SYS_OP_CSR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CSR, 0);
+    }
+    public SYS_OP_CSX_PATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_CSX_PATCH, 0);
+    }
+    public SYS_OP_DECOMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_DECOMP, 0);
+    }
+    public SYS_OP_DESCEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_DESCEND, 0);
+    }
+    public SYS_OP_DISTINCT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_DISTINCT, 0);
+    }
+    public SYS_OP_DRA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_DRA, 0);
+    }
+    public SYS_OP_DUMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_DUMP, 0);
+    }
+    public SYS_OP_DV_CHECK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_DV_CHECK, 0);
+    }
+    public SYS_OP_ENFORCE_NOT_NULL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ENFORCE_NOT_NULL, 0);
+    }
+    public SYSOPER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSOPER, 0);
+    }
+    public SYS_OP_EXTRACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_EXTRACT, 0);
+    }
+    public SYS_OP_GROUPING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_GROUPING, 0);
+    }
+    public SYS_OP_GUID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_GUID, 0);
+    }
+    public SYS_OP_IIX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_IIX, 0);
+    }
+    public SYS_OP_ITR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ITR, 0);
+    }
+    public SYS_OP_LBID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LBID, 0);
+    }
+    public SYS_OP_LOBLOC2BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LOBLOC2BLOB, 0);
+    }
+    public SYS_OP_LOBLOC2CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LOBLOC2CLOB, 0);
+    }
+    public SYS_OP_LOBLOC2ID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LOBLOC2ID, 0);
+    }
+    public SYS_OP_LOBLOC2NCLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LOBLOC2NCLOB, 0);
+    }
+    public SYS_OP_LOBLOC2TYP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LOBLOC2TYP, 0);
+    }
+    public SYS_OP_LSVI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LSVI, 0);
+    }
+    public SYS_OP_LVL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_LVL, 0);
+    }
+    public SYS_OP_MAKEOID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_MAKEOID, 0);
+    }
+    public SYS_OP_MAP_NONNULL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_MAP_NONNULL, 0);
+    }
+    public SYS_OP_MSR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_MSR, 0);
+    }
+    public SYS_OP_NICOMBINE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NICOMBINE, 0);
+    }
+    public SYS_OP_NIEXTRACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NIEXTRACT, 0);
+    }
+    public SYS_OP_NII(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NII, 0);
+    }
+    public SYS_OP_NIX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NIX, 0);
+    }
+    public SYS_OP_NOEXPAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NOEXPAND, 0);
+    }
+    public SYS_OP_NTCIMG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NTCIMG, 0);
+    }
+    public SYS_OP_NUMTORAW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_NUMTORAW, 0);
+    }
+    public SYS_OP_OIDVALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_OIDVALUE, 0);
+    }
+    public SYS_OP_OPNSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_OPNSIZE, 0);
+    }
+    public SYS_OP_PAR_1(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_PAR_1, 0);
+    }
+    public SYS_OP_PARGID_1(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_PARGID_1, 0);
+    }
+    public SYS_OP_PARGID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_PARGID, 0);
+    }
+    public SYS_OP_PAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_PAR, 0);
+    }
+    public SYS_OP_PIVOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_PIVOT, 0);
+    }
+    public SYS_OP_R2O(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_R2O, 0);
+    }
+    public SYS_OP_RAWTONUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_RAWTONUM, 0);
+    }
+    public SYS_OP_RDTM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_RDTM, 0);
+    }
+    public SYS_OP_REF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_REF, 0);
+    }
+    public SYS_OP_RMTD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_RMTD, 0);
+    }
+    public SYS_OP_ROWIDTOOBJ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_ROWIDTOOBJ, 0);
+    }
+    public SYS_OP_RPB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_RPB, 0);
+    }
+    public SYS_OPTLOBPRBSC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OPTLOBPRBSC, 0);
+    }
+    public SYS_OP_TOSETID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_TOSETID, 0);
+    }
+    public SYS_OP_TPR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_TPR, 0);
+    }
+    public SYS_OP_TRTB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_TRTB, 0);
+    }
+    public SYS_OPTXICMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OPTXICMP, 0);
+    }
+    public SYS_OPTXQCASTASNQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OPTXQCASTASNQ, 0);
+    }
+    public SYS_OP_UNDESCEND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_UNDESCEND, 0);
+    }
+    public SYS_OP_VECAND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VECAND, 0);
+    }
+    public SYS_OP_VECBIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VECBIT, 0);
+    }
+    public SYS_OP_VECOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VECOR, 0);
+    }
+    public SYS_OP_VECXOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VECXOR, 0);
+    }
+    public SYS_OP_VERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VERSION, 0);
+    }
+    public SYS_OP_VREF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VREF, 0);
+    }
+    public SYS_OP_VVD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_VVD, 0);
+    }
+    public SYS_OP_XMLCONS_FOR_CSX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_XMLCONS_FOR_CSX, 0);
+    }
+    public SYS_OP_XPTHATG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_XPTHATG, 0);
+    }
+    public SYS_OP_XPTHIDX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_XPTHIDX, 0);
+    }
+    public SYS_OP_XPTHOP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_XPTHOP, 0);
+    }
+    public SYS_OP_XTXT2SQLT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_OP_XTXT2SQLT, 0);
+    }
+    public SYS_ORDERKEY_DEPTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ORDERKEY_DEPTH, 0);
+    }
+    public SYS_ORDERKEY_MAXCHILD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ORDERKEY_MAXCHILD, 0);
+    }
+    public SYS_ORDERKEY_PARENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ORDERKEY_PARENT, 0);
+    }
+    public SYS_PARALLEL_TXN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PARALLEL_TXN, 0);
+    }
+    public SYS_PATHID_IS_ATTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PATHID_IS_ATTR, 0);
+    }
+    public SYS_PATHID_IS_NMSPC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PATHID_IS_NMSPC, 0);
+    }
+    public SYS_PATHID_LASTNAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PATHID_LASTNAME, 0);
+    }
+    public SYS_PATHID_LASTNMSPC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PATHID_LASTNMSPC, 0);
+    }
+    public SYS_PATH_REVERSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PATH_REVERSE, 0);
+    }
+    public SYS_PXQEXTRACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_PXQEXTRACT, 0);
+    }
+    public SYS_RID_ORDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_RID_ORDER, 0);
+    }
+    public SYS_ROW_DELTA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_ROW_DELTA, 0);
+    }
+    public SYS_SC_2_XMLT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_SC_2_XMLT, 0);
+    }
+    public SYS_SYNRCIREDO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_SYNRCIREDO, 0);
+    }
+    public SYSTEM_DEFINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM_DEFINED, 0);
+    }
+    public SYSTEM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTEM, 0);
+    }
+    public SYSTIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYSTIMESTAMP, 0);
+    }
+    public SYS_TYPEID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_TYPEID, 0);
+    }
+    public SYS_UMAKEXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_UMAKEXML, 0);
+    }
+    public SYS_XMLANALYZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLANALYZE, 0);
+    }
+    public SYS_XMLCONTAINS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLCONTAINS, 0);
+    }
+    public SYS_XMLCONV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLCONV, 0);
+    }
+    public SYS_XMLEXNSURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLEXNSURI, 0);
+    }
+    public SYS_XMLGEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLGEN, 0);
+    }
+    public SYS_XMLI_LOC_ISNODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLI_LOC_ISNODE, 0);
+    }
+    public SYS_XMLI_LOC_ISTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLI_LOC_ISTEXT, 0);
+    }
+    public SYS_XMLINSTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLINSTR, 0);
+    }
+    public SYS_XMLLOCATOR_GETSVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLLOCATOR_GETSVAL, 0);
+    }
+    public SYS_XMLNODEID_GETCID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETCID, 0);
+    }
+    public SYS_XMLNODEID_GETLOCATOR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETLOCATOR, 0);
+    }
+    public SYS_XMLNODEID_GETOKEY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETOKEY, 0);
+    }
+    public SYS_XMLNODEID_GETPATHID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETPATHID, 0);
+    }
+    public SYS_XMLNODEID_GETPTRID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETPTRID, 0);
+    }
+    public SYS_XMLNODEID_GETRID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETRID, 0);
+    }
+    public SYS_XMLNODEID_GETSVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETSVAL, 0);
+    }
+    public SYS_XMLNODEID_GETTID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID_GETTID, 0);
+    }
+    public SYS_XMLNODEID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLNODEID, 0);
+    }
+    public SYS_XMLT_2_SC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLT_2_SC, 0);
+    }
+    public SYS_XMLTRANSLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLTRANSLATE, 0);
+    }
+    public SYS_XMLTYPE2SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XMLTYPE2SQL, 0);
+    }
+    public SYS_XQ_ASQLCNV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQ_ASQLCNV, 0);
+    }
+    public SYS_XQ_ATOMCNVCHK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQ_ATOMCNVCHK, 0);
+    }
+    public SYS_XQBASEURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQBASEURI, 0);
+    }
+    public SYS_XQCASTABLEERRH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQCASTABLEERRH, 0);
+    }
+    public SYS_XQCODEP2STR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQCODEP2STR, 0);
+    }
+    public SYS_XQCODEPEQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQCODEPEQ, 0);
+    }
+    public SYS_XQCON2SEQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQCON2SEQ, 0);
+    }
+    public SYS_XQCONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQCONCAT, 0);
+    }
+    public SYS_XQDELETE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQDELETE, 0);
+    }
+    public SYS_XQDFLTCOLATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQDFLTCOLATION, 0);
+    }
+    public SYS_XQDOC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQDOC, 0);
+    }
+    public SYS_XQDOCURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQDOCURI, 0);
+    }
+    public SYS_XQDURDIV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQDURDIV, 0);
+    }
+    public SYS_XQED4URI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQED4URI, 0);
+    }
+    public SYS_XQENDSWITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQENDSWITH, 0);
+    }
+    public SYS_XQERRH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQERRH, 0);
+    }
+    public SYS_XQERR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQERR, 0);
+    }
+    public SYS_XQESHTMLURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQESHTMLURI, 0);
+    }
+    public SYS_XQEXLOBVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQEXLOBVAL, 0);
+    }
+    public SYS_XQEXSTWRP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQEXSTWRP, 0);
+    }
+    public SYS_XQEXTRACT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQEXTRACT, 0);
+    }
+    public SYS_XQEXTRREF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQEXTRREF, 0);
+    }
+    public SYS_XQEXVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQEXVAL, 0);
+    }
+    public SYS_XQFB2STR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFB2STR, 0);
+    }
+    public SYS_XQFNBOOL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNBOOL, 0);
+    }
+    public SYS_XQFNCMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNCMP, 0);
+    }
+    public SYS_XQFNDATIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNDATIM, 0);
+    }
+    public SYS_XQFNLNAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNLNAME, 0);
+    }
+    public SYS_XQFNNM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNNM, 0);
+    }
+    public SYS_XQFNNSURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNNSURI, 0);
+    }
+    public SYS_XQFNPREDTRUTH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNPREDTRUTH, 0);
+    }
+    public SYS_XQFNQNM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNQNM, 0);
+    }
+    public SYS_XQFNROOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFNROOT, 0);
+    }
+    public SYS_XQFORMATNUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFORMATNUM, 0);
+    }
+    public SYS_XQFTCONTAIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFTCONTAIN, 0);
+    }
+    public SYS_XQFUNCR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQFUNCR, 0);
+    }
+    public SYS_XQGETCONTENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQGETCONTENT, 0);
+    }
+    public SYS_XQINDXOF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQINDXOF, 0);
+    }
+    public SYS_XQINSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQINSERT, 0);
+    }
+    public SYS_XQINSPFX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQINSPFX, 0);
+    }
+    public SYS_XQIRI2URI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQIRI2URI, 0);
+    }
+    public SYS_XQLANG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQLANG, 0);
+    }
+    public SYS_XQLLNMFRMQNM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQLLNMFRMQNM, 0);
+    }
+    public SYS_XQMKNODEREF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQMKNODEREF, 0);
+    }
+    public SYS_XQNILLED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQNILLED, 0);
+    }
+    public SYS_XQNODENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQNODENAME, 0);
+    }
+    public SYS_XQNORMSPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQNORMSPACE, 0);
+    }
+    public SYS_XQNORMUCODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQNORMUCODE, 0);
+    }
+    public SYS_XQ_NRNG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQ_NRNG, 0);
+    }
+    public SYS_XQNSP4PFX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQNSP4PFX, 0);
+    }
+    public SYS_XQNSPFRMQNM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQNSPFRMQNM, 0);
+    }
+    public SYS_XQPFXFRMQNM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPFXFRMQNM, 0);
+    }
+    public SYS_XQ_PKSQL2XML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQ_PKSQL2XML, 0);
+    }
+    public SYS_XQPOLYABS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYABS, 0);
+    }
+    public SYS_XQPOLYADD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYADD, 0);
+    }
+    public SYS_XQPOLYCEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYCEL, 0);
+    }
+    public SYS_XQPOLYCSTBL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYCSTBL, 0);
+    }
+    public SYS_XQPOLYCST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYCST, 0);
+    }
+    public SYS_XQPOLYDIV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYDIV, 0);
+    }
+    public SYS_XQPOLYFLR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYFLR, 0);
+    }
+    public SYS_XQPOLYMOD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYMOD, 0);
+    }
+    public SYS_XQPOLYMUL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYMUL, 0);
+    }
+    public SYS_XQPOLYRND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYRND, 0);
+    }
+    public SYS_XQPOLYSQRT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYSQRT, 0);
+    }
+    public SYS_XQPOLYSUB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYSUB, 0);
+    }
+    public SYS_XQPOLYUMUS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYUMUS, 0);
+    }
+    public SYS_XQPOLYUPLS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYUPLS, 0);
+    }
+    public SYS_XQPOLYVEQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYVEQ, 0);
+    }
+    public SYS_XQPOLYVGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYVGE, 0);
+    }
+    public SYS_XQPOLYVGT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYVGT, 0);
+    }
+    public SYS_XQPOLYVLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYVLE, 0);
+    }
+    public SYS_XQPOLYVLT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYVLT, 0);
+    }
+    public SYS_XQPOLYVNE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQPOLYVNE, 0);
+    }
+    public SYS_XQREF2VAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQREF2VAL, 0);
+    }
+    public SYS_XQRENAME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRENAME, 0);
+    }
+    public SYS_XQREPLACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQREPLACE, 0);
+    }
+    public SYS_XQRESVURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRESVURI, 0);
+    }
+    public SYS_XQRNDHALF2EVN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRNDHALF2EVN, 0);
+    }
+    public SYS_XQRSLVQNM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRSLVQNM, 0);
+    }
+    public SYS_XQRYENVPGET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRYENVPGET, 0);
+    }
+    public SYS_XQRYVARGET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRYVARGET, 0);
+    }
+    public SYS_XQRYWRP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQRYWRP, 0);
+    }
+    public SYS_XQSEQ2CON4XC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQ2CON4XC, 0);
+    }
+    public SYS_XQSEQ2CON(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQ2CON, 0);
+    }
+    public SYS_XQSEQDEEPEQ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQDEEPEQ, 0);
+    }
+    public SYS_XQSEQINSB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQINSB, 0);
+    }
+    public SYS_XQSEQRM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQRM, 0);
+    }
+    public SYS_XQSEQRVS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQRVS, 0);
+    }
+    public SYS_XQSEQSUB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQSUB, 0);
+    }
+    public SYS_XQSEQTYPMATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSEQTYPMATCH, 0);
+    }
+    public SYS_XQSTARTSWITH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSTARTSWITH, 0);
+    }
+    public SYS_XQSTATBURI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSTATBURI, 0);
+    }
+    public SYS_XQSTR2CODEP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSTR2CODEP, 0);
+    }
+    public SYS_XQSTRJOIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSTRJOIN, 0);
+    }
+    public SYS_XQSUBSTRAFT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSUBSTRAFT, 0);
+    }
+    public SYS_XQSUBSTRBEF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQSUBSTRBEF, 0);
+    }
+    public SYS_XQTOKENIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQTOKENIZE, 0);
+    }
+    public SYS_XQTREATAS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQTREATAS, 0);
+    }
+    public SYS_XQ_UPKXML2SQL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQ_UPKXML2SQL, 0);
+    }
+    public SYS_XQXFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.SYS_XQXFORM, 0);
+    }
+    public TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE, 0);
+    }
+    public TABLE_LOOKUP_BY_NL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE_LOOKUP_BY_NL, 0);
+    }
+    public TABLES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLES, 0);
+    }
+    public TABLESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE, 0);
+    }
+    public TABLESPACE_NO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLESPACE_NO, 0);
+    }
+    public TABLE_STATS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABLE_STATS, 0);
+    }
+    public TABNO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TABNO, 0);
+    }
+    public TANH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TANH, 0);
+    }
+    public TAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TAN, 0);
+    }
+    public TBLORIDXPARTNUM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TBLORIDXPARTNUM, 0);
+    }
+    public TEMPFILE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPFILE, 0);
+    }
+    public TEMPLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPLATE, 0);
+    }
+    public TEMPLATE_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPLATE_TABLE, 0);
+    }
+    public TEMPORARY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMPORARY, 0);
+    }
+    public TEMP_TABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEMP_TABLE, 0);
+    }
+    public TEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TEST, 0);
+    }
+    public THAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THAN, 0);
+    }
+    public THE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THE, 0);
+    }
+    public THEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THEN, 0);
+    }
+    public THREAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THREAD, 0);
+    }
+    public THROUGH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.THROUGH, 0);
+    }
+    public TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME, 0);
+    }
+    public TIMING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMING, 0);
+    }
+    public TIMEOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEOUT, 0);
+    }
+    public TIMES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMES, 0);
+    }
+    public TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMESTAMP, 0);
+    }
+    public TIMEZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE, 0);
+    }
+    public TIMEZONE_ABBR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_ABBR, 0);
+    }
+    public TIMEZONE_HOUR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_HOUR, 0);
+    }
+    public TIMEZONE_MINUTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_MINUTE, 0);
+    }
+    public TIME_ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIME_ZONE, 0);
+    }
+    public TIMEZONE_OFFSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_OFFSET, 0);
+    }
+    public TIMEZONE_REGION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIMEZONE_REGION, 0);
+    }
+    public TIV_GB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIV_GB, 0);
+    }
+    public TIV_SSF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TIV_SSF, 0);
+    }
+    public TO_BINARY_DOUBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_BINARY_DOUBLE, 0);
+    }
+    public TO_BINARY_FLOAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_BINARY_FLOAT, 0);
+    }
+    public TO_BLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_BLOB, 0);
+    }
+    public TO_CHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_CHAR, 0);
+    }
+    public TO_CLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_CLOB, 0);
+    }
+    public TO_DATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_DATE, 0);
+    }
+    public TO_DSINTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_DSINTERVAL, 0);
+    }
+    public TO_LOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_LOB, 0);
+    }
+    public TO_MULTI_BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_MULTI_BYTE, 0);
+    }
+    public TO_NCHAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_NCHAR, 0);
+    }
+    public TO_NCLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_NCLOB, 0);
+    }
+    public TO_NUMBER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_NUMBER, 0);
+    }
+    public TOPLEVEL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TOPLEVEL, 0);
+    }
+    public TO_SINGLE_BYTE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_SINGLE_BYTE, 0);
+    }
+    public TO_TIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_TIME, 0);
+    }
+    public TO_TIMESTAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_TIMESTAMP, 0);
+    }
+    public TO_TIMESTAMP_TZ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_TIMESTAMP_TZ, 0);
+    }
+    public TO_TIME_TZ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_TIME_TZ, 0);
+    }
+    public TO_YMINTERVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TO_YMINTERVAL, 0);
+    }
+    public TRACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRACE, 0);
+    }
+    public TRACING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRACING, 0);
+    }
+    public TRACKING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRACKING, 0);
+    }
+    public TRAILING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRAILING, 0);
+    }
+    public TRANSACTION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSACTION, 0);
+    }
+    public TRANSFORM_DISTINCT_AGG(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSFORM_DISTINCT_AGG, 0);
+    }
+    public TRANSITIONAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSITIONAL, 0);
+    }
+    public TRANSITION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSITION, 0);
+    }
+    public TRANSLATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRANSLATE, 0);
+    }
+    public TREAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TREAT, 0);
+    }
+    public TRIGGERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIGGERS, 0);
+    }
+    public TRIM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRIM, 0);
+    }
+    public TRUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUE, 0);
+    }
+    public TRUNCATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNCATE, 0);
+    }
+    public TRUNC(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUNC, 0);
+    }
+    public TRUSTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TRUSTED, 0);
+    }
+    public TUNING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TUNING, 0);
+    }
+    public TX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TX, 0);
+    }
+    public TYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPE, 0);
+    }
+    public TYPES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TYPES, 0);
+    }
+    public TZ_OFFSET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.TZ_OFFSET, 0);
+    }
+    public UB2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UB2, 0);
+    }
+    public UBA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UBA, 0);
+    }
+    public UID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UID, 0);
+    }
+    public UNARCHIVED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNARCHIVED, 0);
+    }
+    public UNBOUNDED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNBOUNDED, 0);
+    }
+    public UNBOUND(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNBOUND, 0);
+    }
+    public UNDER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNDER, 0);
+    }
+    public UNDO(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNDO, 0);
+    }
+    public UNDROP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNDROP, 0);
+    }
+    public UNIFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNIFORM, 0);
+    }
+    public UNISTR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNISTR, 0);
+    }
+    public UNLIMITED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLIMITED, 0);
+    }
+    public UNLOAD(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLOAD, 0);
+    }
+    public UNLOCK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNLOCK, 0);
+    }
+    public UNNEST_INNERJ_DISTINCT_VIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNNEST_INNERJ_DISTINCT_VIEW, 0);
+    }
+    public UNNEST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNNEST, 0);
+    }
+    public UNNEST_NOSEMIJ_NODISTINCTVIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNNEST_NOSEMIJ_NODISTINCTVIEW, 0);
+    }
+    public UNNEST_SEMIJ_VIEW(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNNEST_SEMIJ_VIEW, 0);
+    }
+    public UNPACKED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNPACKED, 0);
+    }
+    public UNPIVOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNPIVOT, 0);
+    }
+    public UNPROTECTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNPROTECTED, 0);
+    }
+    public UNQUIESCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNQUIESCE, 0);
+    }
+    public UNRECOVERABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNRECOVERABLE, 0);
+    }
+    public UNRESTRICTED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNRESTRICTED, 0);
+    }
+    public UNTIL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNTIL, 0);
+    }
+    public UNUSABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSABLE, 0);
+    }
+    public UNUSED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UNUSED, 0);
+    }
+    public UPDATABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATABLE, 0);
+    }
+    public UPDATED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATED, 0);
+    }
+    public UPDATEXML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPDATEXML, 0);
+    }
+    public UPD_INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPD_INDEXES, 0);
+    }
+    public UPD_JOININDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPD_JOININDEX, 0);
+    }
+    public UPGRADE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPGRADE, 0);
+    }
+    public UPPER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPPER, 0);
+    }
+    public UPSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UPSERT, 0);
+    }
+    public UROWID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.UROWID, 0);
+    }
+    public USAGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USAGE, 0);
+    }
+    public USE_ANTI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_ANTI, 0);
+    }
+    public USE_CONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_CONCAT, 0);
+    }
+    public USE_HASH_AGGREGATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_HASH_AGGREGATION, 0);
+    }
+    public USE_HASH_GBY_FOR_PUSHDOWN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_HASH_GBY_FOR_PUSHDOWN, 0);
+    }
+    public USE_HASH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_HASH, 0);
+    }
+    public USE_INVISIBLE_INDEXES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_INVISIBLE_INDEXES, 0);
+    }
+    public USE_MERGE_CARTESIAN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_MERGE_CARTESIAN, 0);
+    }
+    public USE_MERGE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_MERGE, 0);
+    }
+    public USE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE, 0);
+    }
+    public USE_NL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_NL, 0);
+    }
+    public USE_NL_WITH_INDEX(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_NL_WITH_INDEX, 0);
+    }
+    public USE_PRIVATE_OUTLINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_PRIVATE_OUTLINES, 0);
+    }
+    public USER_DEFINED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER_DEFINED, 0);
+    }
+    public USERENV(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USERENV, 0);
+    }
+    public USERGROUP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USERGROUP, 0);
+    }
+    public USER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER, 0);
+    }
+    public USER_RECYCLEBIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USER_RECYCLEBIN, 0);
+    }
+    public USERS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USERS, 0);
+    }
+    public USE_SEMI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_SEMI, 0);
+    }
+    public USE_STORED_OUTLINES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_STORED_OUTLINES, 0);
+    }
+    public USE_TTT_FOR_GSETS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_TTT_FOR_GSETS, 0);
+    }
+    public USE_WEAK_NAME_RESL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USE_WEAK_NAME_RESL, 0);
+    }
+    public USING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.USING, 0);
+    }
+    public VALIDATE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATE, 0);
+    }
+    public VALIDATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALIDATION, 0);
+    }
+    public VALUE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VALUE, 0);
+    }
+    public VARIANCE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARIANCE, 0);
+    }
+    public VAR_POP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VAR_POP, 0);
+    }
+    public VARRAY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAY, 0);
+    }
+    public VARRAYS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARRAYS, 0);
+    }
+    public VAR_SAMP(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VAR_SAMP, 0);
+    }
+    public VARYING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VARYING, 0);
+    }
+    public VECTOR_READ(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VECTOR_READ, 0);
+    }
+    public VECTOR_READ_TRACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VECTOR_READ_TRACE, 0);
+    }
+    public VERIFY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERIFY, 0);
+    }
+    public VERSIONING(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONING, 0);
+    }
+    public VERSION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSION, 0);
+    }
+    public VERSIONS_ENDSCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS_ENDSCN, 0);
+    }
+    public VERSIONS_ENDTIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS_ENDTIME, 0);
+    }
+    public VERSIONS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS, 0);
+    }
+    public VERSIONS_OPERATION(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS_OPERATION, 0);
+    }
+    public VERSIONS_STARTSCN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS_STARTSCN, 0);
+    }
+    public VERSIONS_STARTTIME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS_STARTTIME, 0);
+    }
+    public VERSIONS_XID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VERSIONS_XID, 0);
+    }
+    public VIRTUAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VIRTUAL, 0);
+    }
+    public VISIBLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VISIBLE, 0);
+    }
+    public VOLUME(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VOLUME, 0);
+    }
+    public VSIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.VSIZE, 0);
+    }
+    public WAIT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WAIT, 0);
+    }
+    public WALLET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WALLET, 0);
+    }
+    public WELLFORMED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WELLFORMED, 0);
+    }
+    public WHENEVER(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHENEVER, 0);
+    }
+    public WHEN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHEN, 0);
+    }
+    public WHITESPACE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WHITESPACE, 0);
+    }
+    public WIDTH_BUCKET(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WIDTH_BUCKET, 0);
+    }
+    public WITHIN(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHIN, 0);
+    }
+    public WITHOUT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WITHOUT, 0);
+    }
+    public WORK(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WORK, 0);
+    }
+    public WRAPPED(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRAPPED, 0);
+    }
+    public WRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.WRITE, 0);
+    }
+    public XDB_FASTPATH_INSERT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XDB_FASTPATH_INSERT, 0);
+    }
+    public X_DYN_PRUNE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.X_DYN_PRUNE, 0);
+    }
+    public XID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XID, 0);
+    }
+    public XML2OBJECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XML2OBJECT, 0);
+    }
+    public XMLATTRIBUTES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLATTRIBUTES, 0);
+    }
+    public XMLCAST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCAST, 0);
+    }
+    public XMLCDATA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCDATA, 0);
+    }
+    public XMLCOLATTVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCOLATTVAL, 0);
+    }
+    public XMLCOMMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCOMMENT, 0);
+    }
+    public XMLCONCAT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLCONCAT, 0);
+    }
+    public XMLDIFF(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLDIFF, 0);
+    }
+    public XML_DML_RWT_STMT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XML_DML_RWT_STMT, 0);
+    }
+    public XMLELEMENT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLELEMENT, 0);
+    }
+    public XMLEXISTS2(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLEXISTS2, 0);
+    }
+    public XMLEXISTS(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLEXISTS, 0);
+    }
+    public XMLFOREST(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLFOREST, 0);
+    }
+    public XMLINDEX_REWRITE_IN_SELECT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLINDEX_REWRITE_IN_SELECT, 0);
+    }
+    public XMLINDEX_REWRITE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLINDEX_REWRITE, 0);
+    }
+    public XMLINDEX_SEL_IDX_TBL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLINDEX_SEL_IDX_TBL, 0);
+    }
+    public XMLISNODE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLISNODE, 0);
+    }
+    public XMLISVALID(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLISVALID, 0);
+    }
+    public XML(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XML, 0);
+    }
+    public XMLNAMESPACES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLNAMESPACES, 0);
+    }
+    public XMLPARSE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLPARSE, 0);
+    }
+    public XMLPATCH(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLPATCH, 0);
+    }
+    public XMLPI(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLPI, 0);
+    }
+    public XMLQUERY(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLQUERY, 0);
+    }
+    public XMLQUERYVAL(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLQUERYVAL, 0);
+    }
+    public XMLROOT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLROOT, 0);
+    }
+    public XMLSCHEMA(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLSCHEMA, 0);
+    }
+    public XMLSERIALIZE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLSERIALIZE, 0);
+    }
+    public XMLTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTABLE, 0);
+    }
+    public XMLTRANSFORMBLOB(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTRANSFORMBLOB, 0);
+    }
+    public XMLTRANSFORM(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTRANSFORM, 0);
+    }
+    public XMLTYPE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XMLTYPE, 0);
+    }
+    public XPATHTABLE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XPATHTABLE, 0);
+    }
+    public XS_SYS_CONTEXT(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.XS_SYS_CONTEXT, 0);
+    }
+    public YEAR(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YEAR, 0);
+    }
+    public YES(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.YES, 0);
+    }
+    public ZONE(): antlr.TerminalNode | null {
+        return this.getToken(PlSqlParser.ZONE, 0);
+    }
+    public override get ruleIndex(): number {
+        return PlSqlParser.RULE_non_reserved_keywords_pre12c;
+    }
+    public override enterRule(listener: PlSqlParserListener): void {
+        if(listener.enterNon_reserved_keywords_pre12c) {
+             listener.enterNon_reserved_keywords_pre12c(this);
+        }
+    }
+    public override exitRule(listener: PlSqlParserListener): void {
+        if(listener.exitNon_reserved_keywords_pre12c) {
+             listener.exitNon_reserved_keywords_pre12c(this);
+        }
+    }
+}
diff --git a/gitnexus/src/core/ingestion/plsql/generated/PlSqlParserBase.ts b/gitnexus/src/core/ingestion/plsql/generated/PlSqlParserBase.ts
new file mode 100644
index 000000000..36177d68d
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/generated/PlSqlParserBase.ts
@@ -0,0 +1,117 @@
+import { Parser, TokenStream, CommonTokenStream, Token } from 'antlr4ng';
+import { PlSqlLexer } from './PlSqlLexer.js';
+
+export abstract class PlSqlParserBase extends Parser {
+
+  _isVersion10: boolean;
+  _isVersion11: boolean;
+  _isVersion12: boolean;
+  _lastUnitWasPlsql: boolean;
+
+  constructor(input: TokenStream) {
+    super(input);
+    this._isVersion10 = true;
+    this._isVersion11 = true;
+    this._isVersion12 = true;
+    this._lastUnitWasPlsql = false;
+  }
+
+  reset(): void {
+    this._lastUnitWasPlsql = false;
+    super.reset();
+  }
+
+  setLastUnitPlsql(): void { this._lastUnitWasPlsql = true; }
+  setLastUnitSql(): void   { this._lastUnitWasPlsql = false; }
+  isLastUnitSql(): boolean { return !this._lastUnitWasPlsql; }
+  isLastUnitPlsql(): boolean { return this._lastUnitWasPlsql; }
+
+  isSolidusSeparator(): boolean {
+    const stream = this.tokenStream as CommonTokenStream;
+    const solidus = stream.LT(1);
+    if (solidus == null || solidus!.type !== PlSqlLexer.SOLIDUS)
+      return false;
+
+    const solidusLine = solidus!.line;
+
+    const prev = stream.LT(-1);
+    if (prev != null && prev!.type !== Token.EOF && prev!.line === solidusLine)
+      return false;
+
+    const next = stream.LT(2);
+    if (next != null && next!.type !== Token.EOF && next!.line === solidusLine)
+      return false;
+
+    return true;
+  }
+
+  /** True when the current token is the first significant token on its line. */
+  isLineStart(): boolean {
+    const stream = this.tokenStream as CommonTokenStream;
+    const token = stream.LT(1);
+    if (token == null) {
+      return false;
+    }
+
+    const prev = stream.LT(-1);
+    if (prev == null || prev.type === Token.EOF) {
+      return true;
+    }
+
+    return prev.line < token.line;
+  }
+
+  isVersion10(): boolean {
+    return this._isVersion10;
+  }
+
+  isVersion11(): boolean {
+    return this._isVersion11;
+  }
+
+  isVersion12(): boolean {
+    return this._isVersion12;
+  }
+
+  setVersion10(value: boolean): void {
+    this._isVersion10 = value;
+  }
+
+  setVersion11(value: boolean): void {
+    this._isVersion11 = value;
+  }
+
+  setVersion12(value: boolean): void {
+    this._isVersion12 = value;
+  }
+
+  IsNotNumericFunction(): boolean {
+    const lt1 = (this.tokenStream as CommonTokenStream).LT(1);
+    const lt2 = (this.tokenStream as CommonTokenStream).LT(2);
+    if ((lt1!.type === PlSqlLexer.SUM ||
+      lt1!.type === PlSqlLexer.COUNT ||
+      lt1!.type === PlSqlLexer.AVG ||
+      lt1!.type === PlSqlLexer.MIN ||
+      lt1!.type === PlSqlLexer.MAX ||
+      lt1!.type === PlSqlLexer.ROUND ||
+      lt1!.type === PlSqlLexer.LEAST ||
+      lt1!.type === PlSqlLexer.GREATEST) && lt2!.type === PlSqlLexer.LEFT_PAREN)
+      return false;
+    return true;
+  }
+
+  isNotStartOfJoin(): boolean {
+    const lt1 = (this.tokenStream as CommonTokenStream).LT(1);
+    if (lt1!.type == PlSqlLexer.INNER ||
+        lt1!.type == PlSqlLexer.CROSS ||
+        lt1!.type == PlSqlLexer.NATURAL ||
+        lt1!.type == PlSqlLexer.PARTITION ||
+        lt1!.type == PlSqlLexer.FULL ||
+        lt1!.type == PlSqlLexer.LEFT ||
+        lt1!.type == PlSqlLexer.RIGHT ||
+        lt1!.type == PlSqlLexer.OUTER)
+        return false;
+    return true;
+  }
+
+}
diff --git a/gitnexus/src/core/ingestion/plsql/generated/PlSqlParserListener.ts b/gitnexus/src/core/ingestion/plsql/generated/PlSqlParserListener.ts
new file mode 100644
index 000000000..0e27e72b6
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/generated/PlSqlParserListener.ts
@@ -0,0 +1,13489 @@
+
+import { ErrorNode, ParseTreeListener, ParserRuleContext, TerminalNode } from "antlr4ng";
+
+import { PlSqlParserBase } from "./PlSqlParserBase.js"
+
+import { Sql_scriptContext } from "./PlSqlParser.js";
+import { Script_unitContext } from "./PlSqlParser.js";
+import { TerminatorContext } from "./PlSqlParser.js";
+import { Plsql_unitContext } from "./PlSqlParser.js";
+import { Sql_unitContext } from "./PlSqlParser.js";
+import { Alter_diskgroupContext } from "./PlSqlParser.js";
+import { Add_disk_clauseContext } from "./PlSqlParser.js";
+import { Drop_disk_clauseContext } from "./PlSqlParser.js";
+import { Resize_disk_clauseContext } from "./PlSqlParser.js";
+import { Replace_disk_clauseContext } from "./PlSqlParser.js";
+import { Wait_nowaitContext } from "./PlSqlParser.js";
+import { Rename_disk_clauseContext } from "./PlSqlParser.js";
+import { Disk_online_clauseContext } from "./PlSqlParser.js";
+import { Disk_offline_clauseContext } from "./PlSqlParser.js";
+import { Timeout_clauseContext } from "./PlSqlParser.js";
+import { Rebalance_diskgroup_clauseContext } from "./PlSqlParser.js";
+import { PhaseContext } from "./PlSqlParser.js";
+import { Check_diskgroup_clauseContext } from "./PlSqlParser.js";
+import { Diskgroup_template_clausesContext } from "./PlSqlParser.js";
+import { Qualified_template_clauseContext } from "./PlSqlParser.js";
+import { Redundancy_clauseContext } from "./PlSqlParser.js";
+import { Striping_clauseContext } from "./PlSqlParser.js";
+import { Force_noforceContext } from "./PlSqlParser.js";
+import { Diskgroup_directory_clausesContext } from "./PlSqlParser.js";
+import { Dir_nameContext } from "./PlSqlParser.js";
+import { Diskgroup_alias_clausesContext } from "./PlSqlParser.js";
+import { Diskgroup_volume_clausesContext } from "./PlSqlParser.js";
+import { Add_volume_clauseContext } from "./PlSqlParser.js";
+import { Modify_volume_clauseContext } from "./PlSqlParser.js";
+import { Diskgroup_attributesContext } from "./PlSqlParser.js";
+import { Drop_diskgroup_file_clauseContext } from "./PlSqlParser.js";
+import { Convert_redundancy_clauseContext } from "./PlSqlParser.js";
+import { Usergroup_clausesContext } from "./PlSqlParser.js";
+import { User_clausesContext } from "./PlSqlParser.js";
+import { File_permissions_clauseContext } from "./PlSqlParser.js";
+import { File_owner_clauseContext } from "./PlSqlParser.js";
+import { Scrub_clauseContext } from "./PlSqlParser.js";
+import { Quotagroup_clausesContext } from "./PlSqlParser.js";
+import { Property_nameContext } from "./PlSqlParser.js";
+import { Property_valueContext } from "./PlSqlParser.js";
+import { Filegroup_clausesContext } from "./PlSqlParser.js";
+import { Add_filegroup_clauseContext } from "./PlSqlParser.js";
+import { Modify_filegroup_clauseContext } from "./PlSqlParser.js";
+import { Move_to_filegroup_clauseContext } from "./PlSqlParser.js";
+import { Drop_filegroup_clauseContext } from "./PlSqlParser.js";
+import { Quorum_regularContext } from "./PlSqlParser.js";
+import { Undrop_disk_clauseContext } from "./PlSqlParser.js";
+import { Diskgroup_availabilityContext } from "./PlSqlParser.js";
+import { Enable_disable_volumeContext } from "./PlSqlParser.js";
+import { Drop_functionContext } from "./PlSqlParser.js";
+import { Alter_flashback_archiveContext } from "./PlSqlParser.js";
+import { Alter_hierarchyContext } from "./PlSqlParser.js";
+import { Alter_functionContext } from "./PlSqlParser.js";
+import { Alter_javaContext } from "./PlSqlParser.js";
+import { Match_stringContext } from "./PlSqlParser.js";
+import { Create_function_bodyContext } from "./PlSqlParser.js";
+import { Sql_macro_bodyContext } from "./PlSqlParser.js";
+import { Parallel_enable_clauseContext } from "./PlSqlParser.js";
+import { Partition_by_clauseContext } from "./PlSqlParser.js";
+import { Result_cache_clauseContext } from "./PlSqlParser.js";
+import { Accessible_by_clauseContext } from "./PlSqlParser.js";
+import { Default_collation_clauseContext } from "./PlSqlParser.js";
+import { Aggregate_clauseContext } from "./PlSqlParser.js";
+import { Pipelined_using_clauseContext } from "./PlSqlParser.js";
+import { AccessorContext } from "./PlSqlParser.js";
+import { Relies_on_partContext } from "./PlSqlParser.js";
+import { Streaming_clauseContext } from "./PlSqlParser.js";
+import { Alter_outlineContext } from "./PlSqlParser.js";
+import { Outline_optionsContext } from "./PlSqlParser.js";
+import { Alter_lockdown_profileContext } from "./PlSqlParser.js";
+import { Lockdown_featureContext } from "./PlSqlParser.js";
+import { Lockdown_optionsContext } from "./PlSqlParser.js";
+import { Lockdown_statementsContext } from "./PlSqlParser.js";
+import { Statement_clausesContext } from "./PlSqlParser.js";
+import { Clause_optionsContext } from "./PlSqlParser.js";
+import { Option_valuesContext } from "./PlSqlParser.js";
+import { String_listContext } from "./PlSqlParser.js";
+import { Disable_enableContext } from "./PlSqlParser.js";
+import { Drop_lockdown_profileContext } from "./PlSqlParser.js";
+import { Drop_packageContext } from "./PlSqlParser.js";
+import { Alter_packageContext } from "./PlSqlParser.js";
+import { Create_packageContext } from "./PlSqlParser.js";
+import { Create_package_bodyContext } from "./PlSqlParser.js";
+import { Package_obj_specContext } from "./PlSqlParser.js";
+import { Procedure_specContext } from "./PlSqlParser.js";
+import { Function_specContext } from "./PlSqlParser.js";
+import { Package_obj_bodyContext } from "./PlSqlParser.js";
+import { Alter_pmem_filestoreContext } from "./PlSqlParser.js";
+import { Drop_pmem_filestoreContext } from "./PlSqlParser.js";
+import { Drop_procedureContext } from "./PlSqlParser.js";
+import { Alter_procedureContext } from "./PlSqlParser.js";
+import { Function_bodyContext } from "./PlSqlParser.js";
+import { Procedure_bodyContext } from "./PlSqlParser.js";
+import { Create_procedure_bodyContext } from "./PlSqlParser.js";
+import { Alter_resource_costContext } from "./PlSqlParser.js";
+import { Drop_outlineContext } from "./PlSqlParser.js";
+import { Alter_rollback_segmentContext } from "./PlSqlParser.js";
+import { Drop_restore_pointContext } from "./PlSqlParser.js";
+import { Drop_rollback_segmentContext } from "./PlSqlParser.js";
+import { Drop_roleContext } from "./PlSqlParser.js";
+import { Create_pmem_filestoreContext } from "./PlSqlParser.js";
+import { Pmem_filestore_optionsContext } from "./PlSqlParser.js";
+import { File_pathContext } from "./PlSqlParser.js";
+import { Create_rollback_segmentContext } from "./PlSqlParser.js";
+import { Drop_triggerContext } from "./PlSqlParser.js";
+import { Alter_triggerContext } from "./PlSqlParser.js";
+import { Create_triggerContext } from "./PlSqlParser.js";
+import { Trigger_follows_clauseContext } from "./PlSqlParser.js";
+import { Trigger_when_clauseContext } from "./PlSqlParser.js";
+import { Simple_dml_triggerContext } from "./PlSqlParser.js";
+import { For_each_rowContext } from "./PlSqlParser.js";
+import { Compound_dml_triggerContext } from "./PlSqlParser.js";
+import { Non_dml_triggerContext } from "./PlSqlParser.js";
+import { Trigger_bodyContext } from "./PlSqlParser.js";
+import { Compound_trigger_blockContext } from "./PlSqlParser.js";
+import { Timing_point_sectionContext } from "./PlSqlParser.js";
+import { Non_dml_eventContext } from "./PlSqlParser.js";
+import { Dml_event_clauseContext } from "./PlSqlParser.js";
+import { Dml_event_elementContext } from "./PlSqlParser.js";
+import { Dml_event_nested_clauseContext } from "./PlSqlParser.js";
+import { Referencing_clauseContext } from "./PlSqlParser.js";
+import { Referencing_elementContext } from "./PlSqlParser.js";
+import { Drop_typeContext } from "./PlSqlParser.js";
+import { Alter_typeContext } from "./PlSqlParser.js";
+import { Compile_type_clauseContext } from "./PlSqlParser.js";
+import { Replace_type_clauseContext } from "./PlSqlParser.js";
+import { Alter_method_specContext } from "./PlSqlParser.js";
+import { Alter_method_elementContext } from "./PlSqlParser.js";
+import { Alter_attribute_definitionContext } from "./PlSqlParser.js";
+import { Alter_collection_clausesContext } from "./PlSqlParser.js";
+import { Dependent_handling_clauseContext } from "./PlSqlParser.js";
+import { Dependent_exceptions_partContext } from "./PlSqlParser.js";
+import { Create_typeContext } from "./PlSqlParser.js";
+import { Create_type_specContext } from "./PlSqlParser.js";
+import { Create_type_bodyContext } from "./PlSqlParser.js";
+import { Type_definitionContext } from "./PlSqlParser.js";
+import { Object_type_defContext } from "./PlSqlParser.js";
+import { Object_as_partContext } from "./PlSqlParser.js";
+import { Object_under_partContext } from "./PlSqlParser.js";
+import { Nested_table_type_defContext } from "./PlSqlParser.js";
+import { Sqlj_object_typeContext } from "./PlSqlParser.js";
+import { Type_bodyContext } from "./PlSqlParser.js";
+import { Type_body_elementsContext } from "./PlSqlParser.js";
+import { Map_order_func_declarationContext } from "./PlSqlParser.js";
+import { Subprog_decl_in_typeContext } from "./PlSqlParser.js";
+import { Proc_decl_in_typeContext } from "./PlSqlParser.js";
+import { Func_decl_in_typeContext } from "./PlSqlParser.js";
+import { Constructor_declarationContext } from "./PlSqlParser.js";
+import { Modifier_clauseContext } from "./PlSqlParser.js";
+import { Object_member_specContext } from "./PlSqlParser.js";
+import { Sqlj_object_type_attrContext } from "./PlSqlParser.js";
+import { Element_specContext } from "./PlSqlParser.js";
+import { Element_spec_optionsContext } from "./PlSqlParser.js";
+import { Subprogram_specContext } from "./PlSqlParser.js";
+import { Overriding_subprogram_specContext } from "./PlSqlParser.js";
+import { Overriding_function_specContext } from "./PlSqlParser.js";
+import { Overriding_procedure_specContext } from "./PlSqlParser.js";
+import { Type_procedure_specContext } from "./PlSqlParser.js";
+import { Type_function_specContext } from "./PlSqlParser.js";
+import { Constructor_specContext } from "./PlSqlParser.js";
+import { Map_order_function_specContext } from "./PlSqlParser.js";
+import { Pragma_clauseContext } from "./PlSqlParser.js";
+import { Pragma_elementsContext } from "./PlSqlParser.js";
+import { Type_elements_parameterContext } from "./PlSqlParser.js";
+import { Drop_sequenceContext } from "./PlSqlParser.js";
+import { Alter_sequenceContext } from "./PlSqlParser.js";
+import { Alter_sessionContext } from "./PlSqlParser.js";
+import { Alter_session_set_clauseContext } from "./PlSqlParser.js";
+import { Create_sequenceContext } from "./PlSqlParser.js";
+import { Sequence_specContext } from "./PlSqlParser.js";
+import { Sequence_start_clauseContext } from "./PlSqlParser.js";
+import { Create_analytic_viewContext } from "./PlSqlParser.js";
+import { Classification_clauseContext } from "./PlSqlParser.js";
+import { Caption_clauseContext } from "./PlSqlParser.js";
+import { Description_clauseContext } from "./PlSqlParser.js";
+import { Classification_itemContext } from "./PlSqlParser.js";
+import { LanguageContext } from "./PlSqlParser.js";
+import { Cav_using_clauseContext } from "./PlSqlParser.js";
+import { Dim_by_clauseContext } from "./PlSqlParser.js";
+import { Dim_keyContext } from "./PlSqlParser.js";
+import { Dim_refContext } from "./PlSqlParser.js";
+import { Hier_refContext } from "./PlSqlParser.js";
+import { Measures_clauseContext } from "./PlSqlParser.js";
+import { Av_measureContext } from "./PlSqlParser.js";
+import { Base_meas_clauseContext } from "./PlSqlParser.js";
+import { Meas_aggregate_clauseContext } from "./PlSqlParser.js";
+import { Calc_meas_clauseContext } from "./PlSqlParser.js";
+import { Default_measure_clauseContext } from "./PlSqlParser.js";
+import { Default_aggregate_clauseContext } from "./PlSqlParser.js";
+import { Cache_clauseContext } from "./PlSqlParser.js";
+import { Cache_specificationContext } from "./PlSqlParser.js";
+import { Levels_clauseContext } from "./PlSqlParser.js";
+import { Level_specificationContext } from "./PlSqlParser.js";
+import { Level_group_typeContext } from "./PlSqlParser.js";
+import { Fact_columns_clauseContext } from "./PlSqlParser.js";
+import { Qry_transform_clauseContext } from "./PlSqlParser.js";
+import { Create_attribute_dimensionContext } from "./PlSqlParser.js";
+import { Ad_using_clauseContext } from "./PlSqlParser.js";
+import { Source_clauseContext } from "./PlSqlParser.js";
+import { Join_path_clauseContext } from "./PlSqlParser.js";
+import { Join_conditionContext } from "./PlSqlParser.js";
+import { Join_condition_itemContext } from "./PlSqlParser.js";
+import { Attributes_clauseContext } from "./PlSqlParser.js";
+import { Ad_attributes_clauseContext } from "./PlSqlParser.js";
+import { Ad_level_clauseContext } from "./PlSqlParser.js";
+import { Key_clauseContext } from "./PlSqlParser.js";
+import { Alternate_key_clauseContext } from "./PlSqlParser.js";
+import { Dim_order_clauseContext } from "./PlSqlParser.js";
+import { All_clauseContext } from "./PlSqlParser.js";
+import { Create_audit_policyContext } from "./PlSqlParser.js";
+import { Privilege_audit_clauseContext } from "./PlSqlParser.js";
+import { Action_audit_clauseContext } from "./PlSqlParser.js";
+import { System_actionsContext } from "./PlSqlParser.js";
+import { Standard_actionsContext } from "./PlSqlParser.js";
+import { Actions_clauseContext } from "./PlSqlParser.js";
+import { Object_actionContext } from "./PlSqlParser.js";
+import { System_actionContext } from "./PlSqlParser.js";
+import { Component_actionsContext } from "./PlSqlParser.js";
+import { Component_actionContext } from "./PlSqlParser.js";
+import { Role_audit_clauseContext } from "./PlSqlParser.js";
+import { Create_controlfileContext } from "./PlSqlParser.js";
+import { Controlfile_optionsContext } from "./PlSqlParser.js";
+import { Logfile_clauseContext } from "./PlSqlParser.js";
+import { Character_set_clauseContext } from "./PlSqlParser.js";
+import { File_specificationContext } from "./PlSqlParser.js";
+import { Create_diskgroupContext } from "./PlSqlParser.js";
+import { Qualified_disk_clauseContext } from "./PlSqlParser.js";
+import { Create_editionContext } from "./PlSqlParser.js";
+import { Create_flashback_archiveContext } from "./PlSqlParser.js";
+import { Flashback_archive_quotaContext } from "./PlSqlParser.js";
+import { Flashback_archive_retentionContext } from "./PlSqlParser.js";
+import { Create_hierarchyContext } from "./PlSqlParser.js";
+import { Hier_using_clauseContext } from "./PlSqlParser.js";
+import { Level_hier_clauseContext } from "./PlSqlParser.js";
+import { Hier_attrs_clauseContext } from "./PlSqlParser.js";
+import { Hier_attr_clauseContext } from "./PlSqlParser.js";
+import { Hier_attr_nameContext } from "./PlSqlParser.js";
+import { Create_indexContext } from "./PlSqlParser.js";
+import { Cluster_index_clauseContext } from "./PlSqlParser.js";
+import { Cluster_nameContext } from "./PlSqlParser.js";
+import { Table_index_clauseContext } from "./PlSqlParser.js";
+import { Bitmap_join_index_clauseContext } from "./PlSqlParser.js";
+import { Index_exprContext } from "./PlSqlParser.js";
+import { Index_propertiesContext } from "./PlSqlParser.js";
+import { Domain_index_clauseContext } from "./PlSqlParser.js";
+import { Local_domain_index_clauseContext } from "./PlSqlParser.js";
+import { Xmlindex_clauseContext } from "./PlSqlParser.js";
+import { Local_xmlindex_clauseContext } from "./PlSqlParser.js";
+import { Global_partitioned_indexContext } from "./PlSqlParser.js";
+import { Index_partitioning_clauseContext } from "./PlSqlParser.js";
+import { Index_partitioning_values_listContext } from "./PlSqlParser.js";
+import { Local_partitioned_indexContext } from "./PlSqlParser.js";
+import { On_range_partitioned_tableContext } from "./PlSqlParser.js";
+import { On_list_partitioned_tableContext } from "./PlSqlParser.js";
+import { Partitioned_tableContext } from "./PlSqlParser.js";
+import { On_hash_partitioned_tableContext } from "./PlSqlParser.js";
+import { On_hash_partitioned_clauseContext } from "./PlSqlParser.js";
+import { On_comp_partitioned_tableContext } from "./PlSqlParser.js";
+import { On_comp_partitioned_clauseContext } from "./PlSqlParser.js";
+import { Index_subpartition_clauseContext } from "./PlSqlParser.js";
+import { Index_subpartition_subclauseContext } from "./PlSqlParser.js";
+import { Odci_parametersContext } from "./PlSqlParser.js";
+import { IndextypeContext } from "./PlSqlParser.js";
+import { Alter_indexContext } from "./PlSqlParser.js";
+import { Alter_index_ops_set1Context } from "./PlSqlParser.js";
+import { Alter_index_ops_set2Context } from "./PlSqlParser.js";
+import { Visible_or_invisibleContext } from "./PlSqlParser.js";
+import { Monitoring_nomonitoringContext } from "./PlSqlParser.js";
+import { Rebuild_clauseContext } from "./PlSqlParser.js";
+import { Alter_index_partitioningContext } from "./PlSqlParser.js";
+import { Modify_index_default_attrsContext } from "./PlSqlParser.js";
+import { Add_hash_index_partitionContext } from "./PlSqlParser.js";
+import { Coalesce_index_partitionContext } from "./PlSqlParser.js";
+import { Modify_index_partitionContext } from "./PlSqlParser.js";
+import { Modify_index_partitions_opsContext } from "./PlSqlParser.js";
+import { Rename_index_partitionContext } from "./PlSqlParser.js";
+import { Drop_index_partitionContext } from "./PlSqlParser.js";
+import { Split_index_partitionContext } from "./PlSqlParser.js";
+import { Index_partition_descriptionContext } from "./PlSqlParser.js";
+import { Modify_index_subpartitionContext } from "./PlSqlParser.js";
+import { Partition_name_oldContext } from "./PlSqlParser.js";
+import { New_partition_nameContext } from "./PlSqlParser.js";
+import { New_index_nameContext } from "./PlSqlParser.js";
+import { Alter_inmemory_join_groupContext } from "./PlSqlParser.js";
+import { Create_userContext } from "./PlSqlParser.js";
+import { Alter_userContext } from "./PlSqlParser.js";
+import { Drop_userContext } from "./PlSqlParser.js";
+import { Alter_identified_byContext } from "./PlSqlParser.js";
+import { Identified_byContext } from "./PlSqlParser.js";
+import { Identified_other_clauseContext } from "./PlSqlParser.js";
+import { User_tablespace_clauseContext } from "./PlSqlParser.js";
+import { Quota_clauseContext } from "./PlSqlParser.js";
+import { Profile_clauseContext } from "./PlSqlParser.js";
+import { Role_clauseContext } from "./PlSqlParser.js";
+import { User_default_role_clauseContext } from "./PlSqlParser.js";
+import { Password_expire_clauseContext } from "./PlSqlParser.js";
+import { User_lock_clauseContext } from "./PlSqlParser.js";
+import { User_editions_clauseContext } from "./PlSqlParser.js";
+import { Alter_user_editions_clauseContext } from "./PlSqlParser.js";
+import { Proxy_clauseContext } from "./PlSqlParser.js";
+import { Container_namesContext } from "./PlSqlParser.js";
+import { Set_container_dataContext } from "./PlSqlParser.js";
+import { Add_rem_container_dataContext } from "./PlSqlParser.js";
+import { Container_data_clauseContext } from "./PlSqlParser.js";
+import { Administer_key_managementContext } from "./PlSqlParser.js";
+import { Keystore_management_clausesContext } from "./PlSqlParser.js";
+import { Create_keystoreContext } from "./PlSqlParser.js";
+import { Open_keystoreContext } from "./PlSqlParser.js";
+import { Force_keystoreContext } from "./PlSqlParser.js";
+import { Close_keystoreContext } from "./PlSqlParser.js";
+import { Backup_keystoreContext } from "./PlSqlParser.js";
+import { Alter_keystore_passwordContext } from "./PlSqlParser.js";
+import { Merge_into_new_keystoreContext } from "./PlSqlParser.js";
+import { Merge_into_existing_keystoreContext } from "./PlSqlParser.js";
+import { Isolate_keystoreContext } from "./PlSqlParser.js";
+import { Unite_keystoreContext } from "./PlSqlParser.js";
+import { Key_management_clausesContext } from "./PlSqlParser.js";
+import { Set_keyContext } from "./PlSqlParser.js";
+import { Create_keyContext } from "./PlSqlParser.js";
+import { MkidContext } from "./PlSqlParser.js";
+import { MkContext } from "./PlSqlParser.js";
+import { Use_keyContext } from "./PlSqlParser.js";
+import { Set_key_tagContext } from "./PlSqlParser.js";
+import { Export_keysContext } from "./PlSqlParser.js";
+import { Import_keysContext } from "./PlSqlParser.js";
+import { Migrate_keysContext } from "./PlSqlParser.js";
+import { Reverse_migrate_keysContext } from "./PlSqlParser.js";
+import { Move_keysContext } from "./PlSqlParser.js";
+import { Identified_by_storeContext } from "./PlSqlParser.js";
+import { Using_algorithm_clauseContext } from "./PlSqlParser.js";
+import { Using_tag_clauseContext } from "./PlSqlParser.js";
+import { Secret_management_clausesContext } from "./PlSqlParser.js";
+import { Add_update_secretContext } from "./PlSqlParser.js";
+import { Delete_secretContext } from "./PlSqlParser.js";
+import { Add_update_secret_sepsContext } from "./PlSqlParser.js";
+import { Delete_secret_sepsContext } from "./PlSqlParser.js";
+import { Zero_downtime_software_patching_clausesContext } from "./PlSqlParser.js";
+import { With_backup_clauseContext } from "./PlSqlParser.js";
+import { Identified_by_password_clauseContext } from "./PlSqlParser.js";
+import { Keystore_passwordContext } from "./PlSqlParser.js";
+import { PathContext } from "./PlSqlParser.js";
+import { SecretContext } from "./PlSqlParser.js";
+import { AnalyzeContext } from "./PlSqlParser.js";
+import { Partition_extention_clauseContext } from "./PlSqlParser.js";
+import { Validation_clausesContext } from "./PlSqlParser.js";
+import { Compute_clausesContext } from "./PlSqlParser.js";
+import { For_clauseContext } from "./PlSqlParser.js";
+import { Online_or_offlineContext } from "./PlSqlParser.js";
+import { Into_clause1Context } from "./PlSqlParser.js";
+import { Partition_key_valueContext } from "./PlSqlParser.js";
+import { Subpartition_key_valueContext } from "./PlSqlParser.js";
+import { Associate_statisticsContext } from "./PlSqlParser.js";
+import { Column_associationContext } from "./PlSqlParser.js";
+import { Function_associationContext } from "./PlSqlParser.js";
+import { Indextype_nameContext } from "./PlSqlParser.js";
+import { Using_statistics_typeContext } from "./PlSqlParser.js";
+import { Statistics_type_nameContext } from "./PlSqlParser.js";
+import { Default_cost_clauseContext } from "./PlSqlParser.js";
+import { Cpu_costContext } from "./PlSqlParser.js";
+import { Io_costContext } from "./PlSqlParser.js";
+import { Network_costContext } from "./PlSqlParser.js";
+import { Default_selectivity_clauseContext } from "./PlSqlParser.js";
+import { Default_selectivityContext } from "./PlSqlParser.js";
+import { Storage_table_clauseContext } from "./PlSqlParser.js";
+import { Unified_auditingContext } from "./PlSqlParser.js";
+import { Policy_nameContext } from "./PlSqlParser.js";
+import { Audit_traditionalContext } from "./PlSqlParser.js";
+import { Audit_direct_pathContext } from "./PlSqlParser.js";
+import { Audit_container_clauseContext } from "./PlSqlParser.js";
+import { Audit_operation_clauseContext } from "./PlSqlParser.js";
+import { Auditing_by_clauseContext } from "./PlSqlParser.js";
+import { Audit_userContext } from "./PlSqlParser.js";
+import { Audit_schema_object_clauseContext } from "./PlSqlParser.js";
+import { Sql_operationContext } from "./PlSqlParser.js";
+import { Auditing_on_clauseContext } from "./PlSqlParser.js";
+import { Model_nameContext } from "./PlSqlParser.js";
+import { Object_nameContext } from "./PlSqlParser.js";
+import { Profile_nameContext } from "./PlSqlParser.js";
+import { Sql_statement_shortcutContext } from "./PlSqlParser.js";
+import { Drop_indexContext } from "./PlSqlParser.js";
+import { Disassociate_statisticsContext } from "./PlSqlParser.js";
+import { Drop_indextypeContext } from "./PlSqlParser.js";
+import { Drop_inmemory_join_groupContext } from "./PlSqlParser.js";
+import { Flashback_tableContext } from "./PlSqlParser.js";
+import { Restore_pointContext } from "./PlSqlParser.js";
+import { Purge_statementContext } from "./PlSqlParser.js";
+import { Noaudit_statementContext } from "./PlSqlParser.js";
+import { Rename_objectContext } from "./PlSqlParser.js";
+import { Grant_statementContext } from "./PlSqlParser.js";
+import { Container_clauseContext } from "./PlSqlParser.js";
+import { Revoke_statementContext } from "./PlSqlParser.js";
+import { Revoke_system_privilegeContext } from "./PlSqlParser.js";
+import { Revokee_clauseContext } from "./PlSqlParser.js";
+import { Revoke_object_privilegesContext } from "./PlSqlParser.js";
+import { On_object_clauseContext } from "./PlSqlParser.js";
+import { Revoke_roles_from_programsContext } from "./PlSqlParser.js";
+import { Program_unitContext } from "./PlSqlParser.js";
+import { Create_dimensionContext } from "./PlSqlParser.js";
+import { Create_directoryContext } from "./PlSqlParser.js";
+import { Directory_nameContext } from "./PlSqlParser.js";
+import { Directory_pathContext } from "./PlSqlParser.js";
+import { Create_inmemory_join_groupContext } from "./PlSqlParser.js";
+import { Drop_hierarchyContext } from "./PlSqlParser.js";
+import { Alter_libraryContext } from "./PlSqlParser.js";
+import { Drop_javaContext } from "./PlSqlParser.js";
+import { Drop_libraryContext } from "./PlSqlParser.js";
+import { Create_javaContext } from "./PlSqlParser.js";
+import { Create_libraryContext } from "./PlSqlParser.js";
+import { Plsql_library_sourceContext } from "./PlSqlParser.js";
+import { Credential_nameContext } from "./PlSqlParser.js";
+import { Library_editionableContext } from "./PlSqlParser.js";
+import { Library_debugContext } from "./PlSqlParser.js";
+import { Compiler_parameters_clauseContext } from "./PlSqlParser.js";
+import { Parameter_valueContext } from "./PlSqlParser.js";
+import { Library_nameContext } from "./PlSqlParser.js";
+import { Alter_dimensionContext } from "./PlSqlParser.js";
+import { Level_clauseContext } from "./PlSqlParser.js";
+import { Hierarchy_clauseContext } from "./PlSqlParser.js";
+import { Dimension_join_clauseContext } from "./PlSqlParser.js";
+import { Attribute_clauseContext } from "./PlSqlParser.js";
+import { Extended_attribute_clauseContext } from "./PlSqlParser.js";
+import { Column_one_or_more_sub_clauseContext } from "./PlSqlParser.js";
+import { Alter_viewContext } from "./PlSqlParser.js";
+import { Alter_view_editionableContext } from "./PlSqlParser.js";
+import { Create_viewContext } from "./PlSqlParser.js";
+import { Editioning_clauseContext } from "./PlSqlParser.js";
+import { View_optionsContext } from "./PlSqlParser.js";
+import { View_alias_constraintContext } from "./PlSqlParser.js";
+import { Object_view_clauseContext } from "./PlSqlParser.js";
+import { Inline_constraintContext } from "./PlSqlParser.js";
+import { Inline_ref_constraintContext } from "./PlSqlParser.js";
+import { Out_of_line_ref_constraintContext } from "./PlSqlParser.js";
+import { Out_of_line_constraintContext } from "./PlSqlParser.js";
+import { Constraint_stateContext } from "./PlSqlParser.js";
+import { Xmltype_view_clauseContext } from "./PlSqlParser.js";
+import { Xml_schema_specContext } from "./PlSqlParser.js";
+import { Xml_schema_urlContext } from "./PlSqlParser.js";
+import { ElementContext } from "./PlSqlParser.js";
+import { Alter_tablespaceContext } from "./PlSqlParser.js";
+import { Datafile_tempfile_clausesContext } from "./PlSqlParser.js";
+import { Tablespace_logging_clausesContext } from "./PlSqlParser.js";
+import { Tablespace_group_clauseContext } from "./PlSqlParser.js";
+import { Tablespace_group_nameContext } from "./PlSqlParser.js";
+import { Tablespace_state_clausesContext } from "./PlSqlParser.js";
+import { Flashback_mode_clauseContext } from "./PlSqlParser.js";
+import { New_tablespace_nameContext } from "./PlSqlParser.js";
+import { Create_tablespaceContext } from "./PlSqlParser.js";
+import { Permanent_tablespace_clauseContext } from "./PlSqlParser.js";
+import { Tablespace_encryption_specContext } from "./PlSqlParser.js";
+import { Logging_clauseContext } from "./PlSqlParser.js";
+import { Extent_management_clauseContext } from "./PlSqlParser.js";
+import { Segment_management_clauseContext } from "./PlSqlParser.js";
+import { Temporary_tablespace_clauseContext } from "./PlSqlParser.js";
+import { Undo_tablespace_clauseContext } from "./PlSqlParser.js";
+import { Tablespace_retention_clauseContext } from "./PlSqlParser.js";
+import { Create_tablespace_setContext } from "./PlSqlParser.js";
+import { Permanent_tablespace_attrsContext } from "./PlSqlParser.js";
+import { Tablespace_encryption_clauseContext } from "./PlSqlParser.js";
+import { Default_tablespace_paramsContext } from "./PlSqlParser.js";
+import { Default_table_compressionContext } from "./PlSqlParser.js";
+import { Low_highContext } from "./PlSqlParser.js";
+import { Default_index_compressionContext } from "./PlSqlParser.js";
+import { Inmmemory_clauseContext } from "./PlSqlParser.js";
+import { Datafile_specificationContext } from "./PlSqlParser.js";
+import { Tempfile_specificationContext } from "./PlSqlParser.js";
+import { Datafile_tempfile_specContext } from "./PlSqlParser.js";
+import { Redo_log_file_specContext } from "./PlSqlParser.js";
+import { Autoextend_clauseContext } from "./PlSqlParser.js";
+import { Maxsize_clauseContext } from "./PlSqlParser.js";
+import { Build_clauseContext } from "./PlSqlParser.js";
+import { Parallel_clauseContext } from "./PlSqlParser.js";
+import { Parallel_instances_clauseContext } from "./PlSqlParser.js";
+import { Alter_materialized_viewContext } from "./PlSqlParser.js";
+import { Alter_mv_option1Context } from "./PlSqlParser.js";
+import { Alter_mv_refreshContext } from "./PlSqlParser.js";
+import { Rollback_segmentContext } from "./PlSqlParser.js";
+import { Modify_mv_column_clauseContext } from "./PlSqlParser.js";
+import { Alter_materialized_view_logContext } from "./PlSqlParser.js";
+import { Add_mv_log_column_clauseContext } from "./PlSqlParser.js";
+import { Move_mv_log_clauseContext } from "./PlSqlParser.js";
+import { Mv_log_augmentationContext } from "./PlSqlParser.js";
+import { Create_materialized_view_logContext } from "./PlSqlParser.js";
+import { New_values_clauseContext } from "./PlSqlParser.js";
+import { Mv_log_purge_clauseContext } from "./PlSqlParser.js";
+import { Create_materialized_zonemapContext } from "./PlSqlParser.js";
+import { Alter_materialized_zonemapContext } from "./PlSqlParser.js";
+import { Drop_materialized_zonemapContext } from "./PlSqlParser.js";
+import { Zonemap_refresh_clauseContext } from "./PlSqlParser.js";
+import { Zonemap_attributesContext } from "./PlSqlParser.js";
+import { Zonemap_nameContext } from "./PlSqlParser.js";
+import { Operator_nameContext } from "./PlSqlParser.js";
+import { Operator_function_nameContext } from "./PlSqlParser.js";
+import { Create_zonemap_on_tableContext } from "./PlSqlParser.js";
+import { Create_zonemap_as_subqueryContext } from "./PlSqlParser.js";
+import { Alter_operatorContext } from "./PlSqlParser.js";
+import { Drop_operatorContext } from "./PlSqlParser.js";
+import { Create_operatorContext } from "./PlSqlParser.js";
+import { Binding_clauseContext } from "./PlSqlParser.js";
+import { Add_binding_clauseContext } from "./PlSqlParser.js";
+import { Implementation_clauseContext } from "./PlSqlParser.js";
+import { Primary_operator_listContext } from "./PlSqlParser.js";
+import { Primary_operator_itemContext } from "./PlSqlParser.js";
+import { Operator_context_clauseContext } from "./PlSqlParser.js";
+import { Using_function_clauseContext } from "./PlSqlParser.js";
+import { Drop_binding_clauseContext } from "./PlSqlParser.js";
+import { Create_materialized_viewContext } from "./PlSqlParser.js";
+import { Scoped_table_ref_constraintContext } from "./PlSqlParser.js";
+import { Mv_column_aliasContext } from "./PlSqlParser.js";
+import { Create_mv_refreshContext } from "./PlSqlParser.js";
+import { Query_rewrite_clauseContext } from "./PlSqlParser.js";
+import { Unusable_editions_clauseContext } from "./PlSqlParser.js";
+import { Drop_materialized_viewContext } from "./PlSqlParser.js";
+import { Drop_materialized_view_logContext } from "./PlSqlParser.js";
+import { Create_contextContext } from "./PlSqlParser.js";
+import { Oracle_namespaceContext } from "./PlSqlParser.js";
+import { Create_clusterContext } from "./PlSqlParser.js";
+import { Create_profileContext } from "./PlSqlParser.js";
+import { Resource_parametersContext } from "./PlSqlParser.js";
+import { Password_parametersContext } from "./PlSqlParser.js";
+import { Create_lockdown_profileContext } from "./PlSqlParser.js";
+import { Static_base_profileContext } from "./PlSqlParser.js";
+import { Dynamic_base_profileContext } from "./PlSqlParser.js";
+import { Create_outlineContext } from "./PlSqlParser.js";
+import { Create_restore_pointContext } from "./PlSqlParser.js";
+import { Create_roleContext } from "./PlSqlParser.js";
+import { Create_tableContext } from "./PlSqlParser.js";
+import { Xmltype_tableContext } from "./PlSqlParser.js";
+import { Xmltype_virtual_columnsContext } from "./PlSqlParser.js";
+import { Xmltype_column_propertiesContext } from "./PlSqlParser.js";
+import { Xmltype_storageContext } from "./PlSqlParser.js";
+import { Xmlschema_specContext } from "./PlSqlParser.js";
+import { Object_tableContext } from "./PlSqlParser.js";
+import { Object_typeContext } from "./PlSqlParser.js";
+import { Oid_index_clauseContext } from "./PlSqlParser.js";
+import { Oid_clauseContext } from "./PlSqlParser.js";
+import { Object_propertiesContext } from "./PlSqlParser.js";
+import { Object_table_substitutionContext } from "./PlSqlParser.js";
+import { Relational_tableContext } from "./PlSqlParser.js";
+import { Relational_table_propertiesContext } from "./PlSqlParser.js";
+import { Relational_table_propertyContext } from "./PlSqlParser.js";
+import { Immutable_table_clausesContext } from "./PlSqlParser.js";
+import { Immutable_table_no_drop_clauseContext } from "./PlSqlParser.js";
+import { Immutable_table_no_delete_clauseContext } from "./PlSqlParser.js";
+import { Blockchain_table_clausesContext } from "./PlSqlParser.js";
+import { Blockchain_drop_table_clauseContext } from "./PlSqlParser.js";
+import { Blockchain_row_retention_clauseContext } from "./PlSqlParser.js";
+import { Blockchain_hash_and_data_format_clauseContext } from "./PlSqlParser.js";
+import { Collation_nameContext } from "./PlSqlParser.js";
+import { Table_propertiesContext } from "./PlSqlParser.js";
+import { Read_only_clauseContext } from "./PlSqlParser.js";
+import { Indexing_clauseContext } from "./PlSqlParser.js";
+import { Attribute_clustering_clauseContext } from "./PlSqlParser.js";
+import { Clustering_joinContext } from "./PlSqlParser.js";
+import { Clustering_join_itemContext } from "./PlSqlParser.js";
+import { Equijoin_conditionContext } from "./PlSqlParser.js";
+import { Cluster_clauseContext } from "./PlSqlParser.js";
+import { Clustering_columnsContext } from "./PlSqlParser.js";
+import { Clustering_column_groupContext } from "./PlSqlParser.js";
+import { Yes_noContext } from "./PlSqlParser.js";
+import { Zonemap_clauseContext } from "./PlSqlParser.js";
+import { Logical_replication_clauseContext } from "./PlSqlParser.js";
+import { Table_nameContext } from "./PlSqlParser.js";
+import { Relational_propertyContext } from "./PlSqlParser.js";
+import { Table_partitioning_clausesContext } from "./PlSqlParser.js";
+import { Range_partitionsContext } from "./PlSqlParser.js";
+import { List_partitionsContext } from "./PlSqlParser.js";
+import { Hash_partitionsContext } from "./PlSqlParser.js";
+import { Individual_hash_partitionsContext } from "./PlSqlParser.js";
+import { Hash_partitions_by_quantityContext } from "./PlSqlParser.js";
+import { Hash_partition_quantityContext } from "./PlSqlParser.js";
+import { Composite_range_partitionsContext } from "./PlSqlParser.js";
+import { Composite_list_partitionsContext } from "./PlSqlParser.js";
+import { Composite_hash_partitionsContext } from "./PlSqlParser.js";
+import { Reference_partitioningContext } from "./PlSqlParser.js";
+import { Reference_partition_descContext } from "./PlSqlParser.js";
+import { System_partitioningContext } from "./PlSqlParser.js";
+import { Range_partition_descContext } from "./PlSqlParser.js";
+import { List_partition_descContext } from "./PlSqlParser.js";
+import { Subpartition_templateContext } from "./PlSqlParser.js";
+import { Hash_subpartition_quantityContext } from "./PlSqlParser.js";
+import { Subpartition_by_rangeContext } from "./PlSqlParser.js";
+import { Subpartition_by_listContext } from "./PlSqlParser.js";
+import { Subpartition_by_hashContext } from "./PlSqlParser.js";
+import { Subpartition_nameContext } from "./PlSqlParser.js";
+import { Range_subpartition_descContext } from "./PlSqlParser.js";
+import { List_subpartition_descContext } from "./PlSqlParser.js";
+import { Individual_hash_subpartsContext } from "./PlSqlParser.js";
+import { Hash_subparts_by_quantityContext } from "./PlSqlParser.js";
+import { Range_values_clauseContext } from "./PlSqlParser.js";
+import { Range_values_listContext } from "./PlSqlParser.js";
+import { List_values_clauseContext } from "./PlSqlParser.js";
+import { Table_partition_descriptionContext } from "./PlSqlParser.js";
+import { Partitioning_storage_clauseContext } from "./PlSqlParser.js";
+import { Lob_partitioning_storageContext } from "./PlSqlParser.js";
+import { Size_clauseContext } from "./PlSqlParser.js";
+import { Table_compressionContext } from "./PlSqlParser.js";
+import { Inmemory_table_clauseContext } from "./PlSqlParser.js";
+import { Inmemory_attributesContext } from "./PlSqlParser.js";
+import { Inmemory_memcompressContext } from "./PlSqlParser.js";
+import { Inmemory_priorityContext } from "./PlSqlParser.js";
+import { Inmemory_distributeContext } from "./PlSqlParser.js";
+import { Inmemory_duplicateContext } from "./PlSqlParser.js";
+import { Inmemory_column_clauseContext } from "./PlSqlParser.js";
+import { Physical_attributes_clauseContext } from "./PlSqlParser.js";
+import { Storage_clauseContext } from "./PlSqlParser.js";
+import { Deferred_segment_creationContext } from "./PlSqlParser.js";
+import { Segment_attributes_clauseContext } from "./PlSqlParser.js";
+import { Physical_propertiesContext } from "./PlSqlParser.js";
+import { Ilm_clauseContext } from "./PlSqlParser.js";
+import { Ilm_policy_clauseContext } from "./PlSqlParser.js";
+import { Ilm_compression_policyContext } from "./PlSqlParser.js";
+import { Ilm_tiering_policyContext } from "./PlSqlParser.js";
+import { Ilm_after_onContext } from "./PlSqlParser.js";
+import { Segment_groupContext } from "./PlSqlParser.js";
+import { Ilm_inmemory_policyContext } from "./PlSqlParser.js";
+import { Ilm_time_periodContext } from "./PlSqlParser.js";
+import { Heap_org_table_clauseContext } from "./PlSqlParser.js";
+import { External_table_clauseContext } from "./PlSqlParser.js";
+import { Access_driver_typeContext } from "./PlSqlParser.js";
+import { External_table_data_propsContext } from "./PlSqlParser.js";
+import { External_table_data_formatContext } from "./PlSqlParser.js";
+import { External_table_transformContext } from "./PlSqlParser.js";
+import { External_table_fieldContext } from "./PlSqlParser.js";
+import { External_table_field_listContext } from "./PlSqlParser.js";
+import { External_table_fields_clauseContext } from "./PlSqlParser.js";
+import { External_table_position_clauseContext } from "./PlSqlParser.js";
+import { External_table_datatype_clauseContext } from "./PlSqlParser.js";
+import { External_table_delimit_clauseContext } from "./PlSqlParser.js";
+import { External_table_trim_clauseContext } from "./PlSqlParser.js";
+import { External_table_date_format_clauseContext } from "./PlSqlParser.js";
+import { External_table_init_clauseContext } from "./PlSqlParser.js";
+import { External_table_condition_clauseContext } from "./PlSqlParser.js";
+import { External_table_lls_clauseContext } from "./PlSqlParser.js";
+import { External_table_recordsContext } from "./PlSqlParser.js";
+import { External_table_record_options_clauseContext } from "./PlSqlParser.js";
+import { External_table_output_filesContext } from "./PlSqlParser.js";
+import { External_table_fieldsContext } from "./PlSqlParser.js";
+import { External_table_datapumpContext } from "./PlSqlParser.js";
+import { External_table_hiveContext } from "./PlSqlParser.js";
+import { External_table_hive_parameter_mapContext } from "./PlSqlParser.js";
+import { External_table_hive_parameter_map_entryContext } from "./PlSqlParser.js";
+import { External_table_directoryContext } from "./PlSqlParser.js";
+import { Row_movement_clauseContext } from "./PlSqlParser.js";
+import { Flashback_archive_clauseContext } from "./PlSqlParser.js";
+import { Log_grpContext } from "./PlSqlParser.js";
+import { Supplemental_table_loggingContext } from "./PlSqlParser.js";
+import { Supplemental_log_grp_clauseContext } from "./PlSqlParser.js";
+import { Supplemental_id_key_clauseContext } from "./PlSqlParser.js";
+import { Allocate_extent_clauseContext } from "./PlSqlParser.js";
+import { Deallocate_unused_clauseContext } from "./PlSqlParser.js";
+import { Shrink_clauseContext } from "./PlSqlParser.js";
+import { Records_per_block_clauseContext } from "./PlSqlParser.js";
+import { Upgrade_table_clauseContext } from "./PlSqlParser.js";
+import { Truncate_tableContext } from "./PlSqlParser.js";
+import { Drop_tableContext } from "./PlSqlParser.js";
+import { Drop_tablespaceContext } from "./PlSqlParser.js";
+import { Drop_tablespace_setContext } from "./PlSqlParser.js";
+import { Including_contents_clauseContext } from "./PlSqlParser.js";
+import { Drop_viewContext } from "./PlSqlParser.js";
+import { Comment_on_columnContext } from "./PlSqlParser.js";
+import { Enable_or_disableContext } from "./PlSqlParser.js";
+import { Allow_or_disallowContext } from "./PlSqlParser.js";
+import { Alter_synonymContext } from "./PlSqlParser.js";
+import { Create_synonymContext } from "./PlSqlParser.js";
+import { Drop_synonymContext } from "./PlSqlParser.js";
+import { Create_spfileContext } from "./PlSqlParser.js";
+import { Spfile_nameContext } from "./PlSqlParser.js";
+import { Pfile_nameContext } from "./PlSqlParser.js";
+import { Comment_on_tableContext } from "./PlSqlParser.js";
+import { Comment_on_materializedContext } from "./PlSqlParser.js";
+import { Alter_analytic_viewContext } from "./PlSqlParser.js";
+import { Alter_add_cache_clauseContext } from "./PlSqlParser.js";
+import { Levels_itemContext } from "./PlSqlParser.js";
+import { Measure_listContext } from "./PlSqlParser.js";
+import { Alter_drop_cache_clauseContext } from "./PlSqlParser.js";
+import { Alter_attribute_dimensionContext } from "./PlSqlParser.js";
+import { Alter_audit_policyContext } from "./PlSqlParser.js";
+import { Alter_clusterContext } from "./PlSqlParser.js";
+import { Drop_analytic_viewContext } from "./PlSqlParser.js";
+import { Drop_attribute_dimensionContext } from "./PlSqlParser.js";
+import { Drop_audit_policyContext } from "./PlSqlParser.js";
+import { Drop_flashback_archiveContext } from "./PlSqlParser.js";
+import { Drop_clusterContext } from "./PlSqlParser.js";
+import { Drop_contextContext } from "./PlSqlParser.js";
+import { Drop_directoryContext } from "./PlSqlParser.js";
+import { Drop_diskgroupContext } from "./PlSqlParser.js";
+import { Drop_editionContext } from "./PlSqlParser.js";
+import { Truncate_clusterContext } from "./PlSqlParser.js";
+import { Cache_or_nocacheContext } from "./PlSqlParser.js";
+import { Database_nameContext } from "./PlSqlParser.js";
+import { Alter_databaseContext } from "./PlSqlParser.js";
+import { Database_clauseContext } from "./PlSqlParser.js";
+import { Startup_clausesContext } from "./PlSqlParser.js";
+import { Resetlogs_or_noresetlogsContext } from "./PlSqlParser.js";
+import { Upgrade_or_downgradeContext } from "./PlSqlParser.js";
+import { Recovery_clausesContext } from "./PlSqlParser.js";
+import { Begin_or_endContext } from "./PlSqlParser.js";
+import { General_recoveryContext } from "./PlSqlParser.js";
+import { Full_database_recoveryContext } from "./PlSqlParser.js";
+import { Partial_database_recoveryContext } from "./PlSqlParser.js";
+import { Partial_database_recovery_10gContext } from "./PlSqlParser.js";
+import { Managed_standby_recoveryContext } from "./PlSqlParser.js";
+import { Db_nameContext } from "./PlSqlParser.js";
+import { Database_file_clausesContext } from "./PlSqlParser.js";
+import { Create_datafile_clauseContext } from "./PlSqlParser.js";
+import { Alter_datafile_clauseContext } from "./PlSqlParser.js";
+import { Alter_tempfile_clauseContext } from "./PlSqlParser.js";
+import { Move_datafile_clauseContext } from "./PlSqlParser.js";
+import { Logfile_clausesContext } from "./PlSqlParser.js";
+import { Add_logfile_clausesContext } from "./PlSqlParser.js";
+import { Group_redo_logfileContext } from "./PlSqlParser.js";
+import { Drop_logfile_clausesContext } from "./PlSqlParser.js";
+import { Switch_logfile_clauseContext } from "./PlSqlParser.js";
+import { Supplemental_db_loggingContext } from "./PlSqlParser.js";
+import { Add_or_dropContext } from "./PlSqlParser.js";
+import { Supplemental_plsql_clauseContext } from "./PlSqlParser.js";
+import { Logfile_descriptorContext } from "./PlSqlParser.js";
+import { Controlfile_clausesContext } from "./PlSqlParser.js";
+import { Trace_file_clauseContext } from "./PlSqlParser.js";
+import { Standby_database_clausesContext } from "./PlSqlParser.js";
+import { Activate_standby_db_clauseContext } from "./PlSqlParser.js";
+import { Maximize_standby_db_clauseContext } from "./PlSqlParser.js";
+import { Register_logfile_clauseContext } from "./PlSqlParser.js";
+import { Commit_switchover_clauseContext } from "./PlSqlParser.js";
+import { Start_standby_clauseContext } from "./PlSqlParser.js";
+import { Stop_standby_clauseContext } from "./PlSqlParser.js";
+import { Convert_database_clauseContext } from "./PlSqlParser.js";
+import { Default_settings_clauseContext } from "./PlSqlParser.js";
+import { Set_time_zone_clauseContext } from "./PlSqlParser.js";
+import { Instance_clausesContext } from "./PlSqlParser.js";
+import { Security_clauseContext } from "./PlSqlParser.js";
+import { DomainContext } from "./PlSqlParser.js";
+import { DatabaseContext } from "./PlSqlParser.js";
+import { Edition_nameContext } from "./PlSqlParser.js";
+import { FilenumberContext } from "./PlSqlParser.js";
+import { FilenameContext } from "./PlSqlParser.js";
+import { Prepare_clauseContext } from "./PlSqlParser.js";
+import { Drop_mirror_clauseContext } from "./PlSqlParser.js";
+import { Lost_write_protectionContext } from "./PlSqlParser.js";
+import { Cdb_fleet_clausesContext } from "./PlSqlParser.js";
+import { Lead_cdb_clauseContext } from "./PlSqlParser.js";
+import { Lead_cdb_uri_clauseContext } from "./PlSqlParser.js";
+import { Property_clausesContext } from "./PlSqlParser.js";
+import { Replay_upgrade_clausesContext } from "./PlSqlParser.js";
+import { Alter_database_linkContext } from "./PlSqlParser.js";
+import { Password_valueContext } from "./PlSqlParser.js";
+import { Link_authenticationContext } from "./PlSqlParser.js";
+import { Create_schemaContext } from "./PlSqlParser.js";
+import { Create_databaseContext } from "./PlSqlParser.js";
+import { Database_logging_clausesContext } from "./PlSqlParser.js";
+import { Database_logging_sub_clauseContext } from "./PlSqlParser.js";
+import { Tablespace_clausesContext } from "./PlSqlParser.js";
+import { Enable_pluggable_databaseContext } from "./PlSqlParser.js";
+import { File_name_convertContext } from "./PlSqlParser.js";
+import { Filename_convert_sub_clauseContext } from "./PlSqlParser.js";
+import { Tablespace_datafile_clausesContext } from "./PlSqlParser.js";
+import { Undo_mode_clauseContext } from "./PlSqlParser.js";
+import { Default_tablespaceContext } from "./PlSqlParser.js";
+import { Default_temp_tablespaceContext } from "./PlSqlParser.js";
+import { Undo_tablespaceContext } from "./PlSqlParser.js";
+import { Drop_databaseContext } from "./PlSqlParser.js";
+import { Create_database_linkContext } from "./PlSqlParser.js";
+import { Drop_database_linkContext } from "./PlSqlParser.js";
+import { Alter_tablespace_setContext } from "./PlSqlParser.js";
+import { Alter_tablespace_attrsContext } from "./PlSqlParser.js";
+import { Alter_tablespace_encryptionContext } from "./PlSqlParser.js";
+import { Ts_file_name_convertContext } from "./PlSqlParser.js";
+import { Alter_roleContext } from "./PlSqlParser.js";
+import { Role_identified_clauseContext } from "./PlSqlParser.js";
+import { Alter_tableContext } from "./PlSqlParser.js";
+import { Alter_table_bodyContext } from "./PlSqlParser.js";
+import { Alter_table_actionContext } from "./PlSqlParser.js";
+import { Enable_disable_clausesContext } from "./PlSqlParser.js";
+import { Memoptimize_read_write_clauseContext } from "./PlSqlParser.js";
+import { Alter_table_propertiesContext } from "./PlSqlParser.js";
+import { Alter_table_partitioningContext } from "./PlSqlParser.js";
+import { Add_table_partitionContext } from "./PlSqlParser.js";
+import { Drop_table_partitionContext } from "./PlSqlParser.js";
+import { Merge_table_partitionContext } from "./PlSqlParser.js";
+import { Modify_table_partitionContext } from "./PlSqlParser.js";
+import { Split_table_partitionContext } from "./PlSqlParser.js";
+import { Truncate_table_partitionContext } from "./PlSqlParser.js";
+import { Exchange_table_partitionContext } from "./PlSqlParser.js";
+import { Coalesce_table_partitionContext } from "./PlSqlParser.js";
+import { Alter_interval_partitionContext } from "./PlSqlParser.js";
+import { Move_table_partitionContext } from "./PlSqlParser.js";
+import { Filter_conditionContext } from "./PlSqlParser.js";
+import { Rename_table_partitionContext } from "./PlSqlParser.js";
+import { Partition_extended_namesContext } from "./PlSqlParser.js";
+import { Subpartition_extended_namesContext } from "./PlSqlParser.js";
+import { Alter_table_properties_1Context } from "./PlSqlParser.js";
+import { Alter_iot_clausesContext } from "./PlSqlParser.js";
+import { Alter_mapping_table_clauseContext } from "./PlSqlParser.js";
+import { Alter_overflow_clauseContext } from "./PlSqlParser.js";
+import { Add_overflow_clauseContext } from "./PlSqlParser.js";
+import { Update_index_clausesContext } from "./PlSqlParser.js";
+import { Update_global_index_clauseContext } from "./PlSqlParser.js";
+import { Update_all_indexes_clauseContext } from "./PlSqlParser.js";
+import { Update_all_indexes_index_clauseContext } from "./PlSqlParser.js";
+import { Update_index_partitionContext } from "./PlSqlParser.js";
+import { Update_index_subpartitionContext } from "./PlSqlParser.js";
+import { Enable_disable_clauseContext } from "./PlSqlParser.js";
+import { Using_index_clauseContext } from "./PlSqlParser.js";
+import { Index_attributesContext } from "./PlSqlParser.js";
+import { Sort_or_nosortContext } from "./PlSqlParser.js";
+import { Exceptions_clauseContext } from "./PlSqlParser.js";
+import { Move_table_clauseContext } from "./PlSqlParser.js";
+import { Modify_to_partitionedContext } from "./PlSqlParser.js";
+import { Index_org_table_clauseContext } from "./PlSqlParser.js";
+import { Mapping_table_clauseContext } from "./PlSqlParser.js";
+import { Key_compressionContext } from "./PlSqlParser.js";
+import { Index_org_overflow_clauseContext } from "./PlSqlParser.js";
+import { Column_clausesContext } from "./PlSqlParser.js";
+import { Modify_collection_retrievalContext } from "./PlSqlParser.js";
+import { Collection_itemContext } from "./PlSqlParser.js";
+import { Rename_column_clauseContext } from "./PlSqlParser.js";
+import { Old_column_nameContext } from "./PlSqlParser.js";
+import { New_column_nameContext } from "./PlSqlParser.js";
+import { Add_modify_drop_column_clausesContext } from "./PlSqlParser.js";
+import { Drop_column_clauseContext } from "./PlSqlParser.js";
+import { Modify_column_clausesContext } from "./PlSqlParser.js";
+import { Modify_col_propertiesContext } from "./PlSqlParser.js";
+import { Modify_col_visibilityContext } from "./PlSqlParser.js";
+import { Modify_col_substitutableContext } from "./PlSqlParser.js";
+import { Add_column_clauseContext } from "./PlSqlParser.js";
+import { Varray_col_propertiesContext } from "./PlSqlParser.js";
+import { Varray_storage_clauseContext } from "./PlSqlParser.js";
+import { Lob_segnameContext } from "./PlSqlParser.js";
+import { Lob_itemContext } from "./PlSqlParser.js";
+import { Lob_storage_parametersContext } from "./PlSqlParser.js";
+import { Lob_storage_clauseContext } from "./PlSqlParser.js";
+import { Modify_lob_storage_clauseContext } from "./PlSqlParser.js";
+import { Modify_lob_parametersContext } from "./PlSqlParser.js";
+import { Lob_parametersContext } from "./PlSqlParser.js";
+import { Lob_deduplicate_clauseContext } from "./PlSqlParser.js";
+import { Lob_compression_clauseContext } from "./PlSqlParser.js";
+import { Lob_retention_clauseContext } from "./PlSqlParser.js";
+import { Encryption_specContext } from "./PlSqlParser.js";
+import { TablespaceContext } from "./PlSqlParser.js";
+import { Varray_itemContext } from "./PlSqlParser.js";
+import { Column_propertiesContext } from "./PlSqlParser.js";
+import { Lob_partition_storageContext } from "./PlSqlParser.js";
+import { Period_definitionContext } from "./PlSqlParser.js";
+import { Start_time_columnContext } from "./PlSqlParser.js";
+import { End_time_columnContext } from "./PlSqlParser.js";
+import { Column_definitionContext } from "./PlSqlParser.js";
+import { Column_collation_nameContext } from "./PlSqlParser.js";
+import { Identity_clauseContext } from "./PlSqlParser.js";
+import { Identity_options_parenthesesContext } from "./PlSqlParser.js";
+import { Identity_optionsContext } from "./PlSqlParser.js";
+import { Virtual_column_definitionContext } from "./PlSqlParser.js";
+import { Virtual_column_expressionContext } from "./PlSqlParser.js";
+import { Autogenerated_sequence_definitionContext } from "./PlSqlParser.js";
+import { By_user_for_statistics_clauseContext } from "./PlSqlParser.js";
+import { Evaluation_edition_clauseContext } from "./PlSqlParser.js";
+import { Nested_table_col_propertiesContext } from "./PlSqlParser.js";
+import { Nested_itemContext } from "./PlSqlParser.js";
+import { Substitutable_column_clauseContext } from "./PlSqlParser.js";
+import { Partition_nameContext } from "./PlSqlParser.js";
+import { Supplemental_logging_propsContext } from "./PlSqlParser.js";
+import { Object_type_col_propertiesContext } from "./PlSqlParser.js";
+import { Constraint_clausesContext } from "./PlSqlParser.js";
+import { Old_constraint_nameContext } from "./PlSqlParser.js";
+import { New_constraint_nameContext } from "./PlSqlParser.js";
+import { Drop_constraint_clauseContext } from "./PlSqlParser.js";
+import { Check_constraintContext } from "./PlSqlParser.js";
+import { Foreign_key_clauseContext } from "./PlSqlParser.js";
+import { References_clauseContext } from "./PlSqlParser.js";
+import { On_delete_clauseContext } from "./PlSqlParser.js";
+import { Anonymous_blockContext } from "./PlSqlParser.js";
+import { Invoker_rights_clauseContext } from "./PlSqlParser.js";
+import { Call_specContext } from "./PlSqlParser.js";
+import { Java_specContext } from "./PlSqlParser.js";
+import { C_specContext } from "./PlSqlParser.js";
+import { C_agent_in_clauseContext } from "./PlSqlParser.js";
+import { C_parameters_clauseContext } from "./PlSqlParser.js";
+import { C_external_parameterContext } from "./PlSqlParser.js";
+import { C_propertyContext } from "./PlSqlParser.js";
+import { ParameterContext } from "./PlSqlParser.js";
+import { Default_value_partContext } from "./PlSqlParser.js";
+import { Seq_of_declare_specsContext } from "./PlSqlParser.js";
+import { Declare_specContext } from "./PlSqlParser.js";
+import { Variable_declarationContext } from "./PlSqlParser.js";
+import { Subtype_declarationContext } from "./PlSqlParser.js";
+import { Cursor_declarationContext } from "./PlSqlParser.js";
+import { Parameter_specContext } from "./PlSqlParser.js";
+import { Exception_declarationContext } from "./PlSqlParser.js";
+import { Pragma_declarationContext } from "./PlSqlParser.js";
+import { Record_type_defContext } from "./PlSqlParser.js";
+import { Field_specContext } from "./PlSqlParser.js";
+import { Ref_cursor_type_defContext } from "./PlSqlParser.js";
+import { Type_declarationContext } from "./PlSqlParser.js";
+import { Table_type_defContext } from "./PlSqlParser.js";
+import { Table_indexed_by_partContext } from "./PlSqlParser.js";
+import { Varray_type_defContext } from "./PlSqlParser.js";
+import { Seq_of_statementsContext } from "./PlSqlParser.js";
+import { Label_declarationContext } from "./PlSqlParser.js";
+import { StatementContext } from "./PlSqlParser.js";
+import { Assignment_statementContext } from "./PlSqlParser.js";
+import { Continue_statementContext } from "./PlSqlParser.js";
+import { Exit_statementContext } from "./PlSqlParser.js";
+import { Goto_statementContext } from "./PlSqlParser.js";
+import { If_statementContext } from "./PlSqlParser.js";
+import { Elsif_partContext } from "./PlSqlParser.js";
+import { Else_partContext } from "./PlSqlParser.js";
+import { Loop_statementContext } from "./PlSqlParser.js";
+import { Cursor_loop_paramContext } from "./PlSqlParser.js";
+import { Forall_statementContext } from "./PlSqlParser.js";
+import { Bounds_clauseContext } from "./PlSqlParser.js";
+import { Between_boundContext } from "./PlSqlParser.js";
+import { Lower_boundContext } from "./PlSqlParser.js";
+import { Upper_boundContext } from "./PlSqlParser.js";
+import { Null_statementContext } from "./PlSqlParser.js";
+import { Raise_statementContext } from "./PlSqlParser.js";
+import { Return_statementContext } from "./PlSqlParser.js";
+import { Call_statementContext } from "./PlSqlParser.js";
+import { Pipe_row_statementContext } from "./PlSqlParser.js";
+import { Selection_directiveContext } from "./PlSqlParser.js";
+import { Error_directiveContext } from "./PlSqlParser.js";
+import { Selection_directive_bodyContext } from "./PlSqlParser.js";
+import { BodyContext } from "./PlSqlParser.js";
+import { Exception_handlerContext } from "./PlSqlParser.js";
+import { Trigger_blockContext } from "./PlSqlParser.js";
+import { Tps_blockContext } from "./PlSqlParser.js";
+import { BlockContext } from "./PlSqlParser.js";
+import { Sql_statementContext } from "./PlSqlParser.js";
+import { Execute_immediateContext } from "./PlSqlParser.js";
+import { Dynamic_returning_clauseContext } from "./PlSqlParser.js";
+import { Data_manipulation_language_statementsContext } from "./PlSqlParser.js";
+import { Cursor_manipulation_statementsContext } from "./PlSqlParser.js";
+import { Close_statementContext } from "./PlSqlParser.js";
+import { Open_statementContext } from "./PlSqlParser.js";
+import { Fetch_statementContext } from "./PlSqlParser.js";
+import { Variable_or_collectionContext } from "./PlSqlParser.js";
+import { Open_for_statementContext } from "./PlSqlParser.js";
+import { Transaction_control_statementsContext } from "./PlSqlParser.js";
+import { Set_transaction_commandContext } from "./PlSqlParser.js";
+import { Set_constraint_commandContext } from "./PlSqlParser.js";
+import { Commit_statementContext } from "./PlSqlParser.js";
+import { Write_clauseContext } from "./PlSqlParser.js";
+import { Rollback_statementContext } from "./PlSqlParser.js";
+import { Savepoint_statementContext } from "./PlSqlParser.js";
+import { Collection_method_callContext } from "./PlSqlParser.js";
+import { Explain_statementContext } from "./PlSqlParser.js";
+import { Select_only_statementContext } from "./PlSqlParser.js";
+import { Select_statementContext } from "./PlSqlParser.js";
+import { With_clauseContext } from "./PlSqlParser.js";
+import { With_factoring_clauseContext } from "./PlSqlParser.js";
+import { Subquery_factoring_clauseContext } from "./PlSqlParser.js";
+import { Search_clauseContext } from "./PlSqlParser.js";
+import { Cycle_clauseContext } from "./PlSqlParser.js";
+import { Subav_factoring_clauseContext } from "./PlSqlParser.js";
+import { Subav_clauseContext } from "./PlSqlParser.js";
+import { Hierarchies_clauseContext } from "./PlSqlParser.js";
+import { Filter_clausesContext } from "./PlSqlParser.js";
+import { Filter_clauseContext } from "./PlSqlParser.js";
+import { Add_calcs_clauseContext } from "./PlSqlParser.js";
+import { Add_calc_meas_clauseContext } from "./PlSqlParser.js";
+import { SubqueryContext } from "./PlSqlParser.js";
+import { Subquery_no_withContext } from "./PlSqlParser.js";
+import { Subquery_basic_elementsContext } from "./PlSqlParser.js";
+import { Subquery_operation_partContext } from "./PlSqlParser.js";
+import { Query_blockContext } from "./PlSqlParser.js";
+import { Selected_listContext } from "./PlSqlParser.js";
+import { From_clauseContext } from "./PlSqlParser.js";
+import { Select_list_elementsContext } from "./PlSqlParser.js";
+import { Table_ref_listContext } from "./PlSqlParser.js";
+import { Table_refContext } from "./PlSqlParser.js";
+import { Table_ref_auxContext } from "./PlSqlParser.js";
+import { Table_ref_aux_internal_oneContext } from "./PlSqlParser.js";
+import { Table_ref_aux_internal_twoContext } from "./PlSqlParser.js";
+import { Table_ref_aux_internal_threContext } from "./PlSqlParser.js";
+import { Join_clauseContext } from "./PlSqlParser.js";
+import { Join_on_partContext } from "./PlSqlParser.js";
+import { Join_using_partContext } from "./PlSqlParser.js";
+import { Outer_join_typeContext } from "./PlSqlParser.js";
+import { Query_partition_clauseContext } from "./PlSqlParser.js";
+import { Flashback_query_clauseContext } from "./PlSqlParser.js";
+import { Pivot_clauseContext } from "./PlSqlParser.js";
+import { Pivot_elementContext } from "./PlSqlParser.js";
+import { Pivot_for_clauseContext } from "./PlSqlParser.js";
+import { Pivot_in_clauseContext } from "./PlSqlParser.js";
+import { Pivot_in_clause_elementContext } from "./PlSqlParser.js";
+import { Pivot_in_clause_elementsContext } from "./PlSqlParser.js";
+import { Unpivot_clauseContext } from "./PlSqlParser.js";
+import { Unpivot_in_clauseContext } from "./PlSqlParser.js";
+import { Unpivot_in_elementsContext } from "./PlSqlParser.js";
+import { Hierarchical_query_clauseContext } from "./PlSqlParser.js";
+import { Start_partContext } from "./PlSqlParser.js";
+import { Group_by_clauseContext } from "./PlSqlParser.js";
+import { Group_by_elementsContext } from "./PlSqlParser.js";
+import { Rollup_cube_clauseContext } from "./PlSqlParser.js";
+import { Grouping_sets_clauseContext } from "./PlSqlParser.js";
+import { Grouping_sets_elementsContext } from "./PlSqlParser.js";
+import { Having_clauseContext } from "./PlSqlParser.js";
+import { Model_clauseContext } from "./PlSqlParser.js";
+import { Cell_reference_optionsContext } from "./PlSqlParser.js";
+import { Return_rows_clauseContext } from "./PlSqlParser.js";
+import { Reference_modelContext } from "./PlSqlParser.js";
+import { Main_modelContext } from "./PlSqlParser.js";
+import { Model_column_clausesContext } from "./PlSqlParser.js";
+import { Model_column_partition_partContext } from "./PlSqlParser.js";
+import { Model_column_listContext } from "./PlSqlParser.js";
+import { Model_columnContext } from "./PlSqlParser.js";
+import { Model_rules_clauseContext } from "./PlSqlParser.js";
+import { Model_rules_partContext } from "./PlSqlParser.js";
+import { Model_rules_elementContext } from "./PlSqlParser.js";
+import { Cell_assignmentContext } from "./PlSqlParser.js";
+import { Model_iterate_clauseContext } from "./PlSqlParser.js";
+import { Until_partContext } from "./PlSqlParser.js";
+import { Order_by_clauseContext } from "./PlSqlParser.js";
+import { Order_by_elementsContext } from "./PlSqlParser.js";
+import { Offset_clauseContext } from "./PlSqlParser.js";
+import { Fetch_clauseContext } from "./PlSqlParser.js";
+import { For_update_clauseContext } from "./PlSqlParser.js";
+import { For_update_of_partContext } from "./PlSqlParser.js";
+import { For_update_optionsContext } from "./PlSqlParser.js";
+import { Update_statementContext } from "./PlSqlParser.js";
+import { Update_set_clauseContext } from "./PlSqlParser.js";
+import { Column_based_update_set_clauseContext } from "./PlSqlParser.js";
+import { Delete_statementContext } from "./PlSqlParser.js";
+import { Insert_statementContext } from "./PlSqlParser.js";
+import { Single_table_insertContext } from "./PlSqlParser.js";
+import { Multi_table_insertContext } from "./PlSqlParser.js";
+import { Multi_table_elementContext } from "./PlSqlParser.js";
+import { Conditional_insert_clauseContext } from "./PlSqlParser.js";
+import { Conditional_insert_when_partContext } from "./PlSqlParser.js";
+import { Conditional_insert_else_partContext } from "./PlSqlParser.js";
+import { Insert_into_clauseContext } from "./PlSqlParser.js";
+import { Values_clauseContext } from "./PlSqlParser.js";
+import { Merge_statementContext } from "./PlSqlParser.js";
+import { Merge_update_clauseContext } from "./PlSqlParser.js";
+import { Merge_elementContext } from "./PlSqlParser.js";
+import { Merge_update_delete_partContext } from "./PlSqlParser.js";
+import { Merge_insert_clauseContext } from "./PlSqlParser.js";
+import { Selected_tableviewContext } from "./PlSqlParser.js";
+import { Lock_table_statementContext } from "./PlSqlParser.js";
+import { Wait_nowait_partContext } from "./PlSqlParser.js";
+import { Lock_table_elementContext } from "./PlSqlParser.js";
+import { Lock_modeContext } from "./PlSqlParser.js";
+import { General_table_refContext } from "./PlSqlParser.js";
+import { Static_returning_clauseContext } from "./PlSqlParser.js";
+import { Error_logging_clauseContext } from "./PlSqlParser.js";
+import { Error_logging_into_partContext } from "./PlSqlParser.js";
+import { Error_logging_reject_partContext } from "./PlSqlParser.js";
+import { Dml_table_expression_clauseContext } from "./PlSqlParser.js";
+import { Table_collection_expressionContext } from "./PlSqlParser.js";
+import { Subquery_restriction_clauseContext } from "./PlSqlParser.js";
+import { Sample_clauseContext } from "./PlSqlParser.js";
+import { Seed_partContext } from "./PlSqlParser.js";
+import { ConditionContext } from "./PlSqlParser.js";
+import { Expressions_Context } from "./PlSqlParser.js";
+import { ExpressionContext } from "./PlSqlParser.js";
+import { Cursor_expressionContext } from "./PlSqlParser.js";
+import { Logical_expressionContext } from "./PlSqlParser.js";
+import { Unary_logical_expressionContext } from "./PlSqlParser.js";
+import { Unary_logical_operationContext } from "./PlSqlParser.js";
+import { Logical_operationContext } from "./PlSqlParser.js";
+import { Multiset_expressionContext } from "./PlSqlParser.js";
+import { Relational_expressionContext } from "./PlSqlParser.js";
+import { Compound_expressionContext } from "./PlSqlParser.js";
+import { Relational_operatorContext } from "./PlSqlParser.js";
+import { In_elementsContext } from "./PlSqlParser.js";
+import { Between_elementsContext } from "./PlSqlParser.js";
+import { ConcatenationContext } from "./PlSqlParser.js";
+import { Interval_expressionContext } from "./PlSqlParser.js";
+import { Model_expressionContext } from "./PlSqlParser.js";
+import { Model_expression_elementContext } from "./PlSqlParser.js";
+import { Single_column_for_loopContext } from "./PlSqlParser.js";
+import { Multi_column_for_loopContext } from "./PlSqlParser.js";
+import { Unary_expressionContext } from "./PlSqlParser.js";
+import { Unary_expression_coreContext } from "./PlSqlParser.js";
+import { Selection_directive_expressionContext } from "./PlSqlParser.js";
+import { Implicit_cursor_expressionContext } from "./PlSqlParser.js";
+import { Collection_expressionContext } from "./PlSqlParser.js";
+import { Case_statementContext } from "./PlSqlParser.js";
+import { Simple_case_statementContext } from "./PlSqlParser.js";
+import { Searched_case_statementContext } from "./PlSqlParser.js";
+import { Case_when_part_statementContext } from "./PlSqlParser.js";
+import { Case_else_part_statementContext } from "./PlSqlParser.js";
+import { Case_expressionContext } from "./PlSqlParser.js";
+import { Simple_case_expressionContext } from "./PlSqlParser.js";
+import { Searched_case_expressionContext } from "./PlSqlParser.js";
+import { Case_when_part_expressionContext } from "./PlSqlParser.js";
+import { Case_else_part_expressionContext } from "./PlSqlParser.js";
+import { AtomContext } from "./PlSqlParser.js";
+import { Quantified_expressionContext } from "./PlSqlParser.js";
+import { String_functionContext } from "./PlSqlParser.js";
+import { Standard_functionContext } from "./PlSqlParser.js";
+import { Json_functionContext } from "./PlSqlParser.js";
+import { Json_object_contentContext } from "./PlSqlParser.js";
+import { Json_object_entryContext } from "./PlSqlParser.js";
+import { Json_table_clauseContext } from "./PlSqlParser.js";
+import { Json_array_elementContext } from "./PlSqlParser.js";
+import { Json_on_null_clauseContext } from "./PlSqlParser.js";
+import { Json_return_clauseContext } from "./PlSqlParser.js";
+import { Json_transform_opContext } from "./PlSqlParser.js";
+import { Json_column_clauseContext } from "./PlSqlParser.js";
+import { Json_column_definitionContext } from "./PlSqlParser.js";
+import { Json_query_returning_clauseContext } from "./PlSqlParser.js";
+import { Json_query_return_typeContext } from "./PlSqlParser.js";
+import { Json_query_wrapper_clauseContext } from "./PlSqlParser.js";
+import { Json_query_on_error_clauseContext } from "./PlSqlParser.js";
+import { Json_query_on_empty_clauseContext } from "./PlSqlParser.js";
+import { Json_value_return_clauseContext } from "./PlSqlParser.js";
+import { Json_value_return_typeContext } from "./PlSqlParser.js";
+import { Json_value_on_mismatch_clauseContext } from "./PlSqlParser.js";
+import { LiteralContext } from "./PlSqlParser.js";
+import { Numeric_function_wrapperContext } from "./PlSqlParser.js";
+import { Numeric_functionContext } from "./PlSqlParser.js";
+import { Listagg_overflow_clauseContext } from "./PlSqlParser.js";
+import { Other_functionContext } from "./PlSqlParser.js";
+import { Over_clause_keywordContext } from "./PlSqlParser.js";
+import { Within_or_over_clause_keywordContext } from "./PlSqlParser.js";
+import { Standard_prediction_function_keywordContext } from "./PlSqlParser.js";
+import { Over_clauseContext } from "./PlSqlParser.js";
+import { Windowing_clauseContext } from "./PlSqlParser.js";
+import { Windowing_typeContext } from "./PlSqlParser.js";
+import { Windowing_elementsContext } from "./PlSqlParser.js";
+import { Using_clauseContext } from "./PlSqlParser.js";
+import { Using_elementContext } from "./PlSqlParser.js";
+import { Assignable_elementContext } from "./PlSqlParser.js";
+import { Collect_order_by_partContext } from "./PlSqlParser.js";
+import { Within_or_over_partContext } from "./PlSqlParser.js";
+import { String_delimiterContext } from "./PlSqlParser.js";
+import { Cost_matrix_clauseContext } from "./PlSqlParser.js";
+import { Xml_passing_clauseContext } from "./PlSqlParser.js";
+import { Xml_attributes_clauseContext } from "./PlSqlParser.js";
+import { Xml_namespaces_clauseContext } from "./PlSqlParser.js";
+import { Xml_table_columnContext } from "./PlSqlParser.js";
+import { Xml_general_default_partContext } from "./PlSqlParser.js";
+import { Xml_multiuse_expression_elementContext } from "./PlSqlParser.js";
+import { Xmlroot_param_version_partContext } from "./PlSqlParser.js";
+import { Xmlroot_param_standalone_partContext } from "./PlSqlParser.js";
+import { Xmlserialize_param_enconding_partContext } from "./PlSqlParser.js";
+import { Xmlserialize_param_version_partContext } from "./PlSqlParser.js";
+import { Xmlserialize_param_ident_partContext } from "./PlSqlParser.js";
+import { Annotations_clauseContext } from "./PlSqlParser.js";
+import { Annotations_listContext } from "./PlSqlParser.js";
+import { AnnotationContext } from "./PlSqlParser.js";
+import { Sql_plus_commandContext } from "./PlSqlParser.js";
+import { Execute_commandContext } from "./PlSqlParser.js";
+import { Start_commandContext } from "./PlSqlParser.js";
+import { Sql_plus_filepathContext } from "./PlSqlParser.js";
+import { Whenever_commandContext } from "./PlSqlParser.js";
+import { Set_commandContext } from "./PlSqlParser.js";
+import { Timing_commandContext } from "./PlSqlParser.js";
+import { Clear_commandContext } from "./PlSqlParser.js";
+import { Partition_extension_clauseContext } from "./PlSqlParser.js";
+import { Column_aliasContext } from "./PlSqlParser.js";
+import { Table_aliasContext } from "./PlSqlParser.js";
+import { Where_clauseContext } from "./PlSqlParser.js";
+import { Into_clauseContext } from "./PlSqlParser.js";
+import { Xml_column_nameContext } from "./PlSqlParser.js";
+import { Cost_class_nameContext } from "./PlSqlParser.js";
+import { Attribute_nameContext } from "./PlSqlParser.js";
+import { Savepoint_nameContext } from "./PlSqlParser.js";
+import { Rollback_segment_nameContext } from "./PlSqlParser.js";
+import { Schema_nameContext } from "./PlSqlParser.js";
+import { Routine_nameContext } from "./PlSqlParser.js";
+import { Package_nameContext } from "./PlSqlParser.js";
+import { Implementation_type_nameContext } from "./PlSqlParser.js";
+import { Parameter_nameContext } from "./PlSqlParser.js";
+import { Reference_model_nameContext } from "./PlSqlParser.js";
+import { Main_model_nameContext } from "./PlSqlParser.js";
+import { Container_tableview_nameContext } from "./PlSqlParser.js";
+import { Aggregate_function_nameContext } from "./PlSqlParser.js";
+import { Query_nameContext } from "./PlSqlParser.js";
+import { Grantee_nameContext } from "./PlSqlParser.js";
+import { Role_nameContext } from "./PlSqlParser.js";
+import { Constraint_nameContext } from "./PlSqlParser.js";
+import { Label_nameContext } from "./PlSqlParser.js";
+import { Type_nameContext } from "./PlSqlParser.js";
+import { Sequence_nameContext } from "./PlSqlParser.js";
+import { Exception_nameContext } from "./PlSqlParser.js";
+import { Function_nameContext } from "./PlSqlParser.js";
+import { Procedure_nameContext } from "./PlSqlParser.js";
+import { Trigger_nameContext } from "./PlSqlParser.js";
+import { Variable_nameContext } from "./PlSqlParser.js";
+import { Index_nameContext } from "./PlSqlParser.js";
+import { Cursor_nameContext } from "./PlSqlParser.js";
+import { Record_nameContext } from "./PlSqlParser.js";
+import { Link_nameContext } from "./PlSqlParser.js";
+import { Local_link_nameContext } from "./PlSqlParser.js";
+import { Connection_qualifierContext } from "./PlSqlParser.js";
+import { Column_nameContext } from "./PlSqlParser.js";
+import { Tableview_nameContext } from "./PlSqlParser.js";
+import { XmltableContext } from "./PlSqlParser.js";
+import { Char_set_nameContext } from "./PlSqlParser.js";
+import { Synonym_nameContext } from "./PlSqlParser.js";
+import { Schema_object_nameContext } from "./PlSqlParser.js";
+import { Dir_object_nameContext } from "./PlSqlParser.js";
+import { User_object_nameContext } from "./PlSqlParser.js";
+import { Grant_object_nameContext } from "./PlSqlParser.js";
+import { Column_listContext } from "./PlSqlParser.js";
+import { Paren_column_listContext } from "./PlSqlParser.js";
+import { Keep_clauseContext } from "./PlSqlParser.js";
+import { Function_argumentContext } from "./PlSqlParser.js";
+import { Function_argument_analyticContext } from "./PlSqlParser.js";
+import { Function_argument_modelingContext } from "./PlSqlParser.js";
+import { Respect_or_ignore_nullsContext } from "./PlSqlParser.js";
+import { ArgumentContext } from "./PlSqlParser.js";
+import { Type_specContext } from "./PlSqlParser.js";
+import { DatatypeContext } from "./PlSqlParser.js";
+import { Precision_partContext } from "./PlSqlParser.js";
+import { Native_datatype_elementContext } from "./PlSqlParser.js";
+import { Bind_variableContext } from "./PlSqlParser.js";
+import { General_elementContext } from "./PlSqlParser.js";
+import { General_element_partContext } from "./PlSqlParser.js";
+import { Table_elementContext } from "./PlSqlParser.js";
+import { Object_privilegeContext } from "./PlSqlParser.js";
+import { System_privilegeContext } from "./PlSqlParser.js";
+import { ConstantContext } from "./PlSqlParser.js";
+import { NumericContext } from "./PlSqlParser.js";
+import { Numeric_negativeContext } from "./PlSqlParser.js";
+import { Quoted_stringContext } from "./PlSqlParser.js";
+import { IdentifierContext } from "./PlSqlParser.js";
+import { Id_expressionContext } from "./PlSqlParser.js";
+import { Inquiry_directiveContext } from "./PlSqlParser.js";
+import { Outer_join_signContext } from "./PlSqlParser.js";
+import { Regular_idContext } from "./PlSqlParser.js";
+import { Non_reserved_keywords_in_18cContext } from "./PlSqlParser.js";
+import { Non_reserved_keywords_in_12cContext } from "./PlSqlParser.js";
+import { Non_reserved_keywords_pre12cContext } from "./PlSqlParser.js";
+
+
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * `PlSqlParser`.
+ */
+export class PlSqlParserListener implements ParseTreeListener {
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_script`.
+     * @param ctx the parse tree
+     */
+    enterSql_script?: (ctx: Sql_scriptContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_script`.
+     * @param ctx the parse tree
+     */
+    exitSql_script?: (ctx: Sql_scriptContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.script_unit`.
+     * @param ctx the parse tree
+     */
+    enterScript_unit?: (ctx: Script_unitContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.script_unit`.
+     * @param ctx the parse tree
+     */
+    exitScript_unit?: (ctx: Script_unitContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.terminator`.
+     * @param ctx the parse tree
+     */
+    enterTerminator?: (ctx: TerminatorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.terminator`.
+     * @param ctx the parse tree
+     */
+    exitTerminator?: (ctx: TerminatorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.plsql_unit`.
+     * @param ctx the parse tree
+     */
+    enterPlsql_unit?: (ctx: Plsql_unitContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.plsql_unit`.
+     * @param ctx the parse tree
+     */
+    exitPlsql_unit?: (ctx: Plsql_unitContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_unit`.
+     * @param ctx the parse tree
+     */
+    enterSql_unit?: (ctx: Sql_unitContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_unit`.
+     * @param ctx the parse tree
+     */
+    exitSql_unit?: (ctx: Sql_unitContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_diskgroup`.
+     * @param ctx the parse tree
+     */
+    enterAlter_diskgroup?: (ctx: Alter_diskgroupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_diskgroup`.
+     * @param ctx the parse tree
+     */
+    exitAlter_diskgroup?: (ctx: Alter_diskgroupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_disk_clause?: (ctx: Add_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_disk_clause?: (ctx: Add_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_disk_clause?: (ctx: Drop_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_disk_clause?: (ctx: Drop_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.resize_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterResize_disk_clause?: (ctx: Resize_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.resize_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitResize_disk_clause?: (ctx: Resize_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.replace_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterReplace_disk_clause?: (ctx: Replace_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.replace_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitReplace_disk_clause?: (ctx: Replace_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.wait_nowait`.
+     * @param ctx the parse tree
+     */
+    enterWait_nowait?: (ctx: Wait_nowaitContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.wait_nowait`.
+     * @param ctx the parse tree
+     */
+    exitWait_nowait?: (ctx: Wait_nowaitContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rename_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterRename_disk_clause?: (ctx: Rename_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rename_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitRename_disk_clause?: (ctx: Rename_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.disk_online_clause`.
+     * @param ctx the parse tree
+     */
+    enterDisk_online_clause?: (ctx: Disk_online_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.disk_online_clause`.
+     * @param ctx the parse tree
+     */
+    exitDisk_online_clause?: (ctx: Disk_online_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.disk_offline_clause`.
+     * @param ctx the parse tree
+     */
+    enterDisk_offline_clause?: (ctx: Disk_offline_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.disk_offline_clause`.
+     * @param ctx the parse tree
+     */
+    exitDisk_offline_clause?: (ctx: Disk_offline_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.timeout_clause`.
+     * @param ctx the parse tree
+     */
+    enterTimeout_clause?: (ctx: Timeout_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.timeout_clause`.
+     * @param ctx the parse tree
+     */
+    exitTimeout_clause?: (ctx: Timeout_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rebalance_diskgroup_clause`.
+     * @param ctx the parse tree
+     */
+    enterRebalance_diskgroup_clause?: (ctx: Rebalance_diskgroup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rebalance_diskgroup_clause`.
+     * @param ctx the parse tree
+     */
+    exitRebalance_diskgroup_clause?: (ctx: Rebalance_diskgroup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.phase`.
+     * @param ctx the parse tree
+     */
+    enterPhase?: (ctx: PhaseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.phase`.
+     * @param ctx the parse tree
+     */
+    exitPhase?: (ctx: PhaseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.check_diskgroup_clause`.
+     * @param ctx the parse tree
+     */
+    enterCheck_diskgroup_clause?: (ctx: Check_diskgroup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.check_diskgroup_clause`.
+     * @param ctx the parse tree
+     */
+    exitCheck_diskgroup_clause?: (ctx: Check_diskgroup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.diskgroup_template_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDiskgroup_template_clauses?: (ctx: Diskgroup_template_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.diskgroup_template_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDiskgroup_template_clauses?: (ctx: Diskgroup_template_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.qualified_template_clause`.
+     * @param ctx the parse tree
+     */
+    enterQualified_template_clause?: (ctx: Qualified_template_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.qualified_template_clause`.
+     * @param ctx the parse tree
+     */
+    exitQualified_template_clause?: (ctx: Qualified_template_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.redundancy_clause`.
+     * @param ctx the parse tree
+     */
+    enterRedundancy_clause?: (ctx: Redundancy_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.redundancy_clause`.
+     * @param ctx the parse tree
+     */
+    exitRedundancy_clause?: (ctx: Redundancy_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.striping_clause`.
+     * @param ctx the parse tree
+     */
+    enterStriping_clause?: (ctx: Striping_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.striping_clause`.
+     * @param ctx the parse tree
+     */
+    exitStriping_clause?: (ctx: Striping_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.force_noforce`.
+     * @param ctx the parse tree
+     */
+    enterForce_noforce?: (ctx: Force_noforceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.force_noforce`.
+     * @param ctx the parse tree
+     */
+    exitForce_noforce?: (ctx: Force_noforceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.diskgroup_directory_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDiskgroup_directory_clauses?: (ctx: Diskgroup_directory_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.diskgroup_directory_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDiskgroup_directory_clauses?: (ctx: Diskgroup_directory_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dir_name`.
+     * @param ctx the parse tree
+     */
+    enterDir_name?: (ctx: Dir_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dir_name`.
+     * @param ctx the parse tree
+     */
+    exitDir_name?: (ctx: Dir_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.diskgroup_alias_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDiskgroup_alias_clauses?: (ctx: Diskgroup_alias_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.diskgroup_alias_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDiskgroup_alias_clauses?: (ctx: Diskgroup_alias_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.diskgroup_volume_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDiskgroup_volume_clauses?: (ctx: Diskgroup_volume_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.diskgroup_volume_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDiskgroup_volume_clauses?: (ctx: Diskgroup_volume_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_volume_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_volume_clause?: (ctx: Add_volume_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_volume_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_volume_clause?: (ctx: Add_volume_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_volume_clause`.
+     * @param ctx the parse tree
+     */
+    enterModify_volume_clause?: (ctx: Modify_volume_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_volume_clause`.
+     * @param ctx the parse tree
+     */
+    exitModify_volume_clause?: (ctx: Modify_volume_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.diskgroup_attributes`.
+     * @param ctx the parse tree
+     */
+    enterDiskgroup_attributes?: (ctx: Diskgroup_attributesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.diskgroup_attributes`.
+     * @param ctx the parse tree
+     */
+    exitDiskgroup_attributes?: (ctx: Diskgroup_attributesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_diskgroup_file_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_diskgroup_file_clause?: (ctx: Drop_diskgroup_file_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_diskgroup_file_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_diskgroup_file_clause?: (ctx: Drop_diskgroup_file_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.convert_redundancy_clause`.
+     * @param ctx the parse tree
+     */
+    enterConvert_redundancy_clause?: (ctx: Convert_redundancy_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.convert_redundancy_clause`.
+     * @param ctx the parse tree
+     */
+    exitConvert_redundancy_clause?: (ctx: Convert_redundancy_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.usergroup_clauses`.
+     * @param ctx the parse tree
+     */
+    enterUsergroup_clauses?: (ctx: Usergroup_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.usergroup_clauses`.
+     * @param ctx the parse tree
+     */
+    exitUsergroup_clauses?: (ctx: Usergroup_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.user_clauses`.
+     * @param ctx the parse tree
+     */
+    enterUser_clauses?: (ctx: User_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.user_clauses`.
+     * @param ctx the parse tree
+     */
+    exitUser_clauses?: (ctx: User_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.file_permissions_clause`.
+     * @param ctx the parse tree
+     */
+    enterFile_permissions_clause?: (ctx: File_permissions_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.file_permissions_clause`.
+     * @param ctx the parse tree
+     */
+    exitFile_permissions_clause?: (ctx: File_permissions_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.file_owner_clause`.
+     * @param ctx the parse tree
+     */
+    enterFile_owner_clause?: (ctx: File_owner_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.file_owner_clause`.
+     * @param ctx the parse tree
+     */
+    exitFile_owner_clause?: (ctx: File_owner_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.scrub_clause`.
+     * @param ctx the parse tree
+     */
+    enterScrub_clause?: (ctx: Scrub_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.scrub_clause`.
+     * @param ctx the parse tree
+     */
+    exitScrub_clause?: (ctx: Scrub_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.quotagroup_clauses`.
+     * @param ctx the parse tree
+     */
+    enterQuotagroup_clauses?: (ctx: Quotagroup_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.quotagroup_clauses`.
+     * @param ctx the parse tree
+     */
+    exitQuotagroup_clauses?: (ctx: Quotagroup_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.property_name`.
+     * @param ctx the parse tree
+     */
+    enterProperty_name?: (ctx: Property_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.property_name`.
+     * @param ctx the parse tree
+     */
+    exitProperty_name?: (ctx: Property_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.property_value`.
+     * @param ctx the parse tree
+     */
+    enterProperty_value?: (ctx: Property_valueContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.property_value`.
+     * @param ctx the parse tree
+     */
+    exitProperty_value?: (ctx: Property_valueContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filegroup_clauses`.
+     * @param ctx the parse tree
+     */
+    enterFilegroup_clauses?: (ctx: Filegroup_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filegroup_clauses`.
+     * @param ctx the parse tree
+     */
+    exitFilegroup_clauses?: (ctx: Filegroup_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_filegroup_clause?: (ctx: Add_filegroup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_filegroup_clause?: (ctx: Add_filegroup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    enterModify_filegroup_clause?: (ctx: Modify_filegroup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    exitModify_filegroup_clause?: (ctx: Modify_filegroup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.move_to_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    enterMove_to_filegroup_clause?: (ctx: Move_to_filegroup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.move_to_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    exitMove_to_filegroup_clause?: (ctx: Move_to_filegroup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_filegroup_clause?: (ctx: Drop_filegroup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_filegroup_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_filegroup_clause?: (ctx: Drop_filegroup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.quorum_regular`.
+     * @param ctx the parse tree
+     */
+    enterQuorum_regular?: (ctx: Quorum_regularContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.quorum_regular`.
+     * @param ctx the parse tree
+     */
+    exitQuorum_regular?: (ctx: Quorum_regularContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.undrop_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterUndrop_disk_clause?: (ctx: Undrop_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.undrop_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitUndrop_disk_clause?: (ctx: Undrop_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.diskgroup_availability`.
+     * @param ctx the parse tree
+     */
+    enterDiskgroup_availability?: (ctx: Diskgroup_availabilityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.diskgroup_availability`.
+     * @param ctx the parse tree
+     */
+    exitDiskgroup_availability?: (ctx: Diskgroup_availabilityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.enable_disable_volume`.
+     * @param ctx the parse tree
+     */
+    enterEnable_disable_volume?: (ctx: Enable_disable_volumeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.enable_disable_volume`.
+     * @param ctx the parse tree
+     */
+    exitEnable_disable_volume?: (ctx: Enable_disable_volumeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_function`.
+     * @param ctx the parse tree
+     */
+    enterDrop_function?: (ctx: Drop_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_function`.
+     * @param ctx the parse tree
+     */
+    exitDrop_function?: (ctx: Drop_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_flashback_archive`.
+     * @param ctx the parse tree
+     */
+    enterAlter_flashback_archive?: (ctx: Alter_flashback_archiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_flashback_archive`.
+     * @param ctx the parse tree
+     */
+    exitAlter_flashback_archive?: (ctx: Alter_flashback_archiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_hierarchy`.
+     * @param ctx the parse tree
+     */
+    enterAlter_hierarchy?: (ctx: Alter_hierarchyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_hierarchy`.
+     * @param ctx the parse tree
+     */
+    exitAlter_hierarchy?: (ctx: Alter_hierarchyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_function`.
+     * @param ctx the parse tree
+     */
+    enterAlter_function?: (ctx: Alter_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_function`.
+     * @param ctx the parse tree
+     */
+    exitAlter_function?: (ctx: Alter_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_java`.
+     * @param ctx the parse tree
+     */
+    enterAlter_java?: (ctx: Alter_javaContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_java`.
+     * @param ctx the parse tree
+     */
+    exitAlter_java?: (ctx: Alter_javaContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.match_string`.
+     * @param ctx the parse tree
+     */
+    enterMatch_string?: (ctx: Match_stringContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.match_string`.
+     * @param ctx the parse tree
+     */
+    exitMatch_string?: (ctx: Match_stringContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_function_body`.
+     * @param ctx the parse tree
+     */
+    enterCreate_function_body?: (ctx: Create_function_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_function_body`.
+     * @param ctx the parse tree
+     */
+    exitCreate_function_body?: (ctx: Create_function_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_macro_body`.
+     * @param ctx the parse tree
+     */
+    enterSql_macro_body?: (ctx: Sql_macro_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_macro_body`.
+     * @param ctx the parse tree
+     */
+    exitSql_macro_body?: (ctx: Sql_macro_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parallel_enable_clause`.
+     * @param ctx the parse tree
+     */
+    enterParallel_enable_clause?: (ctx: Parallel_enable_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parallel_enable_clause`.
+     * @param ctx the parse tree
+     */
+    exitParallel_enable_clause?: (ctx: Parallel_enable_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_by_clause`.
+     * @param ctx the parse tree
+     */
+    enterPartition_by_clause?: (ctx: Partition_by_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_by_clause`.
+     * @param ctx the parse tree
+     */
+    exitPartition_by_clause?: (ctx: Partition_by_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.result_cache_clause`.
+     * @param ctx the parse tree
+     */
+    enterResult_cache_clause?: (ctx: Result_cache_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.result_cache_clause`.
+     * @param ctx the parse tree
+     */
+    exitResult_cache_clause?: (ctx: Result_cache_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.accessible_by_clause`.
+     * @param ctx the parse tree
+     */
+    enterAccessible_by_clause?: (ctx: Accessible_by_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.accessible_by_clause`.
+     * @param ctx the parse tree
+     */
+    exitAccessible_by_clause?: (ctx: Accessible_by_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_collation_clause`.
+     * @param ctx the parse tree
+     */
+    enterDefault_collation_clause?: (ctx: Default_collation_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_collation_clause`.
+     * @param ctx the parse tree
+     */
+    exitDefault_collation_clause?: (ctx: Default_collation_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.aggregate_clause`.
+     * @param ctx the parse tree
+     */
+    enterAggregate_clause?: (ctx: Aggregate_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.aggregate_clause`.
+     * @param ctx the parse tree
+     */
+    exitAggregate_clause?: (ctx: Aggregate_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pipelined_using_clause`.
+     * @param ctx the parse tree
+     */
+    enterPipelined_using_clause?: (ctx: Pipelined_using_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pipelined_using_clause`.
+     * @param ctx the parse tree
+     */
+    exitPipelined_using_clause?: (ctx: Pipelined_using_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.accessor`.
+     * @param ctx the parse tree
+     */
+    enterAccessor?: (ctx: AccessorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.accessor`.
+     * @param ctx the parse tree
+     */
+    exitAccessor?: (ctx: AccessorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relies_on_part`.
+     * @param ctx the parse tree
+     */
+    enterRelies_on_part?: (ctx: Relies_on_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relies_on_part`.
+     * @param ctx the parse tree
+     */
+    exitRelies_on_part?: (ctx: Relies_on_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.streaming_clause`.
+     * @param ctx the parse tree
+     */
+    enterStreaming_clause?: (ctx: Streaming_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.streaming_clause`.
+     * @param ctx the parse tree
+     */
+    exitStreaming_clause?: (ctx: Streaming_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_outline`.
+     * @param ctx the parse tree
+     */
+    enterAlter_outline?: (ctx: Alter_outlineContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_outline`.
+     * @param ctx the parse tree
+     */
+    exitAlter_outline?: (ctx: Alter_outlineContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.outline_options`.
+     * @param ctx the parse tree
+     */
+    enterOutline_options?: (ctx: Outline_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.outline_options`.
+     * @param ctx the parse tree
+     */
+    exitOutline_options?: (ctx: Outline_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_lockdown_profile`.
+     * @param ctx the parse tree
+     */
+    enterAlter_lockdown_profile?: (ctx: Alter_lockdown_profileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_lockdown_profile`.
+     * @param ctx the parse tree
+     */
+    exitAlter_lockdown_profile?: (ctx: Alter_lockdown_profileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lockdown_feature`.
+     * @param ctx the parse tree
+     */
+    enterLockdown_feature?: (ctx: Lockdown_featureContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lockdown_feature`.
+     * @param ctx the parse tree
+     */
+    exitLockdown_feature?: (ctx: Lockdown_featureContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lockdown_options`.
+     * @param ctx the parse tree
+     */
+    enterLockdown_options?: (ctx: Lockdown_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lockdown_options`.
+     * @param ctx the parse tree
+     */
+    exitLockdown_options?: (ctx: Lockdown_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lockdown_statements`.
+     * @param ctx the parse tree
+     */
+    enterLockdown_statements?: (ctx: Lockdown_statementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lockdown_statements`.
+     * @param ctx the parse tree
+     */
+    exitLockdown_statements?: (ctx: Lockdown_statementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.statement_clauses`.
+     * @param ctx the parse tree
+     */
+    enterStatement_clauses?: (ctx: Statement_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.statement_clauses`.
+     * @param ctx the parse tree
+     */
+    exitStatement_clauses?: (ctx: Statement_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.clause_options`.
+     * @param ctx the parse tree
+     */
+    enterClause_options?: (ctx: Clause_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.clause_options`.
+     * @param ctx the parse tree
+     */
+    exitClause_options?: (ctx: Clause_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.option_values`.
+     * @param ctx the parse tree
+     */
+    enterOption_values?: (ctx: Option_valuesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.option_values`.
+     * @param ctx the parse tree
+     */
+    exitOption_values?: (ctx: Option_valuesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.string_list`.
+     * @param ctx the parse tree
+     */
+    enterString_list?: (ctx: String_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.string_list`.
+     * @param ctx the parse tree
+     */
+    exitString_list?: (ctx: String_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.disable_enable`.
+     * @param ctx the parse tree
+     */
+    enterDisable_enable?: (ctx: Disable_enableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.disable_enable`.
+     * @param ctx the parse tree
+     */
+    exitDisable_enable?: (ctx: Disable_enableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_lockdown_profile`.
+     * @param ctx the parse tree
+     */
+    enterDrop_lockdown_profile?: (ctx: Drop_lockdown_profileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_lockdown_profile`.
+     * @param ctx the parse tree
+     */
+    exitDrop_lockdown_profile?: (ctx: Drop_lockdown_profileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_package`.
+     * @param ctx the parse tree
+     */
+    enterDrop_package?: (ctx: Drop_packageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_package`.
+     * @param ctx the parse tree
+     */
+    exitDrop_package?: (ctx: Drop_packageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_package`.
+     * @param ctx the parse tree
+     */
+    enterAlter_package?: (ctx: Alter_packageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_package`.
+     * @param ctx the parse tree
+     */
+    exitAlter_package?: (ctx: Alter_packageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_package`.
+     * @param ctx the parse tree
+     */
+    enterCreate_package?: (ctx: Create_packageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_package`.
+     * @param ctx the parse tree
+     */
+    exitCreate_package?: (ctx: Create_packageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_package_body`.
+     * @param ctx the parse tree
+     */
+    enterCreate_package_body?: (ctx: Create_package_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_package_body`.
+     * @param ctx the parse tree
+     */
+    exitCreate_package_body?: (ctx: Create_package_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.package_obj_spec`.
+     * @param ctx the parse tree
+     */
+    enterPackage_obj_spec?: (ctx: Package_obj_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.package_obj_spec`.
+     * @param ctx the parse tree
+     */
+    exitPackage_obj_spec?: (ctx: Package_obj_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.procedure_spec`.
+     * @param ctx the parse tree
+     */
+    enterProcedure_spec?: (ctx: Procedure_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.procedure_spec`.
+     * @param ctx the parse tree
+     */
+    exitProcedure_spec?: (ctx: Procedure_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_spec`.
+     * @param ctx the parse tree
+     */
+    enterFunction_spec?: (ctx: Function_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_spec`.
+     * @param ctx the parse tree
+     */
+    exitFunction_spec?: (ctx: Function_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.package_obj_body`.
+     * @param ctx the parse tree
+     */
+    enterPackage_obj_body?: (ctx: Package_obj_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.package_obj_body`.
+     * @param ctx the parse tree
+     */
+    exitPackage_obj_body?: (ctx: Package_obj_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_pmem_filestore`.
+     * @param ctx the parse tree
+     */
+    enterAlter_pmem_filestore?: (ctx: Alter_pmem_filestoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_pmem_filestore`.
+     * @param ctx the parse tree
+     */
+    exitAlter_pmem_filestore?: (ctx: Alter_pmem_filestoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_pmem_filestore`.
+     * @param ctx the parse tree
+     */
+    enterDrop_pmem_filestore?: (ctx: Drop_pmem_filestoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_pmem_filestore`.
+     * @param ctx the parse tree
+     */
+    exitDrop_pmem_filestore?: (ctx: Drop_pmem_filestoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_procedure`.
+     * @param ctx the parse tree
+     */
+    enterDrop_procedure?: (ctx: Drop_procedureContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_procedure`.
+     * @param ctx the parse tree
+     */
+    exitDrop_procedure?: (ctx: Drop_procedureContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_procedure`.
+     * @param ctx the parse tree
+     */
+    enterAlter_procedure?: (ctx: Alter_procedureContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_procedure`.
+     * @param ctx the parse tree
+     */
+    exitAlter_procedure?: (ctx: Alter_procedureContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_body`.
+     * @param ctx the parse tree
+     */
+    enterFunction_body?: (ctx: Function_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_body`.
+     * @param ctx the parse tree
+     */
+    exitFunction_body?: (ctx: Function_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.procedure_body`.
+     * @param ctx the parse tree
+     */
+    enterProcedure_body?: (ctx: Procedure_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.procedure_body`.
+     * @param ctx the parse tree
+     */
+    exitProcedure_body?: (ctx: Procedure_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_procedure_body`.
+     * @param ctx the parse tree
+     */
+    enterCreate_procedure_body?: (ctx: Create_procedure_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_procedure_body`.
+     * @param ctx the parse tree
+     */
+    exitCreate_procedure_body?: (ctx: Create_procedure_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_resource_cost`.
+     * @param ctx the parse tree
+     */
+    enterAlter_resource_cost?: (ctx: Alter_resource_costContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_resource_cost`.
+     * @param ctx the parse tree
+     */
+    exitAlter_resource_cost?: (ctx: Alter_resource_costContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_outline`.
+     * @param ctx the parse tree
+     */
+    enterDrop_outline?: (ctx: Drop_outlineContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_outline`.
+     * @param ctx the parse tree
+     */
+    exitDrop_outline?: (ctx: Drop_outlineContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_rollback_segment`.
+     * @param ctx the parse tree
+     */
+    enterAlter_rollback_segment?: (ctx: Alter_rollback_segmentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_rollback_segment`.
+     * @param ctx the parse tree
+     */
+    exitAlter_rollback_segment?: (ctx: Alter_rollback_segmentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_restore_point`.
+     * @param ctx the parse tree
+     */
+    enterDrop_restore_point?: (ctx: Drop_restore_pointContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_restore_point`.
+     * @param ctx the parse tree
+     */
+    exitDrop_restore_point?: (ctx: Drop_restore_pointContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_rollback_segment`.
+     * @param ctx the parse tree
+     */
+    enterDrop_rollback_segment?: (ctx: Drop_rollback_segmentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_rollback_segment`.
+     * @param ctx the parse tree
+     */
+    exitDrop_rollback_segment?: (ctx: Drop_rollback_segmentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_role`.
+     * @param ctx the parse tree
+     */
+    enterDrop_role?: (ctx: Drop_roleContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_role`.
+     * @param ctx the parse tree
+     */
+    exitDrop_role?: (ctx: Drop_roleContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_pmem_filestore`.
+     * @param ctx the parse tree
+     */
+    enterCreate_pmem_filestore?: (ctx: Create_pmem_filestoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_pmem_filestore`.
+     * @param ctx the parse tree
+     */
+    exitCreate_pmem_filestore?: (ctx: Create_pmem_filestoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pmem_filestore_options`.
+     * @param ctx the parse tree
+     */
+    enterPmem_filestore_options?: (ctx: Pmem_filestore_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pmem_filestore_options`.
+     * @param ctx the parse tree
+     */
+    exitPmem_filestore_options?: (ctx: Pmem_filestore_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.file_path`.
+     * @param ctx the parse tree
+     */
+    enterFile_path?: (ctx: File_pathContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.file_path`.
+     * @param ctx the parse tree
+     */
+    exitFile_path?: (ctx: File_pathContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_rollback_segment`.
+     * @param ctx the parse tree
+     */
+    enterCreate_rollback_segment?: (ctx: Create_rollback_segmentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_rollback_segment`.
+     * @param ctx the parse tree
+     */
+    exitCreate_rollback_segment?: (ctx: Create_rollback_segmentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_trigger`.
+     * @param ctx the parse tree
+     */
+    enterDrop_trigger?: (ctx: Drop_triggerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_trigger`.
+     * @param ctx the parse tree
+     */
+    exitDrop_trigger?: (ctx: Drop_triggerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_trigger`.
+     * @param ctx the parse tree
+     */
+    enterAlter_trigger?: (ctx: Alter_triggerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_trigger`.
+     * @param ctx the parse tree
+     */
+    exitAlter_trigger?: (ctx: Alter_triggerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_trigger`.
+     * @param ctx the parse tree
+     */
+    enterCreate_trigger?: (ctx: Create_triggerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_trigger`.
+     * @param ctx the parse tree
+     */
+    exitCreate_trigger?: (ctx: Create_triggerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.trigger_follows_clause`.
+     * @param ctx the parse tree
+     */
+    enterTrigger_follows_clause?: (ctx: Trigger_follows_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.trigger_follows_clause`.
+     * @param ctx the parse tree
+     */
+    exitTrigger_follows_clause?: (ctx: Trigger_follows_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.trigger_when_clause`.
+     * @param ctx the parse tree
+     */
+    enterTrigger_when_clause?: (ctx: Trigger_when_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.trigger_when_clause`.
+     * @param ctx the parse tree
+     */
+    exitTrigger_when_clause?: (ctx: Trigger_when_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.simple_dml_trigger`.
+     * @param ctx the parse tree
+     */
+    enterSimple_dml_trigger?: (ctx: Simple_dml_triggerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.simple_dml_trigger`.
+     * @param ctx the parse tree
+     */
+    exitSimple_dml_trigger?: (ctx: Simple_dml_triggerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.for_each_row`.
+     * @param ctx the parse tree
+     */
+    enterFor_each_row?: (ctx: For_each_rowContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.for_each_row`.
+     * @param ctx the parse tree
+     */
+    exitFor_each_row?: (ctx: For_each_rowContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.compound_dml_trigger`.
+     * @param ctx the parse tree
+     */
+    enterCompound_dml_trigger?: (ctx: Compound_dml_triggerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.compound_dml_trigger`.
+     * @param ctx the parse tree
+     */
+    exitCompound_dml_trigger?: (ctx: Compound_dml_triggerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.non_dml_trigger`.
+     * @param ctx the parse tree
+     */
+    enterNon_dml_trigger?: (ctx: Non_dml_triggerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.non_dml_trigger`.
+     * @param ctx the parse tree
+     */
+    exitNon_dml_trigger?: (ctx: Non_dml_triggerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.trigger_body`.
+     * @param ctx the parse tree
+     */
+    enterTrigger_body?: (ctx: Trigger_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.trigger_body`.
+     * @param ctx the parse tree
+     */
+    exitTrigger_body?: (ctx: Trigger_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.compound_trigger_block`.
+     * @param ctx the parse tree
+     */
+    enterCompound_trigger_block?: (ctx: Compound_trigger_blockContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.compound_trigger_block`.
+     * @param ctx the parse tree
+     */
+    exitCompound_trigger_block?: (ctx: Compound_trigger_blockContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.timing_point_section`.
+     * @param ctx the parse tree
+     */
+    enterTiming_point_section?: (ctx: Timing_point_sectionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.timing_point_section`.
+     * @param ctx the parse tree
+     */
+    exitTiming_point_section?: (ctx: Timing_point_sectionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.non_dml_event`.
+     * @param ctx the parse tree
+     */
+    enterNon_dml_event?: (ctx: Non_dml_eventContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.non_dml_event`.
+     * @param ctx the parse tree
+     */
+    exitNon_dml_event?: (ctx: Non_dml_eventContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dml_event_clause`.
+     * @param ctx the parse tree
+     */
+    enterDml_event_clause?: (ctx: Dml_event_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dml_event_clause`.
+     * @param ctx the parse tree
+     */
+    exitDml_event_clause?: (ctx: Dml_event_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dml_event_element`.
+     * @param ctx the parse tree
+     */
+    enterDml_event_element?: (ctx: Dml_event_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dml_event_element`.
+     * @param ctx the parse tree
+     */
+    exitDml_event_element?: (ctx: Dml_event_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dml_event_nested_clause`.
+     * @param ctx the parse tree
+     */
+    enterDml_event_nested_clause?: (ctx: Dml_event_nested_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dml_event_nested_clause`.
+     * @param ctx the parse tree
+     */
+    exitDml_event_nested_clause?: (ctx: Dml_event_nested_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.referencing_clause`.
+     * @param ctx the parse tree
+     */
+    enterReferencing_clause?: (ctx: Referencing_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.referencing_clause`.
+     * @param ctx the parse tree
+     */
+    exitReferencing_clause?: (ctx: Referencing_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.referencing_element`.
+     * @param ctx the parse tree
+     */
+    enterReferencing_element?: (ctx: Referencing_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.referencing_element`.
+     * @param ctx the parse tree
+     */
+    exitReferencing_element?: (ctx: Referencing_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_type`.
+     * @param ctx the parse tree
+     */
+    enterDrop_type?: (ctx: Drop_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_type`.
+     * @param ctx the parse tree
+     */
+    exitDrop_type?: (ctx: Drop_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_type`.
+     * @param ctx the parse tree
+     */
+    enterAlter_type?: (ctx: Alter_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_type`.
+     * @param ctx the parse tree
+     */
+    exitAlter_type?: (ctx: Alter_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.compile_type_clause`.
+     * @param ctx the parse tree
+     */
+    enterCompile_type_clause?: (ctx: Compile_type_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.compile_type_clause`.
+     * @param ctx the parse tree
+     */
+    exitCompile_type_clause?: (ctx: Compile_type_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.replace_type_clause`.
+     * @param ctx the parse tree
+     */
+    enterReplace_type_clause?: (ctx: Replace_type_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.replace_type_clause`.
+     * @param ctx the parse tree
+     */
+    exitReplace_type_clause?: (ctx: Replace_type_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_method_spec`.
+     * @param ctx the parse tree
+     */
+    enterAlter_method_spec?: (ctx: Alter_method_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_method_spec`.
+     * @param ctx the parse tree
+     */
+    exitAlter_method_spec?: (ctx: Alter_method_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_method_element`.
+     * @param ctx the parse tree
+     */
+    enterAlter_method_element?: (ctx: Alter_method_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_method_element`.
+     * @param ctx the parse tree
+     */
+    exitAlter_method_element?: (ctx: Alter_method_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_attribute_definition`.
+     * @param ctx the parse tree
+     */
+    enterAlter_attribute_definition?: (ctx: Alter_attribute_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_attribute_definition`.
+     * @param ctx the parse tree
+     */
+    exitAlter_attribute_definition?: (ctx: Alter_attribute_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_collection_clauses`.
+     * @param ctx the parse tree
+     */
+    enterAlter_collection_clauses?: (ctx: Alter_collection_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_collection_clauses`.
+     * @param ctx the parse tree
+     */
+    exitAlter_collection_clauses?: (ctx: Alter_collection_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dependent_handling_clause`.
+     * @param ctx the parse tree
+     */
+    enterDependent_handling_clause?: (ctx: Dependent_handling_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dependent_handling_clause`.
+     * @param ctx the parse tree
+     */
+    exitDependent_handling_clause?: (ctx: Dependent_handling_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dependent_exceptions_part`.
+     * @param ctx the parse tree
+     */
+    enterDependent_exceptions_part?: (ctx: Dependent_exceptions_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dependent_exceptions_part`.
+     * @param ctx the parse tree
+     */
+    exitDependent_exceptions_part?: (ctx: Dependent_exceptions_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_type`.
+     * @param ctx the parse tree
+     */
+    enterCreate_type?: (ctx: Create_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_type`.
+     * @param ctx the parse tree
+     */
+    exitCreate_type?: (ctx: Create_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_type_spec`.
+     * @param ctx the parse tree
+     */
+    enterCreate_type_spec?: (ctx: Create_type_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_type_spec`.
+     * @param ctx the parse tree
+     */
+    exitCreate_type_spec?: (ctx: Create_type_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_type_body`.
+     * @param ctx the parse tree
+     */
+    enterCreate_type_body?: (ctx: Create_type_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_type_body`.
+     * @param ctx the parse tree
+     */
+    exitCreate_type_body?: (ctx: Create_type_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_definition`.
+     * @param ctx the parse tree
+     */
+    enterType_definition?: (ctx: Type_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_definition`.
+     * @param ctx the parse tree
+     */
+    exitType_definition?: (ctx: Type_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_type_def`.
+     * @param ctx the parse tree
+     */
+    enterObject_type_def?: (ctx: Object_type_defContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_type_def`.
+     * @param ctx the parse tree
+     */
+    exitObject_type_def?: (ctx: Object_type_defContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_as_part`.
+     * @param ctx the parse tree
+     */
+    enterObject_as_part?: (ctx: Object_as_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_as_part`.
+     * @param ctx the parse tree
+     */
+    exitObject_as_part?: (ctx: Object_as_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_under_part`.
+     * @param ctx the parse tree
+     */
+    enterObject_under_part?: (ctx: Object_under_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_under_part`.
+     * @param ctx the parse tree
+     */
+    exitObject_under_part?: (ctx: Object_under_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.nested_table_type_def`.
+     * @param ctx the parse tree
+     */
+    enterNested_table_type_def?: (ctx: Nested_table_type_defContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.nested_table_type_def`.
+     * @param ctx the parse tree
+     */
+    exitNested_table_type_def?: (ctx: Nested_table_type_defContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sqlj_object_type`.
+     * @param ctx the parse tree
+     */
+    enterSqlj_object_type?: (ctx: Sqlj_object_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sqlj_object_type`.
+     * @param ctx the parse tree
+     */
+    exitSqlj_object_type?: (ctx: Sqlj_object_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_body`.
+     * @param ctx the parse tree
+     */
+    enterType_body?: (ctx: Type_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_body`.
+     * @param ctx the parse tree
+     */
+    exitType_body?: (ctx: Type_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_body_elements`.
+     * @param ctx the parse tree
+     */
+    enterType_body_elements?: (ctx: Type_body_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_body_elements`.
+     * @param ctx the parse tree
+     */
+    exitType_body_elements?: (ctx: Type_body_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.map_order_func_declaration`.
+     * @param ctx the parse tree
+     */
+    enterMap_order_func_declaration?: (ctx: Map_order_func_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.map_order_func_declaration`.
+     * @param ctx the parse tree
+     */
+    exitMap_order_func_declaration?: (ctx: Map_order_func_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subprog_decl_in_type`.
+     * @param ctx the parse tree
+     */
+    enterSubprog_decl_in_type?: (ctx: Subprog_decl_in_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subprog_decl_in_type`.
+     * @param ctx the parse tree
+     */
+    exitSubprog_decl_in_type?: (ctx: Subprog_decl_in_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.proc_decl_in_type`.
+     * @param ctx the parse tree
+     */
+    enterProc_decl_in_type?: (ctx: Proc_decl_in_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.proc_decl_in_type`.
+     * @param ctx the parse tree
+     */
+    exitProc_decl_in_type?: (ctx: Proc_decl_in_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.func_decl_in_type`.
+     * @param ctx the parse tree
+     */
+    enterFunc_decl_in_type?: (ctx: Func_decl_in_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.func_decl_in_type`.
+     * @param ctx the parse tree
+     */
+    exitFunc_decl_in_type?: (ctx: Func_decl_in_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.constructor_declaration`.
+     * @param ctx the parse tree
+     */
+    enterConstructor_declaration?: (ctx: Constructor_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.constructor_declaration`.
+     * @param ctx the parse tree
+     */
+    exitConstructor_declaration?: (ctx: Constructor_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modifier_clause`.
+     * @param ctx the parse tree
+     */
+    enterModifier_clause?: (ctx: Modifier_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modifier_clause`.
+     * @param ctx the parse tree
+     */
+    exitModifier_clause?: (ctx: Modifier_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_member_spec`.
+     * @param ctx the parse tree
+     */
+    enterObject_member_spec?: (ctx: Object_member_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_member_spec`.
+     * @param ctx the parse tree
+     */
+    exitObject_member_spec?: (ctx: Object_member_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sqlj_object_type_attr`.
+     * @param ctx the parse tree
+     */
+    enterSqlj_object_type_attr?: (ctx: Sqlj_object_type_attrContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sqlj_object_type_attr`.
+     * @param ctx the parse tree
+     */
+    exitSqlj_object_type_attr?: (ctx: Sqlj_object_type_attrContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.element_spec`.
+     * @param ctx the parse tree
+     */
+    enterElement_spec?: (ctx: Element_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.element_spec`.
+     * @param ctx the parse tree
+     */
+    exitElement_spec?: (ctx: Element_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.element_spec_options`.
+     * @param ctx the parse tree
+     */
+    enterElement_spec_options?: (ctx: Element_spec_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.element_spec_options`.
+     * @param ctx the parse tree
+     */
+    exitElement_spec_options?: (ctx: Element_spec_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subprogram_spec`.
+     * @param ctx the parse tree
+     */
+    enterSubprogram_spec?: (ctx: Subprogram_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subprogram_spec`.
+     * @param ctx the parse tree
+     */
+    exitSubprogram_spec?: (ctx: Subprogram_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.overriding_subprogram_spec`.
+     * @param ctx the parse tree
+     */
+    enterOverriding_subprogram_spec?: (ctx: Overriding_subprogram_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.overriding_subprogram_spec`.
+     * @param ctx the parse tree
+     */
+    exitOverriding_subprogram_spec?: (ctx: Overriding_subprogram_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.overriding_function_spec`.
+     * @param ctx the parse tree
+     */
+    enterOverriding_function_spec?: (ctx: Overriding_function_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.overriding_function_spec`.
+     * @param ctx the parse tree
+     */
+    exitOverriding_function_spec?: (ctx: Overriding_function_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.overriding_procedure_spec`.
+     * @param ctx the parse tree
+     */
+    enterOverriding_procedure_spec?: (ctx: Overriding_procedure_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.overriding_procedure_spec`.
+     * @param ctx the parse tree
+     */
+    exitOverriding_procedure_spec?: (ctx: Overriding_procedure_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_procedure_spec`.
+     * @param ctx the parse tree
+     */
+    enterType_procedure_spec?: (ctx: Type_procedure_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_procedure_spec`.
+     * @param ctx the parse tree
+     */
+    exitType_procedure_spec?: (ctx: Type_procedure_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_function_spec`.
+     * @param ctx the parse tree
+     */
+    enterType_function_spec?: (ctx: Type_function_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_function_spec`.
+     * @param ctx the parse tree
+     */
+    exitType_function_spec?: (ctx: Type_function_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.constructor_spec`.
+     * @param ctx the parse tree
+     */
+    enterConstructor_spec?: (ctx: Constructor_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.constructor_spec`.
+     * @param ctx the parse tree
+     */
+    exitConstructor_spec?: (ctx: Constructor_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.map_order_function_spec`.
+     * @param ctx the parse tree
+     */
+    enterMap_order_function_spec?: (ctx: Map_order_function_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.map_order_function_spec`.
+     * @param ctx the parse tree
+     */
+    exitMap_order_function_spec?: (ctx: Map_order_function_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pragma_clause`.
+     * @param ctx the parse tree
+     */
+    enterPragma_clause?: (ctx: Pragma_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pragma_clause`.
+     * @param ctx the parse tree
+     */
+    exitPragma_clause?: (ctx: Pragma_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pragma_elements`.
+     * @param ctx the parse tree
+     */
+    enterPragma_elements?: (ctx: Pragma_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pragma_elements`.
+     * @param ctx the parse tree
+     */
+    exitPragma_elements?: (ctx: Pragma_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_elements_parameter`.
+     * @param ctx the parse tree
+     */
+    enterType_elements_parameter?: (ctx: Type_elements_parameterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_elements_parameter`.
+     * @param ctx the parse tree
+     */
+    exitType_elements_parameter?: (ctx: Type_elements_parameterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_sequence`.
+     * @param ctx the parse tree
+     */
+    enterDrop_sequence?: (ctx: Drop_sequenceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_sequence`.
+     * @param ctx the parse tree
+     */
+    exitDrop_sequence?: (ctx: Drop_sequenceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_sequence`.
+     * @param ctx the parse tree
+     */
+    enterAlter_sequence?: (ctx: Alter_sequenceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_sequence`.
+     * @param ctx the parse tree
+     */
+    exitAlter_sequence?: (ctx: Alter_sequenceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_session`.
+     * @param ctx the parse tree
+     */
+    enterAlter_session?: (ctx: Alter_sessionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_session`.
+     * @param ctx the parse tree
+     */
+    exitAlter_session?: (ctx: Alter_sessionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_session_set_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_session_set_clause?: (ctx: Alter_session_set_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_session_set_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_session_set_clause?: (ctx: Alter_session_set_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_sequence`.
+     * @param ctx the parse tree
+     */
+    enterCreate_sequence?: (ctx: Create_sequenceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_sequence`.
+     * @param ctx the parse tree
+     */
+    exitCreate_sequence?: (ctx: Create_sequenceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sequence_spec`.
+     * @param ctx the parse tree
+     */
+    enterSequence_spec?: (ctx: Sequence_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sequence_spec`.
+     * @param ctx the parse tree
+     */
+    exitSequence_spec?: (ctx: Sequence_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sequence_start_clause`.
+     * @param ctx the parse tree
+     */
+    enterSequence_start_clause?: (ctx: Sequence_start_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sequence_start_clause`.
+     * @param ctx the parse tree
+     */
+    exitSequence_start_clause?: (ctx: Sequence_start_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_analytic_view`.
+     * @param ctx the parse tree
+     */
+    enterCreate_analytic_view?: (ctx: Create_analytic_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_analytic_view`.
+     * @param ctx the parse tree
+     */
+    exitCreate_analytic_view?: (ctx: Create_analytic_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.classification_clause`.
+     * @param ctx the parse tree
+     */
+    enterClassification_clause?: (ctx: Classification_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.classification_clause`.
+     * @param ctx the parse tree
+     */
+    exitClassification_clause?: (ctx: Classification_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.caption_clause`.
+     * @param ctx the parse tree
+     */
+    enterCaption_clause?: (ctx: Caption_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.caption_clause`.
+     * @param ctx the parse tree
+     */
+    exitCaption_clause?: (ctx: Caption_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.description_clause`.
+     * @param ctx the parse tree
+     */
+    enterDescription_clause?: (ctx: Description_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.description_clause`.
+     * @param ctx the parse tree
+     */
+    exitDescription_clause?: (ctx: Description_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.classification_item`.
+     * @param ctx the parse tree
+     */
+    enterClassification_item?: (ctx: Classification_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.classification_item`.
+     * @param ctx the parse tree
+     */
+    exitClassification_item?: (ctx: Classification_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.language`.
+     * @param ctx the parse tree
+     */
+    enterLanguage?: (ctx: LanguageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.language`.
+     * @param ctx the parse tree
+     */
+    exitLanguage?: (ctx: LanguageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cav_using_clause`.
+     * @param ctx the parse tree
+     */
+    enterCav_using_clause?: (ctx: Cav_using_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cav_using_clause`.
+     * @param ctx the parse tree
+     */
+    exitCav_using_clause?: (ctx: Cav_using_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dim_by_clause`.
+     * @param ctx the parse tree
+     */
+    enterDim_by_clause?: (ctx: Dim_by_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dim_by_clause`.
+     * @param ctx the parse tree
+     */
+    exitDim_by_clause?: (ctx: Dim_by_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dim_key`.
+     * @param ctx the parse tree
+     */
+    enterDim_key?: (ctx: Dim_keyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dim_key`.
+     * @param ctx the parse tree
+     */
+    exitDim_key?: (ctx: Dim_keyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dim_ref`.
+     * @param ctx the parse tree
+     */
+    enterDim_ref?: (ctx: Dim_refContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dim_ref`.
+     * @param ctx the parse tree
+     */
+    exitDim_ref?: (ctx: Dim_refContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hier_ref`.
+     * @param ctx the parse tree
+     */
+    enterHier_ref?: (ctx: Hier_refContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hier_ref`.
+     * @param ctx the parse tree
+     */
+    exitHier_ref?: (ctx: Hier_refContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.measures_clause`.
+     * @param ctx the parse tree
+     */
+    enterMeasures_clause?: (ctx: Measures_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.measures_clause`.
+     * @param ctx the parse tree
+     */
+    exitMeasures_clause?: (ctx: Measures_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.av_measure`.
+     * @param ctx the parse tree
+     */
+    enterAv_measure?: (ctx: Av_measureContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.av_measure`.
+     * @param ctx the parse tree
+     */
+    exitAv_measure?: (ctx: Av_measureContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.base_meas_clause`.
+     * @param ctx the parse tree
+     */
+    enterBase_meas_clause?: (ctx: Base_meas_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.base_meas_clause`.
+     * @param ctx the parse tree
+     */
+    exitBase_meas_clause?: (ctx: Base_meas_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.meas_aggregate_clause`.
+     * @param ctx the parse tree
+     */
+    enterMeas_aggregate_clause?: (ctx: Meas_aggregate_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.meas_aggregate_clause`.
+     * @param ctx the parse tree
+     */
+    exitMeas_aggregate_clause?: (ctx: Meas_aggregate_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.calc_meas_clause`.
+     * @param ctx the parse tree
+     */
+    enterCalc_meas_clause?: (ctx: Calc_meas_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.calc_meas_clause`.
+     * @param ctx the parse tree
+     */
+    exitCalc_meas_clause?: (ctx: Calc_meas_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_measure_clause`.
+     * @param ctx the parse tree
+     */
+    enterDefault_measure_clause?: (ctx: Default_measure_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_measure_clause`.
+     * @param ctx the parse tree
+     */
+    exitDefault_measure_clause?: (ctx: Default_measure_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_aggregate_clause`.
+     * @param ctx the parse tree
+     */
+    enterDefault_aggregate_clause?: (ctx: Default_aggregate_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_aggregate_clause`.
+     * @param ctx the parse tree
+     */
+    exitDefault_aggregate_clause?: (ctx: Default_aggregate_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cache_clause`.
+     * @param ctx the parse tree
+     */
+    enterCache_clause?: (ctx: Cache_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cache_clause`.
+     * @param ctx the parse tree
+     */
+    exitCache_clause?: (ctx: Cache_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cache_specification`.
+     * @param ctx the parse tree
+     */
+    enterCache_specification?: (ctx: Cache_specificationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cache_specification`.
+     * @param ctx the parse tree
+     */
+    exitCache_specification?: (ctx: Cache_specificationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.levels_clause`.
+     * @param ctx the parse tree
+     */
+    enterLevels_clause?: (ctx: Levels_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.levels_clause`.
+     * @param ctx the parse tree
+     */
+    exitLevels_clause?: (ctx: Levels_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.level_specification`.
+     * @param ctx the parse tree
+     */
+    enterLevel_specification?: (ctx: Level_specificationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.level_specification`.
+     * @param ctx the parse tree
+     */
+    exitLevel_specification?: (ctx: Level_specificationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.level_group_type`.
+     * @param ctx the parse tree
+     */
+    enterLevel_group_type?: (ctx: Level_group_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.level_group_type`.
+     * @param ctx the parse tree
+     */
+    exitLevel_group_type?: (ctx: Level_group_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.fact_columns_clause`.
+     * @param ctx the parse tree
+     */
+    enterFact_columns_clause?: (ctx: Fact_columns_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.fact_columns_clause`.
+     * @param ctx the parse tree
+     */
+    exitFact_columns_clause?: (ctx: Fact_columns_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.qry_transform_clause`.
+     * @param ctx the parse tree
+     */
+    enterQry_transform_clause?: (ctx: Qry_transform_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.qry_transform_clause`.
+     * @param ctx the parse tree
+     */
+    exitQry_transform_clause?: (ctx: Qry_transform_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_attribute_dimension`.
+     * @param ctx the parse tree
+     */
+    enterCreate_attribute_dimension?: (ctx: Create_attribute_dimensionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_attribute_dimension`.
+     * @param ctx the parse tree
+     */
+    exitCreate_attribute_dimension?: (ctx: Create_attribute_dimensionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ad_using_clause`.
+     * @param ctx the parse tree
+     */
+    enterAd_using_clause?: (ctx: Ad_using_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ad_using_clause`.
+     * @param ctx the parse tree
+     */
+    exitAd_using_clause?: (ctx: Ad_using_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.source_clause`.
+     * @param ctx the parse tree
+     */
+    enterSource_clause?: (ctx: Source_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.source_clause`.
+     * @param ctx the parse tree
+     */
+    exitSource_clause?: (ctx: Source_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.join_path_clause`.
+     * @param ctx the parse tree
+     */
+    enterJoin_path_clause?: (ctx: Join_path_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.join_path_clause`.
+     * @param ctx the parse tree
+     */
+    exitJoin_path_clause?: (ctx: Join_path_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.join_condition`.
+     * @param ctx the parse tree
+     */
+    enterJoin_condition?: (ctx: Join_conditionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.join_condition`.
+     * @param ctx the parse tree
+     */
+    exitJoin_condition?: (ctx: Join_conditionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.join_condition_item`.
+     * @param ctx the parse tree
+     */
+    enterJoin_condition_item?: (ctx: Join_condition_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.join_condition_item`.
+     * @param ctx the parse tree
+     */
+    exitJoin_condition_item?: (ctx: Join_condition_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.attributes_clause`.
+     * @param ctx the parse tree
+     */
+    enterAttributes_clause?: (ctx: Attributes_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.attributes_clause`.
+     * @param ctx the parse tree
+     */
+    exitAttributes_clause?: (ctx: Attributes_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ad_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    enterAd_attributes_clause?: (ctx: Ad_attributes_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ad_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    exitAd_attributes_clause?: (ctx: Ad_attributes_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ad_level_clause`.
+     * @param ctx the parse tree
+     */
+    enterAd_level_clause?: (ctx: Ad_level_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ad_level_clause`.
+     * @param ctx the parse tree
+     */
+    exitAd_level_clause?: (ctx: Ad_level_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.key_clause`.
+     * @param ctx the parse tree
+     */
+    enterKey_clause?: (ctx: Key_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.key_clause`.
+     * @param ctx the parse tree
+     */
+    exitKey_clause?: (ctx: Key_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alternate_key_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlternate_key_clause?: (ctx: Alternate_key_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alternate_key_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlternate_key_clause?: (ctx: Alternate_key_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dim_order_clause`.
+     * @param ctx the parse tree
+     */
+    enterDim_order_clause?: (ctx: Dim_order_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dim_order_clause`.
+     * @param ctx the parse tree
+     */
+    exitDim_order_clause?: (ctx: Dim_order_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.all_clause`.
+     * @param ctx the parse tree
+     */
+    enterAll_clause?: (ctx: All_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.all_clause`.
+     * @param ctx the parse tree
+     */
+    exitAll_clause?: (ctx: All_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_audit_policy`.
+     * @param ctx the parse tree
+     */
+    enterCreate_audit_policy?: (ctx: Create_audit_policyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_audit_policy`.
+     * @param ctx the parse tree
+     */
+    exitCreate_audit_policy?: (ctx: Create_audit_policyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.privilege_audit_clause`.
+     * @param ctx the parse tree
+     */
+    enterPrivilege_audit_clause?: (ctx: Privilege_audit_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.privilege_audit_clause`.
+     * @param ctx the parse tree
+     */
+    exitPrivilege_audit_clause?: (ctx: Privilege_audit_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.action_audit_clause`.
+     * @param ctx the parse tree
+     */
+    enterAction_audit_clause?: (ctx: Action_audit_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.action_audit_clause`.
+     * @param ctx the parse tree
+     */
+    exitAction_audit_clause?: (ctx: Action_audit_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.system_actions`.
+     * @param ctx the parse tree
+     */
+    enterSystem_actions?: (ctx: System_actionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.system_actions`.
+     * @param ctx the parse tree
+     */
+    exitSystem_actions?: (ctx: System_actionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.standard_actions`.
+     * @param ctx the parse tree
+     */
+    enterStandard_actions?: (ctx: Standard_actionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.standard_actions`.
+     * @param ctx the parse tree
+     */
+    exitStandard_actions?: (ctx: Standard_actionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.actions_clause`.
+     * @param ctx the parse tree
+     */
+    enterActions_clause?: (ctx: Actions_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.actions_clause`.
+     * @param ctx the parse tree
+     */
+    exitActions_clause?: (ctx: Actions_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_action`.
+     * @param ctx the parse tree
+     */
+    enterObject_action?: (ctx: Object_actionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_action`.
+     * @param ctx the parse tree
+     */
+    exitObject_action?: (ctx: Object_actionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.system_action`.
+     * @param ctx the parse tree
+     */
+    enterSystem_action?: (ctx: System_actionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.system_action`.
+     * @param ctx the parse tree
+     */
+    exitSystem_action?: (ctx: System_actionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.component_actions`.
+     * @param ctx the parse tree
+     */
+    enterComponent_actions?: (ctx: Component_actionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.component_actions`.
+     * @param ctx the parse tree
+     */
+    exitComponent_actions?: (ctx: Component_actionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.component_action`.
+     * @param ctx the parse tree
+     */
+    enterComponent_action?: (ctx: Component_actionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.component_action`.
+     * @param ctx the parse tree
+     */
+    exitComponent_action?: (ctx: Component_actionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.role_audit_clause`.
+     * @param ctx the parse tree
+     */
+    enterRole_audit_clause?: (ctx: Role_audit_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.role_audit_clause`.
+     * @param ctx the parse tree
+     */
+    exitRole_audit_clause?: (ctx: Role_audit_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_controlfile`.
+     * @param ctx the parse tree
+     */
+    enterCreate_controlfile?: (ctx: Create_controlfileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_controlfile`.
+     * @param ctx the parse tree
+     */
+    exitCreate_controlfile?: (ctx: Create_controlfileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.controlfile_options`.
+     * @param ctx the parse tree
+     */
+    enterControlfile_options?: (ctx: Controlfile_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.controlfile_options`.
+     * @param ctx the parse tree
+     */
+    exitControlfile_options?: (ctx: Controlfile_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logfile_clause`.
+     * @param ctx the parse tree
+     */
+    enterLogfile_clause?: (ctx: Logfile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logfile_clause`.
+     * @param ctx the parse tree
+     */
+    exitLogfile_clause?: (ctx: Logfile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.character_set_clause`.
+     * @param ctx the parse tree
+     */
+    enterCharacter_set_clause?: (ctx: Character_set_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.character_set_clause`.
+     * @param ctx the parse tree
+     */
+    exitCharacter_set_clause?: (ctx: Character_set_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.file_specification`.
+     * @param ctx the parse tree
+     */
+    enterFile_specification?: (ctx: File_specificationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.file_specification`.
+     * @param ctx the parse tree
+     */
+    exitFile_specification?: (ctx: File_specificationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_diskgroup`.
+     * @param ctx the parse tree
+     */
+    enterCreate_diskgroup?: (ctx: Create_diskgroupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_diskgroup`.
+     * @param ctx the parse tree
+     */
+    exitCreate_diskgroup?: (ctx: Create_diskgroupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.qualified_disk_clause`.
+     * @param ctx the parse tree
+     */
+    enterQualified_disk_clause?: (ctx: Qualified_disk_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.qualified_disk_clause`.
+     * @param ctx the parse tree
+     */
+    exitQualified_disk_clause?: (ctx: Qualified_disk_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_edition`.
+     * @param ctx the parse tree
+     */
+    enterCreate_edition?: (ctx: Create_editionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_edition`.
+     * @param ctx the parse tree
+     */
+    exitCreate_edition?: (ctx: Create_editionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_flashback_archive`.
+     * @param ctx the parse tree
+     */
+    enterCreate_flashback_archive?: (ctx: Create_flashback_archiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_flashback_archive`.
+     * @param ctx the parse tree
+     */
+    exitCreate_flashback_archive?: (ctx: Create_flashback_archiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.flashback_archive_quota`.
+     * @param ctx the parse tree
+     */
+    enterFlashback_archive_quota?: (ctx: Flashback_archive_quotaContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.flashback_archive_quota`.
+     * @param ctx the parse tree
+     */
+    exitFlashback_archive_quota?: (ctx: Flashback_archive_quotaContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.flashback_archive_retention`.
+     * @param ctx the parse tree
+     */
+    enterFlashback_archive_retention?: (ctx: Flashback_archive_retentionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.flashback_archive_retention`.
+     * @param ctx the parse tree
+     */
+    exitFlashback_archive_retention?: (ctx: Flashback_archive_retentionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_hierarchy`.
+     * @param ctx the parse tree
+     */
+    enterCreate_hierarchy?: (ctx: Create_hierarchyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_hierarchy`.
+     * @param ctx the parse tree
+     */
+    exitCreate_hierarchy?: (ctx: Create_hierarchyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hier_using_clause`.
+     * @param ctx the parse tree
+     */
+    enterHier_using_clause?: (ctx: Hier_using_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hier_using_clause`.
+     * @param ctx the parse tree
+     */
+    exitHier_using_clause?: (ctx: Hier_using_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.level_hier_clause`.
+     * @param ctx the parse tree
+     */
+    enterLevel_hier_clause?: (ctx: Level_hier_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.level_hier_clause`.
+     * @param ctx the parse tree
+     */
+    exitLevel_hier_clause?: (ctx: Level_hier_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hier_attrs_clause`.
+     * @param ctx the parse tree
+     */
+    enterHier_attrs_clause?: (ctx: Hier_attrs_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hier_attrs_clause`.
+     * @param ctx the parse tree
+     */
+    exitHier_attrs_clause?: (ctx: Hier_attrs_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hier_attr_clause`.
+     * @param ctx the parse tree
+     */
+    enterHier_attr_clause?: (ctx: Hier_attr_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hier_attr_clause`.
+     * @param ctx the parse tree
+     */
+    exitHier_attr_clause?: (ctx: Hier_attr_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hier_attr_name`.
+     * @param ctx the parse tree
+     */
+    enterHier_attr_name?: (ctx: Hier_attr_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hier_attr_name`.
+     * @param ctx the parse tree
+     */
+    exitHier_attr_name?: (ctx: Hier_attr_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_index`.
+     * @param ctx the parse tree
+     */
+    enterCreate_index?: (ctx: Create_indexContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_index`.
+     * @param ctx the parse tree
+     */
+    exitCreate_index?: (ctx: Create_indexContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cluster_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterCluster_index_clause?: (ctx: Cluster_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cluster_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitCluster_index_clause?: (ctx: Cluster_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cluster_name`.
+     * @param ctx the parse tree
+     */
+    enterCluster_name?: (ctx: Cluster_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cluster_name`.
+     * @param ctx the parse tree
+     */
+    exitCluster_name?: (ctx: Cluster_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterTable_index_clause?: (ctx: Table_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitTable_index_clause?: (ctx: Table_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.bitmap_join_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterBitmap_join_index_clause?: (ctx: Bitmap_join_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.bitmap_join_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitBitmap_join_index_clause?: (ctx: Bitmap_join_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_expr`.
+     * @param ctx the parse tree
+     */
+    enterIndex_expr?: (ctx: Index_exprContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_expr`.
+     * @param ctx the parse tree
+     */
+    exitIndex_expr?: (ctx: Index_exprContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_properties`.
+     * @param ctx the parse tree
+     */
+    enterIndex_properties?: (ctx: Index_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_properties`.
+     * @param ctx the parse tree
+     */
+    exitIndex_properties?: (ctx: Index_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.domain_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterDomain_index_clause?: (ctx: Domain_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.domain_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitDomain_index_clause?: (ctx: Domain_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.local_domain_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterLocal_domain_index_clause?: (ctx: Local_domain_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.local_domain_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitLocal_domain_index_clause?: (ctx: Local_domain_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlindex_clause`.
+     * @param ctx the parse tree
+     */
+    enterXmlindex_clause?: (ctx: Xmlindex_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlindex_clause`.
+     * @param ctx the parse tree
+     */
+    exitXmlindex_clause?: (ctx: Xmlindex_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.local_xmlindex_clause`.
+     * @param ctx the parse tree
+     */
+    enterLocal_xmlindex_clause?: (ctx: Local_xmlindex_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.local_xmlindex_clause`.
+     * @param ctx the parse tree
+     */
+    exitLocal_xmlindex_clause?: (ctx: Local_xmlindex_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.global_partitioned_index`.
+     * @param ctx the parse tree
+     */
+    enterGlobal_partitioned_index?: (ctx: Global_partitioned_indexContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.global_partitioned_index`.
+     * @param ctx the parse tree
+     */
+    exitGlobal_partitioned_index?: (ctx: Global_partitioned_indexContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_partitioning_clause`.
+     * @param ctx the parse tree
+     */
+    enterIndex_partitioning_clause?: (ctx: Index_partitioning_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_partitioning_clause`.
+     * @param ctx the parse tree
+     */
+    exitIndex_partitioning_clause?: (ctx: Index_partitioning_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_partitioning_values_list`.
+     * @param ctx the parse tree
+     */
+    enterIndex_partitioning_values_list?: (ctx: Index_partitioning_values_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_partitioning_values_list`.
+     * @param ctx the parse tree
+     */
+    exitIndex_partitioning_values_list?: (ctx: Index_partitioning_values_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.local_partitioned_index`.
+     * @param ctx the parse tree
+     */
+    enterLocal_partitioned_index?: (ctx: Local_partitioned_indexContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.local_partitioned_index`.
+     * @param ctx the parse tree
+     */
+    exitLocal_partitioned_index?: (ctx: Local_partitioned_indexContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_range_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    enterOn_range_partitioned_table?: (ctx: On_range_partitioned_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_range_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    exitOn_range_partitioned_table?: (ctx: On_range_partitioned_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_list_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    enterOn_list_partitioned_table?: (ctx: On_list_partitioned_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_list_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    exitOn_list_partitioned_table?: (ctx: On_list_partitioned_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partitioned_table`.
+     * @param ctx the parse tree
+     */
+    enterPartitioned_table?: (ctx: Partitioned_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partitioned_table`.
+     * @param ctx the parse tree
+     */
+    exitPartitioned_table?: (ctx: Partitioned_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_hash_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    enterOn_hash_partitioned_table?: (ctx: On_hash_partitioned_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_hash_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    exitOn_hash_partitioned_table?: (ctx: On_hash_partitioned_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_hash_partitioned_clause`.
+     * @param ctx the parse tree
+     */
+    enterOn_hash_partitioned_clause?: (ctx: On_hash_partitioned_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_hash_partitioned_clause`.
+     * @param ctx the parse tree
+     */
+    exitOn_hash_partitioned_clause?: (ctx: On_hash_partitioned_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_comp_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    enterOn_comp_partitioned_table?: (ctx: On_comp_partitioned_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_comp_partitioned_table`.
+     * @param ctx the parse tree
+     */
+    exitOn_comp_partitioned_table?: (ctx: On_comp_partitioned_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_comp_partitioned_clause`.
+     * @param ctx the parse tree
+     */
+    enterOn_comp_partitioned_clause?: (ctx: On_comp_partitioned_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_comp_partitioned_clause`.
+     * @param ctx the parse tree
+     */
+    exitOn_comp_partitioned_clause?: (ctx: On_comp_partitioned_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_subpartition_clause`.
+     * @param ctx the parse tree
+     */
+    enterIndex_subpartition_clause?: (ctx: Index_subpartition_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_subpartition_clause`.
+     * @param ctx the parse tree
+     */
+    exitIndex_subpartition_clause?: (ctx: Index_subpartition_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_subpartition_subclause`.
+     * @param ctx the parse tree
+     */
+    enterIndex_subpartition_subclause?: (ctx: Index_subpartition_subclauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_subpartition_subclause`.
+     * @param ctx the parse tree
+     */
+    exitIndex_subpartition_subclause?: (ctx: Index_subpartition_subclauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.odci_parameters`.
+     * @param ctx the parse tree
+     */
+    enterOdci_parameters?: (ctx: Odci_parametersContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.odci_parameters`.
+     * @param ctx the parse tree
+     */
+    exitOdci_parameters?: (ctx: Odci_parametersContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.indextype`.
+     * @param ctx the parse tree
+     */
+    enterIndextype?: (ctx: IndextypeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.indextype`.
+     * @param ctx the parse tree
+     */
+    exitIndextype?: (ctx: IndextypeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_index`.
+     * @param ctx the parse tree
+     */
+    enterAlter_index?: (ctx: Alter_indexContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_index`.
+     * @param ctx the parse tree
+     */
+    exitAlter_index?: (ctx: Alter_indexContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_index_ops_set1`.
+     * @param ctx the parse tree
+     */
+    enterAlter_index_ops_set1?: (ctx: Alter_index_ops_set1Context) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_index_ops_set1`.
+     * @param ctx the parse tree
+     */
+    exitAlter_index_ops_set1?: (ctx: Alter_index_ops_set1Context) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_index_ops_set2`.
+     * @param ctx the parse tree
+     */
+    enterAlter_index_ops_set2?: (ctx: Alter_index_ops_set2Context) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_index_ops_set2`.
+     * @param ctx the parse tree
+     */
+    exitAlter_index_ops_set2?: (ctx: Alter_index_ops_set2Context) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.visible_or_invisible`.
+     * @param ctx the parse tree
+     */
+    enterVisible_or_invisible?: (ctx: Visible_or_invisibleContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.visible_or_invisible`.
+     * @param ctx the parse tree
+     */
+    exitVisible_or_invisible?: (ctx: Visible_or_invisibleContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.monitoring_nomonitoring`.
+     * @param ctx the parse tree
+     */
+    enterMonitoring_nomonitoring?: (ctx: Monitoring_nomonitoringContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.monitoring_nomonitoring`.
+     * @param ctx the parse tree
+     */
+    exitMonitoring_nomonitoring?: (ctx: Monitoring_nomonitoringContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rebuild_clause`.
+     * @param ctx the parse tree
+     */
+    enterRebuild_clause?: (ctx: Rebuild_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rebuild_clause`.
+     * @param ctx the parse tree
+     */
+    exitRebuild_clause?: (ctx: Rebuild_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_index_partitioning`.
+     * @param ctx the parse tree
+     */
+    enterAlter_index_partitioning?: (ctx: Alter_index_partitioningContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_index_partitioning`.
+     * @param ctx the parse tree
+     */
+    exitAlter_index_partitioning?: (ctx: Alter_index_partitioningContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_index_default_attrs`.
+     * @param ctx the parse tree
+     */
+    enterModify_index_default_attrs?: (ctx: Modify_index_default_attrsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_index_default_attrs`.
+     * @param ctx the parse tree
+     */
+    exitModify_index_default_attrs?: (ctx: Modify_index_default_attrsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_hash_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterAdd_hash_index_partition?: (ctx: Add_hash_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_hash_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitAdd_hash_index_partition?: (ctx: Add_hash_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.coalesce_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterCoalesce_index_partition?: (ctx: Coalesce_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.coalesce_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitCoalesce_index_partition?: (ctx: Coalesce_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterModify_index_partition?: (ctx: Modify_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitModify_index_partition?: (ctx: Modify_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_index_partitions_ops`.
+     * @param ctx the parse tree
+     */
+    enterModify_index_partitions_ops?: (ctx: Modify_index_partitions_opsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_index_partitions_ops`.
+     * @param ctx the parse tree
+     */
+    exitModify_index_partitions_ops?: (ctx: Modify_index_partitions_opsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rename_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterRename_index_partition?: (ctx: Rename_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rename_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitRename_index_partition?: (ctx: Rename_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterDrop_index_partition?: (ctx: Drop_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitDrop_index_partition?: (ctx: Drop_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.split_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterSplit_index_partition?: (ctx: Split_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.split_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitSplit_index_partition?: (ctx: Split_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_partition_description`.
+     * @param ctx the parse tree
+     */
+    enterIndex_partition_description?: (ctx: Index_partition_descriptionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_partition_description`.
+     * @param ctx the parse tree
+     */
+    exitIndex_partition_description?: (ctx: Index_partition_descriptionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_index_subpartition`.
+     * @param ctx the parse tree
+     */
+    enterModify_index_subpartition?: (ctx: Modify_index_subpartitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_index_subpartition`.
+     * @param ctx the parse tree
+     */
+    exitModify_index_subpartition?: (ctx: Modify_index_subpartitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_name_old`.
+     * @param ctx the parse tree
+     */
+    enterPartition_name_old?: (ctx: Partition_name_oldContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_name_old`.
+     * @param ctx the parse tree
+     */
+    exitPartition_name_old?: (ctx: Partition_name_oldContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.new_partition_name`.
+     * @param ctx the parse tree
+     */
+    enterNew_partition_name?: (ctx: New_partition_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.new_partition_name`.
+     * @param ctx the parse tree
+     */
+    exitNew_partition_name?: (ctx: New_partition_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.new_index_name`.
+     * @param ctx the parse tree
+     */
+    enterNew_index_name?: (ctx: New_index_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.new_index_name`.
+     * @param ctx the parse tree
+     */
+    exitNew_index_name?: (ctx: New_index_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_inmemory_join_group`.
+     * @param ctx the parse tree
+     */
+    enterAlter_inmemory_join_group?: (ctx: Alter_inmemory_join_groupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_inmemory_join_group`.
+     * @param ctx the parse tree
+     */
+    exitAlter_inmemory_join_group?: (ctx: Alter_inmemory_join_groupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_user`.
+     * @param ctx the parse tree
+     */
+    enterCreate_user?: (ctx: Create_userContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_user`.
+     * @param ctx the parse tree
+     */
+    exitCreate_user?: (ctx: Create_userContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_user`.
+     * @param ctx the parse tree
+     */
+    enterAlter_user?: (ctx: Alter_userContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_user`.
+     * @param ctx the parse tree
+     */
+    exitAlter_user?: (ctx: Alter_userContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_user`.
+     * @param ctx the parse tree
+     */
+    enterDrop_user?: (ctx: Drop_userContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_user`.
+     * @param ctx the parse tree
+     */
+    exitDrop_user?: (ctx: Drop_userContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_identified_by`.
+     * @param ctx the parse tree
+     */
+    enterAlter_identified_by?: (ctx: Alter_identified_byContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_identified_by`.
+     * @param ctx the parse tree
+     */
+    exitAlter_identified_by?: (ctx: Alter_identified_byContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identified_by`.
+     * @param ctx the parse tree
+     */
+    enterIdentified_by?: (ctx: Identified_byContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identified_by`.
+     * @param ctx the parse tree
+     */
+    exitIdentified_by?: (ctx: Identified_byContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identified_other_clause`.
+     * @param ctx the parse tree
+     */
+    enterIdentified_other_clause?: (ctx: Identified_other_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identified_other_clause`.
+     * @param ctx the parse tree
+     */
+    exitIdentified_other_clause?: (ctx: Identified_other_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.user_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    enterUser_tablespace_clause?: (ctx: User_tablespace_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.user_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    exitUser_tablespace_clause?: (ctx: User_tablespace_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.quota_clause`.
+     * @param ctx the parse tree
+     */
+    enterQuota_clause?: (ctx: Quota_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.quota_clause`.
+     * @param ctx the parse tree
+     */
+    exitQuota_clause?: (ctx: Quota_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.profile_clause`.
+     * @param ctx the parse tree
+     */
+    enterProfile_clause?: (ctx: Profile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.profile_clause`.
+     * @param ctx the parse tree
+     */
+    exitProfile_clause?: (ctx: Profile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.role_clause`.
+     * @param ctx the parse tree
+     */
+    enterRole_clause?: (ctx: Role_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.role_clause`.
+     * @param ctx the parse tree
+     */
+    exitRole_clause?: (ctx: Role_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.user_default_role_clause`.
+     * @param ctx the parse tree
+     */
+    enterUser_default_role_clause?: (ctx: User_default_role_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.user_default_role_clause`.
+     * @param ctx the parse tree
+     */
+    exitUser_default_role_clause?: (ctx: User_default_role_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.password_expire_clause`.
+     * @param ctx the parse tree
+     */
+    enterPassword_expire_clause?: (ctx: Password_expire_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.password_expire_clause`.
+     * @param ctx the parse tree
+     */
+    exitPassword_expire_clause?: (ctx: Password_expire_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.user_lock_clause`.
+     * @param ctx the parse tree
+     */
+    enterUser_lock_clause?: (ctx: User_lock_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.user_lock_clause`.
+     * @param ctx the parse tree
+     */
+    exitUser_lock_clause?: (ctx: User_lock_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.user_editions_clause`.
+     * @param ctx the parse tree
+     */
+    enterUser_editions_clause?: (ctx: User_editions_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.user_editions_clause`.
+     * @param ctx the parse tree
+     */
+    exitUser_editions_clause?: (ctx: User_editions_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_user_editions_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_user_editions_clause?: (ctx: Alter_user_editions_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_user_editions_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_user_editions_clause?: (ctx: Alter_user_editions_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.proxy_clause`.
+     * @param ctx the parse tree
+     */
+    enterProxy_clause?: (ctx: Proxy_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.proxy_clause`.
+     * @param ctx the parse tree
+     */
+    exitProxy_clause?: (ctx: Proxy_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.container_names`.
+     * @param ctx the parse tree
+     */
+    enterContainer_names?: (ctx: Container_namesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.container_names`.
+     * @param ctx the parse tree
+     */
+    exitContainer_names?: (ctx: Container_namesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_container_data`.
+     * @param ctx the parse tree
+     */
+    enterSet_container_data?: (ctx: Set_container_dataContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_container_data`.
+     * @param ctx the parse tree
+     */
+    exitSet_container_data?: (ctx: Set_container_dataContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_rem_container_data`.
+     * @param ctx the parse tree
+     */
+    enterAdd_rem_container_data?: (ctx: Add_rem_container_dataContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_rem_container_data`.
+     * @param ctx the parse tree
+     */
+    exitAdd_rem_container_data?: (ctx: Add_rem_container_dataContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.container_data_clause`.
+     * @param ctx the parse tree
+     */
+    enterContainer_data_clause?: (ctx: Container_data_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.container_data_clause`.
+     * @param ctx the parse tree
+     */
+    exitContainer_data_clause?: (ctx: Container_data_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.administer_key_management`.
+     * @param ctx the parse tree
+     */
+    enterAdminister_key_management?: (ctx: Administer_key_managementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.administer_key_management`.
+     * @param ctx the parse tree
+     */
+    exitAdminister_key_management?: (ctx: Administer_key_managementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.keystore_management_clauses`.
+     * @param ctx the parse tree
+     */
+    enterKeystore_management_clauses?: (ctx: Keystore_management_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.keystore_management_clauses`.
+     * @param ctx the parse tree
+     */
+    exitKeystore_management_clauses?: (ctx: Keystore_management_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_keystore`.
+     * @param ctx the parse tree
+     */
+    enterCreate_keystore?: (ctx: Create_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_keystore`.
+     * @param ctx the parse tree
+     */
+    exitCreate_keystore?: (ctx: Create_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.open_keystore`.
+     * @param ctx the parse tree
+     */
+    enterOpen_keystore?: (ctx: Open_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.open_keystore`.
+     * @param ctx the parse tree
+     */
+    exitOpen_keystore?: (ctx: Open_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.force_keystore`.
+     * @param ctx the parse tree
+     */
+    enterForce_keystore?: (ctx: Force_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.force_keystore`.
+     * @param ctx the parse tree
+     */
+    exitForce_keystore?: (ctx: Force_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.close_keystore`.
+     * @param ctx the parse tree
+     */
+    enterClose_keystore?: (ctx: Close_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.close_keystore`.
+     * @param ctx the parse tree
+     */
+    exitClose_keystore?: (ctx: Close_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.backup_keystore`.
+     * @param ctx the parse tree
+     */
+    enterBackup_keystore?: (ctx: Backup_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.backup_keystore`.
+     * @param ctx the parse tree
+     */
+    exitBackup_keystore?: (ctx: Backup_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_keystore_password`.
+     * @param ctx the parse tree
+     */
+    enterAlter_keystore_password?: (ctx: Alter_keystore_passwordContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_keystore_password`.
+     * @param ctx the parse tree
+     */
+    exitAlter_keystore_password?: (ctx: Alter_keystore_passwordContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_into_new_keystore`.
+     * @param ctx the parse tree
+     */
+    enterMerge_into_new_keystore?: (ctx: Merge_into_new_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_into_new_keystore`.
+     * @param ctx the parse tree
+     */
+    exitMerge_into_new_keystore?: (ctx: Merge_into_new_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_into_existing_keystore`.
+     * @param ctx the parse tree
+     */
+    enterMerge_into_existing_keystore?: (ctx: Merge_into_existing_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_into_existing_keystore`.
+     * @param ctx the parse tree
+     */
+    exitMerge_into_existing_keystore?: (ctx: Merge_into_existing_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.isolate_keystore`.
+     * @param ctx the parse tree
+     */
+    enterIsolate_keystore?: (ctx: Isolate_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.isolate_keystore`.
+     * @param ctx the parse tree
+     */
+    exitIsolate_keystore?: (ctx: Isolate_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unite_keystore`.
+     * @param ctx the parse tree
+     */
+    enterUnite_keystore?: (ctx: Unite_keystoreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unite_keystore`.
+     * @param ctx the parse tree
+     */
+    exitUnite_keystore?: (ctx: Unite_keystoreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.key_management_clauses`.
+     * @param ctx the parse tree
+     */
+    enterKey_management_clauses?: (ctx: Key_management_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.key_management_clauses`.
+     * @param ctx the parse tree
+     */
+    exitKey_management_clauses?: (ctx: Key_management_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_key`.
+     * @param ctx the parse tree
+     */
+    enterSet_key?: (ctx: Set_keyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_key`.
+     * @param ctx the parse tree
+     */
+    exitSet_key?: (ctx: Set_keyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_key`.
+     * @param ctx the parse tree
+     */
+    enterCreate_key?: (ctx: Create_keyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_key`.
+     * @param ctx the parse tree
+     */
+    exitCreate_key?: (ctx: Create_keyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.mkid`.
+     * @param ctx the parse tree
+     */
+    enterMkid?: (ctx: MkidContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.mkid`.
+     * @param ctx the parse tree
+     */
+    exitMkid?: (ctx: MkidContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.mk`.
+     * @param ctx the parse tree
+     */
+    enterMk?: (ctx: MkContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.mk`.
+     * @param ctx the parse tree
+     */
+    exitMk?: (ctx: MkContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.use_key`.
+     * @param ctx the parse tree
+     */
+    enterUse_key?: (ctx: Use_keyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.use_key`.
+     * @param ctx the parse tree
+     */
+    exitUse_key?: (ctx: Use_keyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_key_tag`.
+     * @param ctx the parse tree
+     */
+    enterSet_key_tag?: (ctx: Set_key_tagContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_key_tag`.
+     * @param ctx the parse tree
+     */
+    exitSet_key_tag?: (ctx: Set_key_tagContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.export_keys`.
+     * @param ctx the parse tree
+     */
+    enterExport_keys?: (ctx: Export_keysContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.export_keys`.
+     * @param ctx the parse tree
+     */
+    exitExport_keys?: (ctx: Export_keysContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.import_keys`.
+     * @param ctx the parse tree
+     */
+    enterImport_keys?: (ctx: Import_keysContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.import_keys`.
+     * @param ctx the parse tree
+     */
+    exitImport_keys?: (ctx: Import_keysContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.migrate_keys`.
+     * @param ctx the parse tree
+     */
+    enterMigrate_keys?: (ctx: Migrate_keysContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.migrate_keys`.
+     * @param ctx the parse tree
+     */
+    exitMigrate_keys?: (ctx: Migrate_keysContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.reverse_migrate_keys`.
+     * @param ctx the parse tree
+     */
+    enterReverse_migrate_keys?: (ctx: Reverse_migrate_keysContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.reverse_migrate_keys`.
+     * @param ctx the parse tree
+     */
+    exitReverse_migrate_keys?: (ctx: Reverse_migrate_keysContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.move_keys`.
+     * @param ctx the parse tree
+     */
+    enterMove_keys?: (ctx: Move_keysContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.move_keys`.
+     * @param ctx the parse tree
+     */
+    exitMove_keys?: (ctx: Move_keysContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identified_by_store`.
+     * @param ctx the parse tree
+     */
+    enterIdentified_by_store?: (ctx: Identified_by_storeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identified_by_store`.
+     * @param ctx the parse tree
+     */
+    exitIdentified_by_store?: (ctx: Identified_by_storeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_algorithm_clause`.
+     * @param ctx the parse tree
+     */
+    enterUsing_algorithm_clause?: (ctx: Using_algorithm_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_algorithm_clause`.
+     * @param ctx the parse tree
+     */
+    exitUsing_algorithm_clause?: (ctx: Using_algorithm_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_tag_clause`.
+     * @param ctx the parse tree
+     */
+    enterUsing_tag_clause?: (ctx: Using_tag_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_tag_clause`.
+     * @param ctx the parse tree
+     */
+    exitUsing_tag_clause?: (ctx: Using_tag_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.secret_management_clauses`.
+     * @param ctx the parse tree
+     */
+    enterSecret_management_clauses?: (ctx: Secret_management_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.secret_management_clauses`.
+     * @param ctx the parse tree
+     */
+    exitSecret_management_clauses?: (ctx: Secret_management_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_update_secret`.
+     * @param ctx the parse tree
+     */
+    enterAdd_update_secret?: (ctx: Add_update_secretContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_update_secret`.
+     * @param ctx the parse tree
+     */
+    exitAdd_update_secret?: (ctx: Add_update_secretContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.delete_secret`.
+     * @param ctx the parse tree
+     */
+    enterDelete_secret?: (ctx: Delete_secretContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.delete_secret`.
+     * @param ctx the parse tree
+     */
+    exitDelete_secret?: (ctx: Delete_secretContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_update_secret_seps`.
+     * @param ctx the parse tree
+     */
+    enterAdd_update_secret_seps?: (ctx: Add_update_secret_sepsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_update_secret_seps`.
+     * @param ctx the parse tree
+     */
+    exitAdd_update_secret_seps?: (ctx: Add_update_secret_sepsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.delete_secret_seps`.
+     * @param ctx the parse tree
+     */
+    enterDelete_secret_seps?: (ctx: Delete_secret_sepsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.delete_secret_seps`.
+     * @param ctx the parse tree
+     */
+    exitDelete_secret_seps?: (ctx: Delete_secret_sepsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.zero_downtime_software_patching_clauses`.
+     * @param ctx the parse tree
+     */
+    enterZero_downtime_software_patching_clauses?: (ctx: Zero_downtime_software_patching_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.zero_downtime_software_patching_clauses`.
+     * @param ctx the parse tree
+     */
+    exitZero_downtime_software_patching_clauses?: (ctx: Zero_downtime_software_patching_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.with_backup_clause`.
+     * @param ctx the parse tree
+     */
+    enterWith_backup_clause?: (ctx: With_backup_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.with_backup_clause`.
+     * @param ctx the parse tree
+     */
+    exitWith_backup_clause?: (ctx: With_backup_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identified_by_password_clause`.
+     * @param ctx the parse tree
+     */
+    enterIdentified_by_password_clause?: (ctx: Identified_by_password_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identified_by_password_clause`.
+     * @param ctx the parse tree
+     */
+    exitIdentified_by_password_clause?: (ctx: Identified_by_password_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.keystore_password`.
+     * @param ctx the parse tree
+     */
+    enterKeystore_password?: (ctx: Keystore_passwordContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.keystore_password`.
+     * @param ctx the parse tree
+     */
+    exitKeystore_password?: (ctx: Keystore_passwordContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.path`.
+     * @param ctx the parse tree
+     */
+    enterPath?: (ctx: PathContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.path`.
+     * @param ctx the parse tree
+     */
+    exitPath?: (ctx: PathContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.secret`.
+     * @param ctx the parse tree
+     */
+    enterSecret?: (ctx: SecretContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.secret`.
+     * @param ctx the parse tree
+     */
+    exitSecret?: (ctx: SecretContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.analyze`.
+     * @param ctx the parse tree
+     */
+    enterAnalyze?: (ctx: AnalyzeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.analyze`.
+     * @param ctx the parse tree
+     */
+    exitAnalyze?: (ctx: AnalyzeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_extention_clause`.
+     * @param ctx the parse tree
+     */
+    enterPartition_extention_clause?: (ctx: Partition_extention_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_extention_clause`.
+     * @param ctx the parse tree
+     */
+    exitPartition_extention_clause?: (ctx: Partition_extention_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.validation_clauses`.
+     * @param ctx the parse tree
+     */
+    enterValidation_clauses?: (ctx: Validation_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.validation_clauses`.
+     * @param ctx the parse tree
+     */
+    exitValidation_clauses?: (ctx: Validation_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.compute_clauses`.
+     * @param ctx the parse tree
+     */
+    enterCompute_clauses?: (ctx: Compute_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.compute_clauses`.
+     * @param ctx the parse tree
+     */
+    exitCompute_clauses?: (ctx: Compute_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.for_clause`.
+     * @param ctx the parse tree
+     */
+    enterFor_clause?: (ctx: For_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.for_clause`.
+     * @param ctx the parse tree
+     */
+    exitFor_clause?: (ctx: For_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.online_or_offline`.
+     * @param ctx the parse tree
+     */
+    enterOnline_or_offline?: (ctx: Online_or_offlineContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.online_or_offline`.
+     * @param ctx the parse tree
+     */
+    exitOnline_or_offline?: (ctx: Online_or_offlineContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.into_clause1`.
+     * @param ctx the parse tree
+     */
+    enterInto_clause1?: (ctx: Into_clause1Context) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.into_clause1`.
+     * @param ctx the parse tree
+     */
+    exitInto_clause1?: (ctx: Into_clause1Context) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_key_value`.
+     * @param ctx the parse tree
+     */
+    enterPartition_key_value?: (ctx: Partition_key_valueContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_key_value`.
+     * @param ctx the parse tree
+     */
+    exitPartition_key_value?: (ctx: Partition_key_valueContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_key_value`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_key_value?: (ctx: Subpartition_key_valueContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_key_value`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_key_value?: (ctx: Subpartition_key_valueContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.associate_statistics`.
+     * @param ctx the parse tree
+     */
+    enterAssociate_statistics?: (ctx: Associate_statisticsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.associate_statistics`.
+     * @param ctx the parse tree
+     */
+    exitAssociate_statistics?: (ctx: Associate_statisticsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_association`.
+     * @param ctx the parse tree
+     */
+    enterColumn_association?: (ctx: Column_associationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_association`.
+     * @param ctx the parse tree
+     */
+    exitColumn_association?: (ctx: Column_associationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_association`.
+     * @param ctx the parse tree
+     */
+    enterFunction_association?: (ctx: Function_associationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_association`.
+     * @param ctx the parse tree
+     */
+    exitFunction_association?: (ctx: Function_associationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.indextype_name`.
+     * @param ctx the parse tree
+     */
+    enterIndextype_name?: (ctx: Indextype_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.indextype_name`.
+     * @param ctx the parse tree
+     */
+    exitIndextype_name?: (ctx: Indextype_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_statistics_type`.
+     * @param ctx the parse tree
+     */
+    enterUsing_statistics_type?: (ctx: Using_statistics_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_statistics_type`.
+     * @param ctx the parse tree
+     */
+    exitUsing_statistics_type?: (ctx: Using_statistics_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.statistics_type_name`.
+     * @param ctx the parse tree
+     */
+    enterStatistics_type_name?: (ctx: Statistics_type_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.statistics_type_name`.
+     * @param ctx the parse tree
+     */
+    exitStatistics_type_name?: (ctx: Statistics_type_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_cost_clause`.
+     * @param ctx the parse tree
+     */
+    enterDefault_cost_clause?: (ctx: Default_cost_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_cost_clause`.
+     * @param ctx the parse tree
+     */
+    exitDefault_cost_clause?: (ctx: Default_cost_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cpu_cost`.
+     * @param ctx the parse tree
+     */
+    enterCpu_cost?: (ctx: Cpu_costContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cpu_cost`.
+     * @param ctx the parse tree
+     */
+    exitCpu_cost?: (ctx: Cpu_costContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.io_cost`.
+     * @param ctx the parse tree
+     */
+    enterIo_cost?: (ctx: Io_costContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.io_cost`.
+     * @param ctx the parse tree
+     */
+    exitIo_cost?: (ctx: Io_costContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.network_cost`.
+     * @param ctx the parse tree
+     */
+    enterNetwork_cost?: (ctx: Network_costContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.network_cost`.
+     * @param ctx the parse tree
+     */
+    exitNetwork_cost?: (ctx: Network_costContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_selectivity_clause`.
+     * @param ctx the parse tree
+     */
+    enterDefault_selectivity_clause?: (ctx: Default_selectivity_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_selectivity_clause`.
+     * @param ctx the parse tree
+     */
+    exitDefault_selectivity_clause?: (ctx: Default_selectivity_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_selectivity`.
+     * @param ctx the parse tree
+     */
+    enterDefault_selectivity?: (ctx: Default_selectivityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_selectivity`.
+     * @param ctx the parse tree
+     */
+    exitDefault_selectivity?: (ctx: Default_selectivityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.storage_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterStorage_table_clause?: (ctx: Storage_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.storage_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitStorage_table_clause?: (ctx: Storage_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unified_auditing`.
+     * @param ctx the parse tree
+     */
+    enterUnified_auditing?: (ctx: Unified_auditingContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unified_auditing`.
+     * @param ctx the parse tree
+     */
+    exitUnified_auditing?: (ctx: Unified_auditingContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.policy_name`.
+     * @param ctx the parse tree
+     */
+    enterPolicy_name?: (ctx: Policy_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.policy_name`.
+     * @param ctx the parse tree
+     */
+    exitPolicy_name?: (ctx: Policy_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.audit_traditional`.
+     * @param ctx the parse tree
+     */
+    enterAudit_traditional?: (ctx: Audit_traditionalContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.audit_traditional`.
+     * @param ctx the parse tree
+     */
+    exitAudit_traditional?: (ctx: Audit_traditionalContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.audit_direct_path`.
+     * @param ctx the parse tree
+     */
+    enterAudit_direct_path?: (ctx: Audit_direct_pathContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.audit_direct_path`.
+     * @param ctx the parse tree
+     */
+    exitAudit_direct_path?: (ctx: Audit_direct_pathContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.audit_container_clause`.
+     * @param ctx the parse tree
+     */
+    enterAudit_container_clause?: (ctx: Audit_container_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.audit_container_clause`.
+     * @param ctx the parse tree
+     */
+    exitAudit_container_clause?: (ctx: Audit_container_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.audit_operation_clause`.
+     * @param ctx the parse tree
+     */
+    enterAudit_operation_clause?: (ctx: Audit_operation_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.audit_operation_clause`.
+     * @param ctx the parse tree
+     */
+    exitAudit_operation_clause?: (ctx: Audit_operation_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.auditing_by_clause`.
+     * @param ctx the parse tree
+     */
+    enterAuditing_by_clause?: (ctx: Auditing_by_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.auditing_by_clause`.
+     * @param ctx the parse tree
+     */
+    exitAuditing_by_clause?: (ctx: Auditing_by_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.audit_user`.
+     * @param ctx the parse tree
+     */
+    enterAudit_user?: (ctx: Audit_userContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.audit_user`.
+     * @param ctx the parse tree
+     */
+    exitAudit_user?: (ctx: Audit_userContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.audit_schema_object_clause`.
+     * @param ctx the parse tree
+     */
+    enterAudit_schema_object_clause?: (ctx: Audit_schema_object_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.audit_schema_object_clause`.
+     * @param ctx the parse tree
+     */
+    exitAudit_schema_object_clause?: (ctx: Audit_schema_object_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_operation`.
+     * @param ctx the parse tree
+     */
+    enterSql_operation?: (ctx: Sql_operationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_operation`.
+     * @param ctx the parse tree
+     */
+    exitSql_operation?: (ctx: Sql_operationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.auditing_on_clause`.
+     * @param ctx the parse tree
+     */
+    enterAuditing_on_clause?: (ctx: Auditing_on_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.auditing_on_clause`.
+     * @param ctx the parse tree
+     */
+    exitAuditing_on_clause?: (ctx: Auditing_on_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_name`.
+     * @param ctx the parse tree
+     */
+    enterModel_name?: (ctx: Model_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_name`.
+     * @param ctx the parse tree
+     */
+    exitModel_name?: (ctx: Model_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_name`.
+     * @param ctx the parse tree
+     */
+    enterObject_name?: (ctx: Object_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_name`.
+     * @param ctx the parse tree
+     */
+    exitObject_name?: (ctx: Object_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.profile_name`.
+     * @param ctx the parse tree
+     */
+    enterProfile_name?: (ctx: Profile_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.profile_name`.
+     * @param ctx the parse tree
+     */
+    exitProfile_name?: (ctx: Profile_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_statement_shortcut`.
+     * @param ctx the parse tree
+     */
+    enterSql_statement_shortcut?: (ctx: Sql_statement_shortcutContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_statement_shortcut`.
+     * @param ctx the parse tree
+     */
+    exitSql_statement_shortcut?: (ctx: Sql_statement_shortcutContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_index`.
+     * @param ctx the parse tree
+     */
+    enterDrop_index?: (ctx: Drop_indexContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_index`.
+     * @param ctx the parse tree
+     */
+    exitDrop_index?: (ctx: Drop_indexContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.disassociate_statistics`.
+     * @param ctx the parse tree
+     */
+    enterDisassociate_statistics?: (ctx: Disassociate_statisticsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.disassociate_statistics`.
+     * @param ctx the parse tree
+     */
+    exitDisassociate_statistics?: (ctx: Disassociate_statisticsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_indextype`.
+     * @param ctx the parse tree
+     */
+    enterDrop_indextype?: (ctx: Drop_indextypeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_indextype`.
+     * @param ctx the parse tree
+     */
+    exitDrop_indextype?: (ctx: Drop_indextypeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_inmemory_join_group`.
+     * @param ctx the parse tree
+     */
+    enterDrop_inmemory_join_group?: (ctx: Drop_inmemory_join_groupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_inmemory_join_group`.
+     * @param ctx the parse tree
+     */
+    exitDrop_inmemory_join_group?: (ctx: Drop_inmemory_join_groupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.flashback_table`.
+     * @param ctx the parse tree
+     */
+    enterFlashback_table?: (ctx: Flashback_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.flashback_table`.
+     * @param ctx the parse tree
+     */
+    exitFlashback_table?: (ctx: Flashback_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.restore_point`.
+     * @param ctx the parse tree
+     */
+    enterRestore_point?: (ctx: Restore_pointContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.restore_point`.
+     * @param ctx the parse tree
+     */
+    exitRestore_point?: (ctx: Restore_pointContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.purge_statement`.
+     * @param ctx the parse tree
+     */
+    enterPurge_statement?: (ctx: Purge_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.purge_statement`.
+     * @param ctx the parse tree
+     */
+    exitPurge_statement?: (ctx: Purge_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.noaudit_statement`.
+     * @param ctx the parse tree
+     */
+    enterNoaudit_statement?: (ctx: Noaudit_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.noaudit_statement`.
+     * @param ctx the parse tree
+     */
+    exitNoaudit_statement?: (ctx: Noaudit_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rename_object`.
+     * @param ctx the parse tree
+     */
+    enterRename_object?: (ctx: Rename_objectContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rename_object`.
+     * @param ctx the parse tree
+     */
+    exitRename_object?: (ctx: Rename_objectContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.grant_statement`.
+     * @param ctx the parse tree
+     */
+    enterGrant_statement?: (ctx: Grant_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.grant_statement`.
+     * @param ctx the parse tree
+     */
+    exitGrant_statement?: (ctx: Grant_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.container_clause`.
+     * @param ctx the parse tree
+     */
+    enterContainer_clause?: (ctx: Container_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.container_clause`.
+     * @param ctx the parse tree
+     */
+    exitContainer_clause?: (ctx: Container_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.revoke_statement`.
+     * @param ctx the parse tree
+     */
+    enterRevoke_statement?: (ctx: Revoke_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.revoke_statement`.
+     * @param ctx the parse tree
+     */
+    exitRevoke_statement?: (ctx: Revoke_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.revoke_system_privilege`.
+     * @param ctx the parse tree
+     */
+    enterRevoke_system_privilege?: (ctx: Revoke_system_privilegeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.revoke_system_privilege`.
+     * @param ctx the parse tree
+     */
+    exitRevoke_system_privilege?: (ctx: Revoke_system_privilegeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.revokee_clause`.
+     * @param ctx the parse tree
+     */
+    enterRevokee_clause?: (ctx: Revokee_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.revokee_clause`.
+     * @param ctx the parse tree
+     */
+    exitRevokee_clause?: (ctx: Revokee_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.revoke_object_privileges`.
+     * @param ctx the parse tree
+     */
+    enterRevoke_object_privileges?: (ctx: Revoke_object_privilegesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.revoke_object_privileges`.
+     * @param ctx the parse tree
+     */
+    exitRevoke_object_privileges?: (ctx: Revoke_object_privilegesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_object_clause`.
+     * @param ctx the parse tree
+     */
+    enterOn_object_clause?: (ctx: On_object_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_object_clause`.
+     * @param ctx the parse tree
+     */
+    exitOn_object_clause?: (ctx: On_object_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.revoke_roles_from_programs`.
+     * @param ctx the parse tree
+     */
+    enterRevoke_roles_from_programs?: (ctx: Revoke_roles_from_programsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.revoke_roles_from_programs`.
+     * @param ctx the parse tree
+     */
+    exitRevoke_roles_from_programs?: (ctx: Revoke_roles_from_programsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.program_unit`.
+     * @param ctx the parse tree
+     */
+    enterProgram_unit?: (ctx: Program_unitContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.program_unit`.
+     * @param ctx the parse tree
+     */
+    exitProgram_unit?: (ctx: Program_unitContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_dimension`.
+     * @param ctx the parse tree
+     */
+    enterCreate_dimension?: (ctx: Create_dimensionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_dimension`.
+     * @param ctx the parse tree
+     */
+    exitCreate_dimension?: (ctx: Create_dimensionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_directory`.
+     * @param ctx the parse tree
+     */
+    enterCreate_directory?: (ctx: Create_directoryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_directory`.
+     * @param ctx the parse tree
+     */
+    exitCreate_directory?: (ctx: Create_directoryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.directory_name`.
+     * @param ctx the parse tree
+     */
+    enterDirectory_name?: (ctx: Directory_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.directory_name`.
+     * @param ctx the parse tree
+     */
+    exitDirectory_name?: (ctx: Directory_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.directory_path`.
+     * @param ctx the parse tree
+     */
+    enterDirectory_path?: (ctx: Directory_pathContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.directory_path`.
+     * @param ctx the parse tree
+     */
+    exitDirectory_path?: (ctx: Directory_pathContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_inmemory_join_group`.
+     * @param ctx the parse tree
+     */
+    enterCreate_inmemory_join_group?: (ctx: Create_inmemory_join_groupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_inmemory_join_group`.
+     * @param ctx the parse tree
+     */
+    exitCreate_inmemory_join_group?: (ctx: Create_inmemory_join_groupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_hierarchy`.
+     * @param ctx the parse tree
+     */
+    enterDrop_hierarchy?: (ctx: Drop_hierarchyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_hierarchy`.
+     * @param ctx the parse tree
+     */
+    exitDrop_hierarchy?: (ctx: Drop_hierarchyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_library`.
+     * @param ctx the parse tree
+     */
+    enterAlter_library?: (ctx: Alter_libraryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_library`.
+     * @param ctx the parse tree
+     */
+    exitAlter_library?: (ctx: Alter_libraryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_java`.
+     * @param ctx the parse tree
+     */
+    enterDrop_java?: (ctx: Drop_javaContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_java`.
+     * @param ctx the parse tree
+     */
+    exitDrop_java?: (ctx: Drop_javaContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_library`.
+     * @param ctx the parse tree
+     */
+    enterDrop_library?: (ctx: Drop_libraryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_library`.
+     * @param ctx the parse tree
+     */
+    exitDrop_library?: (ctx: Drop_libraryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_java`.
+     * @param ctx the parse tree
+     */
+    enterCreate_java?: (ctx: Create_javaContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_java`.
+     * @param ctx the parse tree
+     */
+    exitCreate_java?: (ctx: Create_javaContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_library`.
+     * @param ctx the parse tree
+     */
+    enterCreate_library?: (ctx: Create_libraryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_library`.
+     * @param ctx the parse tree
+     */
+    exitCreate_library?: (ctx: Create_libraryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.plsql_library_source`.
+     * @param ctx the parse tree
+     */
+    enterPlsql_library_source?: (ctx: Plsql_library_sourceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.plsql_library_source`.
+     * @param ctx the parse tree
+     */
+    exitPlsql_library_source?: (ctx: Plsql_library_sourceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.credential_name`.
+     * @param ctx the parse tree
+     */
+    enterCredential_name?: (ctx: Credential_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.credential_name`.
+     * @param ctx the parse tree
+     */
+    exitCredential_name?: (ctx: Credential_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.library_editionable`.
+     * @param ctx the parse tree
+     */
+    enterLibrary_editionable?: (ctx: Library_editionableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.library_editionable`.
+     * @param ctx the parse tree
+     */
+    exitLibrary_editionable?: (ctx: Library_editionableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.library_debug`.
+     * @param ctx the parse tree
+     */
+    enterLibrary_debug?: (ctx: Library_debugContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.library_debug`.
+     * @param ctx the parse tree
+     */
+    exitLibrary_debug?: (ctx: Library_debugContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.compiler_parameters_clause`.
+     * @param ctx the parse tree
+     */
+    enterCompiler_parameters_clause?: (ctx: Compiler_parameters_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.compiler_parameters_clause`.
+     * @param ctx the parse tree
+     */
+    exitCompiler_parameters_clause?: (ctx: Compiler_parameters_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parameter_value`.
+     * @param ctx the parse tree
+     */
+    enterParameter_value?: (ctx: Parameter_valueContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parameter_value`.
+     * @param ctx the parse tree
+     */
+    exitParameter_value?: (ctx: Parameter_valueContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.library_name`.
+     * @param ctx the parse tree
+     */
+    enterLibrary_name?: (ctx: Library_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.library_name`.
+     * @param ctx the parse tree
+     */
+    exitLibrary_name?: (ctx: Library_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_dimension`.
+     * @param ctx the parse tree
+     */
+    enterAlter_dimension?: (ctx: Alter_dimensionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_dimension`.
+     * @param ctx the parse tree
+     */
+    exitAlter_dimension?: (ctx: Alter_dimensionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.level_clause`.
+     * @param ctx the parse tree
+     */
+    enterLevel_clause?: (ctx: Level_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.level_clause`.
+     * @param ctx the parse tree
+     */
+    exitLevel_clause?: (ctx: Level_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hierarchy_clause`.
+     * @param ctx the parse tree
+     */
+    enterHierarchy_clause?: (ctx: Hierarchy_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hierarchy_clause`.
+     * @param ctx the parse tree
+     */
+    exitHierarchy_clause?: (ctx: Hierarchy_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dimension_join_clause`.
+     * @param ctx the parse tree
+     */
+    enterDimension_join_clause?: (ctx: Dimension_join_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dimension_join_clause`.
+     * @param ctx the parse tree
+     */
+    exitDimension_join_clause?: (ctx: Dimension_join_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.attribute_clause`.
+     * @param ctx the parse tree
+     */
+    enterAttribute_clause?: (ctx: Attribute_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.attribute_clause`.
+     * @param ctx the parse tree
+     */
+    exitAttribute_clause?: (ctx: Attribute_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.extended_attribute_clause`.
+     * @param ctx the parse tree
+     */
+    enterExtended_attribute_clause?: (ctx: Extended_attribute_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.extended_attribute_clause`.
+     * @param ctx the parse tree
+     */
+    exitExtended_attribute_clause?: (ctx: Extended_attribute_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_one_or_more_sub_clause`.
+     * @param ctx the parse tree
+     */
+    enterColumn_one_or_more_sub_clause?: (ctx: Column_one_or_more_sub_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_one_or_more_sub_clause`.
+     * @param ctx the parse tree
+     */
+    exitColumn_one_or_more_sub_clause?: (ctx: Column_one_or_more_sub_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_view`.
+     * @param ctx the parse tree
+     */
+    enterAlter_view?: (ctx: Alter_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_view`.
+     * @param ctx the parse tree
+     */
+    exitAlter_view?: (ctx: Alter_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_view_editionable`.
+     * @param ctx the parse tree
+     */
+    enterAlter_view_editionable?: (ctx: Alter_view_editionableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_view_editionable`.
+     * @param ctx the parse tree
+     */
+    exitAlter_view_editionable?: (ctx: Alter_view_editionableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_view`.
+     * @param ctx the parse tree
+     */
+    enterCreate_view?: (ctx: Create_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_view`.
+     * @param ctx the parse tree
+     */
+    exitCreate_view?: (ctx: Create_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.editioning_clause`.
+     * @param ctx the parse tree
+     */
+    enterEditioning_clause?: (ctx: Editioning_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.editioning_clause`.
+     * @param ctx the parse tree
+     */
+    exitEditioning_clause?: (ctx: Editioning_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.view_options`.
+     * @param ctx the parse tree
+     */
+    enterView_options?: (ctx: View_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.view_options`.
+     * @param ctx the parse tree
+     */
+    exitView_options?: (ctx: View_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.view_alias_constraint`.
+     * @param ctx the parse tree
+     */
+    enterView_alias_constraint?: (ctx: View_alias_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.view_alias_constraint`.
+     * @param ctx the parse tree
+     */
+    exitView_alias_constraint?: (ctx: View_alias_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_view_clause`.
+     * @param ctx the parse tree
+     */
+    enterObject_view_clause?: (ctx: Object_view_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_view_clause`.
+     * @param ctx the parse tree
+     */
+    exitObject_view_clause?: (ctx: Object_view_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inline_constraint`.
+     * @param ctx the parse tree
+     */
+    enterInline_constraint?: (ctx: Inline_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inline_constraint`.
+     * @param ctx the parse tree
+     */
+    exitInline_constraint?: (ctx: Inline_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inline_ref_constraint`.
+     * @param ctx the parse tree
+     */
+    enterInline_ref_constraint?: (ctx: Inline_ref_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inline_ref_constraint`.
+     * @param ctx the parse tree
+     */
+    exitInline_ref_constraint?: (ctx: Inline_ref_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.out_of_line_ref_constraint`.
+     * @param ctx the parse tree
+     */
+    enterOut_of_line_ref_constraint?: (ctx: Out_of_line_ref_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.out_of_line_ref_constraint`.
+     * @param ctx the parse tree
+     */
+    exitOut_of_line_ref_constraint?: (ctx: Out_of_line_ref_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.out_of_line_constraint`.
+     * @param ctx the parse tree
+     */
+    enterOut_of_line_constraint?: (ctx: Out_of_line_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.out_of_line_constraint`.
+     * @param ctx the parse tree
+     */
+    exitOut_of_line_constraint?: (ctx: Out_of_line_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.constraint_state`.
+     * @param ctx the parse tree
+     */
+    enterConstraint_state?: (ctx: Constraint_stateContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.constraint_state`.
+     * @param ctx the parse tree
+     */
+    exitConstraint_state?: (ctx: Constraint_stateContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmltype_view_clause`.
+     * @param ctx the parse tree
+     */
+    enterXmltype_view_clause?: (ctx: Xmltype_view_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmltype_view_clause`.
+     * @param ctx the parse tree
+     */
+    exitXmltype_view_clause?: (ctx: Xmltype_view_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_schema_spec`.
+     * @param ctx the parse tree
+     */
+    enterXml_schema_spec?: (ctx: Xml_schema_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_schema_spec`.
+     * @param ctx the parse tree
+     */
+    exitXml_schema_spec?: (ctx: Xml_schema_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_schema_url`.
+     * @param ctx the parse tree
+     */
+    enterXml_schema_url?: (ctx: Xml_schema_urlContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_schema_url`.
+     * @param ctx the parse tree
+     */
+    exitXml_schema_url?: (ctx: Xml_schema_urlContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.element`.
+     * @param ctx the parse tree
+     */
+    enterElement?: (ctx: ElementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.element`.
+     * @param ctx the parse tree
+     */
+    exitElement?: (ctx: ElementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_tablespace`.
+     * @param ctx the parse tree
+     */
+    enterAlter_tablespace?: (ctx: Alter_tablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_tablespace`.
+     * @param ctx the parse tree
+     */
+    exitAlter_tablespace?: (ctx: Alter_tablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.datafile_tempfile_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDatafile_tempfile_clauses?: (ctx: Datafile_tempfile_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.datafile_tempfile_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDatafile_tempfile_clauses?: (ctx: Datafile_tempfile_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_logging_clauses`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_logging_clauses?: (ctx: Tablespace_logging_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_logging_clauses`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_logging_clauses?: (ctx: Tablespace_logging_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_group_clause`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_group_clause?: (ctx: Tablespace_group_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_group_clause`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_group_clause?: (ctx: Tablespace_group_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_group_name`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_group_name?: (ctx: Tablespace_group_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_group_name`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_group_name?: (ctx: Tablespace_group_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_state_clauses`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_state_clauses?: (ctx: Tablespace_state_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_state_clauses`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_state_clauses?: (ctx: Tablespace_state_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.flashback_mode_clause`.
+     * @param ctx the parse tree
+     */
+    enterFlashback_mode_clause?: (ctx: Flashback_mode_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.flashback_mode_clause`.
+     * @param ctx the parse tree
+     */
+    exitFlashback_mode_clause?: (ctx: Flashback_mode_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.new_tablespace_name`.
+     * @param ctx the parse tree
+     */
+    enterNew_tablespace_name?: (ctx: New_tablespace_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.new_tablespace_name`.
+     * @param ctx the parse tree
+     */
+    exitNew_tablespace_name?: (ctx: New_tablespace_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_tablespace`.
+     * @param ctx the parse tree
+     */
+    enterCreate_tablespace?: (ctx: Create_tablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_tablespace`.
+     * @param ctx the parse tree
+     */
+    exitCreate_tablespace?: (ctx: Create_tablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.permanent_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    enterPermanent_tablespace_clause?: (ctx: Permanent_tablespace_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.permanent_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    exitPermanent_tablespace_clause?: (ctx: Permanent_tablespace_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_encryption_spec`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_encryption_spec?: (ctx: Tablespace_encryption_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_encryption_spec`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_encryption_spec?: (ctx: Tablespace_encryption_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logging_clause`.
+     * @param ctx the parse tree
+     */
+    enterLogging_clause?: (ctx: Logging_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logging_clause`.
+     * @param ctx the parse tree
+     */
+    exitLogging_clause?: (ctx: Logging_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.extent_management_clause`.
+     * @param ctx the parse tree
+     */
+    enterExtent_management_clause?: (ctx: Extent_management_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.extent_management_clause`.
+     * @param ctx the parse tree
+     */
+    exitExtent_management_clause?: (ctx: Extent_management_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.segment_management_clause`.
+     * @param ctx the parse tree
+     */
+    enterSegment_management_clause?: (ctx: Segment_management_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.segment_management_clause`.
+     * @param ctx the parse tree
+     */
+    exitSegment_management_clause?: (ctx: Segment_management_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.temporary_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    enterTemporary_tablespace_clause?: (ctx: Temporary_tablespace_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.temporary_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    exitTemporary_tablespace_clause?: (ctx: Temporary_tablespace_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.undo_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    enterUndo_tablespace_clause?: (ctx: Undo_tablespace_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.undo_tablespace_clause`.
+     * @param ctx the parse tree
+     */
+    exitUndo_tablespace_clause?: (ctx: Undo_tablespace_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_retention_clause`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_retention_clause?: (ctx: Tablespace_retention_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_retention_clause`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_retention_clause?: (ctx: Tablespace_retention_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_tablespace_set`.
+     * @param ctx the parse tree
+     */
+    enterCreate_tablespace_set?: (ctx: Create_tablespace_setContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_tablespace_set`.
+     * @param ctx the parse tree
+     */
+    exitCreate_tablespace_set?: (ctx: Create_tablespace_setContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.permanent_tablespace_attrs`.
+     * @param ctx the parse tree
+     */
+    enterPermanent_tablespace_attrs?: (ctx: Permanent_tablespace_attrsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.permanent_tablespace_attrs`.
+     * @param ctx the parse tree
+     */
+    exitPermanent_tablespace_attrs?: (ctx: Permanent_tablespace_attrsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_encryption_clause`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_encryption_clause?: (ctx: Tablespace_encryption_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_encryption_clause`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_encryption_clause?: (ctx: Tablespace_encryption_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_tablespace_params`.
+     * @param ctx the parse tree
+     */
+    enterDefault_tablespace_params?: (ctx: Default_tablespace_paramsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_tablespace_params`.
+     * @param ctx the parse tree
+     */
+    exitDefault_tablespace_params?: (ctx: Default_tablespace_paramsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_table_compression`.
+     * @param ctx the parse tree
+     */
+    enterDefault_table_compression?: (ctx: Default_table_compressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_table_compression`.
+     * @param ctx the parse tree
+     */
+    exitDefault_table_compression?: (ctx: Default_table_compressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.low_high`.
+     * @param ctx the parse tree
+     */
+    enterLow_high?: (ctx: Low_highContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.low_high`.
+     * @param ctx the parse tree
+     */
+    exitLow_high?: (ctx: Low_highContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_index_compression`.
+     * @param ctx the parse tree
+     */
+    enterDefault_index_compression?: (ctx: Default_index_compressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_index_compression`.
+     * @param ctx the parse tree
+     */
+    exitDefault_index_compression?: (ctx: Default_index_compressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmmemory_clause`.
+     * @param ctx the parse tree
+     */
+    enterInmmemory_clause?: (ctx: Inmmemory_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmmemory_clause`.
+     * @param ctx the parse tree
+     */
+    exitInmmemory_clause?: (ctx: Inmmemory_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.datafile_specification`.
+     * @param ctx the parse tree
+     */
+    enterDatafile_specification?: (ctx: Datafile_specificationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.datafile_specification`.
+     * @param ctx the parse tree
+     */
+    exitDatafile_specification?: (ctx: Datafile_specificationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tempfile_specification`.
+     * @param ctx the parse tree
+     */
+    enterTempfile_specification?: (ctx: Tempfile_specificationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tempfile_specification`.
+     * @param ctx the parse tree
+     */
+    exitTempfile_specification?: (ctx: Tempfile_specificationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.datafile_tempfile_spec`.
+     * @param ctx the parse tree
+     */
+    enterDatafile_tempfile_spec?: (ctx: Datafile_tempfile_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.datafile_tempfile_spec`.
+     * @param ctx the parse tree
+     */
+    exitDatafile_tempfile_spec?: (ctx: Datafile_tempfile_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.redo_log_file_spec`.
+     * @param ctx the parse tree
+     */
+    enterRedo_log_file_spec?: (ctx: Redo_log_file_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.redo_log_file_spec`.
+     * @param ctx the parse tree
+     */
+    exitRedo_log_file_spec?: (ctx: Redo_log_file_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.autoextend_clause`.
+     * @param ctx the parse tree
+     */
+    enterAutoextend_clause?: (ctx: Autoextend_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.autoextend_clause`.
+     * @param ctx the parse tree
+     */
+    exitAutoextend_clause?: (ctx: Autoextend_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.maxsize_clause`.
+     * @param ctx the parse tree
+     */
+    enterMaxsize_clause?: (ctx: Maxsize_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.maxsize_clause`.
+     * @param ctx the parse tree
+     */
+    exitMaxsize_clause?: (ctx: Maxsize_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.build_clause`.
+     * @param ctx the parse tree
+     */
+    enterBuild_clause?: (ctx: Build_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.build_clause`.
+     * @param ctx the parse tree
+     */
+    exitBuild_clause?: (ctx: Build_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parallel_clause`.
+     * @param ctx the parse tree
+     */
+    enterParallel_clause?: (ctx: Parallel_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parallel_clause`.
+     * @param ctx the parse tree
+     */
+    exitParallel_clause?: (ctx: Parallel_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parallel_instances_clause`.
+     * @param ctx the parse tree
+     */
+    enterParallel_instances_clause?: (ctx: Parallel_instances_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parallel_instances_clause`.
+     * @param ctx the parse tree
+     */
+    exitParallel_instances_clause?: (ctx: Parallel_instances_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_materialized_view`.
+     * @param ctx the parse tree
+     */
+    enterAlter_materialized_view?: (ctx: Alter_materialized_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_materialized_view`.
+     * @param ctx the parse tree
+     */
+    exitAlter_materialized_view?: (ctx: Alter_materialized_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_mv_option1`.
+     * @param ctx the parse tree
+     */
+    enterAlter_mv_option1?: (ctx: Alter_mv_option1Context) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_mv_option1`.
+     * @param ctx the parse tree
+     */
+    exitAlter_mv_option1?: (ctx: Alter_mv_option1Context) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_mv_refresh`.
+     * @param ctx the parse tree
+     */
+    enterAlter_mv_refresh?: (ctx: Alter_mv_refreshContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_mv_refresh`.
+     * @param ctx the parse tree
+     */
+    exitAlter_mv_refresh?: (ctx: Alter_mv_refreshContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rollback_segment`.
+     * @param ctx the parse tree
+     */
+    enterRollback_segment?: (ctx: Rollback_segmentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rollback_segment`.
+     * @param ctx the parse tree
+     */
+    exitRollback_segment?: (ctx: Rollback_segmentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_mv_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterModify_mv_column_clause?: (ctx: Modify_mv_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_mv_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitModify_mv_column_clause?: (ctx: Modify_mv_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_materialized_view_log`.
+     * @param ctx the parse tree
+     */
+    enterAlter_materialized_view_log?: (ctx: Alter_materialized_view_logContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_materialized_view_log`.
+     * @param ctx the parse tree
+     */
+    exitAlter_materialized_view_log?: (ctx: Alter_materialized_view_logContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_mv_log_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_mv_log_column_clause?: (ctx: Add_mv_log_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_mv_log_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_mv_log_column_clause?: (ctx: Add_mv_log_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.move_mv_log_clause`.
+     * @param ctx the parse tree
+     */
+    enterMove_mv_log_clause?: (ctx: Move_mv_log_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.move_mv_log_clause`.
+     * @param ctx the parse tree
+     */
+    exitMove_mv_log_clause?: (ctx: Move_mv_log_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.mv_log_augmentation`.
+     * @param ctx the parse tree
+     */
+    enterMv_log_augmentation?: (ctx: Mv_log_augmentationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.mv_log_augmentation`.
+     * @param ctx the parse tree
+     */
+    exitMv_log_augmentation?: (ctx: Mv_log_augmentationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_materialized_view_log`.
+     * @param ctx the parse tree
+     */
+    enterCreate_materialized_view_log?: (ctx: Create_materialized_view_logContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_materialized_view_log`.
+     * @param ctx the parse tree
+     */
+    exitCreate_materialized_view_log?: (ctx: Create_materialized_view_logContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.new_values_clause`.
+     * @param ctx the parse tree
+     */
+    enterNew_values_clause?: (ctx: New_values_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.new_values_clause`.
+     * @param ctx the parse tree
+     */
+    exitNew_values_clause?: (ctx: New_values_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.mv_log_purge_clause`.
+     * @param ctx the parse tree
+     */
+    enterMv_log_purge_clause?: (ctx: Mv_log_purge_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.mv_log_purge_clause`.
+     * @param ctx the parse tree
+     */
+    exitMv_log_purge_clause?: (ctx: Mv_log_purge_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_materialized_zonemap`.
+     * @param ctx the parse tree
+     */
+    enterCreate_materialized_zonemap?: (ctx: Create_materialized_zonemapContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_materialized_zonemap`.
+     * @param ctx the parse tree
+     */
+    exitCreate_materialized_zonemap?: (ctx: Create_materialized_zonemapContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_materialized_zonemap`.
+     * @param ctx the parse tree
+     */
+    enterAlter_materialized_zonemap?: (ctx: Alter_materialized_zonemapContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_materialized_zonemap`.
+     * @param ctx the parse tree
+     */
+    exitAlter_materialized_zonemap?: (ctx: Alter_materialized_zonemapContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_materialized_zonemap`.
+     * @param ctx the parse tree
+     */
+    enterDrop_materialized_zonemap?: (ctx: Drop_materialized_zonemapContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_materialized_zonemap`.
+     * @param ctx the parse tree
+     */
+    exitDrop_materialized_zonemap?: (ctx: Drop_materialized_zonemapContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.zonemap_refresh_clause`.
+     * @param ctx the parse tree
+     */
+    enterZonemap_refresh_clause?: (ctx: Zonemap_refresh_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.zonemap_refresh_clause`.
+     * @param ctx the parse tree
+     */
+    exitZonemap_refresh_clause?: (ctx: Zonemap_refresh_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.zonemap_attributes`.
+     * @param ctx the parse tree
+     */
+    enterZonemap_attributes?: (ctx: Zonemap_attributesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.zonemap_attributes`.
+     * @param ctx the parse tree
+     */
+    exitZonemap_attributes?: (ctx: Zonemap_attributesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.zonemap_name`.
+     * @param ctx the parse tree
+     */
+    enterZonemap_name?: (ctx: Zonemap_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.zonemap_name`.
+     * @param ctx the parse tree
+     */
+    exitZonemap_name?: (ctx: Zonemap_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.operator_name`.
+     * @param ctx the parse tree
+     */
+    enterOperator_name?: (ctx: Operator_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.operator_name`.
+     * @param ctx the parse tree
+     */
+    exitOperator_name?: (ctx: Operator_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.operator_function_name`.
+     * @param ctx the parse tree
+     */
+    enterOperator_function_name?: (ctx: Operator_function_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.operator_function_name`.
+     * @param ctx the parse tree
+     */
+    exitOperator_function_name?: (ctx: Operator_function_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_zonemap_on_table`.
+     * @param ctx the parse tree
+     */
+    enterCreate_zonemap_on_table?: (ctx: Create_zonemap_on_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_zonemap_on_table`.
+     * @param ctx the parse tree
+     */
+    exitCreate_zonemap_on_table?: (ctx: Create_zonemap_on_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_zonemap_as_subquery`.
+     * @param ctx the parse tree
+     */
+    enterCreate_zonemap_as_subquery?: (ctx: Create_zonemap_as_subqueryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_zonemap_as_subquery`.
+     * @param ctx the parse tree
+     */
+    exitCreate_zonemap_as_subquery?: (ctx: Create_zonemap_as_subqueryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_operator`.
+     * @param ctx the parse tree
+     */
+    enterAlter_operator?: (ctx: Alter_operatorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_operator`.
+     * @param ctx the parse tree
+     */
+    exitAlter_operator?: (ctx: Alter_operatorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_operator`.
+     * @param ctx the parse tree
+     */
+    enterDrop_operator?: (ctx: Drop_operatorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_operator`.
+     * @param ctx the parse tree
+     */
+    exitDrop_operator?: (ctx: Drop_operatorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_operator`.
+     * @param ctx the parse tree
+     */
+    enterCreate_operator?: (ctx: Create_operatorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_operator`.
+     * @param ctx the parse tree
+     */
+    exitCreate_operator?: (ctx: Create_operatorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.binding_clause`.
+     * @param ctx the parse tree
+     */
+    enterBinding_clause?: (ctx: Binding_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.binding_clause`.
+     * @param ctx the parse tree
+     */
+    exitBinding_clause?: (ctx: Binding_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_binding_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_binding_clause?: (ctx: Add_binding_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_binding_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_binding_clause?: (ctx: Add_binding_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.implementation_clause`.
+     * @param ctx the parse tree
+     */
+    enterImplementation_clause?: (ctx: Implementation_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.implementation_clause`.
+     * @param ctx the parse tree
+     */
+    exitImplementation_clause?: (ctx: Implementation_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.primary_operator_list`.
+     * @param ctx the parse tree
+     */
+    enterPrimary_operator_list?: (ctx: Primary_operator_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.primary_operator_list`.
+     * @param ctx the parse tree
+     */
+    exitPrimary_operator_list?: (ctx: Primary_operator_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.primary_operator_item`.
+     * @param ctx the parse tree
+     */
+    enterPrimary_operator_item?: (ctx: Primary_operator_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.primary_operator_item`.
+     * @param ctx the parse tree
+     */
+    exitPrimary_operator_item?: (ctx: Primary_operator_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.operator_context_clause`.
+     * @param ctx the parse tree
+     */
+    enterOperator_context_clause?: (ctx: Operator_context_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.operator_context_clause`.
+     * @param ctx the parse tree
+     */
+    exitOperator_context_clause?: (ctx: Operator_context_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_function_clause`.
+     * @param ctx the parse tree
+     */
+    enterUsing_function_clause?: (ctx: Using_function_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_function_clause`.
+     * @param ctx the parse tree
+     */
+    exitUsing_function_clause?: (ctx: Using_function_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_binding_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_binding_clause?: (ctx: Drop_binding_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_binding_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_binding_clause?: (ctx: Drop_binding_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_materialized_view`.
+     * @param ctx the parse tree
+     */
+    enterCreate_materialized_view?: (ctx: Create_materialized_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_materialized_view`.
+     * @param ctx the parse tree
+     */
+    exitCreate_materialized_view?: (ctx: Create_materialized_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.scoped_table_ref_constraint`.
+     * @param ctx the parse tree
+     */
+    enterScoped_table_ref_constraint?: (ctx: Scoped_table_ref_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.scoped_table_ref_constraint`.
+     * @param ctx the parse tree
+     */
+    exitScoped_table_ref_constraint?: (ctx: Scoped_table_ref_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.mv_column_alias`.
+     * @param ctx the parse tree
+     */
+    enterMv_column_alias?: (ctx: Mv_column_aliasContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.mv_column_alias`.
+     * @param ctx the parse tree
+     */
+    exitMv_column_alias?: (ctx: Mv_column_aliasContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_mv_refresh`.
+     * @param ctx the parse tree
+     */
+    enterCreate_mv_refresh?: (ctx: Create_mv_refreshContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_mv_refresh`.
+     * @param ctx the parse tree
+     */
+    exitCreate_mv_refresh?: (ctx: Create_mv_refreshContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.query_rewrite_clause`.
+     * @param ctx the parse tree
+     */
+    enterQuery_rewrite_clause?: (ctx: Query_rewrite_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.query_rewrite_clause`.
+     * @param ctx the parse tree
+     */
+    exitQuery_rewrite_clause?: (ctx: Query_rewrite_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unusable_editions_clause`.
+     * @param ctx the parse tree
+     */
+    enterUnusable_editions_clause?: (ctx: Unusable_editions_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unusable_editions_clause`.
+     * @param ctx the parse tree
+     */
+    exitUnusable_editions_clause?: (ctx: Unusable_editions_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_materialized_view`.
+     * @param ctx the parse tree
+     */
+    enterDrop_materialized_view?: (ctx: Drop_materialized_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_materialized_view`.
+     * @param ctx the parse tree
+     */
+    exitDrop_materialized_view?: (ctx: Drop_materialized_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_materialized_view_log`.
+     * @param ctx the parse tree
+     */
+    enterDrop_materialized_view_log?: (ctx: Drop_materialized_view_logContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_materialized_view_log`.
+     * @param ctx the parse tree
+     */
+    exitDrop_materialized_view_log?: (ctx: Drop_materialized_view_logContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_context`.
+     * @param ctx the parse tree
+     */
+    enterCreate_context?: (ctx: Create_contextContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_context`.
+     * @param ctx the parse tree
+     */
+    exitCreate_context?: (ctx: Create_contextContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.oracle_namespace`.
+     * @param ctx the parse tree
+     */
+    enterOracle_namespace?: (ctx: Oracle_namespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.oracle_namespace`.
+     * @param ctx the parse tree
+     */
+    exitOracle_namespace?: (ctx: Oracle_namespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_cluster`.
+     * @param ctx the parse tree
+     */
+    enterCreate_cluster?: (ctx: Create_clusterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_cluster`.
+     * @param ctx the parse tree
+     */
+    exitCreate_cluster?: (ctx: Create_clusterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_profile`.
+     * @param ctx the parse tree
+     */
+    enterCreate_profile?: (ctx: Create_profileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_profile`.
+     * @param ctx the parse tree
+     */
+    exitCreate_profile?: (ctx: Create_profileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.resource_parameters`.
+     * @param ctx the parse tree
+     */
+    enterResource_parameters?: (ctx: Resource_parametersContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.resource_parameters`.
+     * @param ctx the parse tree
+     */
+    exitResource_parameters?: (ctx: Resource_parametersContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.password_parameters`.
+     * @param ctx the parse tree
+     */
+    enterPassword_parameters?: (ctx: Password_parametersContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.password_parameters`.
+     * @param ctx the parse tree
+     */
+    exitPassword_parameters?: (ctx: Password_parametersContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_lockdown_profile`.
+     * @param ctx the parse tree
+     */
+    enterCreate_lockdown_profile?: (ctx: Create_lockdown_profileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_lockdown_profile`.
+     * @param ctx the parse tree
+     */
+    exitCreate_lockdown_profile?: (ctx: Create_lockdown_profileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.static_base_profile`.
+     * @param ctx the parse tree
+     */
+    enterStatic_base_profile?: (ctx: Static_base_profileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.static_base_profile`.
+     * @param ctx the parse tree
+     */
+    exitStatic_base_profile?: (ctx: Static_base_profileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dynamic_base_profile`.
+     * @param ctx the parse tree
+     */
+    enterDynamic_base_profile?: (ctx: Dynamic_base_profileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dynamic_base_profile`.
+     * @param ctx the parse tree
+     */
+    exitDynamic_base_profile?: (ctx: Dynamic_base_profileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_outline`.
+     * @param ctx the parse tree
+     */
+    enterCreate_outline?: (ctx: Create_outlineContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_outline`.
+     * @param ctx the parse tree
+     */
+    exitCreate_outline?: (ctx: Create_outlineContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_restore_point`.
+     * @param ctx the parse tree
+     */
+    enterCreate_restore_point?: (ctx: Create_restore_pointContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_restore_point`.
+     * @param ctx the parse tree
+     */
+    exitCreate_restore_point?: (ctx: Create_restore_pointContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_role`.
+     * @param ctx the parse tree
+     */
+    enterCreate_role?: (ctx: Create_roleContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_role`.
+     * @param ctx the parse tree
+     */
+    exitCreate_role?: (ctx: Create_roleContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_table`.
+     * @param ctx the parse tree
+     */
+    enterCreate_table?: (ctx: Create_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_table`.
+     * @param ctx the parse tree
+     */
+    exitCreate_table?: (ctx: Create_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmltype_table`.
+     * @param ctx the parse tree
+     */
+    enterXmltype_table?: (ctx: Xmltype_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmltype_table`.
+     * @param ctx the parse tree
+     */
+    exitXmltype_table?: (ctx: Xmltype_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmltype_virtual_columns`.
+     * @param ctx the parse tree
+     */
+    enterXmltype_virtual_columns?: (ctx: Xmltype_virtual_columnsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmltype_virtual_columns`.
+     * @param ctx the parse tree
+     */
+    exitXmltype_virtual_columns?: (ctx: Xmltype_virtual_columnsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmltype_column_properties`.
+     * @param ctx the parse tree
+     */
+    enterXmltype_column_properties?: (ctx: Xmltype_column_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmltype_column_properties`.
+     * @param ctx the parse tree
+     */
+    exitXmltype_column_properties?: (ctx: Xmltype_column_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmltype_storage`.
+     * @param ctx the parse tree
+     */
+    enterXmltype_storage?: (ctx: Xmltype_storageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmltype_storage`.
+     * @param ctx the parse tree
+     */
+    exitXmltype_storage?: (ctx: Xmltype_storageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlschema_spec`.
+     * @param ctx the parse tree
+     */
+    enterXmlschema_spec?: (ctx: Xmlschema_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlschema_spec`.
+     * @param ctx the parse tree
+     */
+    exitXmlschema_spec?: (ctx: Xmlschema_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_table`.
+     * @param ctx the parse tree
+     */
+    enterObject_table?: (ctx: Object_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_table`.
+     * @param ctx the parse tree
+     */
+    exitObject_table?: (ctx: Object_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_type`.
+     * @param ctx the parse tree
+     */
+    enterObject_type?: (ctx: Object_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_type`.
+     * @param ctx the parse tree
+     */
+    exitObject_type?: (ctx: Object_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.oid_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterOid_index_clause?: (ctx: Oid_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.oid_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitOid_index_clause?: (ctx: Oid_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.oid_clause`.
+     * @param ctx the parse tree
+     */
+    enterOid_clause?: (ctx: Oid_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.oid_clause`.
+     * @param ctx the parse tree
+     */
+    exitOid_clause?: (ctx: Oid_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_properties`.
+     * @param ctx the parse tree
+     */
+    enterObject_properties?: (ctx: Object_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_properties`.
+     * @param ctx the parse tree
+     */
+    exitObject_properties?: (ctx: Object_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_table_substitution`.
+     * @param ctx the parse tree
+     */
+    enterObject_table_substitution?: (ctx: Object_table_substitutionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_table_substitution`.
+     * @param ctx the parse tree
+     */
+    exitObject_table_substitution?: (ctx: Object_table_substitutionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relational_table`.
+     * @param ctx the parse tree
+     */
+    enterRelational_table?: (ctx: Relational_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relational_table`.
+     * @param ctx the parse tree
+     */
+    exitRelational_table?: (ctx: Relational_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relational_table_properties`.
+     * @param ctx the parse tree
+     */
+    enterRelational_table_properties?: (ctx: Relational_table_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relational_table_properties`.
+     * @param ctx the parse tree
+     */
+    exitRelational_table_properties?: (ctx: Relational_table_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relational_table_property`.
+     * @param ctx the parse tree
+     */
+    enterRelational_table_property?: (ctx: Relational_table_propertyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relational_table_property`.
+     * @param ctx the parse tree
+     */
+    exitRelational_table_property?: (ctx: Relational_table_propertyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.immutable_table_clauses`.
+     * @param ctx the parse tree
+     */
+    enterImmutable_table_clauses?: (ctx: Immutable_table_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.immutable_table_clauses`.
+     * @param ctx the parse tree
+     */
+    exitImmutable_table_clauses?: (ctx: Immutable_table_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.immutable_table_no_drop_clause`.
+     * @param ctx the parse tree
+     */
+    enterImmutable_table_no_drop_clause?: (ctx: Immutable_table_no_drop_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.immutable_table_no_drop_clause`.
+     * @param ctx the parse tree
+     */
+    exitImmutable_table_no_drop_clause?: (ctx: Immutable_table_no_drop_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.immutable_table_no_delete_clause`.
+     * @param ctx the parse tree
+     */
+    enterImmutable_table_no_delete_clause?: (ctx: Immutable_table_no_delete_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.immutable_table_no_delete_clause`.
+     * @param ctx the parse tree
+     */
+    exitImmutable_table_no_delete_clause?: (ctx: Immutable_table_no_delete_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.blockchain_table_clauses`.
+     * @param ctx the parse tree
+     */
+    enterBlockchain_table_clauses?: (ctx: Blockchain_table_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.blockchain_table_clauses`.
+     * @param ctx the parse tree
+     */
+    exitBlockchain_table_clauses?: (ctx: Blockchain_table_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.blockchain_drop_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterBlockchain_drop_table_clause?: (ctx: Blockchain_drop_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.blockchain_drop_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitBlockchain_drop_table_clause?: (ctx: Blockchain_drop_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.blockchain_row_retention_clause`.
+     * @param ctx the parse tree
+     */
+    enterBlockchain_row_retention_clause?: (ctx: Blockchain_row_retention_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.blockchain_row_retention_clause`.
+     * @param ctx the parse tree
+     */
+    exitBlockchain_row_retention_clause?: (ctx: Blockchain_row_retention_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.blockchain_hash_and_data_format_clause`.
+     * @param ctx the parse tree
+     */
+    enterBlockchain_hash_and_data_format_clause?: (ctx: Blockchain_hash_and_data_format_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.blockchain_hash_and_data_format_clause`.
+     * @param ctx the parse tree
+     */
+    exitBlockchain_hash_and_data_format_clause?: (ctx: Blockchain_hash_and_data_format_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.collation_name`.
+     * @param ctx the parse tree
+     */
+    enterCollation_name?: (ctx: Collation_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.collation_name`.
+     * @param ctx the parse tree
+     */
+    exitCollation_name?: (ctx: Collation_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_properties`.
+     * @param ctx the parse tree
+     */
+    enterTable_properties?: (ctx: Table_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_properties`.
+     * @param ctx the parse tree
+     */
+    exitTable_properties?: (ctx: Table_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.read_only_clause`.
+     * @param ctx the parse tree
+     */
+    enterRead_only_clause?: (ctx: Read_only_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.read_only_clause`.
+     * @param ctx the parse tree
+     */
+    exitRead_only_clause?: (ctx: Read_only_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.indexing_clause`.
+     * @param ctx the parse tree
+     */
+    enterIndexing_clause?: (ctx: Indexing_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.indexing_clause`.
+     * @param ctx the parse tree
+     */
+    exitIndexing_clause?: (ctx: Indexing_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.attribute_clustering_clause`.
+     * @param ctx the parse tree
+     */
+    enterAttribute_clustering_clause?: (ctx: Attribute_clustering_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.attribute_clustering_clause`.
+     * @param ctx the parse tree
+     */
+    exitAttribute_clustering_clause?: (ctx: Attribute_clustering_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.clustering_join`.
+     * @param ctx the parse tree
+     */
+    enterClustering_join?: (ctx: Clustering_joinContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.clustering_join`.
+     * @param ctx the parse tree
+     */
+    exitClustering_join?: (ctx: Clustering_joinContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.clustering_join_item`.
+     * @param ctx the parse tree
+     */
+    enterClustering_join_item?: (ctx: Clustering_join_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.clustering_join_item`.
+     * @param ctx the parse tree
+     */
+    exitClustering_join_item?: (ctx: Clustering_join_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.equijoin_condition`.
+     * @param ctx the parse tree
+     */
+    enterEquijoin_condition?: (ctx: Equijoin_conditionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.equijoin_condition`.
+     * @param ctx the parse tree
+     */
+    exitEquijoin_condition?: (ctx: Equijoin_conditionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cluster_clause`.
+     * @param ctx the parse tree
+     */
+    enterCluster_clause?: (ctx: Cluster_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cluster_clause`.
+     * @param ctx the parse tree
+     */
+    exitCluster_clause?: (ctx: Cluster_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.clustering_columns`.
+     * @param ctx the parse tree
+     */
+    enterClustering_columns?: (ctx: Clustering_columnsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.clustering_columns`.
+     * @param ctx the parse tree
+     */
+    exitClustering_columns?: (ctx: Clustering_columnsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.clustering_column_group`.
+     * @param ctx the parse tree
+     */
+    enterClustering_column_group?: (ctx: Clustering_column_groupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.clustering_column_group`.
+     * @param ctx the parse tree
+     */
+    exitClustering_column_group?: (ctx: Clustering_column_groupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.yes_no`.
+     * @param ctx the parse tree
+     */
+    enterYes_no?: (ctx: Yes_noContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.yes_no`.
+     * @param ctx the parse tree
+     */
+    exitYes_no?: (ctx: Yes_noContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.zonemap_clause`.
+     * @param ctx the parse tree
+     */
+    enterZonemap_clause?: (ctx: Zonemap_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.zonemap_clause`.
+     * @param ctx the parse tree
+     */
+    exitZonemap_clause?: (ctx: Zonemap_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logical_replication_clause`.
+     * @param ctx the parse tree
+     */
+    enterLogical_replication_clause?: (ctx: Logical_replication_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logical_replication_clause`.
+     * @param ctx the parse tree
+     */
+    exitLogical_replication_clause?: (ctx: Logical_replication_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_name`.
+     * @param ctx the parse tree
+     */
+    enterTable_name?: (ctx: Table_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_name`.
+     * @param ctx the parse tree
+     */
+    exitTable_name?: (ctx: Table_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relational_property`.
+     * @param ctx the parse tree
+     */
+    enterRelational_property?: (ctx: Relational_propertyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relational_property`.
+     * @param ctx the parse tree
+     */
+    exitRelational_property?: (ctx: Relational_propertyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_partitioning_clauses`.
+     * @param ctx the parse tree
+     */
+    enterTable_partitioning_clauses?: (ctx: Table_partitioning_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_partitioning_clauses`.
+     * @param ctx the parse tree
+     */
+    exitTable_partitioning_clauses?: (ctx: Table_partitioning_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.range_partitions`.
+     * @param ctx the parse tree
+     */
+    enterRange_partitions?: (ctx: Range_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.range_partitions`.
+     * @param ctx the parse tree
+     */
+    exitRange_partitions?: (ctx: Range_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.list_partitions`.
+     * @param ctx the parse tree
+     */
+    enterList_partitions?: (ctx: List_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.list_partitions`.
+     * @param ctx the parse tree
+     */
+    exitList_partitions?: (ctx: List_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hash_partitions`.
+     * @param ctx the parse tree
+     */
+    enterHash_partitions?: (ctx: Hash_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hash_partitions`.
+     * @param ctx the parse tree
+     */
+    exitHash_partitions?: (ctx: Hash_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.individual_hash_partitions`.
+     * @param ctx the parse tree
+     */
+    enterIndividual_hash_partitions?: (ctx: Individual_hash_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.individual_hash_partitions`.
+     * @param ctx the parse tree
+     */
+    exitIndividual_hash_partitions?: (ctx: Individual_hash_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hash_partitions_by_quantity`.
+     * @param ctx the parse tree
+     */
+    enterHash_partitions_by_quantity?: (ctx: Hash_partitions_by_quantityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hash_partitions_by_quantity`.
+     * @param ctx the parse tree
+     */
+    exitHash_partitions_by_quantity?: (ctx: Hash_partitions_by_quantityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hash_partition_quantity`.
+     * @param ctx the parse tree
+     */
+    enterHash_partition_quantity?: (ctx: Hash_partition_quantityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hash_partition_quantity`.
+     * @param ctx the parse tree
+     */
+    exitHash_partition_quantity?: (ctx: Hash_partition_quantityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.composite_range_partitions`.
+     * @param ctx the parse tree
+     */
+    enterComposite_range_partitions?: (ctx: Composite_range_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.composite_range_partitions`.
+     * @param ctx the parse tree
+     */
+    exitComposite_range_partitions?: (ctx: Composite_range_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.composite_list_partitions`.
+     * @param ctx the parse tree
+     */
+    enterComposite_list_partitions?: (ctx: Composite_list_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.composite_list_partitions`.
+     * @param ctx the parse tree
+     */
+    exitComposite_list_partitions?: (ctx: Composite_list_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.composite_hash_partitions`.
+     * @param ctx the parse tree
+     */
+    enterComposite_hash_partitions?: (ctx: Composite_hash_partitionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.composite_hash_partitions`.
+     * @param ctx the parse tree
+     */
+    exitComposite_hash_partitions?: (ctx: Composite_hash_partitionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.reference_partitioning`.
+     * @param ctx the parse tree
+     */
+    enterReference_partitioning?: (ctx: Reference_partitioningContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.reference_partitioning`.
+     * @param ctx the parse tree
+     */
+    exitReference_partitioning?: (ctx: Reference_partitioningContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.reference_partition_desc`.
+     * @param ctx the parse tree
+     */
+    enterReference_partition_desc?: (ctx: Reference_partition_descContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.reference_partition_desc`.
+     * @param ctx the parse tree
+     */
+    exitReference_partition_desc?: (ctx: Reference_partition_descContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.system_partitioning`.
+     * @param ctx the parse tree
+     */
+    enterSystem_partitioning?: (ctx: System_partitioningContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.system_partitioning`.
+     * @param ctx the parse tree
+     */
+    exitSystem_partitioning?: (ctx: System_partitioningContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.range_partition_desc`.
+     * @param ctx the parse tree
+     */
+    enterRange_partition_desc?: (ctx: Range_partition_descContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.range_partition_desc`.
+     * @param ctx the parse tree
+     */
+    exitRange_partition_desc?: (ctx: Range_partition_descContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.list_partition_desc`.
+     * @param ctx the parse tree
+     */
+    enterList_partition_desc?: (ctx: List_partition_descContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.list_partition_desc`.
+     * @param ctx the parse tree
+     */
+    exitList_partition_desc?: (ctx: List_partition_descContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_template`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_template?: (ctx: Subpartition_templateContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_template`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_template?: (ctx: Subpartition_templateContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hash_subpartition_quantity`.
+     * @param ctx the parse tree
+     */
+    enterHash_subpartition_quantity?: (ctx: Hash_subpartition_quantityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hash_subpartition_quantity`.
+     * @param ctx the parse tree
+     */
+    exitHash_subpartition_quantity?: (ctx: Hash_subpartition_quantityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_by_range`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_by_range?: (ctx: Subpartition_by_rangeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_by_range`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_by_range?: (ctx: Subpartition_by_rangeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_by_list`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_by_list?: (ctx: Subpartition_by_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_by_list`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_by_list?: (ctx: Subpartition_by_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_by_hash`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_by_hash?: (ctx: Subpartition_by_hashContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_by_hash`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_by_hash?: (ctx: Subpartition_by_hashContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_name`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_name?: (ctx: Subpartition_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_name`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_name?: (ctx: Subpartition_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.range_subpartition_desc`.
+     * @param ctx the parse tree
+     */
+    enterRange_subpartition_desc?: (ctx: Range_subpartition_descContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.range_subpartition_desc`.
+     * @param ctx the parse tree
+     */
+    exitRange_subpartition_desc?: (ctx: Range_subpartition_descContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.list_subpartition_desc`.
+     * @param ctx the parse tree
+     */
+    enterList_subpartition_desc?: (ctx: List_subpartition_descContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.list_subpartition_desc`.
+     * @param ctx the parse tree
+     */
+    exitList_subpartition_desc?: (ctx: List_subpartition_descContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.individual_hash_subparts`.
+     * @param ctx the parse tree
+     */
+    enterIndividual_hash_subparts?: (ctx: Individual_hash_subpartsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.individual_hash_subparts`.
+     * @param ctx the parse tree
+     */
+    exitIndividual_hash_subparts?: (ctx: Individual_hash_subpartsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hash_subparts_by_quantity`.
+     * @param ctx the parse tree
+     */
+    enterHash_subparts_by_quantity?: (ctx: Hash_subparts_by_quantityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hash_subparts_by_quantity`.
+     * @param ctx the parse tree
+     */
+    exitHash_subparts_by_quantity?: (ctx: Hash_subparts_by_quantityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.range_values_clause`.
+     * @param ctx the parse tree
+     */
+    enterRange_values_clause?: (ctx: Range_values_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.range_values_clause`.
+     * @param ctx the parse tree
+     */
+    exitRange_values_clause?: (ctx: Range_values_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.range_values_list`.
+     * @param ctx the parse tree
+     */
+    enterRange_values_list?: (ctx: Range_values_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.range_values_list`.
+     * @param ctx the parse tree
+     */
+    exitRange_values_list?: (ctx: Range_values_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.list_values_clause`.
+     * @param ctx the parse tree
+     */
+    enterList_values_clause?: (ctx: List_values_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.list_values_clause`.
+     * @param ctx the parse tree
+     */
+    exitList_values_clause?: (ctx: List_values_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_partition_description`.
+     * @param ctx the parse tree
+     */
+    enterTable_partition_description?: (ctx: Table_partition_descriptionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_partition_description`.
+     * @param ctx the parse tree
+     */
+    exitTable_partition_description?: (ctx: Table_partition_descriptionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partitioning_storage_clause`.
+     * @param ctx the parse tree
+     */
+    enterPartitioning_storage_clause?: (ctx: Partitioning_storage_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partitioning_storage_clause`.
+     * @param ctx the parse tree
+     */
+    exitPartitioning_storage_clause?: (ctx: Partitioning_storage_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_partitioning_storage`.
+     * @param ctx the parse tree
+     */
+    enterLob_partitioning_storage?: (ctx: Lob_partitioning_storageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_partitioning_storage`.
+     * @param ctx the parse tree
+     */
+    exitLob_partitioning_storage?: (ctx: Lob_partitioning_storageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.size_clause`.
+     * @param ctx the parse tree
+     */
+    enterSize_clause?: (ctx: Size_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.size_clause`.
+     * @param ctx the parse tree
+     */
+    exitSize_clause?: (ctx: Size_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_compression`.
+     * @param ctx the parse tree
+     */
+    enterTable_compression?: (ctx: Table_compressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_compression`.
+     * @param ctx the parse tree
+     */
+    exitTable_compression?: (ctx: Table_compressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_table_clause?: (ctx: Inmemory_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_table_clause?: (ctx: Inmemory_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_attributes`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_attributes?: (ctx: Inmemory_attributesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_attributes`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_attributes?: (ctx: Inmemory_attributesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_memcompress`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_memcompress?: (ctx: Inmemory_memcompressContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_memcompress`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_memcompress?: (ctx: Inmemory_memcompressContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_priority`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_priority?: (ctx: Inmemory_priorityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_priority`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_priority?: (ctx: Inmemory_priorityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_distribute`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_distribute?: (ctx: Inmemory_distributeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_distribute`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_distribute?: (ctx: Inmemory_distributeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_duplicate`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_duplicate?: (ctx: Inmemory_duplicateContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_duplicate`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_duplicate?: (ctx: Inmemory_duplicateContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inmemory_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterInmemory_column_clause?: (ctx: Inmemory_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inmemory_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitInmemory_column_clause?: (ctx: Inmemory_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.physical_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    enterPhysical_attributes_clause?: (ctx: Physical_attributes_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.physical_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    exitPhysical_attributes_clause?: (ctx: Physical_attributes_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.storage_clause`.
+     * @param ctx the parse tree
+     */
+    enterStorage_clause?: (ctx: Storage_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.storage_clause`.
+     * @param ctx the parse tree
+     */
+    exitStorage_clause?: (ctx: Storage_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.deferred_segment_creation`.
+     * @param ctx the parse tree
+     */
+    enterDeferred_segment_creation?: (ctx: Deferred_segment_creationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.deferred_segment_creation`.
+     * @param ctx the parse tree
+     */
+    exitDeferred_segment_creation?: (ctx: Deferred_segment_creationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.segment_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    enterSegment_attributes_clause?: (ctx: Segment_attributes_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.segment_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    exitSegment_attributes_clause?: (ctx: Segment_attributes_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.physical_properties`.
+     * @param ctx the parse tree
+     */
+    enterPhysical_properties?: (ctx: Physical_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.physical_properties`.
+     * @param ctx the parse tree
+     */
+    exitPhysical_properties?: (ctx: Physical_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_clause`.
+     * @param ctx the parse tree
+     */
+    enterIlm_clause?: (ctx: Ilm_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_clause`.
+     * @param ctx the parse tree
+     */
+    exitIlm_clause?: (ctx: Ilm_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_policy_clause`.
+     * @param ctx the parse tree
+     */
+    enterIlm_policy_clause?: (ctx: Ilm_policy_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_policy_clause`.
+     * @param ctx the parse tree
+     */
+    exitIlm_policy_clause?: (ctx: Ilm_policy_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_compression_policy`.
+     * @param ctx the parse tree
+     */
+    enterIlm_compression_policy?: (ctx: Ilm_compression_policyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_compression_policy`.
+     * @param ctx the parse tree
+     */
+    exitIlm_compression_policy?: (ctx: Ilm_compression_policyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_tiering_policy`.
+     * @param ctx the parse tree
+     */
+    enterIlm_tiering_policy?: (ctx: Ilm_tiering_policyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_tiering_policy`.
+     * @param ctx the parse tree
+     */
+    exitIlm_tiering_policy?: (ctx: Ilm_tiering_policyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_after_on`.
+     * @param ctx the parse tree
+     */
+    enterIlm_after_on?: (ctx: Ilm_after_onContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_after_on`.
+     * @param ctx the parse tree
+     */
+    exitIlm_after_on?: (ctx: Ilm_after_onContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.segment_group`.
+     * @param ctx the parse tree
+     */
+    enterSegment_group?: (ctx: Segment_groupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.segment_group`.
+     * @param ctx the parse tree
+     */
+    exitSegment_group?: (ctx: Segment_groupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_inmemory_policy`.
+     * @param ctx the parse tree
+     */
+    enterIlm_inmemory_policy?: (ctx: Ilm_inmemory_policyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_inmemory_policy`.
+     * @param ctx the parse tree
+     */
+    exitIlm_inmemory_policy?: (ctx: Ilm_inmemory_policyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ilm_time_period`.
+     * @param ctx the parse tree
+     */
+    enterIlm_time_period?: (ctx: Ilm_time_periodContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ilm_time_period`.
+     * @param ctx the parse tree
+     */
+    exitIlm_time_period?: (ctx: Ilm_time_periodContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.heap_org_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterHeap_org_table_clause?: (ctx: Heap_org_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.heap_org_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitHeap_org_table_clause?: (ctx: Heap_org_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_clause?: (ctx: External_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_clause?: (ctx: External_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.access_driver_type`.
+     * @param ctx the parse tree
+     */
+    enterAccess_driver_type?: (ctx: Access_driver_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.access_driver_type`.
+     * @param ctx the parse tree
+     */
+    exitAccess_driver_type?: (ctx: Access_driver_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_data_props`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_data_props?: (ctx: External_table_data_propsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_data_props`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_data_props?: (ctx: External_table_data_propsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_data_format`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_data_format?: (ctx: External_table_data_formatContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_data_format`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_data_format?: (ctx: External_table_data_formatContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_transform`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_transform?: (ctx: External_table_transformContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_transform`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_transform?: (ctx: External_table_transformContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_field`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_field?: (ctx: External_table_fieldContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_field`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_field?: (ctx: External_table_fieldContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_field_list`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_field_list?: (ctx: External_table_field_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_field_list`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_field_list?: (ctx: External_table_field_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_fields_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_fields_clause?: (ctx: External_table_fields_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_fields_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_fields_clause?: (ctx: External_table_fields_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_position_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_position_clause?: (ctx: External_table_position_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_position_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_position_clause?: (ctx: External_table_position_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_datatype_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_datatype_clause?: (ctx: External_table_datatype_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_datatype_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_datatype_clause?: (ctx: External_table_datatype_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_delimit_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_delimit_clause?: (ctx: External_table_delimit_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_delimit_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_delimit_clause?: (ctx: External_table_delimit_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_trim_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_trim_clause?: (ctx: External_table_trim_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_trim_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_trim_clause?: (ctx: External_table_trim_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_date_format_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_date_format_clause?: (ctx: External_table_date_format_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_date_format_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_date_format_clause?: (ctx: External_table_date_format_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_init_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_init_clause?: (ctx: External_table_init_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_init_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_init_clause?: (ctx: External_table_init_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_condition_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_condition_clause?: (ctx: External_table_condition_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_condition_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_condition_clause?: (ctx: External_table_condition_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_lls_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_lls_clause?: (ctx: External_table_lls_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_lls_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_lls_clause?: (ctx: External_table_lls_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_records`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_records?: (ctx: External_table_recordsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_records`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_records?: (ctx: External_table_recordsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_record_options_clause`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_record_options_clause?: (ctx: External_table_record_options_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_record_options_clause`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_record_options_clause?: (ctx: External_table_record_options_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_output_files`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_output_files?: (ctx: External_table_output_filesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_output_files`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_output_files?: (ctx: External_table_output_filesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_fields`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_fields?: (ctx: External_table_fieldsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_fields`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_fields?: (ctx: External_table_fieldsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_datapump`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_datapump?: (ctx: External_table_datapumpContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_datapump`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_datapump?: (ctx: External_table_datapumpContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_hive`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_hive?: (ctx: External_table_hiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_hive`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_hive?: (ctx: External_table_hiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_hive_parameter_map`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_hive_parameter_map?: (ctx: External_table_hive_parameter_mapContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_hive_parameter_map`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_hive_parameter_map?: (ctx: External_table_hive_parameter_mapContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_hive_parameter_map_entry`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_hive_parameter_map_entry?: (ctx: External_table_hive_parameter_map_entryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_hive_parameter_map_entry`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_hive_parameter_map_entry?: (ctx: External_table_hive_parameter_map_entryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.external_table_directory`.
+     * @param ctx the parse tree
+     */
+    enterExternal_table_directory?: (ctx: External_table_directoryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.external_table_directory`.
+     * @param ctx the parse tree
+     */
+    exitExternal_table_directory?: (ctx: External_table_directoryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.row_movement_clause`.
+     * @param ctx the parse tree
+     */
+    enterRow_movement_clause?: (ctx: Row_movement_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.row_movement_clause`.
+     * @param ctx the parse tree
+     */
+    exitRow_movement_clause?: (ctx: Row_movement_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.flashback_archive_clause`.
+     * @param ctx the parse tree
+     */
+    enterFlashback_archive_clause?: (ctx: Flashback_archive_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.flashback_archive_clause`.
+     * @param ctx the parse tree
+     */
+    exitFlashback_archive_clause?: (ctx: Flashback_archive_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.log_grp`.
+     * @param ctx the parse tree
+     */
+    enterLog_grp?: (ctx: Log_grpContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.log_grp`.
+     * @param ctx the parse tree
+     */
+    exitLog_grp?: (ctx: Log_grpContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.supplemental_table_logging`.
+     * @param ctx the parse tree
+     */
+    enterSupplemental_table_logging?: (ctx: Supplemental_table_loggingContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.supplemental_table_logging`.
+     * @param ctx the parse tree
+     */
+    exitSupplemental_table_logging?: (ctx: Supplemental_table_loggingContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.supplemental_log_grp_clause`.
+     * @param ctx the parse tree
+     */
+    enterSupplemental_log_grp_clause?: (ctx: Supplemental_log_grp_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.supplemental_log_grp_clause`.
+     * @param ctx the parse tree
+     */
+    exitSupplemental_log_grp_clause?: (ctx: Supplemental_log_grp_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.supplemental_id_key_clause`.
+     * @param ctx the parse tree
+     */
+    enterSupplemental_id_key_clause?: (ctx: Supplemental_id_key_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.supplemental_id_key_clause`.
+     * @param ctx the parse tree
+     */
+    exitSupplemental_id_key_clause?: (ctx: Supplemental_id_key_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.allocate_extent_clause`.
+     * @param ctx the parse tree
+     */
+    enterAllocate_extent_clause?: (ctx: Allocate_extent_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.allocate_extent_clause`.
+     * @param ctx the parse tree
+     */
+    exitAllocate_extent_clause?: (ctx: Allocate_extent_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.deallocate_unused_clause`.
+     * @param ctx the parse tree
+     */
+    enterDeallocate_unused_clause?: (ctx: Deallocate_unused_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.deallocate_unused_clause`.
+     * @param ctx the parse tree
+     */
+    exitDeallocate_unused_clause?: (ctx: Deallocate_unused_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.shrink_clause`.
+     * @param ctx the parse tree
+     */
+    enterShrink_clause?: (ctx: Shrink_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.shrink_clause`.
+     * @param ctx the parse tree
+     */
+    exitShrink_clause?: (ctx: Shrink_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.records_per_block_clause`.
+     * @param ctx the parse tree
+     */
+    enterRecords_per_block_clause?: (ctx: Records_per_block_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.records_per_block_clause`.
+     * @param ctx the parse tree
+     */
+    exitRecords_per_block_clause?: (ctx: Records_per_block_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.upgrade_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterUpgrade_table_clause?: (ctx: Upgrade_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.upgrade_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitUpgrade_table_clause?: (ctx: Upgrade_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.truncate_table`.
+     * @param ctx the parse tree
+     */
+    enterTruncate_table?: (ctx: Truncate_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.truncate_table`.
+     * @param ctx the parse tree
+     */
+    exitTruncate_table?: (ctx: Truncate_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_table`.
+     * @param ctx the parse tree
+     */
+    enterDrop_table?: (ctx: Drop_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_table`.
+     * @param ctx the parse tree
+     */
+    exitDrop_table?: (ctx: Drop_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_tablespace`.
+     * @param ctx the parse tree
+     */
+    enterDrop_tablespace?: (ctx: Drop_tablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_tablespace`.
+     * @param ctx the parse tree
+     */
+    exitDrop_tablespace?: (ctx: Drop_tablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_tablespace_set`.
+     * @param ctx the parse tree
+     */
+    enterDrop_tablespace_set?: (ctx: Drop_tablespace_setContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_tablespace_set`.
+     * @param ctx the parse tree
+     */
+    exitDrop_tablespace_set?: (ctx: Drop_tablespace_setContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.including_contents_clause`.
+     * @param ctx the parse tree
+     */
+    enterIncluding_contents_clause?: (ctx: Including_contents_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.including_contents_clause`.
+     * @param ctx the parse tree
+     */
+    exitIncluding_contents_clause?: (ctx: Including_contents_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_view`.
+     * @param ctx the parse tree
+     */
+    enterDrop_view?: (ctx: Drop_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_view`.
+     * @param ctx the parse tree
+     */
+    exitDrop_view?: (ctx: Drop_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.comment_on_column`.
+     * @param ctx the parse tree
+     */
+    enterComment_on_column?: (ctx: Comment_on_columnContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.comment_on_column`.
+     * @param ctx the parse tree
+     */
+    exitComment_on_column?: (ctx: Comment_on_columnContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.enable_or_disable`.
+     * @param ctx the parse tree
+     */
+    enterEnable_or_disable?: (ctx: Enable_or_disableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.enable_or_disable`.
+     * @param ctx the parse tree
+     */
+    exitEnable_or_disable?: (ctx: Enable_or_disableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.allow_or_disallow`.
+     * @param ctx the parse tree
+     */
+    enterAllow_or_disallow?: (ctx: Allow_or_disallowContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.allow_or_disallow`.
+     * @param ctx the parse tree
+     */
+    exitAllow_or_disallow?: (ctx: Allow_or_disallowContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_synonym`.
+     * @param ctx the parse tree
+     */
+    enterAlter_synonym?: (ctx: Alter_synonymContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_synonym`.
+     * @param ctx the parse tree
+     */
+    exitAlter_synonym?: (ctx: Alter_synonymContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_synonym`.
+     * @param ctx the parse tree
+     */
+    enterCreate_synonym?: (ctx: Create_synonymContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_synonym`.
+     * @param ctx the parse tree
+     */
+    exitCreate_synonym?: (ctx: Create_synonymContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_synonym`.
+     * @param ctx the parse tree
+     */
+    enterDrop_synonym?: (ctx: Drop_synonymContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_synonym`.
+     * @param ctx the parse tree
+     */
+    exitDrop_synonym?: (ctx: Drop_synonymContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_spfile`.
+     * @param ctx the parse tree
+     */
+    enterCreate_spfile?: (ctx: Create_spfileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_spfile`.
+     * @param ctx the parse tree
+     */
+    exitCreate_spfile?: (ctx: Create_spfileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.spfile_name`.
+     * @param ctx the parse tree
+     */
+    enterSpfile_name?: (ctx: Spfile_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.spfile_name`.
+     * @param ctx the parse tree
+     */
+    exitSpfile_name?: (ctx: Spfile_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pfile_name`.
+     * @param ctx the parse tree
+     */
+    enterPfile_name?: (ctx: Pfile_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pfile_name`.
+     * @param ctx the parse tree
+     */
+    exitPfile_name?: (ctx: Pfile_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.comment_on_table`.
+     * @param ctx the parse tree
+     */
+    enterComment_on_table?: (ctx: Comment_on_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.comment_on_table`.
+     * @param ctx the parse tree
+     */
+    exitComment_on_table?: (ctx: Comment_on_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.comment_on_materialized`.
+     * @param ctx the parse tree
+     */
+    enterComment_on_materialized?: (ctx: Comment_on_materializedContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.comment_on_materialized`.
+     * @param ctx the parse tree
+     */
+    exitComment_on_materialized?: (ctx: Comment_on_materializedContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_analytic_view`.
+     * @param ctx the parse tree
+     */
+    enterAlter_analytic_view?: (ctx: Alter_analytic_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_analytic_view`.
+     * @param ctx the parse tree
+     */
+    exitAlter_analytic_view?: (ctx: Alter_analytic_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_add_cache_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_add_cache_clause?: (ctx: Alter_add_cache_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_add_cache_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_add_cache_clause?: (ctx: Alter_add_cache_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.levels_item`.
+     * @param ctx the parse tree
+     */
+    enterLevels_item?: (ctx: Levels_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.levels_item`.
+     * @param ctx the parse tree
+     */
+    exitLevels_item?: (ctx: Levels_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.measure_list`.
+     * @param ctx the parse tree
+     */
+    enterMeasure_list?: (ctx: Measure_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.measure_list`.
+     * @param ctx the parse tree
+     */
+    exitMeasure_list?: (ctx: Measure_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_drop_cache_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_drop_cache_clause?: (ctx: Alter_drop_cache_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_drop_cache_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_drop_cache_clause?: (ctx: Alter_drop_cache_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_attribute_dimension`.
+     * @param ctx the parse tree
+     */
+    enterAlter_attribute_dimension?: (ctx: Alter_attribute_dimensionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_attribute_dimension`.
+     * @param ctx the parse tree
+     */
+    exitAlter_attribute_dimension?: (ctx: Alter_attribute_dimensionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_audit_policy`.
+     * @param ctx the parse tree
+     */
+    enterAlter_audit_policy?: (ctx: Alter_audit_policyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_audit_policy`.
+     * @param ctx the parse tree
+     */
+    exitAlter_audit_policy?: (ctx: Alter_audit_policyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_cluster`.
+     * @param ctx the parse tree
+     */
+    enterAlter_cluster?: (ctx: Alter_clusterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_cluster`.
+     * @param ctx the parse tree
+     */
+    exitAlter_cluster?: (ctx: Alter_clusterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_analytic_view`.
+     * @param ctx the parse tree
+     */
+    enterDrop_analytic_view?: (ctx: Drop_analytic_viewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_analytic_view`.
+     * @param ctx the parse tree
+     */
+    exitDrop_analytic_view?: (ctx: Drop_analytic_viewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_attribute_dimension`.
+     * @param ctx the parse tree
+     */
+    enterDrop_attribute_dimension?: (ctx: Drop_attribute_dimensionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_attribute_dimension`.
+     * @param ctx the parse tree
+     */
+    exitDrop_attribute_dimension?: (ctx: Drop_attribute_dimensionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_audit_policy`.
+     * @param ctx the parse tree
+     */
+    enterDrop_audit_policy?: (ctx: Drop_audit_policyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_audit_policy`.
+     * @param ctx the parse tree
+     */
+    exitDrop_audit_policy?: (ctx: Drop_audit_policyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_flashback_archive`.
+     * @param ctx the parse tree
+     */
+    enterDrop_flashback_archive?: (ctx: Drop_flashback_archiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_flashback_archive`.
+     * @param ctx the parse tree
+     */
+    exitDrop_flashback_archive?: (ctx: Drop_flashback_archiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_cluster`.
+     * @param ctx the parse tree
+     */
+    enterDrop_cluster?: (ctx: Drop_clusterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_cluster`.
+     * @param ctx the parse tree
+     */
+    exitDrop_cluster?: (ctx: Drop_clusterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_context`.
+     * @param ctx the parse tree
+     */
+    enterDrop_context?: (ctx: Drop_contextContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_context`.
+     * @param ctx the parse tree
+     */
+    exitDrop_context?: (ctx: Drop_contextContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_directory`.
+     * @param ctx the parse tree
+     */
+    enterDrop_directory?: (ctx: Drop_directoryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_directory`.
+     * @param ctx the parse tree
+     */
+    exitDrop_directory?: (ctx: Drop_directoryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_diskgroup`.
+     * @param ctx the parse tree
+     */
+    enterDrop_diskgroup?: (ctx: Drop_diskgroupContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_diskgroup`.
+     * @param ctx the parse tree
+     */
+    exitDrop_diskgroup?: (ctx: Drop_diskgroupContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_edition`.
+     * @param ctx the parse tree
+     */
+    enterDrop_edition?: (ctx: Drop_editionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_edition`.
+     * @param ctx the parse tree
+     */
+    exitDrop_edition?: (ctx: Drop_editionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.truncate_cluster`.
+     * @param ctx the parse tree
+     */
+    enterTruncate_cluster?: (ctx: Truncate_clusterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.truncate_cluster`.
+     * @param ctx the parse tree
+     */
+    exitTruncate_cluster?: (ctx: Truncate_clusterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cache_or_nocache`.
+     * @param ctx the parse tree
+     */
+    enterCache_or_nocache?: (ctx: Cache_or_nocacheContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cache_or_nocache`.
+     * @param ctx the parse tree
+     */
+    exitCache_or_nocache?: (ctx: Cache_or_nocacheContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.database_name`.
+     * @param ctx the parse tree
+     */
+    enterDatabase_name?: (ctx: Database_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.database_name`.
+     * @param ctx the parse tree
+     */
+    exitDatabase_name?: (ctx: Database_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_database`.
+     * @param ctx the parse tree
+     */
+    enterAlter_database?: (ctx: Alter_databaseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_database`.
+     * @param ctx the parse tree
+     */
+    exitAlter_database?: (ctx: Alter_databaseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.database_clause`.
+     * @param ctx the parse tree
+     */
+    enterDatabase_clause?: (ctx: Database_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.database_clause`.
+     * @param ctx the parse tree
+     */
+    exitDatabase_clause?: (ctx: Database_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.startup_clauses`.
+     * @param ctx the parse tree
+     */
+    enterStartup_clauses?: (ctx: Startup_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.startup_clauses`.
+     * @param ctx the parse tree
+     */
+    exitStartup_clauses?: (ctx: Startup_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.resetlogs_or_noresetlogs`.
+     * @param ctx the parse tree
+     */
+    enterResetlogs_or_noresetlogs?: (ctx: Resetlogs_or_noresetlogsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.resetlogs_or_noresetlogs`.
+     * @param ctx the parse tree
+     */
+    exitResetlogs_or_noresetlogs?: (ctx: Resetlogs_or_noresetlogsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.upgrade_or_downgrade`.
+     * @param ctx the parse tree
+     */
+    enterUpgrade_or_downgrade?: (ctx: Upgrade_or_downgradeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.upgrade_or_downgrade`.
+     * @param ctx the parse tree
+     */
+    exitUpgrade_or_downgrade?: (ctx: Upgrade_or_downgradeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.recovery_clauses`.
+     * @param ctx the parse tree
+     */
+    enterRecovery_clauses?: (ctx: Recovery_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.recovery_clauses`.
+     * @param ctx the parse tree
+     */
+    exitRecovery_clauses?: (ctx: Recovery_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.begin_or_end`.
+     * @param ctx the parse tree
+     */
+    enterBegin_or_end?: (ctx: Begin_or_endContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.begin_or_end`.
+     * @param ctx the parse tree
+     */
+    exitBegin_or_end?: (ctx: Begin_or_endContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.general_recovery`.
+     * @param ctx the parse tree
+     */
+    enterGeneral_recovery?: (ctx: General_recoveryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.general_recovery`.
+     * @param ctx the parse tree
+     */
+    exitGeneral_recovery?: (ctx: General_recoveryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.full_database_recovery`.
+     * @param ctx the parse tree
+     */
+    enterFull_database_recovery?: (ctx: Full_database_recoveryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.full_database_recovery`.
+     * @param ctx the parse tree
+     */
+    exitFull_database_recovery?: (ctx: Full_database_recoveryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partial_database_recovery`.
+     * @param ctx the parse tree
+     */
+    enterPartial_database_recovery?: (ctx: Partial_database_recoveryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partial_database_recovery`.
+     * @param ctx the parse tree
+     */
+    exitPartial_database_recovery?: (ctx: Partial_database_recoveryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partial_database_recovery_10g`.
+     * @param ctx the parse tree
+     */
+    enterPartial_database_recovery_10g?: (ctx: Partial_database_recovery_10gContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partial_database_recovery_10g`.
+     * @param ctx the parse tree
+     */
+    exitPartial_database_recovery_10g?: (ctx: Partial_database_recovery_10gContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.managed_standby_recovery`.
+     * @param ctx the parse tree
+     */
+    enterManaged_standby_recovery?: (ctx: Managed_standby_recoveryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.managed_standby_recovery`.
+     * @param ctx the parse tree
+     */
+    exitManaged_standby_recovery?: (ctx: Managed_standby_recoveryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.db_name`.
+     * @param ctx the parse tree
+     */
+    enterDb_name?: (ctx: Db_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.db_name`.
+     * @param ctx the parse tree
+     */
+    exitDb_name?: (ctx: Db_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.database_file_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDatabase_file_clauses?: (ctx: Database_file_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.database_file_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDatabase_file_clauses?: (ctx: Database_file_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_datafile_clause`.
+     * @param ctx the parse tree
+     */
+    enterCreate_datafile_clause?: (ctx: Create_datafile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_datafile_clause`.
+     * @param ctx the parse tree
+     */
+    exitCreate_datafile_clause?: (ctx: Create_datafile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_datafile_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_datafile_clause?: (ctx: Alter_datafile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_datafile_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_datafile_clause?: (ctx: Alter_datafile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_tempfile_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_tempfile_clause?: (ctx: Alter_tempfile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_tempfile_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_tempfile_clause?: (ctx: Alter_tempfile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.move_datafile_clause`.
+     * @param ctx the parse tree
+     */
+    enterMove_datafile_clause?: (ctx: Move_datafile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.move_datafile_clause`.
+     * @param ctx the parse tree
+     */
+    exitMove_datafile_clause?: (ctx: Move_datafile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logfile_clauses`.
+     * @param ctx the parse tree
+     */
+    enterLogfile_clauses?: (ctx: Logfile_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logfile_clauses`.
+     * @param ctx the parse tree
+     */
+    exitLogfile_clauses?: (ctx: Logfile_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_logfile_clauses`.
+     * @param ctx the parse tree
+     */
+    enterAdd_logfile_clauses?: (ctx: Add_logfile_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_logfile_clauses`.
+     * @param ctx the parse tree
+     */
+    exitAdd_logfile_clauses?: (ctx: Add_logfile_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.group_redo_logfile`.
+     * @param ctx the parse tree
+     */
+    enterGroup_redo_logfile?: (ctx: Group_redo_logfileContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.group_redo_logfile`.
+     * @param ctx the parse tree
+     */
+    exitGroup_redo_logfile?: (ctx: Group_redo_logfileContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_logfile_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDrop_logfile_clauses?: (ctx: Drop_logfile_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_logfile_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDrop_logfile_clauses?: (ctx: Drop_logfile_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.switch_logfile_clause`.
+     * @param ctx the parse tree
+     */
+    enterSwitch_logfile_clause?: (ctx: Switch_logfile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.switch_logfile_clause`.
+     * @param ctx the parse tree
+     */
+    exitSwitch_logfile_clause?: (ctx: Switch_logfile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.supplemental_db_logging`.
+     * @param ctx the parse tree
+     */
+    enterSupplemental_db_logging?: (ctx: Supplemental_db_loggingContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.supplemental_db_logging`.
+     * @param ctx the parse tree
+     */
+    exitSupplemental_db_logging?: (ctx: Supplemental_db_loggingContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_or_drop`.
+     * @param ctx the parse tree
+     */
+    enterAdd_or_drop?: (ctx: Add_or_dropContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_or_drop`.
+     * @param ctx the parse tree
+     */
+    exitAdd_or_drop?: (ctx: Add_or_dropContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.supplemental_plsql_clause`.
+     * @param ctx the parse tree
+     */
+    enterSupplemental_plsql_clause?: (ctx: Supplemental_plsql_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.supplemental_plsql_clause`.
+     * @param ctx the parse tree
+     */
+    exitSupplemental_plsql_clause?: (ctx: Supplemental_plsql_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logfile_descriptor`.
+     * @param ctx the parse tree
+     */
+    enterLogfile_descriptor?: (ctx: Logfile_descriptorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logfile_descriptor`.
+     * @param ctx the parse tree
+     */
+    exitLogfile_descriptor?: (ctx: Logfile_descriptorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.controlfile_clauses`.
+     * @param ctx the parse tree
+     */
+    enterControlfile_clauses?: (ctx: Controlfile_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.controlfile_clauses`.
+     * @param ctx the parse tree
+     */
+    exitControlfile_clauses?: (ctx: Controlfile_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.trace_file_clause`.
+     * @param ctx the parse tree
+     */
+    enterTrace_file_clause?: (ctx: Trace_file_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.trace_file_clause`.
+     * @param ctx the parse tree
+     */
+    exitTrace_file_clause?: (ctx: Trace_file_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.standby_database_clauses`.
+     * @param ctx the parse tree
+     */
+    enterStandby_database_clauses?: (ctx: Standby_database_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.standby_database_clauses`.
+     * @param ctx the parse tree
+     */
+    exitStandby_database_clauses?: (ctx: Standby_database_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.activate_standby_db_clause`.
+     * @param ctx the parse tree
+     */
+    enterActivate_standby_db_clause?: (ctx: Activate_standby_db_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.activate_standby_db_clause`.
+     * @param ctx the parse tree
+     */
+    exitActivate_standby_db_clause?: (ctx: Activate_standby_db_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.maximize_standby_db_clause`.
+     * @param ctx the parse tree
+     */
+    enterMaximize_standby_db_clause?: (ctx: Maximize_standby_db_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.maximize_standby_db_clause`.
+     * @param ctx the parse tree
+     */
+    exitMaximize_standby_db_clause?: (ctx: Maximize_standby_db_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.register_logfile_clause`.
+     * @param ctx the parse tree
+     */
+    enterRegister_logfile_clause?: (ctx: Register_logfile_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.register_logfile_clause`.
+     * @param ctx the parse tree
+     */
+    exitRegister_logfile_clause?: (ctx: Register_logfile_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.commit_switchover_clause`.
+     * @param ctx the parse tree
+     */
+    enterCommit_switchover_clause?: (ctx: Commit_switchover_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.commit_switchover_clause`.
+     * @param ctx the parse tree
+     */
+    exitCommit_switchover_clause?: (ctx: Commit_switchover_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.start_standby_clause`.
+     * @param ctx the parse tree
+     */
+    enterStart_standby_clause?: (ctx: Start_standby_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.start_standby_clause`.
+     * @param ctx the parse tree
+     */
+    exitStart_standby_clause?: (ctx: Start_standby_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.stop_standby_clause`.
+     * @param ctx the parse tree
+     */
+    enterStop_standby_clause?: (ctx: Stop_standby_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.stop_standby_clause`.
+     * @param ctx the parse tree
+     */
+    exitStop_standby_clause?: (ctx: Stop_standby_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.convert_database_clause`.
+     * @param ctx the parse tree
+     */
+    enterConvert_database_clause?: (ctx: Convert_database_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.convert_database_clause`.
+     * @param ctx the parse tree
+     */
+    exitConvert_database_clause?: (ctx: Convert_database_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_settings_clause`.
+     * @param ctx the parse tree
+     */
+    enterDefault_settings_clause?: (ctx: Default_settings_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_settings_clause`.
+     * @param ctx the parse tree
+     */
+    exitDefault_settings_clause?: (ctx: Default_settings_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_time_zone_clause`.
+     * @param ctx the parse tree
+     */
+    enterSet_time_zone_clause?: (ctx: Set_time_zone_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_time_zone_clause`.
+     * @param ctx the parse tree
+     */
+    exitSet_time_zone_clause?: (ctx: Set_time_zone_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.instance_clauses`.
+     * @param ctx the parse tree
+     */
+    enterInstance_clauses?: (ctx: Instance_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.instance_clauses`.
+     * @param ctx the parse tree
+     */
+    exitInstance_clauses?: (ctx: Instance_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.security_clause`.
+     * @param ctx the parse tree
+     */
+    enterSecurity_clause?: (ctx: Security_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.security_clause`.
+     * @param ctx the parse tree
+     */
+    exitSecurity_clause?: (ctx: Security_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.domain`.
+     * @param ctx the parse tree
+     */
+    enterDomain?: (ctx: DomainContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.domain`.
+     * @param ctx the parse tree
+     */
+    exitDomain?: (ctx: DomainContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.database`.
+     * @param ctx the parse tree
+     */
+    enterDatabase?: (ctx: DatabaseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.database`.
+     * @param ctx the parse tree
+     */
+    exitDatabase?: (ctx: DatabaseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.edition_name`.
+     * @param ctx the parse tree
+     */
+    enterEdition_name?: (ctx: Edition_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.edition_name`.
+     * @param ctx the parse tree
+     */
+    exitEdition_name?: (ctx: Edition_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filenumber`.
+     * @param ctx the parse tree
+     */
+    enterFilenumber?: (ctx: FilenumberContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filenumber`.
+     * @param ctx the parse tree
+     */
+    exitFilenumber?: (ctx: FilenumberContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filename`.
+     * @param ctx the parse tree
+     */
+    enterFilename?: (ctx: FilenameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filename`.
+     * @param ctx the parse tree
+     */
+    exitFilename?: (ctx: FilenameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.prepare_clause`.
+     * @param ctx the parse tree
+     */
+    enterPrepare_clause?: (ctx: Prepare_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.prepare_clause`.
+     * @param ctx the parse tree
+     */
+    exitPrepare_clause?: (ctx: Prepare_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_mirror_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_mirror_clause?: (ctx: Drop_mirror_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_mirror_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_mirror_clause?: (ctx: Drop_mirror_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lost_write_protection`.
+     * @param ctx the parse tree
+     */
+    enterLost_write_protection?: (ctx: Lost_write_protectionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lost_write_protection`.
+     * @param ctx the parse tree
+     */
+    exitLost_write_protection?: (ctx: Lost_write_protectionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cdb_fleet_clauses`.
+     * @param ctx the parse tree
+     */
+    enterCdb_fleet_clauses?: (ctx: Cdb_fleet_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cdb_fleet_clauses`.
+     * @param ctx the parse tree
+     */
+    exitCdb_fleet_clauses?: (ctx: Cdb_fleet_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lead_cdb_clause`.
+     * @param ctx the parse tree
+     */
+    enterLead_cdb_clause?: (ctx: Lead_cdb_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lead_cdb_clause`.
+     * @param ctx the parse tree
+     */
+    exitLead_cdb_clause?: (ctx: Lead_cdb_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lead_cdb_uri_clause`.
+     * @param ctx the parse tree
+     */
+    enterLead_cdb_uri_clause?: (ctx: Lead_cdb_uri_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lead_cdb_uri_clause`.
+     * @param ctx the parse tree
+     */
+    exitLead_cdb_uri_clause?: (ctx: Lead_cdb_uri_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.property_clauses`.
+     * @param ctx the parse tree
+     */
+    enterProperty_clauses?: (ctx: Property_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.property_clauses`.
+     * @param ctx the parse tree
+     */
+    exitProperty_clauses?: (ctx: Property_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.replay_upgrade_clauses`.
+     * @param ctx the parse tree
+     */
+    enterReplay_upgrade_clauses?: (ctx: Replay_upgrade_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.replay_upgrade_clauses`.
+     * @param ctx the parse tree
+     */
+    exitReplay_upgrade_clauses?: (ctx: Replay_upgrade_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_database_link`.
+     * @param ctx the parse tree
+     */
+    enterAlter_database_link?: (ctx: Alter_database_linkContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_database_link`.
+     * @param ctx the parse tree
+     */
+    exitAlter_database_link?: (ctx: Alter_database_linkContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.password_value`.
+     * @param ctx the parse tree
+     */
+    enterPassword_value?: (ctx: Password_valueContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.password_value`.
+     * @param ctx the parse tree
+     */
+    exitPassword_value?: (ctx: Password_valueContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.link_authentication`.
+     * @param ctx the parse tree
+     */
+    enterLink_authentication?: (ctx: Link_authenticationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.link_authentication`.
+     * @param ctx the parse tree
+     */
+    exitLink_authentication?: (ctx: Link_authenticationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_schema`.
+     * @param ctx the parse tree
+     */
+    enterCreate_schema?: (ctx: Create_schemaContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_schema`.
+     * @param ctx the parse tree
+     */
+    exitCreate_schema?: (ctx: Create_schemaContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_database`.
+     * @param ctx the parse tree
+     */
+    enterCreate_database?: (ctx: Create_databaseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_database`.
+     * @param ctx the parse tree
+     */
+    exitCreate_database?: (ctx: Create_databaseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.database_logging_clauses`.
+     * @param ctx the parse tree
+     */
+    enterDatabase_logging_clauses?: (ctx: Database_logging_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.database_logging_clauses`.
+     * @param ctx the parse tree
+     */
+    exitDatabase_logging_clauses?: (ctx: Database_logging_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.database_logging_sub_clause`.
+     * @param ctx the parse tree
+     */
+    enterDatabase_logging_sub_clause?: (ctx: Database_logging_sub_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.database_logging_sub_clause`.
+     * @param ctx the parse tree
+     */
+    exitDatabase_logging_sub_clause?: (ctx: Database_logging_sub_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_clauses`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_clauses?: (ctx: Tablespace_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_clauses`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_clauses?: (ctx: Tablespace_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.enable_pluggable_database`.
+     * @param ctx the parse tree
+     */
+    enterEnable_pluggable_database?: (ctx: Enable_pluggable_databaseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.enable_pluggable_database`.
+     * @param ctx the parse tree
+     */
+    exitEnable_pluggable_database?: (ctx: Enable_pluggable_databaseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.file_name_convert`.
+     * @param ctx the parse tree
+     */
+    enterFile_name_convert?: (ctx: File_name_convertContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.file_name_convert`.
+     * @param ctx the parse tree
+     */
+    exitFile_name_convert?: (ctx: File_name_convertContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filename_convert_sub_clause`.
+     * @param ctx the parse tree
+     */
+    enterFilename_convert_sub_clause?: (ctx: Filename_convert_sub_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filename_convert_sub_clause`.
+     * @param ctx the parse tree
+     */
+    exitFilename_convert_sub_clause?: (ctx: Filename_convert_sub_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace_datafile_clauses`.
+     * @param ctx the parse tree
+     */
+    enterTablespace_datafile_clauses?: (ctx: Tablespace_datafile_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace_datafile_clauses`.
+     * @param ctx the parse tree
+     */
+    exitTablespace_datafile_clauses?: (ctx: Tablespace_datafile_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.undo_mode_clause`.
+     * @param ctx the parse tree
+     */
+    enterUndo_mode_clause?: (ctx: Undo_mode_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.undo_mode_clause`.
+     * @param ctx the parse tree
+     */
+    exitUndo_mode_clause?: (ctx: Undo_mode_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_tablespace`.
+     * @param ctx the parse tree
+     */
+    enterDefault_tablespace?: (ctx: Default_tablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_tablespace`.
+     * @param ctx the parse tree
+     */
+    exitDefault_tablespace?: (ctx: Default_tablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_temp_tablespace`.
+     * @param ctx the parse tree
+     */
+    enterDefault_temp_tablespace?: (ctx: Default_temp_tablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_temp_tablespace`.
+     * @param ctx the parse tree
+     */
+    exitDefault_temp_tablespace?: (ctx: Default_temp_tablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.undo_tablespace`.
+     * @param ctx the parse tree
+     */
+    enterUndo_tablespace?: (ctx: Undo_tablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.undo_tablespace`.
+     * @param ctx the parse tree
+     */
+    exitUndo_tablespace?: (ctx: Undo_tablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_database`.
+     * @param ctx the parse tree
+     */
+    enterDrop_database?: (ctx: Drop_databaseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_database`.
+     * @param ctx the parse tree
+     */
+    exitDrop_database?: (ctx: Drop_databaseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.create_database_link`.
+     * @param ctx the parse tree
+     */
+    enterCreate_database_link?: (ctx: Create_database_linkContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.create_database_link`.
+     * @param ctx the parse tree
+     */
+    exitCreate_database_link?: (ctx: Create_database_linkContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_database_link`.
+     * @param ctx the parse tree
+     */
+    enterDrop_database_link?: (ctx: Drop_database_linkContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_database_link`.
+     * @param ctx the parse tree
+     */
+    exitDrop_database_link?: (ctx: Drop_database_linkContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_tablespace_set`.
+     * @param ctx the parse tree
+     */
+    enterAlter_tablespace_set?: (ctx: Alter_tablespace_setContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_tablespace_set`.
+     * @param ctx the parse tree
+     */
+    exitAlter_tablespace_set?: (ctx: Alter_tablespace_setContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_tablespace_attrs`.
+     * @param ctx the parse tree
+     */
+    enterAlter_tablespace_attrs?: (ctx: Alter_tablespace_attrsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_tablespace_attrs`.
+     * @param ctx the parse tree
+     */
+    exitAlter_tablespace_attrs?: (ctx: Alter_tablespace_attrsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_tablespace_encryption`.
+     * @param ctx the parse tree
+     */
+    enterAlter_tablespace_encryption?: (ctx: Alter_tablespace_encryptionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_tablespace_encryption`.
+     * @param ctx the parse tree
+     */
+    exitAlter_tablespace_encryption?: (ctx: Alter_tablespace_encryptionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ts_file_name_convert`.
+     * @param ctx the parse tree
+     */
+    enterTs_file_name_convert?: (ctx: Ts_file_name_convertContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ts_file_name_convert`.
+     * @param ctx the parse tree
+     */
+    exitTs_file_name_convert?: (ctx: Ts_file_name_convertContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_role`.
+     * @param ctx the parse tree
+     */
+    enterAlter_role?: (ctx: Alter_roleContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_role`.
+     * @param ctx the parse tree
+     */
+    exitAlter_role?: (ctx: Alter_roleContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.role_identified_clause`.
+     * @param ctx the parse tree
+     */
+    enterRole_identified_clause?: (ctx: Role_identified_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.role_identified_clause`.
+     * @param ctx the parse tree
+     */
+    exitRole_identified_clause?: (ctx: Role_identified_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_table`.
+     * @param ctx the parse tree
+     */
+    enterAlter_table?: (ctx: Alter_tableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_table`.
+     * @param ctx the parse tree
+     */
+    exitAlter_table?: (ctx: Alter_tableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_table_body`.
+     * @param ctx the parse tree
+     */
+    enterAlter_table_body?: (ctx: Alter_table_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_table_body`.
+     * @param ctx the parse tree
+     */
+    exitAlter_table_body?: (ctx: Alter_table_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_table_action`.
+     * @param ctx the parse tree
+     */
+    enterAlter_table_action?: (ctx: Alter_table_actionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_table_action`.
+     * @param ctx the parse tree
+     */
+    exitAlter_table_action?: (ctx: Alter_table_actionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.enable_disable_clauses`.
+     * @param ctx the parse tree
+     */
+    enterEnable_disable_clauses?: (ctx: Enable_disable_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.enable_disable_clauses`.
+     * @param ctx the parse tree
+     */
+    exitEnable_disable_clauses?: (ctx: Enable_disable_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.memoptimize_read_write_clause`.
+     * @param ctx the parse tree
+     */
+    enterMemoptimize_read_write_clause?: (ctx: Memoptimize_read_write_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.memoptimize_read_write_clause`.
+     * @param ctx the parse tree
+     */
+    exitMemoptimize_read_write_clause?: (ctx: Memoptimize_read_write_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_table_properties`.
+     * @param ctx the parse tree
+     */
+    enterAlter_table_properties?: (ctx: Alter_table_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_table_properties`.
+     * @param ctx the parse tree
+     */
+    exitAlter_table_properties?: (ctx: Alter_table_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_table_partitioning`.
+     * @param ctx the parse tree
+     */
+    enterAlter_table_partitioning?: (ctx: Alter_table_partitioningContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_table_partitioning`.
+     * @param ctx the parse tree
+     */
+    exitAlter_table_partitioning?: (ctx: Alter_table_partitioningContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterAdd_table_partition?: (ctx: Add_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitAdd_table_partition?: (ctx: Add_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterDrop_table_partition?: (ctx: Drop_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitDrop_table_partition?: (ctx: Drop_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterMerge_table_partition?: (ctx: Merge_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitMerge_table_partition?: (ctx: Merge_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterModify_table_partition?: (ctx: Modify_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitModify_table_partition?: (ctx: Modify_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.split_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterSplit_table_partition?: (ctx: Split_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.split_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitSplit_table_partition?: (ctx: Split_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.truncate_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterTruncate_table_partition?: (ctx: Truncate_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.truncate_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitTruncate_table_partition?: (ctx: Truncate_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.exchange_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterExchange_table_partition?: (ctx: Exchange_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.exchange_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitExchange_table_partition?: (ctx: Exchange_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.coalesce_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterCoalesce_table_partition?: (ctx: Coalesce_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.coalesce_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitCoalesce_table_partition?: (ctx: Coalesce_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_interval_partition`.
+     * @param ctx the parse tree
+     */
+    enterAlter_interval_partition?: (ctx: Alter_interval_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_interval_partition`.
+     * @param ctx the parse tree
+     */
+    exitAlter_interval_partition?: (ctx: Alter_interval_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.move_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterMove_table_partition?: (ctx: Move_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.move_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitMove_table_partition?: (ctx: Move_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filter_condition`.
+     * @param ctx the parse tree
+     */
+    enterFilter_condition?: (ctx: Filter_conditionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filter_condition`.
+     * @param ctx the parse tree
+     */
+    exitFilter_condition?: (ctx: Filter_conditionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rename_table_partition`.
+     * @param ctx the parse tree
+     */
+    enterRename_table_partition?: (ctx: Rename_table_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rename_table_partition`.
+     * @param ctx the parse tree
+     */
+    exitRename_table_partition?: (ctx: Rename_table_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_extended_names`.
+     * @param ctx the parse tree
+     */
+    enterPartition_extended_names?: (ctx: Partition_extended_namesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_extended_names`.
+     * @param ctx the parse tree
+     */
+    exitPartition_extended_names?: (ctx: Partition_extended_namesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subpartition_extended_names`.
+     * @param ctx the parse tree
+     */
+    enterSubpartition_extended_names?: (ctx: Subpartition_extended_namesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subpartition_extended_names`.
+     * @param ctx the parse tree
+     */
+    exitSubpartition_extended_names?: (ctx: Subpartition_extended_namesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_table_properties_1`.
+     * @param ctx the parse tree
+     */
+    enterAlter_table_properties_1?: (ctx: Alter_table_properties_1Context) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_table_properties_1`.
+     * @param ctx the parse tree
+     */
+    exitAlter_table_properties_1?: (ctx: Alter_table_properties_1Context) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_iot_clauses`.
+     * @param ctx the parse tree
+     */
+    enterAlter_iot_clauses?: (ctx: Alter_iot_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_iot_clauses`.
+     * @param ctx the parse tree
+     */
+    exitAlter_iot_clauses?: (ctx: Alter_iot_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_mapping_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_mapping_table_clause?: (ctx: Alter_mapping_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_mapping_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_mapping_table_clause?: (ctx: Alter_mapping_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.alter_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    enterAlter_overflow_clause?: (ctx: Alter_overflow_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.alter_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    exitAlter_overflow_clause?: (ctx: Alter_overflow_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_overflow_clause?: (ctx: Add_overflow_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_overflow_clause?: (ctx: Add_overflow_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_index_clauses`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_index_clauses?: (ctx: Update_index_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_index_clauses`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_index_clauses?: (ctx: Update_index_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_global_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_global_index_clause?: (ctx: Update_global_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_global_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_global_index_clause?: (ctx: Update_global_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_all_indexes_clause`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_all_indexes_clause?: (ctx: Update_all_indexes_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_all_indexes_clause`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_all_indexes_clause?: (ctx: Update_all_indexes_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_all_indexes_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_all_indexes_index_clause?: (ctx: Update_all_indexes_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_all_indexes_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_all_indexes_index_clause?: (ctx: Update_all_indexes_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_index_partition`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_index_partition?: (ctx: Update_index_partitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_index_partition`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_index_partition?: (ctx: Update_index_partitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_index_subpartition`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_index_subpartition?: (ctx: Update_index_subpartitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_index_subpartition`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_index_subpartition?: (ctx: Update_index_subpartitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.enable_disable_clause`.
+     * @param ctx the parse tree
+     */
+    enterEnable_disable_clause?: (ctx: Enable_disable_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.enable_disable_clause`.
+     * @param ctx the parse tree
+     */
+    exitEnable_disable_clause?: (ctx: Enable_disable_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_index_clause`.
+     * @param ctx the parse tree
+     */
+    enterUsing_index_clause?: (ctx: Using_index_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_index_clause`.
+     * @param ctx the parse tree
+     */
+    exitUsing_index_clause?: (ctx: Using_index_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_attributes`.
+     * @param ctx the parse tree
+     */
+    enterIndex_attributes?: (ctx: Index_attributesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_attributes`.
+     * @param ctx the parse tree
+     */
+    exitIndex_attributes?: (ctx: Index_attributesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sort_or_nosort`.
+     * @param ctx the parse tree
+     */
+    enterSort_or_nosort?: (ctx: Sort_or_nosortContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sort_or_nosort`.
+     * @param ctx the parse tree
+     */
+    exitSort_or_nosort?: (ctx: Sort_or_nosortContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.exceptions_clause`.
+     * @param ctx the parse tree
+     */
+    enterExceptions_clause?: (ctx: Exceptions_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.exceptions_clause`.
+     * @param ctx the parse tree
+     */
+    exitExceptions_clause?: (ctx: Exceptions_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.move_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterMove_table_clause?: (ctx: Move_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.move_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitMove_table_clause?: (ctx: Move_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_to_partitioned`.
+     * @param ctx the parse tree
+     */
+    enterModify_to_partitioned?: (ctx: Modify_to_partitionedContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_to_partitioned`.
+     * @param ctx the parse tree
+     */
+    exitModify_to_partitioned?: (ctx: Modify_to_partitionedContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_org_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterIndex_org_table_clause?: (ctx: Index_org_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_org_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitIndex_org_table_clause?: (ctx: Index_org_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.mapping_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterMapping_table_clause?: (ctx: Mapping_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.mapping_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitMapping_table_clause?: (ctx: Mapping_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.key_compression`.
+     * @param ctx the parse tree
+     */
+    enterKey_compression?: (ctx: Key_compressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.key_compression`.
+     * @param ctx the parse tree
+     */
+    exitKey_compression?: (ctx: Key_compressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_org_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    enterIndex_org_overflow_clause?: (ctx: Index_org_overflow_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_org_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    exitIndex_org_overflow_clause?: (ctx: Index_org_overflow_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_clauses`.
+     * @param ctx the parse tree
+     */
+    enterColumn_clauses?: (ctx: Column_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_clauses`.
+     * @param ctx the parse tree
+     */
+    exitColumn_clauses?: (ctx: Column_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_collection_retrieval`.
+     * @param ctx the parse tree
+     */
+    enterModify_collection_retrieval?: (ctx: Modify_collection_retrievalContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_collection_retrieval`.
+     * @param ctx the parse tree
+     */
+    exitModify_collection_retrieval?: (ctx: Modify_collection_retrievalContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.collection_item`.
+     * @param ctx the parse tree
+     */
+    enterCollection_item?: (ctx: Collection_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.collection_item`.
+     * @param ctx the parse tree
+     */
+    exitCollection_item?: (ctx: Collection_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rename_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterRename_column_clause?: (ctx: Rename_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rename_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitRename_column_clause?: (ctx: Rename_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.old_column_name`.
+     * @param ctx the parse tree
+     */
+    enterOld_column_name?: (ctx: Old_column_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.old_column_name`.
+     * @param ctx the parse tree
+     */
+    exitOld_column_name?: (ctx: Old_column_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.new_column_name`.
+     * @param ctx the parse tree
+     */
+    enterNew_column_name?: (ctx: New_column_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.new_column_name`.
+     * @param ctx the parse tree
+     */
+    exitNew_column_name?: (ctx: New_column_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_modify_drop_column_clauses`.
+     * @param ctx the parse tree
+     */
+    enterAdd_modify_drop_column_clauses?: (ctx: Add_modify_drop_column_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_modify_drop_column_clauses`.
+     * @param ctx the parse tree
+     */
+    exitAdd_modify_drop_column_clauses?: (ctx: Add_modify_drop_column_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_column_clause?: (ctx: Drop_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_column_clause?: (ctx: Drop_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_column_clauses`.
+     * @param ctx the parse tree
+     */
+    enterModify_column_clauses?: (ctx: Modify_column_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_column_clauses`.
+     * @param ctx the parse tree
+     */
+    exitModify_column_clauses?: (ctx: Modify_column_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_col_properties`.
+     * @param ctx the parse tree
+     */
+    enterModify_col_properties?: (ctx: Modify_col_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_col_properties`.
+     * @param ctx the parse tree
+     */
+    exitModify_col_properties?: (ctx: Modify_col_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_col_visibility`.
+     * @param ctx the parse tree
+     */
+    enterModify_col_visibility?: (ctx: Modify_col_visibilityContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_col_visibility`.
+     * @param ctx the parse tree
+     */
+    exitModify_col_visibility?: (ctx: Modify_col_visibilityContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_col_substitutable`.
+     * @param ctx the parse tree
+     */
+    enterModify_col_substitutable?: (ctx: Modify_col_substitutableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_col_substitutable`.
+     * @param ctx the parse tree
+     */
+    exitModify_col_substitutable?: (ctx: Modify_col_substitutableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_column_clause?: (ctx: Add_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_column_clause?: (ctx: Add_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.varray_col_properties`.
+     * @param ctx the parse tree
+     */
+    enterVarray_col_properties?: (ctx: Varray_col_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.varray_col_properties`.
+     * @param ctx the parse tree
+     */
+    exitVarray_col_properties?: (ctx: Varray_col_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.varray_storage_clause`.
+     * @param ctx the parse tree
+     */
+    enterVarray_storage_clause?: (ctx: Varray_storage_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.varray_storage_clause`.
+     * @param ctx the parse tree
+     */
+    exitVarray_storage_clause?: (ctx: Varray_storage_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_segname`.
+     * @param ctx the parse tree
+     */
+    enterLob_segname?: (ctx: Lob_segnameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_segname`.
+     * @param ctx the parse tree
+     */
+    exitLob_segname?: (ctx: Lob_segnameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_item`.
+     * @param ctx the parse tree
+     */
+    enterLob_item?: (ctx: Lob_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_item`.
+     * @param ctx the parse tree
+     */
+    exitLob_item?: (ctx: Lob_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_storage_parameters`.
+     * @param ctx the parse tree
+     */
+    enterLob_storage_parameters?: (ctx: Lob_storage_parametersContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_storage_parameters`.
+     * @param ctx the parse tree
+     */
+    exitLob_storage_parameters?: (ctx: Lob_storage_parametersContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_storage_clause`.
+     * @param ctx the parse tree
+     */
+    enterLob_storage_clause?: (ctx: Lob_storage_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_storage_clause`.
+     * @param ctx the parse tree
+     */
+    exitLob_storage_clause?: (ctx: Lob_storage_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_lob_storage_clause`.
+     * @param ctx the parse tree
+     */
+    enterModify_lob_storage_clause?: (ctx: Modify_lob_storage_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_lob_storage_clause`.
+     * @param ctx the parse tree
+     */
+    exitModify_lob_storage_clause?: (ctx: Modify_lob_storage_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.modify_lob_parameters`.
+     * @param ctx the parse tree
+     */
+    enterModify_lob_parameters?: (ctx: Modify_lob_parametersContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.modify_lob_parameters`.
+     * @param ctx the parse tree
+     */
+    exitModify_lob_parameters?: (ctx: Modify_lob_parametersContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_parameters`.
+     * @param ctx the parse tree
+     */
+    enterLob_parameters?: (ctx: Lob_parametersContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_parameters`.
+     * @param ctx the parse tree
+     */
+    exitLob_parameters?: (ctx: Lob_parametersContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_deduplicate_clause`.
+     * @param ctx the parse tree
+     */
+    enterLob_deduplicate_clause?: (ctx: Lob_deduplicate_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_deduplicate_clause`.
+     * @param ctx the parse tree
+     */
+    exitLob_deduplicate_clause?: (ctx: Lob_deduplicate_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_compression_clause`.
+     * @param ctx the parse tree
+     */
+    enterLob_compression_clause?: (ctx: Lob_compression_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_compression_clause`.
+     * @param ctx the parse tree
+     */
+    exitLob_compression_clause?: (ctx: Lob_compression_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_retention_clause`.
+     * @param ctx the parse tree
+     */
+    enterLob_retention_clause?: (ctx: Lob_retention_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_retention_clause`.
+     * @param ctx the parse tree
+     */
+    exitLob_retention_clause?: (ctx: Lob_retention_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.encryption_spec`.
+     * @param ctx the parse tree
+     */
+    enterEncryption_spec?: (ctx: Encryption_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.encryption_spec`.
+     * @param ctx the parse tree
+     */
+    exitEncryption_spec?: (ctx: Encryption_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tablespace`.
+     * @param ctx the parse tree
+     */
+    enterTablespace?: (ctx: TablespaceContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tablespace`.
+     * @param ctx the parse tree
+     */
+    exitTablespace?: (ctx: TablespaceContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.varray_item`.
+     * @param ctx the parse tree
+     */
+    enterVarray_item?: (ctx: Varray_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.varray_item`.
+     * @param ctx the parse tree
+     */
+    exitVarray_item?: (ctx: Varray_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_properties`.
+     * @param ctx the parse tree
+     */
+    enterColumn_properties?: (ctx: Column_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_properties`.
+     * @param ctx the parse tree
+     */
+    exitColumn_properties?: (ctx: Column_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lob_partition_storage`.
+     * @param ctx the parse tree
+     */
+    enterLob_partition_storage?: (ctx: Lob_partition_storageContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lob_partition_storage`.
+     * @param ctx the parse tree
+     */
+    exitLob_partition_storage?: (ctx: Lob_partition_storageContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.period_definition`.
+     * @param ctx the parse tree
+     */
+    enterPeriod_definition?: (ctx: Period_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.period_definition`.
+     * @param ctx the parse tree
+     */
+    exitPeriod_definition?: (ctx: Period_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.start_time_column`.
+     * @param ctx the parse tree
+     */
+    enterStart_time_column?: (ctx: Start_time_columnContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.start_time_column`.
+     * @param ctx the parse tree
+     */
+    exitStart_time_column?: (ctx: Start_time_columnContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.end_time_column`.
+     * @param ctx the parse tree
+     */
+    enterEnd_time_column?: (ctx: End_time_columnContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.end_time_column`.
+     * @param ctx the parse tree
+     */
+    exitEnd_time_column?: (ctx: End_time_columnContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_definition`.
+     * @param ctx the parse tree
+     */
+    enterColumn_definition?: (ctx: Column_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_definition`.
+     * @param ctx the parse tree
+     */
+    exitColumn_definition?: (ctx: Column_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_collation_name`.
+     * @param ctx the parse tree
+     */
+    enterColumn_collation_name?: (ctx: Column_collation_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_collation_name`.
+     * @param ctx the parse tree
+     */
+    exitColumn_collation_name?: (ctx: Column_collation_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identity_clause`.
+     * @param ctx the parse tree
+     */
+    enterIdentity_clause?: (ctx: Identity_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identity_clause`.
+     * @param ctx the parse tree
+     */
+    exitIdentity_clause?: (ctx: Identity_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identity_options_parentheses`.
+     * @param ctx the parse tree
+     */
+    enterIdentity_options_parentheses?: (ctx: Identity_options_parenthesesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identity_options_parentheses`.
+     * @param ctx the parse tree
+     */
+    exitIdentity_options_parentheses?: (ctx: Identity_options_parenthesesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identity_options`.
+     * @param ctx the parse tree
+     */
+    enterIdentity_options?: (ctx: Identity_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identity_options`.
+     * @param ctx the parse tree
+     */
+    exitIdentity_options?: (ctx: Identity_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.virtual_column_definition`.
+     * @param ctx the parse tree
+     */
+    enterVirtual_column_definition?: (ctx: Virtual_column_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.virtual_column_definition`.
+     * @param ctx the parse tree
+     */
+    exitVirtual_column_definition?: (ctx: Virtual_column_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.virtual_column_expression`.
+     * @param ctx the parse tree
+     */
+    enterVirtual_column_expression?: (ctx: Virtual_column_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.virtual_column_expression`.
+     * @param ctx the parse tree
+     */
+    exitVirtual_column_expression?: (ctx: Virtual_column_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.autogenerated_sequence_definition`.
+     * @param ctx the parse tree
+     */
+    enterAutogenerated_sequence_definition?: (ctx: Autogenerated_sequence_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.autogenerated_sequence_definition`.
+     * @param ctx the parse tree
+     */
+    exitAutogenerated_sequence_definition?: (ctx: Autogenerated_sequence_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.by_user_for_statistics_clause`.
+     * @param ctx the parse tree
+     */
+    enterBy_user_for_statistics_clause?: (ctx: By_user_for_statistics_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.by_user_for_statistics_clause`.
+     * @param ctx the parse tree
+     */
+    exitBy_user_for_statistics_clause?: (ctx: By_user_for_statistics_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.evaluation_edition_clause`.
+     * @param ctx the parse tree
+     */
+    enterEvaluation_edition_clause?: (ctx: Evaluation_edition_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.evaluation_edition_clause`.
+     * @param ctx the parse tree
+     */
+    exitEvaluation_edition_clause?: (ctx: Evaluation_edition_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.nested_table_col_properties`.
+     * @param ctx the parse tree
+     */
+    enterNested_table_col_properties?: (ctx: Nested_table_col_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.nested_table_col_properties`.
+     * @param ctx the parse tree
+     */
+    exitNested_table_col_properties?: (ctx: Nested_table_col_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.nested_item`.
+     * @param ctx the parse tree
+     */
+    enterNested_item?: (ctx: Nested_itemContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.nested_item`.
+     * @param ctx the parse tree
+     */
+    exitNested_item?: (ctx: Nested_itemContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.substitutable_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterSubstitutable_column_clause?: (ctx: Substitutable_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.substitutable_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitSubstitutable_column_clause?: (ctx: Substitutable_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_name`.
+     * @param ctx the parse tree
+     */
+    enterPartition_name?: (ctx: Partition_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_name`.
+     * @param ctx the parse tree
+     */
+    exitPartition_name?: (ctx: Partition_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.supplemental_logging_props`.
+     * @param ctx the parse tree
+     */
+    enterSupplemental_logging_props?: (ctx: Supplemental_logging_propsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.supplemental_logging_props`.
+     * @param ctx the parse tree
+     */
+    exitSupplemental_logging_props?: (ctx: Supplemental_logging_propsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_type_col_properties`.
+     * @param ctx the parse tree
+     */
+    enterObject_type_col_properties?: (ctx: Object_type_col_propertiesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_type_col_properties`.
+     * @param ctx the parse tree
+     */
+    exitObject_type_col_properties?: (ctx: Object_type_col_propertiesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.constraint_clauses`.
+     * @param ctx the parse tree
+     */
+    enterConstraint_clauses?: (ctx: Constraint_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.constraint_clauses`.
+     * @param ctx the parse tree
+     */
+    exitConstraint_clauses?: (ctx: Constraint_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.old_constraint_name`.
+     * @param ctx the parse tree
+     */
+    enterOld_constraint_name?: (ctx: Old_constraint_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.old_constraint_name`.
+     * @param ctx the parse tree
+     */
+    exitOld_constraint_name?: (ctx: Old_constraint_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.new_constraint_name`.
+     * @param ctx the parse tree
+     */
+    enterNew_constraint_name?: (ctx: New_constraint_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.new_constraint_name`.
+     * @param ctx the parse tree
+     */
+    exitNew_constraint_name?: (ctx: New_constraint_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.drop_constraint_clause`.
+     * @param ctx the parse tree
+     */
+    enterDrop_constraint_clause?: (ctx: Drop_constraint_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.drop_constraint_clause`.
+     * @param ctx the parse tree
+     */
+    exitDrop_constraint_clause?: (ctx: Drop_constraint_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.check_constraint`.
+     * @param ctx the parse tree
+     */
+    enterCheck_constraint?: (ctx: Check_constraintContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.check_constraint`.
+     * @param ctx the parse tree
+     */
+    exitCheck_constraint?: (ctx: Check_constraintContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.foreign_key_clause`.
+     * @param ctx the parse tree
+     */
+    enterForeign_key_clause?: (ctx: Foreign_key_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.foreign_key_clause`.
+     * @param ctx the parse tree
+     */
+    exitForeign_key_clause?: (ctx: Foreign_key_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.references_clause`.
+     * @param ctx the parse tree
+     */
+    enterReferences_clause?: (ctx: References_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.references_clause`.
+     * @param ctx the parse tree
+     */
+    exitReferences_clause?: (ctx: References_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.on_delete_clause`.
+     * @param ctx the parse tree
+     */
+    enterOn_delete_clause?: (ctx: On_delete_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.on_delete_clause`.
+     * @param ctx the parse tree
+     */
+    exitOn_delete_clause?: (ctx: On_delete_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.anonymous_block`.
+     * @param ctx the parse tree
+     */
+    enterAnonymous_block?: (ctx: Anonymous_blockContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.anonymous_block`.
+     * @param ctx the parse tree
+     */
+    exitAnonymous_block?: (ctx: Anonymous_blockContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.invoker_rights_clause`.
+     * @param ctx the parse tree
+     */
+    enterInvoker_rights_clause?: (ctx: Invoker_rights_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.invoker_rights_clause`.
+     * @param ctx the parse tree
+     */
+    exitInvoker_rights_clause?: (ctx: Invoker_rights_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.call_spec`.
+     * @param ctx the parse tree
+     */
+    enterCall_spec?: (ctx: Call_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.call_spec`.
+     * @param ctx the parse tree
+     */
+    exitCall_spec?: (ctx: Call_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.java_spec`.
+     * @param ctx the parse tree
+     */
+    enterJava_spec?: (ctx: Java_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.java_spec`.
+     * @param ctx the parse tree
+     */
+    exitJava_spec?: (ctx: Java_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.c_spec`.
+     * @param ctx the parse tree
+     */
+    enterC_spec?: (ctx: C_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.c_spec`.
+     * @param ctx the parse tree
+     */
+    exitC_spec?: (ctx: C_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.c_agent_in_clause`.
+     * @param ctx the parse tree
+     */
+    enterC_agent_in_clause?: (ctx: C_agent_in_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.c_agent_in_clause`.
+     * @param ctx the parse tree
+     */
+    exitC_agent_in_clause?: (ctx: C_agent_in_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.c_parameters_clause`.
+     * @param ctx the parse tree
+     */
+    enterC_parameters_clause?: (ctx: C_parameters_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.c_parameters_clause`.
+     * @param ctx the parse tree
+     */
+    exitC_parameters_clause?: (ctx: C_parameters_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.c_external_parameter`.
+     * @param ctx the parse tree
+     */
+    enterC_external_parameter?: (ctx: C_external_parameterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.c_external_parameter`.
+     * @param ctx the parse tree
+     */
+    exitC_external_parameter?: (ctx: C_external_parameterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.c_property`.
+     * @param ctx the parse tree
+     */
+    enterC_property?: (ctx: C_propertyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.c_property`.
+     * @param ctx the parse tree
+     */
+    exitC_property?: (ctx: C_propertyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parameter`.
+     * @param ctx the parse tree
+     */
+    enterParameter?: (ctx: ParameterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parameter`.
+     * @param ctx the parse tree
+     */
+    exitParameter?: (ctx: ParameterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.default_value_part`.
+     * @param ctx the parse tree
+     */
+    enterDefault_value_part?: (ctx: Default_value_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.default_value_part`.
+     * @param ctx the parse tree
+     */
+    exitDefault_value_part?: (ctx: Default_value_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.seq_of_declare_specs`.
+     * @param ctx the parse tree
+     */
+    enterSeq_of_declare_specs?: (ctx: Seq_of_declare_specsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.seq_of_declare_specs`.
+     * @param ctx the parse tree
+     */
+    exitSeq_of_declare_specs?: (ctx: Seq_of_declare_specsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.declare_spec`.
+     * @param ctx the parse tree
+     */
+    enterDeclare_spec?: (ctx: Declare_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.declare_spec`.
+     * @param ctx the parse tree
+     */
+    exitDeclare_spec?: (ctx: Declare_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.variable_declaration`.
+     * @param ctx the parse tree
+     */
+    enterVariable_declaration?: (ctx: Variable_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.variable_declaration`.
+     * @param ctx the parse tree
+     */
+    exitVariable_declaration?: (ctx: Variable_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subtype_declaration`.
+     * @param ctx the parse tree
+     */
+    enterSubtype_declaration?: (ctx: Subtype_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subtype_declaration`.
+     * @param ctx the parse tree
+     */
+    exitSubtype_declaration?: (ctx: Subtype_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cursor_declaration`.
+     * @param ctx the parse tree
+     */
+    enterCursor_declaration?: (ctx: Cursor_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cursor_declaration`.
+     * @param ctx the parse tree
+     */
+    exitCursor_declaration?: (ctx: Cursor_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parameter_spec`.
+     * @param ctx the parse tree
+     */
+    enterParameter_spec?: (ctx: Parameter_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parameter_spec`.
+     * @param ctx the parse tree
+     */
+    exitParameter_spec?: (ctx: Parameter_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.exception_declaration`.
+     * @param ctx the parse tree
+     */
+    enterException_declaration?: (ctx: Exception_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.exception_declaration`.
+     * @param ctx the parse tree
+     */
+    exitException_declaration?: (ctx: Exception_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pragma_declaration`.
+     * @param ctx the parse tree
+     */
+    enterPragma_declaration?: (ctx: Pragma_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pragma_declaration`.
+     * @param ctx the parse tree
+     */
+    exitPragma_declaration?: (ctx: Pragma_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.record_type_def`.
+     * @param ctx the parse tree
+     */
+    enterRecord_type_def?: (ctx: Record_type_defContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.record_type_def`.
+     * @param ctx the parse tree
+     */
+    exitRecord_type_def?: (ctx: Record_type_defContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.field_spec`.
+     * @param ctx the parse tree
+     */
+    enterField_spec?: (ctx: Field_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.field_spec`.
+     * @param ctx the parse tree
+     */
+    exitField_spec?: (ctx: Field_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.ref_cursor_type_def`.
+     * @param ctx the parse tree
+     */
+    enterRef_cursor_type_def?: (ctx: Ref_cursor_type_defContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.ref_cursor_type_def`.
+     * @param ctx the parse tree
+     */
+    exitRef_cursor_type_def?: (ctx: Ref_cursor_type_defContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_declaration`.
+     * @param ctx the parse tree
+     */
+    enterType_declaration?: (ctx: Type_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_declaration`.
+     * @param ctx the parse tree
+     */
+    exitType_declaration?: (ctx: Type_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_type_def`.
+     * @param ctx the parse tree
+     */
+    enterTable_type_def?: (ctx: Table_type_defContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_type_def`.
+     * @param ctx the parse tree
+     */
+    exitTable_type_def?: (ctx: Table_type_defContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_indexed_by_part`.
+     * @param ctx the parse tree
+     */
+    enterTable_indexed_by_part?: (ctx: Table_indexed_by_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_indexed_by_part`.
+     * @param ctx the parse tree
+     */
+    exitTable_indexed_by_part?: (ctx: Table_indexed_by_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.varray_type_def`.
+     * @param ctx the parse tree
+     */
+    enterVarray_type_def?: (ctx: Varray_type_defContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.varray_type_def`.
+     * @param ctx the parse tree
+     */
+    exitVarray_type_def?: (ctx: Varray_type_defContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.seq_of_statements`.
+     * @param ctx the parse tree
+     */
+    enterSeq_of_statements?: (ctx: Seq_of_statementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.seq_of_statements`.
+     * @param ctx the parse tree
+     */
+    exitSeq_of_statements?: (ctx: Seq_of_statementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.label_declaration`.
+     * @param ctx the parse tree
+     */
+    enterLabel_declaration?: (ctx: Label_declarationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.label_declaration`.
+     * @param ctx the parse tree
+     */
+    exitLabel_declaration?: (ctx: Label_declarationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.statement`.
+     * @param ctx the parse tree
+     */
+    enterStatement?: (ctx: StatementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.statement`.
+     * @param ctx the parse tree
+     */
+    exitStatement?: (ctx: StatementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.assignment_statement`.
+     * @param ctx the parse tree
+     */
+    enterAssignment_statement?: (ctx: Assignment_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.assignment_statement`.
+     * @param ctx the parse tree
+     */
+    exitAssignment_statement?: (ctx: Assignment_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.continue_statement`.
+     * @param ctx the parse tree
+     */
+    enterContinue_statement?: (ctx: Continue_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.continue_statement`.
+     * @param ctx the parse tree
+     */
+    exitContinue_statement?: (ctx: Continue_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.exit_statement`.
+     * @param ctx the parse tree
+     */
+    enterExit_statement?: (ctx: Exit_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.exit_statement`.
+     * @param ctx the parse tree
+     */
+    exitExit_statement?: (ctx: Exit_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.goto_statement`.
+     * @param ctx the parse tree
+     */
+    enterGoto_statement?: (ctx: Goto_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.goto_statement`.
+     * @param ctx the parse tree
+     */
+    exitGoto_statement?: (ctx: Goto_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.if_statement`.
+     * @param ctx the parse tree
+     */
+    enterIf_statement?: (ctx: If_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.if_statement`.
+     * @param ctx the parse tree
+     */
+    exitIf_statement?: (ctx: If_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.elsif_part`.
+     * @param ctx the parse tree
+     */
+    enterElsif_part?: (ctx: Elsif_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.elsif_part`.
+     * @param ctx the parse tree
+     */
+    exitElsif_part?: (ctx: Elsif_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.else_part`.
+     * @param ctx the parse tree
+     */
+    enterElse_part?: (ctx: Else_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.else_part`.
+     * @param ctx the parse tree
+     */
+    exitElse_part?: (ctx: Else_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.loop_statement`.
+     * @param ctx the parse tree
+     */
+    enterLoop_statement?: (ctx: Loop_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.loop_statement`.
+     * @param ctx the parse tree
+     */
+    exitLoop_statement?: (ctx: Loop_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cursor_loop_param`.
+     * @param ctx the parse tree
+     */
+    enterCursor_loop_param?: (ctx: Cursor_loop_paramContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cursor_loop_param`.
+     * @param ctx the parse tree
+     */
+    exitCursor_loop_param?: (ctx: Cursor_loop_paramContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.forall_statement`.
+     * @param ctx the parse tree
+     */
+    enterForall_statement?: (ctx: Forall_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.forall_statement`.
+     * @param ctx the parse tree
+     */
+    exitForall_statement?: (ctx: Forall_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.bounds_clause`.
+     * @param ctx the parse tree
+     */
+    enterBounds_clause?: (ctx: Bounds_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.bounds_clause`.
+     * @param ctx the parse tree
+     */
+    exitBounds_clause?: (ctx: Bounds_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.between_bound`.
+     * @param ctx the parse tree
+     */
+    enterBetween_bound?: (ctx: Between_boundContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.between_bound`.
+     * @param ctx the parse tree
+     */
+    exitBetween_bound?: (ctx: Between_boundContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lower_bound`.
+     * @param ctx the parse tree
+     */
+    enterLower_bound?: (ctx: Lower_boundContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lower_bound`.
+     * @param ctx the parse tree
+     */
+    exitLower_bound?: (ctx: Lower_boundContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.upper_bound`.
+     * @param ctx the parse tree
+     */
+    enterUpper_bound?: (ctx: Upper_boundContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.upper_bound`.
+     * @param ctx the parse tree
+     */
+    exitUpper_bound?: (ctx: Upper_boundContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.null_statement`.
+     * @param ctx the parse tree
+     */
+    enterNull_statement?: (ctx: Null_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.null_statement`.
+     * @param ctx the parse tree
+     */
+    exitNull_statement?: (ctx: Null_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.raise_statement`.
+     * @param ctx the parse tree
+     */
+    enterRaise_statement?: (ctx: Raise_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.raise_statement`.
+     * @param ctx the parse tree
+     */
+    exitRaise_statement?: (ctx: Raise_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.return_statement`.
+     * @param ctx the parse tree
+     */
+    enterReturn_statement?: (ctx: Return_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.return_statement`.
+     * @param ctx the parse tree
+     */
+    exitReturn_statement?: (ctx: Return_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.call_statement`.
+     * @param ctx the parse tree
+     */
+    enterCall_statement?: (ctx: Call_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.call_statement`.
+     * @param ctx the parse tree
+     */
+    exitCall_statement?: (ctx: Call_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pipe_row_statement`.
+     * @param ctx the parse tree
+     */
+    enterPipe_row_statement?: (ctx: Pipe_row_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pipe_row_statement`.
+     * @param ctx the parse tree
+     */
+    exitPipe_row_statement?: (ctx: Pipe_row_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.selection_directive`.
+     * @param ctx the parse tree
+     */
+    enterSelection_directive?: (ctx: Selection_directiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.selection_directive`.
+     * @param ctx the parse tree
+     */
+    exitSelection_directive?: (ctx: Selection_directiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.error_directive`.
+     * @param ctx the parse tree
+     */
+    enterError_directive?: (ctx: Error_directiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.error_directive`.
+     * @param ctx the parse tree
+     */
+    exitError_directive?: (ctx: Error_directiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.selection_directive_body`.
+     * @param ctx the parse tree
+     */
+    enterSelection_directive_body?: (ctx: Selection_directive_bodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.selection_directive_body`.
+     * @param ctx the parse tree
+     */
+    exitSelection_directive_body?: (ctx: Selection_directive_bodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.body`.
+     * @param ctx the parse tree
+     */
+    enterBody?: (ctx: BodyContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.body`.
+     * @param ctx the parse tree
+     */
+    exitBody?: (ctx: BodyContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.exception_handler`.
+     * @param ctx the parse tree
+     */
+    enterException_handler?: (ctx: Exception_handlerContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.exception_handler`.
+     * @param ctx the parse tree
+     */
+    exitException_handler?: (ctx: Exception_handlerContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.trigger_block`.
+     * @param ctx the parse tree
+     */
+    enterTrigger_block?: (ctx: Trigger_blockContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.trigger_block`.
+     * @param ctx the parse tree
+     */
+    exitTrigger_block?: (ctx: Trigger_blockContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tps_block`.
+     * @param ctx the parse tree
+     */
+    enterTps_block?: (ctx: Tps_blockContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tps_block`.
+     * @param ctx the parse tree
+     */
+    exitTps_block?: (ctx: Tps_blockContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.block`.
+     * @param ctx the parse tree
+     */
+    enterBlock?: (ctx: BlockContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.block`.
+     * @param ctx the parse tree
+     */
+    exitBlock?: (ctx: BlockContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_statement`.
+     * @param ctx the parse tree
+     */
+    enterSql_statement?: (ctx: Sql_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_statement`.
+     * @param ctx the parse tree
+     */
+    exitSql_statement?: (ctx: Sql_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.execute_immediate`.
+     * @param ctx the parse tree
+     */
+    enterExecute_immediate?: (ctx: Execute_immediateContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.execute_immediate`.
+     * @param ctx the parse tree
+     */
+    exitExecute_immediate?: (ctx: Execute_immediateContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dynamic_returning_clause`.
+     * @param ctx the parse tree
+     */
+    enterDynamic_returning_clause?: (ctx: Dynamic_returning_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dynamic_returning_clause`.
+     * @param ctx the parse tree
+     */
+    exitDynamic_returning_clause?: (ctx: Dynamic_returning_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.data_manipulation_language_statements`.
+     * @param ctx the parse tree
+     */
+    enterData_manipulation_language_statements?: (ctx: Data_manipulation_language_statementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.data_manipulation_language_statements`.
+     * @param ctx the parse tree
+     */
+    exitData_manipulation_language_statements?: (ctx: Data_manipulation_language_statementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cursor_manipulation_statements`.
+     * @param ctx the parse tree
+     */
+    enterCursor_manipulation_statements?: (ctx: Cursor_manipulation_statementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cursor_manipulation_statements`.
+     * @param ctx the parse tree
+     */
+    exitCursor_manipulation_statements?: (ctx: Cursor_manipulation_statementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.close_statement`.
+     * @param ctx the parse tree
+     */
+    enterClose_statement?: (ctx: Close_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.close_statement`.
+     * @param ctx the parse tree
+     */
+    exitClose_statement?: (ctx: Close_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.open_statement`.
+     * @param ctx the parse tree
+     */
+    enterOpen_statement?: (ctx: Open_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.open_statement`.
+     * @param ctx the parse tree
+     */
+    exitOpen_statement?: (ctx: Open_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.fetch_statement`.
+     * @param ctx the parse tree
+     */
+    enterFetch_statement?: (ctx: Fetch_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.fetch_statement`.
+     * @param ctx the parse tree
+     */
+    exitFetch_statement?: (ctx: Fetch_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.variable_or_collection`.
+     * @param ctx the parse tree
+     */
+    enterVariable_or_collection?: (ctx: Variable_or_collectionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.variable_or_collection`.
+     * @param ctx the parse tree
+     */
+    exitVariable_or_collection?: (ctx: Variable_or_collectionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.open_for_statement`.
+     * @param ctx the parse tree
+     */
+    enterOpen_for_statement?: (ctx: Open_for_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.open_for_statement`.
+     * @param ctx the parse tree
+     */
+    exitOpen_for_statement?: (ctx: Open_for_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.transaction_control_statements`.
+     * @param ctx the parse tree
+     */
+    enterTransaction_control_statements?: (ctx: Transaction_control_statementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.transaction_control_statements`.
+     * @param ctx the parse tree
+     */
+    exitTransaction_control_statements?: (ctx: Transaction_control_statementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_transaction_command`.
+     * @param ctx the parse tree
+     */
+    enterSet_transaction_command?: (ctx: Set_transaction_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_transaction_command`.
+     * @param ctx the parse tree
+     */
+    exitSet_transaction_command?: (ctx: Set_transaction_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_constraint_command`.
+     * @param ctx the parse tree
+     */
+    enterSet_constraint_command?: (ctx: Set_constraint_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_constraint_command`.
+     * @param ctx the parse tree
+     */
+    exitSet_constraint_command?: (ctx: Set_constraint_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.commit_statement`.
+     * @param ctx the parse tree
+     */
+    enterCommit_statement?: (ctx: Commit_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.commit_statement`.
+     * @param ctx the parse tree
+     */
+    exitCommit_statement?: (ctx: Commit_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.write_clause`.
+     * @param ctx the parse tree
+     */
+    enterWrite_clause?: (ctx: Write_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.write_clause`.
+     * @param ctx the parse tree
+     */
+    exitWrite_clause?: (ctx: Write_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rollback_statement`.
+     * @param ctx the parse tree
+     */
+    enterRollback_statement?: (ctx: Rollback_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rollback_statement`.
+     * @param ctx the parse tree
+     */
+    exitRollback_statement?: (ctx: Rollback_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.savepoint_statement`.
+     * @param ctx the parse tree
+     */
+    enterSavepoint_statement?: (ctx: Savepoint_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.savepoint_statement`.
+     * @param ctx the parse tree
+     */
+    exitSavepoint_statement?: (ctx: Savepoint_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.collection_method_call`.
+     * @param ctx the parse tree
+     */
+    enterCollection_method_call?: (ctx: Collection_method_callContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.collection_method_call`.
+     * @param ctx the parse tree
+     */
+    exitCollection_method_call?: (ctx: Collection_method_callContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.explain_statement`.
+     * @param ctx the parse tree
+     */
+    enterExplain_statement?: (ctx: Explain_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.explain_statement`.
+     * @param ctx the parse tree
+     */
+    exitExplain_statement?: (ctx: Explain_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.select_only_statement`.
+     * @param ctx the parse tree
+     */
+    enterSelect_only_statement?: (ctx: Select_only_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.select_only_statement`.
+     * @param ctx the parse tree
+     */
+    exitSelect_only_statement?: (ctx: Select_only_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.select_statement`.
+     * @param ctx the parse tree
+     */
+    enterSelect_statement?: (ctx: Select_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.select_statement`.
+     * @param ctx the parse tree
+     */
+    exitSelect_statement?: (ctx: Select_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.with_clause`.
+     * @param ctx the parse tree
+     */
+    enterWith_clause?: (ctx: With_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.with_clause`.
+     * @param ctx the parse tree
+     */
+    exitWith_clause?: (ctx: With_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.with_factoring_clause`.
+     * @param ctx the parse tree
+     */
+    enterWith_factoring_clause?: (ctx: With_factoring_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.with_factoring_clause`.
+     * @param ctx the parse tree
+     */
+    exitWith_factoring_clause?: (ctx: With_factoring_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subquery_factoring_clause`.
+     * @param ctx the parse tree
+     */
+    enterSubquery_factoring_clause?: (ctx: Subquery_factoring_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subquery_factoring_clause`.
+     * @param ctx the parse tree
+     */
+    exitSubquery_factoring_clause?: (ctx: Subquery_factoring_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.search_clause`.
+     * @param ctx the parse tree
+     */
+    enterSearch_clause?: (ctx: Search_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.search_clause`.
+     * @param ctx the parse tree
+     */
+    exitSearch_clause?: (ctx: Search_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cycle_clause`.
+     * @param ctx the parse tree
+     */
+    enterCycle_clause?: (ctx: Cycle_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cycle_clause`.
+     * @param ctx the parse tree
+     */
+    exitCycle_clause?: (ctx: Cycle_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subav_factoring_clause`.
+     * @param ctx the parse tree
+     */
+    enterSubav_factoring_clause?: (ctx: Subav_factoring_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subav_factoring_clause`.
+     * @param ctx the parse tree
+     */
+    exitSubav_factoring_clause?: (ctx: Subav_factoring_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subav_clause`.
+     * @param ctx the parse tree
+     */
+    enterSubav_clause?: (ctx: Subav_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subav_clause`.
+     * @param ctx the parse tree
+     */
+    exitSubav_clause?: (ctx: Subav_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hierarchies_clause`.
+     * @param ctx the parse tree
+     */
+    enterHierarchies_clause?: (ctx: Hierarchies_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hierarchies_clause`.
+     * @param ctx the parse tree
+     */
+    exitHierarchies_clause?: (ctx: Hierarchies_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filter_clauses`.
+     * @param ctx the parse tree
+     */
+    enterFilter_clauses?: (ctx: Filter_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filter_clauses`.
+     * @param ctx the parse tree
+     */
+    exitFilter_clauses?: (ctx: Filter_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.filter_clause`.
+     * @param ctx the parse tree
+     */
+    enterFilter_clause?: (ctx: Filter_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.filter_clause`.
+     * @param ctx the parse tree
+     */
+    exitFilter_clause?: (ctx: Filter_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_calcs_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_calcs_clause?: (ctx: Add_calcs_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_calcs_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_calcs_clause?: (ctx: Add_calcs_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.add_calc_meas_clause`.
+     * @param ctx the parse tree
+     */
+    enterAdd_calc_meas_clause?: (ctx: Add_calc_meas_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.add_calc_meas_clause`.
+     * @param ctx the parse tree
+     */
+    exitAdd_calc_meas_clause?: (ctx: Add_calc_meas_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subquery`.
+     * @param ctx the parse tree
+     */
+    enterSubquery?: (ctx: SubqueryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subquery`.
+     * @param ctx the parse tree
+     */
+    exitSubquery?: (ctx: SubqueryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subquery_no_with`.
+     * @param ctx the parse tree
+     */
+    enterSubquery_no_with?: (ctx: Subquery_no_withContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subquery_no_with`.
+     * @param ctx the parse tree
+     */
+    exitSubquery_no_with?: (ctx: Subquery_no_withContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subquery_basic_elements`.
+     * @param ctx the parse tree
+     */
+    enterSubquery_basic_elements?: (ctx: Subquery_basic_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subquery_basic_elements`.
+     * @param ctx the parse tree
+     */
+    exitSubquery_basic_elements?: (ctx: Subquery_basic_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subquery_operation_part`.
+     * @param ctx the parse tree
+     */
+    enterSubquery_operation_part?: (ctx: Subquery_operation_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subquery_operation_part`.
+     * @param ctx the parse tree
+     */
+    exitSubquery_operation_part?: (ctx: Subquery_operation_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.query_block`.
+     * @param ctx the parse tree
+     */
+    enterQuery_block?: (ctx: Query_blockContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.query_block`.
+     * @param ctx the parse tree
+     */
+    exitQuery_block?: (ctx: Query_blockContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.selected_list`.
+     * @param ctx the parse tree
+     */
+    enterSelected_list?: (ctx: Selected_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.selected_list`.
+     * @param ctx the parse tree
+     */
+    exitSelected_list?: (ctx: Selected_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.from_clause`.
+     * @param ctx the parse tree
+     */
+    enterFrom_clause?: (ctx: From_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.from_clause`.
+     * @param ctx the parse tree
+     */
+    exitFrom_clause?: (ctx: From_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.select_list_elements`.
+     * @param ctx the parse tree
+     */
+    enterSelect_list_elements?: (ctx: Select_list_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.select_list_elements`.
+     * @param ctx the parse tree
+     */
+    exitSelect_list_elements?: (ctx: Select_list_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_ref_list`.
+     * @param ctx the parse tree
+     */
+    enterTable_ref_list?: (ctx: Table_ref_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_ref_list`.
+     * @param ctx the parse tree
+     */
+    exitTable_ref_list?: (ctx: Table_ref_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_ref`.
+     * @param ctx the parse tree
+     */
+    enterTable_ref?: (ctx: Table_refContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_ref`.
+     * @param ctx the parse tree
+     */
+    exitTable_ref?: (ctx: Table_refContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_ref_aux`.
+     * @param ctx the parse tree
+     */
+    enterTable_ref_aux?: (ctx: Table_ref_auxContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_ref_aux`.
+     * @param ctx the parse tree
+     */
+    exitTable_ref_aux?: (ctx: Table_ref_auxContext) => void;
+    /**
+     * Enter a parse tree produced by the `table_ref_aux_internal_one`
+     * labeled alternative in `PlSqlParser.table_ref_aux_internal`.
+     * @param ctx the parse tree
+     */
+    enterTable_ref_aux_internal_one?: (ctx: Table_ref_aux_internal_oneContext) => void;
+    /**
+     * Exit a parse tree produced by the `table_ref_aux_internal_one`
+     * labeled alternative in `PlSqlParser.table_ref_aux_internal`.
+     * @param ctx the parse tree
+     */
+    exitTable_ref_aux_internal_one?: (ctx: Table_ref_aux_internal_oneContext) => void;
+    /**
+     * Enter a parse tree produced by the `table_ref_aux_internal_two`
+     * labeled alternative in `PlSqlParser.table_ref_aux_internal`.
+     * @param ctx the parse tree
+     */
+    enterTable_ref_aux_internal_two?: (ctx: Table_ref_aux_internal_twoContext) => void;
+    /**
+     * Exit a parse tree produced by the `table_ref_aux_internal_two`
+     * labeled alternative in `PlSqlParser.table_ref_aux_internal`.
+     * @param ctx the parse tree
+     */
+    exitTable_ref_aux_internal_two?: (ctx: Table_ref_aux_internal_twoContext) => void;
+    /**
+     * Enter a parse tree produced by the `table_ref_aux_internal_thre`
+     * labeled alternative in `PlSqlParser.table_ref_aux_internal`.
+     * @param ctx the parse tree
+     */
+    enterTable_ref_aux_internal_thre?: (ctx: Table_ref_aux_internal_threContext) => void;
+    /**
+     * Exit a parse tree produced by the `table_ref_aux_internal_thre`
+     * labeled alternative in `PlSqlParser.table_ref_aux_internal`.
+     * @param ctx the parse tree
+     */
+    exitTable_ref_aux_internal_thre?: (ctx: Table_ref_aux_internal_threContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.join_clause`.
+     * @param ctx the parse tree
+     */
+    enterJoin_clause?: (ctx: Join_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.join_clause`.
+     * @param ctx the parse tree
+     */
+    exitJoin_clause?: (ctx: Join_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.join_on_part`.
+     * @param ctx the parse tree
+     */
+    enterJoin_on_part?: (ctx: Join_on_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.join_on_part`.
+     * @param ctx the parse tree
+     */
+    exitJoin_on_part?: (ctx: Join_on_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.join_using_part`.
+     * @param ctx the parse tree
+     */
+    enterJoin_using_part?: (ctx: Join_using_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.join_using_part`.
+     * @param ctx the parse tree
+     */
+    exitJoin_using_part?: (ctx: Join_using_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.outer_join_type`.
+     * @param ctx the parse tree
+     */
+    enterOuter_join_type?: (ctx: Outer_join_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.outer_join_type`.
+     * @param ctx the parse tree
+     */
+    exitOuter_join_type?: (ctx: Outer_join_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.query_partition_clause`.
+     * @param ctx the parse tree
+     */
+    enterQuery_partition_clause?: (ctx: Query_partition_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.query_partition_clause`.
+     * @param ctx the parse tree
+     */
+    exitQuery_partition_clause?: (ctx: Query_partition_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.flashback_query_clause`.
+     * @param ctx the parse tree
+     */
+    enterFlashback_query_clause?: (ctx: Flashback_query_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.flashback_query_clause`.
+     * @param ctx the parse tree
+     */
+    exitFlashback_query_clause?: (ctx: Flashback_query_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pivot_clause`.
+     * @param ctx the parse tree
+     */
+    enterPivot_clause?: (ctx: Pivot_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pivot_clause`.
+     * @param ctx the parse tree
+     */
+    exitPivot_clause?: (ctx: Pivot_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pivot_element`.
+     * @param ctx the parse tree
+     */
+    enterPivot_element?: (ctx: Pivot_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pivot_element`.
+     * @param ctx the parse tree
+     */
+    exitPivot_element?: (ctx: Pivot_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pivot_for_clause`.
+     * @param ctx the parse tree
+     */
+    enterPivot_for_clause?: (ctx: Pivot_for_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pivot_for_clause`.
+     * @param ctx the parse tree
+     */
+    exitPivot_for_clause?: (ctx: Pivot_for_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pivot_in_clause`.
+     * @param ctx the parse tree
+     */
+    enterPivot_in_clause?: (ctx: Pivot_in_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pivot_in_clause`.
+     * @param ctx the parse tree
+     */
+    exitPivot_in_clause?: (ctx: Pivot_in_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pivot_in_clause_element`.
+     * @param ctx the parse tree
+     */
+    enterPivot_in_clause_element?: (ctx: Pivot_in_clause_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pivot_in_clause_element`.
+     * @param ctx the parse tree
+     */
+    exitPivot_in_clause_element?: (ctx: Pivot_in_clause_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.pivot_in_clause_elements`.
+     * @param ctx the parse tree
+     */
+    enterPivot_in_clause_elements?: (ctx: Pivot_in_clause_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.pivot_in_clause_elements`.
+     * @param ctx the parse tree
+     */
+    exitPivot_in_clause_elements?: (ctx: Pivot_in_clause_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unpivot_clause`.
+     * @param ctx the parse tree
+     */
+    enterUnpivot_clause?: (ctx: Unpivot_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unpivot_clause`.
+     * @param ctx the parse tree
+     */
+    exitUnpivot_clause?: (ctx: Unpivot_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unpivot_in_clause`.
+     * @param ctx the parse tree
+     */
+    enterUnpivot_in_clause?: (ctx: Unpivot_in_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unpivot_in_clause`.
+     * @param ctx the parse tree
+     */
+    exitUnpivot_in_clause?: (ctx: Unpivot_in_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unpivot_in_elements`.
+     * @param ctx the parse tree
+     */
+    enterUnpivot_in_elements?: (ctx: Unpivot_in_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unpivot_in_elements`.
+     * @param ctx the parse tree
+     */
+    exitUnpivot_in_elements?: (ctx: Unpivot_in_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.hierarchical_query_clause`.
+     * @param ctx the parse tree
+     */
+    enterHierarchical_query_clause?: (ctx: Hierarchical_query_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.hierarchical_query_clause`.
+     * @param ctx the parse tree
+     */
+    exitHierarchical_query_clause?: (ctx: Hierarchical_query_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.start_part`.
+     * @param ctx the parse tree
+     */
+    enterStart_part?: (ctx: Start_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.start_part`.
+     * @param ctx the parse tree
+     */
+    exitStart_part?: (ctx: Start_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.group_by_clause`.
+     * @param ctx the parse tree
+     */
+    enterGroup_by_clause?: (ctx: Group_by_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.group_by_clause`.
+     * @param ctx the parse tree
+     */
+    exitGroup_by_clause?: (ctx: Group_by_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.group_by_elements`.
+     * @param ctx the parse tree
+     */
+    enterGroup_by_elements?: (ctx: Group_by_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.group_by_elements`.
+     * @param ctx the parse tree
+     */
+    exitGroup_by_elements?: (ctx: Group_by_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rollup_cube_clause`.
+     * @param ctx the parse tree
+     */
+    enterRollup_cube_clause?: (ctx: Rollup_cube_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rollup_cube_clause`.
+     * @param ctx the parse tree
+     */
+    exitRollup_cube_clause?: (ctx: Rollup_cube_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.grouping_sets_clause`.
+     * @param ctx the parse tree
+     */
+    enterGrouping_sets_clause?: (ctx: Grouping_sets_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.grouping_sets_clause`.
+     * @param ctx the parse tree
+     */
+    exitGrouping_sets_clause?: (ctx: Grouping_sets_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.grouping_sets_elements`.
+     * @param ctx the parse tree
+     */
+    enterGrouping_sets_elements?: (ctx: Grouping_sets_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.grouping_sets_elements`.
+     * @param ctx the parse tree
+     */
+    exitGrouping_sets_elements?: (ctx: Grouping_sets_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.having_clause`.
+     * @param ctx the parse tree
+     */
+    enterHaving_clause?: (ctx: Having_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.having_clause`.
+     * @param ctx the parse tree
+     */
+    exitHaving_clause?: (ctx: Having_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_clause`.
+     * @param ctx the parse tree
+     */
+    enterModel_clause?: (ctx: Model_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_clause`.
+     * @param ctx the parse tree
+     */
+    exitModel_clause?: (ctx: Model_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cell_reference_options`.
+     * @param ctx the parse tree
+     */
+    enterCell_reference_options?: (ctx: Cell_reference_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cell_reference_options`.
+     * @param ctx the parse tree
+     */
+    exitCell_reference_options?: (ctx: Cell_reference_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.return_rows_clause`.
+     * @param ctx the parse tree
+     */
+    enterReturn_rows_clause?: (ctx: Return_rows_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.return_rows_clause`.
+     * @param ctx the parse tree
+     */
+    exitReturn_rows_clause?: (ctx: Return_rows_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.reference_model`.
+     * @param ctx the parse tree
+     */
+    enterReference_model?: (ctx: Reference_modelContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.reference_model`.
+     * @param ctx the parse tree
+     */
+    exitReference_model?: (ctx: Reference_modelContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.main_model`.
+     * @param ctx the parse tree
+     */
+    enterMain_model?: (ctx: Main_modelContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.main_model`.
+     * @param ctx the parse tree
+     */
+    exitMain_model?: (ctx: Main_modelContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_column_clauses`.
+     * @param ctx the parse tree
+     */
+    enterModel_column_clauses?: (ctx: Model_column_clausesContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_column_clauses`.
+     * @param ctx the parse tree
+     */
+    exitModel_column_clauses?: (ctx: Model_column_clausesContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_column_partition_part`.
+     * @param ctx the parse tree
+     */
+    enterModel_column_partition_part?: (ctx: Model_column_partition_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_column_partition_part`.
+     * @param ctx the parse tree
+     */
+    exitModel_column_partition_part?: (ctx: Model_column_partition_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_column_list`.
+     * @param ctx the parse tree
+     */
+    enterModel_column_list?: (ctx: Model_column_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_column_list`.
+     * @param ctx the parse tree
+     */
+    exitModel_column_list?: (ctx: Model_column_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_column`.
+     * @param ctx the parse tree
+     */
+    enterModel_column?: (ctx: Model_columnContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_column`.
+     * @param ctx the parse tree
+     */
+    exitModel_column?: (ctx: Model_columnContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_rules_clause`.
+     * @param ctx the parse tree
+     */
+    enterModel_rules_clause?: (ctx: Model_rules_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_rules_clause`.
+     * @param ctx the parse tree
+     */
+    exitModel_rules_clause?: (ctx: Model_rules_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_rules_part`.
+     * @param ctx the parse tree
+     */
+    enterModel_rules_part?: (ctx: Model_rules_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_rules_part`.
+     * @param ctx the parse tree
+     */
+    exitModel_rules_part?: (ctx: Model_rules_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_rules_element`.
+     * @param ctx the parse tree
+     */
+    enterModel_rules_element?: (ctx: Model_rules_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_rules_element`.
+     * @param ctx the parse tree
+     */
+    exitModel_rules_element?: (ctx: Model_rules_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cell_assignment`.
+     * @param ctx the parse tree
+     */
+    enterCell_assignment?: (ctx: Cell_assignmentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cell_assignment`.
+     * @param ctx the parse tree
+     */
+    exitCell_assignment?: (ctx: Cell_assignmentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_iterate_clause`.
+     * @param ctx the parse tree
+     */
+    enterModel_iterate_clause?: (ctx: Model_iterate_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_iterate_clause`.
+     * @param ctx the parse tree
+     */
+    exitModel_iterate_clause?: (ctx: Model_iterate_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.until_part`.
+     * @param ctx the parse tree
+     */
+    enterUntil_part?: (ctx: Until_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.until_part`.
+     * @param ctx the parse tree
+     */
+    exitUntil_part?: (ctx: Until_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.order_by_clause`.
+     * @param ctx the parse tree
+     */
+    enterOrder_by_clause?: (ctx: Order_by_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.order_by_clause`.
+     * @param ctx the parse tree
+     */
+    exitOrder_by_clause?: (ctx: Order_by_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.order_by_elements`.
+     * @param ctx the parse tree
+     */
+    enterOrder_by_elements?: (ctx: Order_by_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.order_by_elements`.
+     * @param ctx the parse tree
+     */
+    exitOrder_by_elements?: (ctx: Order_by_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.offset_clause`.
+     * @param ctx the parse tree
+     */
+    enterOffset_clause?: (ctx: Offset_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.offset_clause`.
+     * @param ctx the parse tree
+     */
+    exitOffset_clause?: (ctx: Offset_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.fetch_clause`.
+     * @param ctx the parse tree
+     */
+    enterFetch_clause?: (ctx: Fetch_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.fetch_clause`.
+     * @param ctx the parse tree
+     */
+    exitFetch_clause?: (ctx: Fetch_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.for_update_clause`.
+     * @param ctx the parse tree
+     */
+    enterFor_update_clause?: (ctx: For_update_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.for_update_clause`.
+     * @param ctx the parse tree
+     */
+    exitFor_update_clause?: (ctx: For_update_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.for_update_of_part`.
+     * @param ctx the parse tree
+     */
+    enterFor_update_of_part?: (ctx: For_update_of_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.for_update_of_part`.
+     * @param ctx the parse tree
+     */
+    exitFor_update_of_part?: (ctx: For_update_of_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.for_update_options`.
+     * @param ctx the parse tree
+     */
+    enterFor_update_options?: (ctx: For_update_optionsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.for_update_options`.
+     * @param ctx the parse tree
+     */
+    exitFor_update_options?: (ctx: For_update_optionsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_statement`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_statement?: (ctx: Update_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_statement`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_statement?: (ctx: Update_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.update_set_clause`.
+     * @param ctx the parse tree
+     */
+    enterUpdate_set_clause?: (ctx: Update_set_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.update_set_clause`.
+     * @param ctx the parse tree
+     */
+    exitUpdate_set_clause?: (ctx: Update_set_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_based_update_set_clause`.
+     * @param ctx the parse tree
+     */
+    enterColumn_based_update_set_clause?: (ctx: Column_based_update_set_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_based_update_set_clause`.
+     * @param ctx the parse tree
+     */
+    exitColumn_based_update_set_clause?: (ctx: Column_based_update_set_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.delete_statement`.
+     * @param ctx the parse tree
+     */
+    enterDelete_statement?: (ctx: Delete_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.delete_statement`.
+     * @param ctx the parse tree
+     */
+    exitDelete_statement?: (ctx: Delete_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.insert_statement`.
+     * @param ctx the parse tree
+     */
+    enterInsert_statement?: (ctx: Insert_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.insert_statement`.
+     * @param ctx the parse tree
+     */
+    exitInsert_statement?: (ctx: Insert_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.single_table_insert`.
+     * @param ctx the parse tree
+     */
+    enterSingle_table_insert?: (ctx: Single_table_insertContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.single_table_insert`.
+     * @param ctx the parse tree
+     */
+    exitSingle_table_insert?: (ctx: Single_table_insertContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.multi_table_insert`.
+     * @param ctx the parse tree
+     */
+    enterMulti_table_insert?: (ctx: Multi_table_insertContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.multi_table_insert`.
+     * @param ctx the parse tree
+     */
+    exitMulti_table_insert?: (ctx: Multi_table_insertContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.multi_table_element`.
+     * @param ctx the parse tree
+     */
+    enterMulti_table_element?: (ctx: Multi_table_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.multi_table_element`.
+     * @param ctx the parse tree
+     */
+    exitMulti_table_element?: (ctx: Multi_table_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.conditional_insert_clause`.
+     * @param ctx the parse tree
+     */
+    enterConditional_insert_clause?: (ctx: Conditional_insert_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.conditional_insert_clause`.
+     * @param ctx the parse tree
+     */
+    exitConditional_insert_clause?: (ctx: Conditional_insert_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.conditional_insert_when_part`.
+     * @param ctx the parse tree
+     */
+    enterConditional_insert_when_part?: (ctx: Conditional_insert_when_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.conditional_insert_when_part`.
+     * @param ctx the parse tree
+     */
+    exitConditional_insert_when_part?: (ctx: Conditional_insert_when_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.conditional_insert_else_part`.
+     * @param ctx the parse tree
+     */
+    enterConditional_insert_else_part?: (ctx: Conditional_insert_else_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.conditional_insert_else_part`.
+     * @param ctx the parse tree
+     */
+    exitConditional_insert_else_part?: (ctx: Conditional_insert_else_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.insert_into_clause`.
+     * @param ctx the parse tree
+     */
+    enterInsert_into_clause?: (ctx: Insert_into_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.insert_into_clause`.
+     * @param ctx the parse tree
+     */
+    exitInsert_into_clause?: (ctx: Insert_into_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.values_clause`.
+     * @param ctx the parse tree
+     */
+    enterValues_clause?: (ctx: Values_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.values_clause`.
+     * @param ctx the parse tree
+     */
+    exitValues_clause?: (ctx: Values_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_statement`.
+     * @param ctx the parse tree
+     */
+    enterMerge_statement?: (ctx: Merge_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_statement`.
+     * @param ctx the parse tree
+     */
+    exitMerge_statement?: (ctx: Merge_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_update_clause`.
+     * @param ctx the parse tree
+     */
+    enterMerge_update_clause?: (ctx: Merge_update_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_update_clause`.
+     * @param ctx the parse tree
+     */
+    exitMerge_update_clause?: (ctx: Merge_update_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_element`.
+     * @param ctx the parse tree
+     */
+    enterMerge_element?: (ctx: Merge_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_element`.
+     * @param ctx the parse tree
+     */
+    exitMerge_element?: (ctx: Merge_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_update_delete_part`.
+     * @param ctx the parse tree
+     */
+    enterMerge_update_delete_part?: (ctx: Merge_update_delete_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_update_delete_part`.
+     * @param ctx the parse tree
+     */
+    exitMerge_update_delete_part?: (ctx: Merge_update_delete_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.merge_insert_clause`.
+     * @param ctx the parse tree
+     */
+    enterMerge_insert_clause?: (ctx: Merge_insert_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.merge_insert_clause`.
+     * @param ctx the parse tree
+     */
+    exitMerge_insert_clause?: (ctx: Merge_insert_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.selected_tableview`.
+     * @param ctx the parse tree
+     */
+    enterSelected_tableview?: (ctx: Selected_tableviewContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.selected_tableview`.
+     * @param ctx the parse tree
+     */
+    exitSelected_tableview?: (ctx: Selected_tableviewContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lock_table_statement`.
+     * @param ctx the parse tree
+     */
+    enterLock_table_statement?: (ctx: Lock_table_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lock_table_statement`.
+     * @param ctx the parse tree
+     */
+    exitLock_table_statement?: (ctx: Lock_table_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.wait_nowait_part`.
+     * @param ctx the parse tree
+     */
+    enterWait_nowait_part?: (ctx: Wait_nowait_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.wait_nowait_part`.
+     * @param ctx the parse tree
+     */
+    exitWait_nowait_part?: (ctx: Wait_nowait_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lock_table_element`.
+     * @param ctx the parse tree
+     */
+    enterLock_table_element?: (ctx: Lock_table_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lock_table_element`.
+     * @param ctx the parse tree
+     */
+    exitLock_table_element?: (ctx: Lock_table_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.lock_mode`.
+     * @param ctx the parse tree
+     */
+    enterLock_mode?: (ctx: Lock_modeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.lock_mode`.
+     * @param ctx the parse tree
+     */
+    exitLock_mode?: (ctx: Lock_modeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.general_table_ref`.
+     * @param ctx the parse tree
+     */
+    enterGeneral_table_ref?: (ctx: General_table_refContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.general_table_ref`.
+     * @param ctx the parse tree
+     */
+    exitGeneral_table_ref?: (ctx: General_table_refContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.static_returning_clause`.
+     * @param ctx the parse tree
+     */
+    enterStatic_returning_clause?: (ctx: Static_returning_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.static_returning_clause`.
+     * @param ctx the parse tree
+     */
+    exitStatic_returning_clause?: (ctx: Static_returning_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.error_logging_clause`.
+     * @param ctx the parse tree
+     */
+    enterError_logging_clause?: (ctx: Error_logging_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.error_logging_clause`.
+     * @param ctx the parse tree
+     */
+    exitError_logging_clause?: (ctx: Error_logging_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.error_logging_into_part`.
+     * @param ctx the parse tree
+     */
+    enterError_logging_into_part?: (ctx: Error_logging_into_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.error_logging_into_part`.
+     * @param ctx the parse tree
+     */
+    exitError_logging_into_part?: (ctx: Error_logging_into_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.error_logging_reject_part`.
+     * @param ctx the parse tree
+     */
+    enterError_logging_reject_part?: (ctx: Error_logging_reject_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.error_logging_reject_part`.
+     * @param ctx the parse tree
+     */
+    exitError_logging_reject_part?: (ctx: Error_logging_reject_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dml_table_expression_clause`.
+     * @param ctx the parse tree
+     */
+    enterDml_table_expression_clause?: (ctx: Dml_table_expression_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dml_table_expression_clause`.
+     * @param ctx the parse tree
+     */
+    exitDml_table_expression_clause?: (ctx: Dml_table_expression_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_collection_expression`.
+     * @param ctx the parse tree
+     */
+    enterTable_collection_expression?: (ctx: Table_collection_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_collection_expression`.
+     * @param ctx the parse tree
+     */
+    exitTable_collection_expression?: (ctx: Table_collection_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.subquery_restriction_clause`.
+     * @param ctx the parse tree
+     */
+    enterSubquery_restriction_clause?: (ctx: Subquery_restriction_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.subquery_restriction_clause`.
+     * @param ctx the parse tree
+     */
+    exitSubquery_restriction_clause?: (ctx: Subquery_restriction_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sample_clause`.
+     * @param ctx the parse tree
+     */
+    enterSample_clause?: (ctx: Sample_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sample_clause`.
+     * @param ctx the parse tree
+     */
+    exitSample_clause?: (ctx: Sample_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.seed_part`.
+     * @param ctx the parse tree
+     */
+    enterSeed_part?: (ctx: Seed_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.seed_part`.
+     * @param ctx the parse tree
+     */
+    exitSeed_part?: (ctx: Seed_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.condition`.
+     * @param ctx the parse tree
+     */
+    enterCondition?: (ctx: ConditionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.condition`.
+     * @param ctx the parse tree
+     */
+    exitCondition?: (ctx: ConditionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.expressions_`.
+     * @param ctx the parse tree
+     */
+    enterExpressions_?: (ctx: Expressions_Context) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.expressions_`.
+     * @param ctx the parse tree
+     */
+    exitExpressions_?: (ctx: Expressions_Context) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.expression`.
+     * @param ctx the parse tree
+     */
+    enterExpression?: (ctx: ExpressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.expression`.
+     * @param ctx the parse tree
+     */
+    exitExpression?: (ctx: ExpressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cursor_expression`.
+     * @param ctx the parse tree
+     */
+    enterCursor_expression?: (ctx: Cursor_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cursor_expression`.
+     * @param ctx the parse tree
+     */
+    exitCursor_expression?: (ctx: Cursor_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logical_expression`.
+     * @param ctx the parse tree
+     */
+    enterLogical_expression?: (ctx: Logical_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logical_expression`.
+     * @param ctx the parse tree
+     */
+    exitLogical_expression?: (ctx: Logical_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unary_logical_expression`.
+     * @param ctx the parse tree
+     */
+    enterUnary_logical_expression?: (ctx: Unary_logical_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unary_logical_expression`.
+     * @param ctx the parse tree
+     */
+    exitUnary_logical_expression?: (ctx: Unary_logical_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unary_logical_operation`.
+     * @param ctx the parse tree
+     */
+    enterUnary_logical_operation?: (ctx: Unary_logical_operationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unary_logical_operation`.
+     * @param ctx the parse tree
+     */
+    exitUnary_logical_operation?: (ctx: Unary_logical_operationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.logical_operation`.
+     * @param ctx the parse tree
+     */
+    enterLogical_operation?: (ctx: Logical_operationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.logical_operation`.
+     * @param ctx the parse tree
+     */
+    exitLogical_operation?: (ctx: Logical_operationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.multiset_expression`.
+     * @param ctx the parse tree
+     */
+    enterMultiset_expression?: (ctx: Multiset_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.multiset_expression`.
+     * @param ctx the parse tree
+     */
+    exitMultiset_expression?: (ctx: Multiset_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relational_expression`.
+     * @param ctx the parse tree
+     */
+    enterRelational_expression?: (ctx: Relational_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relational_expression`.
+     * @param ctx the parse tree
+     */
+    exitRelational_expression?: (ctx: Relational_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.compound_expression`.
+     * @param ctx the parse tree
+     */
+    enterCompound_expression?: (ctx: Compound_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.compound_expression`.
+     * @param ctx the parse tree
+     */
+    exitCompound_expression?: (ctx: Compound_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.relational_operator`.
+     * @param ctx the parse tree
+     */
+    enterRelational_operator?: (ctx: Relational_operatorContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.relational_operator`.
+     * @param ctx the parse tree
+     */
+    exitRelational_operator?: (ctx: Relational_operatorContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.in_elements`.
+     * @param ctx the parse tree
+     */
+    enterIn_elements?: (ctx: In_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.in_elements`.
+     * @param ctx the parse tree
+     */
+    exitIn_elements?: (ctx: In_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.between_elements`.
+     * @param ctx the parse tree
+     */
+    enterBetween_elements?: (ctx: Between_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.between_elements`.
+     * @param ctx the parse tree
+     */
+    exitBetween_elements?: (ctx: Between_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.concatenation`.
+     * @param ctx the parse tree
+     */
+    enterConcatenation?: (ctx: ConcatenationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.concatenation`.
+     * @param ctx the parse tree
+     */
+    exitConcatenation?: (ctx: ConcatenationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.interval_expression`.
+     * @param ctx the parse tree
+     */
+    enterInterval_expression?: (ctx: Interval_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.interval_expression`.
+     * @param ctx the parse tree
+     */
+    exitInterval_expression?: (ctx: Interval_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_expression`.
+     * @param ctx the parse tree
+     */
+    enterModel_expression?: (ctx: Model_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_expression`.
+     * @param ctx the parse tree
+     */
+    exitModel_expression?: (ctx: Model_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.model_expression_element`.
+     * @param ctx the parse tree
+     */
+    enterModel_expression_element?: (ctx: Model_expression_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.model_expression_element`.
+     * @param ctx the parse tree
+     */
+    exitModel_expression_element?: (ctx: Model_expression_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.single_column_for_loop`.
+     * @param ctx the parse tree
+     */
+    enterSingle_column_for_loop?: (ctx: Single_column_for_loopContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.single_column_for_loop`.
+     * @param ctx the parse tree
+     */
+    exitSingle_column_for_loop?: (ctx: Single_column_for_loopContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.multi_column_for_loop`.
+     * @param ctx the parse tree
+     */
+    enterMulti_column_for_loop?: (ctx: Multi_column_for_loopContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.multi_column_for_loop`.
+     * @param ctx the parse tree
+     */
+    exitMulti_column_for_loop?: (ctx: Multi_column_for_loopContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unary_expression`.
+     * @param ctx the parse tree
+     */
+    enterUnary_expression?: (ctx: Unary_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unary_expression`.
+     * @param ctx the parse tree
+     */
+    exitUnary_expression?: (ctx: Unary_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.unary_expression_core`.
+     * @param ctx the parse tree
+     */
+    enterUnary_expression_core?: (ctx: Unary_expression_coreContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.unary_expression_core`.
+     * @param ctx the parse tree
+     */
+    exitUnary_expression_core?: (ctx: Unary_expression_coreContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.selection_directive_expression`.
+     * @param ctx the parse tree
+     */
+    enterSelection_directive_expression?: (ctx: Selection_directive_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.selection_directive_expression`.
+     * @param ctx the parse tree
+     */
+    exitSelection_directive_expression?: (ctx: Selection_directive_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.implicit_cursor_expression`.
+     * @param ctx the parse tree
+     */
+    enterImplicit_cursor_expression?: (ctx: Implicit_cursor_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.implicit_cursor_expression`.
+     * @param ctx the parse tree
+     */
+    exitImplicit_cursor_expression?: (ctx: Implicit_cursor_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.collection_expression`.
+     * @param ctx the parse tree
+     */
+    enterCollection_expression?: (ctx: Collection_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.collection_expression`.
+     * @param ctx the parse tree
+     */
+    exitCollection_expression?: (ctx: Collection_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.case_statement`.
+     * @param ctx the parse tree
+     */
+    enterCase_statement?: (ctx: Case_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.case_statement`.
+     * @param ctx the parse tree
+     */
+    exitCase_statement?: (ctx: Case_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.simple_case_statement`.
+     * @param ctx the parse tree
+     */
+    enterSimple_case_statement?: (ctx: Simple_case_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.simple_case_statement`.
+     * @param ctx the parse tree
+     */
+    exitSimple_case_statement?: (ctx: Simple_case_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.searched_case_statement`.
+     * @param ctx the parse tree
+     */
+    enterSearched_case_statement?: (ctx: Searched_case_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.searched_case_statement`.
+     * @param ctx the parse tree
+     */
+    exitSearched_case_statement?: (ctx: Searched_case_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.case_when_part_statement`.
+     * @param ctx the parse tree
+     */
+    enterCase_when_part_statement?: (ctx: Case_when_part_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.case_when_part_statement`.
+     * @param ctx the parse tree
+     */
+    exitCase_when_part_statement?: (ctx: Case_when_part_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.case_else_part_statement`.
+     * @param ctx the parse tree
+     */
+    enterCase_else_part_statement?: (ctx: Case_else_part_statementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.case_else_part_statement`.
+     * @param ctx the parse tree
+     */
+    exitCase_else_part_statement?: (ctx: Case_else_part_statementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.case_expression`.
+     * @param ctx the parse tree
+     */
+    enterCase_expression?: (ctx: Case_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.case_expression`.
+     * @param ctx the parse tree
+     */
+    exitCase_expression?: (ctx: Case_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.simple_case_expression`.
+     * @param ctx the parse tree
+     */
+    enterSimple_case_expression?: (ctx: Simple_case_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.simple_case_expression`.
+     * @param ctx the parse tree
+     */
+    exitSimple_case_expression?: (ctx: Simple_case_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.searched_case_expression`.
+     * @param ctx the parse tree
+     */
+    enterSearched_case_expression?: (ctx: Searched_case_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.searched_case_expression`.
+     * @param ctx the parse tree
+     */
+    exitSearched_case_expression?: (ctx: Searched_case_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.case_when_part_expression`.
+     * @param ctx the parse tree
+     */
+    enterCase_when_part_expression?: (ctx: Case_when_part_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.case_when_part_expression`.
+     * @param ctx the parse tree
+     */
+    exitCase_when_part_expression?: (ctx: Case_when_part_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.case_else_part_expression`.
+     * @param ctx the parse tree
+     */
+    enterCase_else_part_expression?: (ctx: Case_else_part_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.case_else_part_expression`.
+     * @param ctx the parse tree
+     */
+    exitCase_else_part_expression?: (ctx: Case_else_part_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.atom`.
+     * @param ctx the parse tree
+     */
+    enterAtom?: (ctx: AtomContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.atom`.
+     * @param ctx the parse tree
+     */
+    exitAtom?: (ctx: AtomContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.quantified_expression`.
+     * @param ctx the parse tree
+     */
+    enterQuantified_expression?: (ctx: Quantified_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.quantified_expression`.
+     * @param ctx the parse tree
+     */
+    exitQuantified_expression?: (ctx: Quantified_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.string_function`.
+     * @param ctx the parse tree
+     */
+    enterString_function?: (ctx: String_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.string_function`.
+     * @param ctx the parse tree
+     */
+    exitString_function?: (ctx: String_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.standard_function`.
+     * @param ctx the parse tree
+     */
+    enterStandard_function?: (ctx: Standard_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.standard_function`.
+     * @param ctx the parse tree
+     */
+    exitStandard_function?: (ctx: Standard_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_function`.
+     * @param ctx the parse tree
+     */
+    enterJson_function?: (ctx: Json_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_function`.
+     * @param ctx the parse tree
+     */
+    exitJson_function?: (ctx: Json_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_object_content`.
+     * @param ctx the parse tree
+     */
+    enterJson_object_content?: (ctx: Json_object_contentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_object_content`.
+     * @param ctx the parse tree
+     */
+    exitJson_object_content?: (ctx: Json_object_contentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_object_entry`.
+     * @param ctx the parse tree
+     */
+    enterJson_object_entry?: (ctx: Json_object_entryContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_object_entry`.
+     * @param ctx the parse tree
+     */
+    exitJson_object_entry?: (ctx: Json_object_entryContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_table_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_table_clause?: (ctx: Json_table_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_table_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_table_clause?: (ctx: Json_table_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_array_element`.
+     * @param ctx the parse tree
+     */
+    enterJson_array_element?: (ctx: Json_array_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_array_element`.
+     * @param ctx the parse tree
+     */
+    exitJson_array_element?: (ctx: Json_array_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_on_null_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_on_null_clause?: (ctx: Json_on_null_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_on_null_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_on_null_clause?: (ctx: Json_on_null_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_return_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_return_clause?: (ctx: Json_return_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_return_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_return_clause?: (ctx: Json_return_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_transform_op`.
+     * @param ctx the parse tree
+     */
+    enterJson_transform_op?: (ctx: Json_transform_opContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_transform_op`.
+     * @param ctx the parse tree
+     */
+    exitJson_transform_op?: (ctx: Json_transform_opContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_column_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_column_clause?: (ctx: Json_column_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_column_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_column_clause?: (ctx: Json_column_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_column_definition`.
+     * @param ctx the parse tree
+     */
+    enterJson_column_definition?: (ctx: Json_column_definitionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_column_definition`.
+     * @param ctx the parse tree
+     */
+    exitJson_column_definition?: (ctx: Json_column_definitionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_query_returning_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_query_returning_clause?: (ctx: Json_query_returning_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_query_returning_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_query_returning_clause?: (ctx: Json_query_returning_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_query_return_type`.
+     * @param ctx the parse tree
+     */
+    enterJson_query_return_type?: (ctx: Json_query_return_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_query_return_type`.
+     * @param ctx the parse tree
+     */
+    exitJson_query_return_type?: (ctx: Json_query_return_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_query_wrapper_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_query_wrapper_clause?: (ctx: Json_query_wrapper_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_query_wrapper_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_query_wrapper_clause?: (ctx: Json_query_wrapper_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_query_on_error_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_query_on_error_clause?: (ctx: Json_query_on_error_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_query_on_error_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_query_on_error_clause?: (ctx: Json_query_on_error_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_query_on_empty_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_query_on_empty_clause?: (ctx: Json_query_on_empty_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_query_on_empty_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_query_on_empty_clause?: (ctx: Json_query_on_empty_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_value_return_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_value_return_clause?: (ctx: Json_value_return_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_value_return_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_value_return_clause?: (ctx: Json_value_return_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_value_return_type`.
+     * @param ctx the parse tree
+     */
+    enterJson_value_return_type?: (ctx: Json_value_return_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_value_return_type`.
+     * @param ctx the parse tree
+     */
+    exitJson_value_return_type?: (ctx: Json_value_return_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.json_value_on_mismatch_clause`.
+     * @param ctx the parse tree
+     */
+    enterJson_value_on_mismatch_clause?: (ctx: Json_value_on_mismatch_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.json_value_on_mismatch_clause`.
+     * @param ctx the parse tree
+     */
+    exitJson_value_on_mismatch_clause?: (ctx: Json_value_on_mismatch_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.literal`.
+     * @param ctx the parse tree
+     */
+    enterLiteral?: (ctx: LiteralContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.literal`.
+     * @param ctx the parse tree
+     */
+    exitLiteral?: (ctx: LiteralContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.numeric_function_wrapper`.
+     * @param ctx the parse tree
+     */
+    enterNumeric_function_wrapper?: (ctx: Numeric_function_wrapperContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.numeric_function_wrapper`.
+     * @param ctx the parse tree
+     */
+    exitNumeric_function_wrapper?: (ctx: Numeric_function_wrapperContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.numeric_function`.
+     * @param ctx the parse tree
+     */
+    enterNumeric_function?: (ctx: Numeric_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.numeric_function`.
+     * @param ctx the parse tree
+     */
+    exitNumeric_function?: (ctx: Numeric_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.listagg_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    enterListagg_overflow_clause?: (ctx: Listagg_overflow_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.listagg_overflow_clause`.
+     * @param ctx the parse tree
+     */
+    exitListagg_overflow_clause?: (ctx: Listagg_overflow_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.other_function`.
+     * @param ctx the parse tree
+     */
+    enterOther_function?: (ctx: Other_functionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.other_function`.
+     * @param ctx the parse tree
+     */
+    exitOther_function?: (ctx: Other_functionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.over_clause_keyword`.
+     * @param ctx the parse tree
+     */
+    enterOver_clause_keyword?: (ctx: Over_clause_keywordContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.over_clause_keyword`.
+     * @param ctx the parse tree
+     */
+    exitOver_clause_keyword?: (ctx: Over_clause_keywordContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.within_or_over_clause_keyword`.
+     * @param ctx the parse tree
+     */
+    enterWithin_or_over_clause_keyword?: (ctx: Within_or_over_clause_keywordContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.within_or_over_clause_keyword`.
+     * @param ctx the parse tree
+     */
+    exitWithin_or_over_clause_keyword?: (ctx: Within_or_over_clause_keywordContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.standard_prediction_function_keyword`.
+     * @param ctx the parse tree
+     */
+    enterStandard_prediction_function_keyword?: (ctx: Standard_prediction_function_keywordContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.standard_prediction_function_keyword`.
+     * @param ctx the parse tree
+     */
+    exitStandard_prediction_function_keyword?: (ctx: Standard_prediction_function_keywordContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.over_clause`.
+     * @param ctx the parse tree
+     */
+    enterOver_clause?: (ctx: Over_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.over_clause`.
+     * @param ctx the parse tree
+     */
+    exitOver_clause?: (ctx: Over_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.windowing_clause`.
+     * @param ctx the parse tree
+     */
+    enterWindowing_clause?: (ctx: Windowing_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.windowing_clause`.
+     * @param ctx the parse tree
+     */
+    exitWindowing_clause?: (ctx: Windowing_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.windowing_type`.
+     * @param ctx the parse tree
+     */
+    enterWindowing_type?: (ctx: Windowing_typeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.windowing_type`.
+     * @param ctx the parse tree
+     */
+    exitWindowing_type?: (ctx: Windowing_typeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.windowing_elements`.
+     * @param ctx the parse tree
+     */
+    enterWindowing_elements?: (ctx: Windowing_elementsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.windowing_elements`.
+     * @param ctx the parse tree
+     */
+    exitWindowing_elements?: (ctx: Windowing_elementsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_clause`.
+     * @param ctx the parse tree
+     */
+    enterUsing_clause?: (ctx: Using_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_clause`.
+     * @param ctx the parse tree
+     */
+    exitUsing_clause?: (ctx: Using_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.using_element`.
+     * @param ctx the parse tree
+     */
+    enterUsing_element?: (ctx: Using_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.using_element`.
+     * @param ctx the parse tree
+     */
+    exitUsing_element?: (ctx: Using_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.assignable_element`.
+     * @param ctx the parse tree
+     */
+    enterAssignable_element?: (ctx: Assignable_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.assignable_element`.
+     * @param ctx the parse tree
+     */
+    exitAssignable_element?: (ctx: Assignable_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.collect_order_by_part`.
+     * @param ctx the parse tree
+     */
+    enterCollect_order_by_part?: (ctx: Collect_order_by_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.collect_order_by_part`.
+     * @param ctx the parse tree
+     */
+    exitCollect_order_by_part?: (ctx: Collect_order_by_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.within_or_over_part`.
+     * @param ctx the parse tree
+     */
+    enterWithin_or_over_part?: (ctx: Within_or_over_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.within_or_over_part`.
+     * @param ctx the parse tree
+     */
+    exitWithin_or_over_part?: (ctx: Within_or_over_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.string_delimiter`.
+     * @param ctx the parse tree
+     */
+    enterString_delimiter?: (ctx: String_delimiterContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.string_delimiter`.
+     * @param ctx the parse tree
+     */
+    exitString_delimiter?: (ctx: String_delimiterContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cost_matrix_clause`.
+     * @param ctx the parse tree
+     */
+    enterCost_matrix_clause?: (ctx: Cost_matrix_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cost_matrix_clause`.
+     * @param ctx the parse tree
+     */
+    exitCost_matrix_clause?: (ctx: Cost_matrix_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_passing_clause`.
+     * @param ctx the parse tree
+     */
+    enterXml_passing_clause?: (ctx: Xml_passing_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_passing_clause`.
+     * @param ctx the parse tree
+     */
+    exitXml_passing_clause?: (ctx: Xml_passing_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    enterXml_attributes_clause?: (ctx: Xml_attributes_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_attributes_clause`.
+     * @param ctx the parse tree
+     */
+    exitXml_attributes_clause?: (ctx: Xml_attributes_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_namespaces_clause`.
+     * @param ctx the parse tree
+     */
+    enterXml_namespaces_clause?: (ctx: Xml_namespaces_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_namespaces_clause`.
+     * @param ctx the parse tree
+     */
+    exitXml_namespaces_clause?: (ctx: Xml_namespaces_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_table_column`.
+     * @param ctx the parse tree
+     */
+    enterXml_table_column?: (ctx: Xml_table_columnContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_table_column`.
+     * @param ctx the parse tree
+     */
+    exitXml_table_column?: (ctx: Xml_table_columnContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_general_default_part`.
+     * @param ctx the parse tree
+     */
+    enterXml_general_default_part?: (ctx: Xml_general_default_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_general_default_part`.
+     * @param ctx the parse tree
+     */
+    exitXml_general_default_part?: (ctx: Xml_general_default_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_multiuse_expression_element`.
+     * @param ctx the parse tree
+     */
+    enterXml_multiuse_expression_element?: (ctx: Xml_multiuse_expression_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_multiuse_expression_element`.
+     * @param ctx the parse tree
+     */
+    exitXml_multiuse_expression_element?: (ctx: Xml_multiuse_expression_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlroot_param_version_part`.
+     * @param ctx the parse tree
+     */
+    enterXmlroot_param_version_part?: (ctx: Xmlroot_param_version_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlroot_param_version_part`.
+     * @param ctx the parse tree
+     */
+    exitXmlroot_param_version_part?: (ctx: Xmlroot_param_version_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlroot_param_standalone_part`.
+     * @param ctx the parse tree
+     */
+    enterXmlroot_param_standalone_part?: (ctx: Xmlroot_param_standalone_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlroot_param_standalone_part`.
+     * @param ctx the parse tree
+     */
+    exitXmlroot_param_standalone_part?: (ctx: Xmlroot_param_standalone_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlserialize_param_enconding_part`.
+     * @param ctx the parse tree
+     */
+    enterXmlserialize_param_enconding_part?: (ctx: Xmlserialize_param_enconding_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlserialize_param_enconding_part`.
+     * @param ctx the parse tree
+     */
+    exitXmlserialize_param_enconding_part?: (ctx: Xmlserialize_param_enconding_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlserialize_param_version_part`.
+     * @param ctx the parse tree
+     */
+    enterXmlserialize_param_version_part?: (ctx: Xmlserialize_param_version_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlserialize_param_version_part`.
+     * @param ctx the parse tree
+     */
+    exitXmlserialize_param_version_part?: (ctx: Xmlserialize_param_version_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmlserialize_param_ident_part`.
+     * @param ctx the parse tree
+     */
+    enterXmlserialize_param_ident_part?: (ctx: Xmlserialize_param_ident_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmlserialize_param_ident_part`.
+     * @param ctx the parse tree
+     */
+    exitXmlserialize_param_ident_part?: (ctx: Xmlserialize_param_ident_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.annotations_clause`.
+     * @param ctx the parse tree
+     */
+    enterAnnotations_clause?: (ctx: Annotations_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.annotations_clause`.
+     * @param ctx the parse tree
+     */
+    exitAnnotations_clause?: (ctx: Annotations_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.annotations_list`.
+     * @param ctx the parse tree
+     */
+    enterAnnotations_list?: (ctx: Annotations_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.annotations_list`.
+     * @param ctx the parse tree
+     */
+    exitAnnotations_list?: (ctx: Annotations_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.annotation`.
+     * @param ctx the parse tree
+     */
+    enterAnnotation?: (ctx: AnnotationContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.annotation`.
+     * @param ctx the parse tree
+     */
+    exitAnnotation?: (ctx: AnnotationContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_plus_command`.
+     * @param ctx the parse tree
+     */
+    enterSql_plus_command?: (ctx: Sql_plus_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_plus_command`.
+     * @param ctx the parse tree
+     */
+    exitSql_plus_command?: (ctx: Sql_plus_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.execute_command`.
+     * @param ctx the parse tree
+     */
+    enterExecute_command?: (ctx: Execute_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.execute_command`.
+     * @param ctx the parse tree
+     */
+    exitExecute_command?: (ctx: Execute_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.start_command`.
+     * @param ctx the parse tree
+     */
+    enterStart_command?: (ctx: Start_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.start_command`.
+     * @param ctx the parse tree
+     */
+    exitStart_command?: (ctx: Start_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sql_plus_filepath`.
+     * @param ctx the parse tree
+     */
+    enterSql_plus_filepath?: (ctx: Sql_plus_filepathContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sql_plus_filepath`.
+     * @param ctx the parse tree
+     */
+    exitSql_plus_filepath?: (ctx: Sql_plus_filepathContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.whenever_command`.
+     * @param ctx the parse tree
+     */
+    enterWhenever_command?: (ctx: Whenever_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.whenever_command`.
+     * @param ctx the parse tree
+     */
+    exitWhenever_command?: (ctx: Whenever_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.set_command`.
+     * @param ctx the parse tree
+     */
+    enterSet_command?: (ctx: Set_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.set_command`.
+     * @param ctx the parse tree
+     */
+    exitSet_command?: (ctx: Set_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.timing_command`.
+     * @param ctx the parse tree
+     */
+    enterTiming_command?: (ctx: Timing_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.timing_command`.
+     * @param ctx the parse tree
+     */
+    exitTiming_command?: (ctx: Timing_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.clear_command`.
+     * @param ctx the parse tree
+     */
+    enterClear_command?: (ctx: Clear_commandContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.clear_command`.
+     * @param ctx the parse tree
+     */
+    exitClear_command?: (ctx: Clear_commandContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.partition_extension_clause`.
+     * @param ctx the parse tree
+     */
+    enterPartition_extension_clause?: (ctx: Partition_extension_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.partition_extension_clause`.
+     * @param ctx the parse tree
+     */
+    exitPartition_extension_clause?: (ctx: Partition_extension_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_alias`.
+     * @param ctx the parse tree
+     */
+    enterColumn_alias?: (ctx: Column_aliasContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_alias`.
+     * @param ctx the parse tree
+     */
+    exitColumn_alias?: (ctx: Column_aliasContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_alias`.
+     * @param ctx the parse tree
+     */
+    enterTable_alias?: (ctx: Table_aliasContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_alias`.
+     * @param ctx the parse tree
+     */
+    exitTable_alias?: (ctx: Table_aliasContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.where_clause`.
+     * @param ctx the parse tree
+     */
+    enterWhere_clause?: (ctx: Where_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.where_clause`.
+     * @param ctx the parse tree
+     */
+    exitWhere_clause?: (ctx: Where_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.into_clause`.
+     * @param ctx the parse tree
+     */
+    enterInto_clause?: (ctx: Into_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.into_clause`.
+     * @param ctx the parse tree
+     */
+    exitInto_clause?: (ctx: Into_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xml_column_name`.
+     * @param ctx the parse tree
+     */
+    enterXml_column_name?: (ctx: Xml_column_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xml_column_name`.
+     * @param ctx the parse tree
+     */
+    exitXml_column_name?: (ctx: Xml_column_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cost_class_name`.
+     * @param ctx the parse tree
+     */
+    enterCost_class_name?: (ctx: Cost_class_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cost_class_name`.
+     * @param ctx the parse tree
+     */
+    exitCost_class_name?: (ctx: Cost_class_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.attribute_name`.
+     * @param ctx the parse tree
+     */
+    enterAttribute_name?: (ctx: Attribute_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.attribute_name`.
+     * @param ctx the parse tree
+     */
+    exitAttribute_name?: (ctx: Attribute_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.savepoint_name`.
+     * @param ctx the parse tree
+     */
+    enterSavepoint_name?: (ctx: Savepoint_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.savepoint_name`.
+     * @param ctx the parse tree
+     */
+    exitSavepoint_name?: (ctx: Savepoint_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.rollback_segment_name`.
+     * @param ctx the parse tree
+     */
+    enterRollback_segment_name?: (ctx: Rollback_segment_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.rollback_segment_name`.
+     * @param ctx the parse tree
+     */
+    exitRollback_segment_name?: (ctx: Rollback_segment_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.schema_name`.
+     * @param ctx the parse tree
+     */
+    enterSchema_name?: (ctx: Schema_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.schema_name`.
+     * @param ctx the parse tree
+     */
+    exitSchema_name?: (ctx: Schema_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.routine_name`.
+     * @param ctx the parse tree
+     */
+    enterRoutine_name?: (ctx: Routine_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.routine_name`.
+     * @param ctx the parse tree
+     */
+    exitRoutine_name?: (ctx: Routine_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.package_name`.
+     * @param ctx the parse tree
+     */
+    enterPackage_name?: (ctx: Package_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.package_name`.
+     * @param ctx the parse tree
+     */
+    exitPackage_name?: (ctx: Package_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.implementation_type_name`.
+     * @param ctx the parse tree
+     */
+    enterImplementation_type_name?: (ctx: Implementation_type_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.implementation_type_name`.
+     * @param ctx the parse tree
+     */
+    exitImplementation_type_name?: (ctx: Implementation_type_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.parameter_name`.
+     * @param ctx the parse tree
+     */
+    enterParameter_name?: (ctx: Parameter_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.parameter_name`.
+     * @param ctx the parse tree
+     */
+    exitParameter_name?: (ctx: Parameter_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.reference_model_name`.
+     * @param ctx the parse tree
+     */
+    enterReference_model_name?: (ctx: Reference_model_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.reference_model_name`.
+     * @param ctx the parse tree
+     */
+    exitReference_model_name?: (ctx: Reference_model_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.main_model_name`.
+     * @param ctx the parse tree
+     */
+    enterMain_model_name?: (ctx: Main_model_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.main_model_name`.
+     * @param ctx the parse tree
+     */
+    exitMain_model_name?: (ctx: Main_model_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.container_tableview_name`.
+     * @param ctx the parse tree
+     */
+    enterContainer_tableview_name?: (ctx: Container_tableview_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.container_tableview_name`.
+     * @param ctx the parse tree
+     */
+    exitContainer_tableview_name?: (ctx: Container_tableview_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.aggregate_function_name`.
+     * @param ctx the parse tree
+     */
+    enterAggregate_function_name?: (ctx: Aggregate_function_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.aggregate_function_name`.
+     * @param ctx the parse tree
+     */
+    exitAggregate_function_name?: (ctx: Aggregate_function_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.query_name`.
+     * @param ctx the parse tree
+     */
+    enterQuery_name?: (ctx: Query_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.query_name`.
+     * @param ctx the parse tree
+     */
+    exitQuery_name?: (ctx: Query_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.grantee_name`.
+     * @param ctx the parse tree
+     */
+    enterGrantee_name?: (ctx: Grantee_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.grantee_name`.
+     * @param ctx the parse tree
+     */
+    exitGrantee_name?: (ctx: Grantee_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.role_name`.
+     * @param ctx the parse tree
+     */
+    enterRole_name?: (ctx: Role_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.role_name`.
+     * @param ctx the parse tree
+     */
+    exitRole_name?: (ctx: Role_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.constraint_name`.
+     * @param ctx the parse tree
+     */
+    enterConstraint_name?: (ctx: Constraint_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.constraint_name`.
+     * @param ctx the parse tree
+     */
+    exitConstraint_name?: (ctx: Constraint_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.label_name`.
+     * @param ctx the parse tree
+     */
+    enterLabel_name?: (ctx: Label_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.label_name`.
+     * @param ctx the parse tree
+     */
+    exitLabel_name?: (ctx: Label_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_name`.
+     * @param ctx the parse tree
+     */
+    enterType_name?: (ctx: Type_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_name`.
+     * @param ctx the parse tree
+     */
+    exitType_name?: (ctx: Type_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.sequence_name`.
+     * @param ctx the parse tree
+     */
+    enterSequence_name?: (ctx: Sequence_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.sequence_name`.
+     * @param ctx the parse tree
+     */
+    exitSequence_name?: (ctx: Sequence_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.exception_name`.
+     * @param ctx the parse tree
+     */
+    enterException_name?: (ctx: Exception_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.exception_name`.
+     * @param ctx the parse tree
+     */
+    exitException_name?: (ctx: Exception_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_name`.
+     * @param ctx the parse tree
+     */
+    enterFunction_name?: (ctx: Function_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_name`.
+     * @param ctx the parse tree
+     */
+    exitFunction_name?: (ctx: Function_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.procedure_name`.
+     * @param ctx the parse tree
+     */
+    enterProcedure_name?: (ctx: Procedure_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.procedure_name`.
+     * @param ctx the parse tree
+     */
+    exitProcedure_name?: (ctx: Procedure_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.trigger_name`.
+     * @param ctx the parse tree
+     */
+    enterTrigger_name?: (ctx: Trigger_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.trigger_name`.
+     * @param ctx the parse tree
+     */
+    exitTrigger_name?: (ctx: Trigger_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.variable_name`.
+     * @param ctx the parse tree
+     */
+    enterVariable_name?: (ctx: Variable_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.variable_name`.
+     * @param ctx the parse tree
+     */
+    exitVariable_name?: (ctx: Variable_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.index_name`.
+     * @param ctx the parse tree
+     */
+    enterIndex_name?: (ctx: Index_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.index_name`.
+     * @param ctx the parse tree
+     */
+    exitIndex_name?: (ctx: Index_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.cursor_name`.
+     * @param ctx the parse tree
+     */
+    enterCursor_name?: (ctx: Cursor_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.cursor_name`.
+     * @param ctx the parse tree
+     */
+    exitCursor_name?: (ctx: Cursor_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.record_name`.
+     * @param ctx the parse tree
+     */
+    enterRecord_name?: (ctx: Record_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.record_name`.
+     * @param ctx the parse tree
+     */
+    exitRecord_name?: (ctx: Record_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.link_name`.
+     * @param ctx the parse tree
+     */
+    enterLink_name?: (ctx: Link_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.link_name`.
+     * @param ctx the parse tree
+     */
+    exitLink_name?: (ctx: Link_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.local_link_name`.
+     * @param ctx the parse tree
+     */
+    enterLocal_link_name?: (ctx: Local_link_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.local_link_name`.
+     * @param ctx the parse tree
+     */
+    exitLocal_link_name?: (ctx: Local_link_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.connection_qualifier`.
+     * @param ctx the parse tree
+     */
+    enterConnection_qualifier?: (ctx: Connection_qualifierContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.connection_qualifier`.
+     * @param ctx the parse tree
+     */
+    exitConnection_qualifier?: (ctx: Connection_qualifierContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_name`.
+     * @param ctx the parse tree
+     */
+    enterColumn_name?: (ctx: Column_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_name`.
+     * @param ctx the parse tree
+     */
+    exitColumn_name?: (ctx: Column_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.tableview_name`.
+     * @param ctx the parse tree
+     */
+    enterTableview_name?: (ctx: Tableview_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.tableview_name`.
+     * @param ctx the parse tree
+     */
+    exitTableview_name?: (ctx: Tableview_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.xmltable`.
+     * @param ctx the parse tree
+     */
+    enterXmltable?: (ctx: XmltableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.xmltable`.
+     * @param ctx the parse tree
+     */
+    exitXmltable?: (ctx: XmltableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.char_set_name`.
+     * @param ctx the parse tree
+     */
+    enterChar_set_name?: (ctx: Char_set_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.char_set_name`.
+     * @param ctx the parse tree
+     */
+    exitChar_set_name?: (ctx: Char_set_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.synonym_name`.
+     * @param ctx the parse tree
+     */
+    enterSynonym_name?: (ctx: Synonym_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.synonym_name`.
+     * @param ctx the parse tree
+     */
+    exitSynonym_name?: (ctx: Synonym_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.schema_object_name`.
+     * @param ctx the parse tree
+     */
+    enterSchema_object_name?: (ctx: Schema_object_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.schema_object_name`.
+     * @param ctx the parse tree
+     */
+    exitSchema_object_name?: (ctx: Schema_object_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.dir_object_name`.
+     * @param ctx the parse tree
+     */
+    enterDir_object_name?: (ctx: Dir_object_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.dir_object_name`.
+     * @param ctx the parse tree
+     */
+    exitDir_object_name?: (ctx: Dir_object_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.user_object_name`.
+     * @param ctx the parse tree
+     */
+    enterUser_object_name?: (ctx: User_object_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.user_object_name`.
+     * @param ctx the parse tree
+     */
+    exitUser_object_name?: (ctx: User_object_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.grant_object_name`.
+     * @param ctx the parse tree
+     */
+    enterGrant_object_name?: (ctx: Grant_object_nameContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.grant_object_name`.
+     * @param ctx the parse tree
+     */
+    exitGrant_object_name?: (ctx: Grant_object_nameContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.column_list`.
+     * @param ctx the parse tree
+     */
+    enterColumn_list?: (ctx: Column_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.column_list`.
+     * @param ctx the parse tree
+     */
+    exitColumn_list?: (ctx: Column_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.paren_column_list`.
+     * @param ctx the parse tree
+     */
+    enterParen_column_list?: (ctx: Paren_column_listContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.paren_column_list`.
+     * @param ctx the parse tree
+     */
+    exitParen_column_list?: (ctx: Paren_column_listContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.keep_clause`.
+     * @param ctx the parse tree
+     */
+    enterKeep_clause?: (ctx: Keep_clauseContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.keep_clause`.
+     * @param ctx the parse tree
+     */
+    exitKeep_clause?: (ctx: Keep_clauseContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_argument`.
+     * @param ctx the parse tree
+     */
+    enterFunction_argument?: (ctx: Function_argumentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_argument`.
+     * @param ctx the parse tree
+     */
+    exitFunction_argument?: (ctx: Function_argumentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_argument_analytic`.
+     * @param ctx the parse tree
+     */
+    enterFunction_argument_analytic?: (ctx: Function_argument_analyticContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_argument_analytic`.
+     * @param ctx the parse tree
+     */
+    exitFunction_argument_analytic?: (ctx: Function_argument_analyticContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.function_argument_modeling`.
+     * @param ctx the parse tree
+     */
+    enterFunction_argument_modeling?: (ctx: Function_argument_modelingContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.function_argument_modeling`.
+     * @param ctx the parse tree
+     */
+    exitFunction_argument_modeling?: (ctx: Function_argument_modelingContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.respect_or_ignore_nulls`.
+     * @param ctx the parse tree
+     */
+    enterRespect_or_ignore_nulls?: (ctx: Respect_or_ignore_nullsContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.respect_or_ignore_nulls`.
+     * @param ctx the parse tree
+     */
+    exitRespect_or_ignore_nulls?: (ctx: Respect_or_ignore_nullsContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.argument`.
+     * @param ctx the parse tree
+     */
+    enterArgument?: (ctx: ArgumentContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.argument`.
+     * @param ctx the parse tree
+     */
+    exitArgument?: (ctx: ArgumentContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.type_spec`.
+     * @param ctx the parse tree
+     */
+    enterType_spec?: (ctx: Type_specContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.type_spec`.
+     * @param ctx the parse tree
+     */
+    exitType_spec?: (ctx: Type_specContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.datatype`.
+     * @param ctx the parse tree
+     */
+    enterDatatype?: (ctx: DatatypeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.datatype`.
+     * @param ctx the parse tree
+     */
+    exitDatatype?: (ctx: DatatypeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.precision_part`.
+     * @param ctx the parse tree
+     */
+    enterPrecision_part?: (ctx: Precision_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.precision_part`.
+     * @param ctx the parse tree
+     */
+    exitPrecision_part?: (ctx: Precision_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.native_datatype_element`.
+     * @param ctx the parse tree
+     */
+    enterNative_datatype_element?: (ctx: Native_datatype_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.native_datatype_element`.
+     * @param ctx the parse tree
+     */
+    exitNative_datatype_element?: (ctx: Native_datatype_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.bind_variable`.
+     * @param ctx the parse tree
+     */
+    enterBind_variable?: (ctx: Bind_variableContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.bind_variable`.
+     * @param ctx the parse tree
+     */
+    exitBind_variable?: (ctx: Bind_variableContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.general_element`.
+     * @param ctx the parse tree
+     */
+    enterGeneral_element?: (ctx: General_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.general_element`.
+     * @param ctx the parse tree
+     */
+    exitGeneral_element?: (ctx: General_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.general_element_part`.
+     * @param ctx the parse tree
+     */
+    enterGeneral_element_part?: (ctx: General_element_partContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.general_element_part`.
+     * @param ctx the parse tree
+     */
+    exitGeneral_element_part?: (ctx: General_element_partContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.table_element`.
+     * @param ctx the parse tree
+     */
+    enterTable_element?: (ctx: Table_elementContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.table_element`.
+     * @param ctx the parse tree
+     */
+    exitTable_element?: (ctx: Table_elementContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.object_privilege`.
+     * @param ctx the parse tree
+     */
+    enterObject_privilege?: (ctx: Object_privilegeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.object_privilege`.
+     * @param ctx the parse tree
+     */
+    exitObject_privilege?: (ctx: Object_privilegeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.system_privilege`.
+     * @param ctx the parse tree
+     */
+    enterSystem_privilege?: (ctx: System_privilegeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.system_privilege`.
+     * @param ctx the parse tree
+     */
+    exitSystem_privilege?: (ctx: System_privilegeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.constant`.
+     * @param ctx the parse tree
+     */
+    enterConstant?: (ctx: ConstantContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.constant`.
+     * @param ctx the parse tree
+     */
+    exitConstant?: (ctx: ConstantContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.numeric`.
+     * @param ctx the parse tree
+     */
+    enterNumeric?: (ctx: NumericContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.numeric`.
+     * @param ctx the parse tree
+     */
+    exitNumeric?: (ctx: NumericContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.numeric_negative`.
+     * @param ctx the parse tree
+     */
+    enterNumeric_negative?: (ctx: Numeric_negativeContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.numeric_negative`.
+     * @param ctx the parse tree
+     */
+    exitNumeric_negative?: (ctx: Numeric_negativeContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.quoted_string`.
+     * @param ctx the parse tree
+     */
+    enterQuoted_string?: (ctx: Quoted_stringContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.quoted_string`.
+     * @param ctx the parse tree
+     */
+    exitQuoted_string?: (ctx: Quoted_stringContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.identifier`.
+     * @param ctx the parse tree
+     */
+    enterIdentifier?: (ctx: IdentifierContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.identifier`.
+     * @param ctx the parse tree
+     */
+    exitIdentifier?: (ctx: IdentifierContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.id_expression`.
+     * @param ctx the parse tree
+     */
+    enterId_expression?: (ctx: Id_expressionContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.id_expression`.
+     * @param ctx the parse tree
+     */
+    exitId_expression?: (ctx: Id_expressionContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.inquiry_directive`.
+     * @param ctx the parse tree
+     */
+    enterInquiry_directive?: (ctx: Inquiry_directiveContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.inquiry_directive`.
+     * @param ctx the parse tree
+     */
+    exitInquiry_directive?: (ctx: Inquiry_directiveContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.outer_join_sign`.
+     * @param ctx the parse tree
+     */
+    enterOuter_join_sign?: (ctx: Outer_join_signContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.outer_join_sign`.
+     * @param ctx the parse tree
+     */
+    exitOuter_join_sign?: (ctx: Outer_join_signContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.regular_id`.
+     * @param ctx the parse tree
+     */
+    enterRegular_id?: (ctx: Regular_idContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.regular_id`.
+     * @param ctx the parse tree
+     */
+    exitRegular_id?: (ctx: Regular_idContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.non_reserved_keywords_in_18c`.
+     * @param ctx the parse tree
+     */
+    enterNon_reserved_keywords_in_18c?: (ctx: Non_reserved_keywords_in_18cContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.non_reserved_keywords_in_18c`.
+     * @param ctx the parse tree
+     */
+    exitNon_reserved_keywords_in_18c?: (ctx: Non_reserved_keywords_in_18cContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.non_reserved_keywords_in_12c`.
+     * @param ctx the parse tree
+     */
+    enterNon_reserved_keywords_in_12c?: (ctx: Non_reserved_keywords_in_12cContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.non_reserved_keywords_in_12c`.
+     * @param ctx the parse tree
+     */
+    exitNon_reserved_keywords_in_12c?: (ctx: Non_reserved_keywords_in_12cContext) => void;
+    /**
+     * Enter a parse tree produced by `PlSqlParser.non_reserved_keywords_pre12c`.
+     * @param ctx the parse tree
+     */
+    enterNon_reserved_keywords_pre12c?: (ctx: Non_reserved_keywords_pre12cContext) => void;
+    /**
+     * Exit a parse tree produced by `PlSqlParser.non_reserved_keywords_pre12c`.
+     * @param ctx the parse tree
+     */
+    exitNon_reserved_keywords_pre12c?: (ctx: Non_reserved_keywords_pre12cContext) => void;
+
+    visitTerminal(node: TerminalNode): void {}
+    visitErrorNode(node: ErrorNode): void {}
+    enterEveryRule(node: ParserRuleContext): void {}
+    exitEveryRule(node: ParserRuleContext): void {}
+}
+
diff --git a/gitnexus/src/core/ingestion/plsql/generated/README.md b/gitnexus/src/core/ingestion/plsql/generated/README.md
new file mode 100644
index 000000000..ae1ac6eab
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/generated/README.md
@@ -0,0 +1,18 @@
+# Generated Oracle PL/SQL parser — do not edit
+
+`PlSqlLexer.ts`, `PlSqlParser.ts` and `PlSqlParserListener.ts` are generated by
+[antlr-ng](https://www.npmjs.com/package/antlr-ng) 1.0.10 for the
+[antlr4ng](https://www.npmjs.com/package/antlr4ng) runtime from the grammars in
+`../grammar/`. Regenerate with:
+
+```sh
+cd gitnexus && node scripts/generate-plsql-parser.mjs
+```
+
+| Input                         | Source                                                                                         | License    |
+| ----------------------------- | ---------------------------------------------------------------------------------------------- | ---------- |
+| `../grammar/PlSql*.g4`        | [antlr/grammars-v4](https://github.com/antlr/grammars-v4/tree/master/sql/plsql) `sql/plsql` at `2766c2eed04f285dc763617c9459650892fcf5b9` (2026-10-28) | Apache-2.0 |
+| `PlSqlLexerBase.ts`, `PlSqlParserBase.ts` | same commit, `sql/plsql/Antlr4ng/` (hand-written base classes the grammar's actions call) | Apache-2.0 |
+
+Lint and formatting skip this directory (`eslint.config.mjs`, `.prettierignore`).
+Do not patch generated files; fix the grammar upstream or in `../grammar/` and regenerate.
diff --git a/gitnexus/src/core/ingestion/plsql/grammar/PlSqlLexer.g4 b/gitnexus/src/core/ingestion/plsql/grammar/PlSqlLexer.g4
new file mode 100644
index 000000000..a354b9b2f
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/grammar/PlSqlLexer.g4
@@ -0,0 +1,2593 @@
+/**
+ * Oracle(c) PL/SQL 11g Parser
+ *
+ * Copyright (c) 2009-2011 Alexandre Porcelli <alexandre.porcelli@gmail.com>
+ * Copyright (c) 2015-2019 Ivan Kochurkin (KvanTTT, kvanttt@gmail.com, Positive Technologies).
+ * Copyright (c) 2017 Mark Adams <madams51703@gmail.com>
+ *
+ * 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.
+ */
+
+// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine
+// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true
+
+lexer grammar PlSqlLexer;
+
+options {
+    superClass = PlSqlLexerBase;
+    caseInsensitive = true;
+}
+
+// Insert here @header for C++ lexer.
+
+ABORT                          : 'ABORT';
+ABS                            : 'ABS';
+ABSENT                         : 'ABSENT';
+ACCESS                         : 'ACCESS';
+ACCESSED                       : 'ACCESSED';
+ACCESSIBLE                     : 'ACCESSIBLE';
+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';
+ANNOTATIONS                    : 'ANNOTATIONS';
+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';
+ARE                            : 'ARE';
+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';
+BADFILE                        : 'BADFILE';
+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';
+BIG                            : 'BIG';
+BIGFILE                        : 'BIGFILE';
+BIGINT                         : 'BIGINT';
+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';
+BLANKS                         : 'BLANKS';
+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';
+BYTES                          : 'BYTES';
+BYTEORDERMARK                  : 'BYTEORDERMARK';
+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';
+CHARACTERS                     : 'CHARACTERS';
+CHARACTERSET                   : 'CHARACTERSET';
+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';
+COLLECTION                     : 'COLLECTION';
+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';
+COMPATIBLE                     : 'COMPATIBLE';
+COMPATIBILITY                  : 'COMPATIBILITY';
+COMPILE                        : 'COMPILE';
+COMPLETE                       : 'COMPLETE';
+COMPLIANCE                     : 'COMPLIANCE';
+COMPONENT                      : 'COMPONENT';
+COMPONENTS                     : 'COMPONENTS';
+COMPOSE                        : 'COMPOSE';
+COMPOSITE                      : 'COMPOSITE';
+COMPOSITE_LIMIT                : 'COMPOSITE_LIMIT';
+COMPOUND                       : 'COMPOUND';
+COMPRESS                       : 'COMPRESS';
+COMPRESSION                    : 'COMPRESSION';
+COMPUTE                        : 'COMPUTE';
+COMPUTATION                    : 'COMPUTATION';
+CONCAT                         : 'CONCAT';
+CONCURRENT                     : 'CONCURRENT';
+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';
+COUNTED                        : 'COUNTED';
+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';
+CSV                            : 'CSV';
+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_CACHE                     : 'DATE_CACHE';
+DATE_FORMAT                    : 'DATE_FORMAT';
+DATE_MODE                      : 'DATE_MODE';
+DAY                            : 'DAY';
+DAYS                           : 'DAYS';
+DAY_TO_SECOND                  : 'DAY_TO_SECOND';
+DBA                            : 'DBA';
+DBA_RECYCLEBIN                 : 'DBA_RECYCLEBIN';
+DBLINK                         : 'DBLINK';
+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';
+DEFAULTIF                      : 'DEFAULTIF';
+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';
+DELIMITED                      : 'DELIMITED';
+DEMAND                         : 'DEMAND';
+DENSE_RANKM                    : 'DENSE_RANKM';
+DEPENDENT                      : 'DEPENDENT';
+DEPRECATE                      : 'DEPRECATE';
+DEPTH                          : 'DEPTH';
+DEQUEUE                        : 'DEQUEUE';
+DEREF                          : 'DEREF';
+DEREF_NO_REWRITE               : 'DEREF_NO_REWRITE';
+DESC                           : 'DESC';
+DESCRIPTION                    : 'DESCRIPTION';
+DESTROY                        : 'DESTROY';
+DETACHED                       : 'DETACHED';
+DETECTED                       : 'DETECTED';
+DETERMINES                     : 'DETERMINES';
+DETERMINISTIC                  : 'DETERMINISTIC';
+DICTIONARY                     : 'DICTIONARY';
+DIMENSION                      : 'DIMENSION';
+DIMENSIONS                     : 'DIMENSIONS';
+DIRECTIO                       : 'DIRECTIO';
+DIRECT_LOAD                    : 'DIRECT_LOAD';
+DIRECTORY                      : 'DIRECTORY';
+DIRECT_PATH                    : 'DIRECT_PATH';
+DISABLE_ALL                    : 'DISABLE_ALL';
+DISABLE                        : 'DISABLE';
+DISABLED                       : 'DISABLED';
+DISABLE_DIRECTORY_LINK_CHECK   : 'DISABLE_DIRECTORY_LINK_CHECK';
+DISABLE_PARALLEL_DML           : 'DISABLE_PARALLEL_DML';
+DISABLE_PRESET                 : 'DISABLE_PRESET';
+DISABLE_RPKE                   : 'DISABLE_RPKE';
+DISALLOW                       : 'DISALLOW';
+DISASSOCIATE                   : 'DISASSOCIATE';
+DISCARD                        : 'DISCARD';
+DISCARDFILE                    : 'DISCARDFILE';
+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';
+DNFS_DISABLE                   : 'DNFS_DISABLE';
+DNFS_ENABLE                    : 'DNFS_ENABLE';
+DNFS_READBUFFERS               : 'DNFS_READBUFFERS';
+DOCFIDELITY                    : 'DOCFIDELITY';
+DOCUMENT                       : 'DOCUMENT';
+DOLLAR_ELSE                    : '$ELSE';
+DOLLAR_ELSIF                   : '$ELSIF';
+DOLLAR_END                     : '$END';
+DOLLAR_ERROR                   : '$ERROR';
+DOLLAR_IF                      : '$IF';
+DOLLAR_THEN                    : '$THEN';
+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';
+EMBEDDED                       : 'EMBEDDED';
+EMPTY_BLOB                     : 'EMPTY_BLOB';
+EMPTY_CLOB                     : 'EMPTY_CLOB';
+EMPTY_                         : 'EMPTY';
+ENABLE_ALL                     : 'ENABLE_ALL';
+ENABLE                         : 'ENABLE';
+ENABLED                        : 'ENABLED';
+ENABLE_PARALLEL_DML            : 'ENABLE_PARALLEL_DML';
+ENABLE_PRESET                  : 'ENABLE_PRESET';
+ENCLOSED                       : 'ENCLOSED';
+ENCODING                       : 'ENCODING';
+ENCRYPT                        : 'ENCRYPT';
+ENCRYPTION                     : 'ENCRYPTION';
+ENCRYPTPASSWORDISNULL          : 'ENCRYPTPASSWORDISNULL';
+END                            : 'END';
+END_OUTLINE_DATA               : 'END_OUTLINE_DATA';
+ENDIAN                         : 'ENDIAN';
+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';
+ERROR_INDEX                    : 'ERROR_INDEX';
+ERROR_CODE                     : 'ERROR_CODE';
+ESCAPE                         : 'ESCAPE';
+ESCAPED                        : 'ESCAPED';
+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';
+EXEC                           : 'EXEC';
+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';
+FIELD                          : 'FIELD';
+FIELDS                         : 'FIELDS';
+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                          : 'FIXED';
+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';
+HADOOP_TRAILERS                : 'HADOOP_TRAILERS';
+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_CHARS_AFTER_EOR         : 'IGNORE_CHARS_AFTER_EOR';
+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';
+INPUTFORMAT                    : 'INPUTFORMAT';
+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';
+INTERNAL                       : 'INTERNAL';
+INTO                           : 'INTO';
+INVALIDATE                     : 'INVALIDATE';
+INVALIDATION                   : 'INVALIDATION';
+INVISIBLE                      : 'INVISIBLE';
+IN_XQUERY                      : 'IN_XQUERY';
+IO_OPTIONS                     : 'IO_OPTIONS';
+IS                             : 'IS';
+IS_LEAF                        : 'IS_LEAF';
+ISOLATION                      : 'ISOLATION';
+ISOLATION_LEVEL                : 'ISOLATION_LEVEL';
+ITEMS                          : 'ITEMS';
+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';
+LATEST                         : 'LATEST';
+LAX                            : 'LAX';
+LAYER                          : 'LAYER';
+LDAP_REGISTRATION_ENABLED      : 'LDAP_REGISTRATION_ENABLED';
+LDAP_REGISTRATION              : 'LDAP_REGISTRATION';
+LDAP_REG_SYNC_INTERVAL         : 'LDAP_REG_SYNC_INTERVAL';
+LDRTRIM                        : 'LDRTRIM';
+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';
+LINES                          : 'LINES';
+LINK                           : 'LINK';
+LIST                           : 'LIST';
+LITTLE                         : 'LITTLE';
+LLS                            : 'LLS';
+LN                             : 'LN';
+LNNVL                          : 'LNNVL';
+LOAD                           : 'LOAD';
+LOB                            : 'LOB';
+LOBFILE                        : 'LOBFILE';
+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';
+LRTRIM                         : 'LRTRIM';
+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';
+MASK                           : 'MASK';
+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';
+NEWLINE_                       : 'NEWLINE';
+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';
+NOBADFILE                      : 'NOBADFILE';
+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';
+NOCHECK                        : 'NOCHECK';
+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';
+NODIRECTIO                     : 'NODIRECTIO';
+NODISCARDFILE                  : 'NODISCARDFILE';
+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';
+NOEXTEND                       : 'NOEXTEND';
+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';
+NOLOG                          : 'NOLOG';
+NOLOGFILE                      : 'NOLOGFILE';
+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';
+NONPARTITIONED                 : 'NONPARTITIONED';
+NONULLIF                       : 'NONULLIF';
+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';
+NOSCALE                        : 'NOSCALE';
+NOSCHEMACHECK                  : 'NOSCHEMACHECK';
+NOSEGMENT                      : 'NOSEGMENT';
+NO_SEMIJOIN                    : 'NO_SEMIJOIN';
+NO_SEMI_TO_INNER               : 'NO_SEMI_TO_INNER';
+NO_SET_TO_JOIN                 : 'NO_SET_TO_JOIN';
+NOSHARD                        : 'NOSHARD';
+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';
+NOTRIM                         : 'NOTRIM';
+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';
+OPTIONALLY                     : 'OPTIONALLY';
+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';
+ORC                            : 'ORC';
+ORACLE_DATE                    : 'ORACLE_DATE';
+ORACLE_NUMBER                  : 'ORACLE_NUMBER';
+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';
+OUTPUTFORMAT                   : 'OUTPUTFORMAT';
+OUT_OF_LINE                    : 'OUT_OF_LINE';
+OUT                            : 'OUT';
+OVERFLOW_NOMOVE                : 'OVERFLOW_NOMOVE';
+OVERFLOW_                      : 'OVERFLOW';
+OVERLAPS                       : 'OVERLAPS';
+OVER                           : 'OVER';
+OVERRIDE                       : 'OVERRIDE';
+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';
+PARQUET                        : 'PARQUET';
+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';
+PERCENT_BULK_EXCEPTIONS        : '%' SPACE* 'BULK_EXCEPTIONS';
+PERCENT_BULK_ROWCOUNT          : '%' SPACE* 'BULK_ROWCOUNT';
+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';
+POSITION                       : 'POSITION';
+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';
+PREPROCESSOR                   : 'PREPROCESSOR';
+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';
+RCFILE                         : 'RCFILE';
+RDBA                           : 'RDBA';
+READ                           : 'READ';
+READS                          : 'READS';
+READSIZE                       : 'READSIZE';
+REALM                          : 'REALM';
+REAL                           : 'REAL';
+REBALANCE                      : 'REBALANCE';
+REBUILD                        : 'REBUILD';
+RECORD                         : 'RECORD';
+RECORDS                        : 'RECORDS';
+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';
+SEQUENCEFILE                   : 'SEQUENCEFILE';
+SEQUENTIAL                     : 'SEQUENTIAL';
+SEQ                            : 'SEQ';
+SERDE                          : 'SERDE';
+SERDEPROPERTIES                : 'SERDEPROPERTIES';
+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';
+SHARD                          : 'SHARD';
+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';
+SIZES                          : 'SIZES';
+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';
+FILE_EXT                       : 'FNC' | 'PKB' | 'PKS' | 'PRC' | 'TRG' | 'VW';
+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';
+STARTOF                        : 'STARTOF';
+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';
+TEMPLATE_TABLE                 : 'TEMPLATE_TABLE';
+TEMPORARY                      : 'TEMPORARY';
+TEMP_TABLE                     : 'TEMP_TABLE';
+TERMINATED                     : 'TERMINATED';
+TEST                           : 'TEST';
+TEXT                           : 'TEXT';
+TEXTFILE                       : 'TEXTFILE';
+THAN                           : 'THAN';
+THEN                           : 'THEN';
+THE                            : 'THE';
+THESE                          : 'THESE';
+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';
+TINYINT                        : 'TINYINT';
+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';
+TRANSFORMS                     : 'TRANSFORMS';
+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';
+UDF                            : 'UDF';
+UID                            : 'UID';
+UNARCHIVED                     : 'UNARCHIVED';
+UNBOUNDED                      : 'UNBOUNDED';
+UNBOUND                        : 'UNBOUND';
+UNCONDITIONAL                  : 'UNCONDITIONAL';
+UNDER                          : 'UNDER';
+UNDO                           : 'UNDO';
+UNDROP                         : 'UNDROP';
+UNIFORM                        : 'UNIFORM';
+UNION                          : 'UNION';
+UNIONTYPE                      : 'UNIONTYPE';
+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';
+UNSIGNED                       : 'UNSIGNED';
+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_NLS_COMP                 : 'USING_NLS_COMP';
+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';
+VARCHARC                       : 'VARCHARC';
+VARIABLE                       : 'VARIABLE';
+VARRAW                         : 'VARRAW';
+VARRAWC                        : 'VARRAWC';
+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';
+WORKERID                       : 'WORKERID';
+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';
+XMLTAG                         : 'XMLTAG';
+XMLTRANSFORMBLOB               : 'XMLTRANSFORMBLOB';
+XMLTRANSFORM                   : 'XMLTRANSFORM';
+XMLTYPE                        : 'XMLTYPE';
+XML                            : 'XML';
+XPATHTABLE                     : 'XPATHTABLE';
+XS_SYS_CONTEXT                 : 'XS_SYS_CONTEXT';
+XS                             : 'XS';
+XTRANSPORT                     : 'XTRANSPORT';
+YEARS                          : 'YEARS';
+YEAR                           : 'YEAR';
+YEAR_TO_MONTH                  : 'YEAR_TO_MONTH';
+YES                            : 'YES';
+YMINTERVAL_UNCONSTRAINED       : 'YMINTERVAL_UNCONSTRAINED';
+ZONEMAP                        : 'ZONEMAP';
+ZONE                           : 'ZONE';
+ZONED                          : 'ZONED';
+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';
+
+CHARSETID   : 'CHARSETID';
+CHARSETFORM : 'CHARSETFORM';
+DURATION    : 'DURATION';
+EXTEND      : 'EXTEND';
+MAXLEN      : 'MAXLEN';
+PERSISTABLE : 'PERSISTABLE';
+POLYMORPHIC : 'POLYMORPHIC';
+STRUCT      : 'STRUCT';
+TDO         : 'TDO';
+WM_CONCAT   : 'WM_CONCAT';
+
+// Rule #358 <NATIONAL_CHAR_STRING_LIT> - subtoken typecast in <REGULAR_ID>, it also incorporates <character_representation>
+//  Lowercase 'n' is a usual addition to the standard
+
+NATIONAL_CHAR_STRING_LIT: 'N' '\'' (~('\'' | '\r' | '\n') | '\'' '\'' | NEWLINE)* '\'';
+
+//  Rule #040 <BIT_STRING_LIT> - subtoken typecast in <REGULAR_ID>
+//  Lowercase 'b' is a usual addition to the standard
+
+BIT_STRING_LIT: 'B' ('\'' [01]* '\'')+;
+
+//  Rule #284 <HEX_STRING_LIT> - subtoken typecast in <REGULAR_ID>
+//  Lowercase 'x' is a usual addition to the standard
+//  The '0X' is used in external_table_clause sub-rules
+
+HEX_STRING_LIT : ('X' | '0X') ('\'' [A-F0-9]* '\'')+;
+DOUBLE_PERIOD  : '..';
+PERIOD         : '.';
+
+//{ Rule #238 <EXACT_NUM_LIT>
+//  This rule is a bit tricky - it resolves the ambiguity with <PERIOD>
+//  It also incorporates <mantisa> and <exponent> for the <APPROXIMATE_NUM_LIT>
+//  Rule #501 <signed_integer> was incorporated directly in the token <APPROXIMATE_NUM_LIT>
+//  See also the rule #617 <unsigned_num_lit>
+/*
+    : (
+            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 #--- <CHAR_STRING> is a base for Rule #065 <char_string_lit> , it incorporates <character_representation>
+// and a superfluous subtoken typecasting of the "QUOTE"
+CHAR_STRING: '\'' (~('\'' | '\r' | '\n') | '\'' '\'' | NEWLINE)* '\'';
+
+// See https://livesql.oracle.com/apex/livesql/file/content_CIREYU9EA54EOKQ7LAMZKRF6P.html
+CHAR_STRING_PERL: 'Q' '\'' ~[ \t\r\n] .*? . '\'' {this.IsQQuoteDelimiter()}? -> type(CHAR_STRING);
+
+DELIMITED_ID: '"' (~ [\u0000"] | '"' '"')+ '"';
+
+PERCENT         : '%';
+AMPERSAND       : '&';
+LEFT_PAREN      : '(';
+RIGHT_PAREN     : ')';
+DOUBLE_ASTERISK : '**';
+ASTERISK        : '*';
+PLUS_SIGN       : '+';
+MINUS_SIGN      : '-';
+COMMA           : ',';
+SOLIDUS         : '/';
+RSOLIDUS        : '\\';
+AT_SIGN         : '@';
+ASSIGN_OP       : ':=';
+HASH_OP         : '#';
+
+LEFT_CURLY_PAREN  : '{';
+RIGHT_CURLY_PAREN : '}';
+
+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);
+// SQL*Plus separates a command word from its arguments with a space or a tab.
+// https://docs.oracle.com/cd/E11882_01/server.112/e16604/ch_twelve034.htm#SQPUG054
+REMARK_COMMENT:
+    'REM' {this.IsNewlineAtPos(-4)}? 'ARK'? ([ \t] ~('\r' | '\n')*)? NEWLINE_EOF -> channel(HIDDEN)
+;
+
+// https://docs.oracle.com/cd/E11882_01/server.112/e16604/ch_twelve032.htm#SQPUG052
+PROMPT_MESSAGE: 'PRO' {this.IsNewlineAtPos(-4)}? 'MPT'? ([ \t] ~('\r' | '\n')*)? NEWLINE_EOF;
+
+REGULAR_ID: SIMPLE_LETTER (SIMPLE_LETTER | '$' | '_' | '#' | [0-9])*;
+
+INQUIRY_DIRECTIVE: '$$' (SIMPLE_LETTER | '_')+;
+
+SPACES: [ \t\r\n\u3000]+ -> channel(HIDDEN);
+
+// Fragment rules
+
+fragment NEWLINE_EOF    : NEWLINE | EOF;
+fragment QUESTION_MARK  : '?';
+fragment SIMPLE_LETTER  : [\p{Letter}];
+fragment FLOAT_FRAGMENT : UNSIGNED_INTEGER* '.'? UNSIGNED_INTEGER+;
+fragment NEWLINE        : '\r'? '\n';
+fragment SPACE          : [ \t];
diff --git a/gitnexus/src/core/ingestion/plsql/grammar/PlSqlParser.g4 b/gitnexus/src/core/ingestion/plsql/grammar/PlSqlParser.g4
new file mode 100644
index 000000000..3fca1aeb8
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/grammar/PlSqlParser.g4
@@ -0,0 +1,10147 @@
+/**
+ * Oracle(c) PL/SQL 11g Parser
+ *
+ * Copyright (c) 2009-2011 Alexandre Porcelli <alexandre.porcelli@gmail.com>
+ * Copyright (c) 2015-2019 Ivan Kochurkin (KvanTTT, kvanttt@gmail.com, Positive Technologies).
+ * Copyright (c) 2017-2018 Mark Adams <madams51703@gmail.com>
+ *
+ * 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.
+ */
+
+// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging
+
+parser grammar PlSqlParser;
+
+options {
+    tokenVocab = PlSqlLexer;
+    superClass = PlSqlParserBase;
+}
+
+// Insert here @header for C++ parser.
+
+sql_script
+    : (sql_plus_command SEMICOLON?)* (
+        script_unit (terminator script_unit)* terminator?
+    )? EOF
+    ;
+
+// Actions set a flag for the `terminator` predicate: bare '/' is accepted only
+// after a SQL unit; a PL/SQL unit requires a preceding SEMICOLON.
+script_unit
+    : plsql_unit {this.setLastUnitPlsql();}
+    | sql_unit {this.setLastUnitSql();}
+    | sql_plus_command {this.setLastUnitSql();}
+    ;
+
+// Separator between units (and optional terminator after the last one).
+// SEMICOLON is always valid; bare '/' only after a SQL unit — the predicate
+// rejects '/' after a PL/SQL block, yielding useful diagnostic.
+// isSolidusSeparator() checks that '/' is on its own line (SQL*Plus separator
+// vs division operator).
+terminator
+    : SEMICOLON
+    | SEMICOLON {this.isSolidusSeparator()}? SOLIDUS
+    | {this.isLastUnitSql() && this.isSolidusSeparator()}? SOLIDUS
+    ;
+
+plsql_unit
+    : anonymous_block
+    | create_function_body
+    | create_procedure_body
+    | create_package
+    | create_package_body
+    | create_trigger
+    | create_type_body
+    ;
+
+// SQL/DDL statements. A trailing terminator is optional (the last unit in a
+// script may omit it); when present it is matched by the `terminator` rule,
+// which accepts SEMICOLON, SOLIDUS, or both.
+sql_unit
+    : 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
+    | call_statement
+    | create_analytic_view
+    | create_attribute_dimension
+    | create_audit_policy
+    | create_cluster
+    | create_context
+    | create_controlfile
+    | create_schema
+    | create_database
+    | create_database_link
+    | create_dimension
+    | create_directory
+    | create_diskgroup
+    | create_edition
+    | create_flashback_archive
+    | 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_pmem_filestore
+    | create_profile
+    | create_restore_point
+    | create_role
+    | create_rollback_segment
+    | create_sequence
+    | create_spfile
+    | create_synonym
+    | create_table
+    | create_tablespace
+    | create_tablespace_set
+    | create_type_spec
+    | 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_view_log
+    | 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
+    | 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
+    ;
+
+// 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
+    ;
+
+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 (
+        EDITIONABLE
+        | NONEDITIONABLE
+        | 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)? (EDITIONABLE | NONEDITIONABLE)? FUNCTION function_name (
+        '(' parameter (',' parameter)* ')'
+    )? RETURN type_spec (SHARING '=' (METADATA | NONE))? (
+        invoker_rights_clause
+        | accessible_by_clause
+        | default_collation_clause
+        | parallel_enable_clause
+        | result_cache_clause
+        | PIPELINED
+        | DETERMINISTIC
+    )* (
+        ((IS | AS) (DECLARE? seq_of_declare_specs? body | call_spec))
+        | aggregate_clause
+        | pipelined_using_clause
+        | 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? ('(' MODE (DEFAULT | FORCE ) ')')?
+    ;
+
+accessible_by_clause
+    : ACCESSIBLE BY '(' accessor (',' accessor)* ')'
+    ;
+
+default_collation_clause
+    : DEFAULT COLLATION USING_NLS_COMP
+    ;
+
+aggregate_clause
+    : AGGREGATE USING implementation_type_name
+    ;
+
+pipelined_using_clause
+    : PIPELINED ((ROW | TABLE) POLYMORPHIC)? USING implementation_type_name
+    ;
+
+accessor
+    : unitKind = (FUNCTION | PROCEDURE | PACKAGE | TRIGGER | TYPE) function_name
+    ;
+
+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)? (EDITIONABLE | NONEDITIONABLE)? PACKAGE (schema_object_name '.')? package_name invoker_rights_clause? (
+        IS
+        | AS
+    ) package_obj_spec* END package_name?
+    ;
+
+create_package_body
+    : CREATE (OR REPLACE)? (EDITIONABLE | NONEDITIONABLE)? PACKAGE BODY (schema_object_name '.')? package_name (
+        IS
+        | AS
+    ) package_obj_body*? (BEGIN seq_of_statements (EXCEPTION exception_handler+)?)? END package_name?
+    ;
+
+// Create Package Specific Clauses
+
+package_obj_spec
+    : pragma_declaration
+    | exception_declaration
+    | procedure_spec
+    | function_spec
+    | variable_declaration
+    | subtype_declaration
+    | cursor_declaration
+    | type_declaration
+    ;
+
+procedure_spec
+    : PROCEDURE identifier ('(' parameter ( ',' parameter)* ')')? (
+        accessible_by_clause
+        | PARALLEL_ENABLE
+        | DETERMINISTIC
+    )* (AS call_spec)? ';'
+    ;
+
+function_spec
+    : FUNCTION identifier ('(' parameter ( ',' parameter)* ')')? RETURN type_spec (
+        DETERMINISTIC
+        | PIPELINED
+        | parallel_enable_clause
+        | RESULT_CACHE
+        | streaming_clause
+    )* (AS call_spec)? ';'
+    ;
+
+package_obj_body
+    : pragma_declaration
+    | exception_declaration
+    | procedure_spec
+    | function_spec
+    | subtype_declaration
+    | cursor_declaration
+    | variable_declaration
+    | type_declaration
+    | procedure_body
+    | function_body
+    | selection_directive
+    ;
+
+// 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 (
+        PIPELINED
+        | DETERMINISTIC
+        | invoker_rights_clause
+        | parallel_enable_clause
+        | result_cache_clause
+        | streaming_clause
+            // see example in section "How Table Functions Stream their Input Data" on streaming_clause in Oracle 9i: https://docs.oracle.com/cd/B10501_01/appdev.920/a96624/08_subs.htm#20554
+    )* (
+        ( (IS | AS) (DECLARE? seq_of_declare_specs? body | call_spec))
+        | (PIPELINED | AGGREGATE) USING implementation_type_name
+    ) ';'
+    ;
+
+procedure_body
+    : PROCEDURE identifier ('(' parameter (',' parameter)* ')')? (
+        accessible_by_clause
+        | PARALLEL_ENABLE
+        | DETERMINISTIC
+    )* (IS | AS) (DECLARE? seq_of_declare_specs? body | call_spec | EXTERNAL) ';'
+    ;
+
+create_procedure_body
+    : CREATE (OR REPLACE)? (EDITIONABLE | NONEDITIONABLE)? PROCEDURE procedure_name (
+        '(' parameter (',' parameter)* ')'
+    )? invoker_rights_clause? (PARALLEL_ENABLE | DETERMINISTIC)* (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)? (EDITIONABLE | NONEDITIONABLE)? 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_block
+    | CALL identifier
+    | trigger_block
+    ;
+
+compound_trigger_block
+    : COMPOUND TRIGGER seq_of_declare_specs? timing_point_section+ END trigger_name?
+    ;
+
+timing_point_section
+    : bk = BEFORE STATEMENT IS tps_block BEFORE STATEMENT ';'
+    | bk = BEFORE EACH ROW IS tps_block BEFORE EACH ROW ';'
+    | ak = AFTER STATEMENT IS tps_block AFTER STATEMENT ';'
+    | ak = AFTER EACH ROW IS tps_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 | REFERENCES) 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
+        | alter_method_spec
+        | alter_attribute_definition
+        | 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) ATTRIBUTE (identifier type_spec? | '(' identifier type_spec (',' identifier type_spec)* ')')
+    | DROP ATTRIBUTE (identifier | '(' identifier (',' identifier)* ')')
+    ;
+
+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_type_spec | create_type_body
+    ;
+
+// Type spec (SQL, no END) — semicolon optional, solidus valid as terminator
+create_type_spec
+    : CREATE (OR REPLACE)? (EDITIONABLE | NONEDITIONABLE)? TYPE type_definition
+    ;
+
+// Type body (PL/SQL, has END) — requires semicolon, solidus optional after
+create_type_body
+    : CREATE (OR REPLACE)? (EDITIONABLE | NONEDITIONABLE)? TYPE 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 function_name
+        (
+            '(' (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 MEMBER overriding_procedure_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))? ';'?
+    ;
+
+overriding_procedure_spec
+    : PROCEDURE procedure_name
+        (
+            '(' type_elements_parameter (',' type_elements_parameter)* ')'
+        )?
+        (IS | AS) (call_spec | 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 (IN OUT NOCOPY | IN OUT | OUT NOCOPY | OUT | IN)? type_spec (ASSIGN_OP constant)?
+    ;
+
+// 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 (IF NOT EXISTS)? sequence_name sequence_spec* (SHARING '=' (METADATA | DATA | NONE))?
+    ;
+
+// Common Sequence
+
+sequence_spec
+    : INCREMENT BY UNSIGNED_INTEGER
+    | sequence_start_clause
+    | MAXVALUE UNSIGNED_INTEGER
+    | NOMAXVALUE
+    | MINVALUE UNSIGNED_INTEGER
+    | NOMINVALUE
+    | CYCLE
+    | NOCYCLE
+    | CACHE UNSIGNED_INTEGER
+    | NOCACHE
+    | ORDER
+    | NOORDER
+    | KEEP
+    | NOKEEP
+    | SCALE (EXTEND | NOEXTEND)?
+    | NOSCALE
+    | SHARD (EXTEND | NOEXTEND)?
+    | NOSHARD
+    | SESSION
+    | GLOBAL
+    ;
+
+sequence_start_clause
+    : START WITH (UNSIGNED_INTEGER | APPROXIMATE_NUM_LIT)
+    ;
+
+// 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 | system_actions)+
+    ;
+
+system_actions
+    : ACTIONS system_privilege (',' system_privilege)*
+    ;
+
+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 (IF NOT EXISTS)? ON (
+        cluster_index_clause
+        | table_index_clause
+        | bitmap_join_index_clause
+    ) (USABLE | UNUSABLE)? ((DEFERRED | IMMEDIATE) INVALIDATION)?
+    ;
+
+cluster_index_clause
+    : CLUSTER cluster_name index_attributes?
+    ;
+
+cluster_name
+    : (id_expression '.')? id_expression
+    ;
+
+table_index_clause
+    : tableview_name table_alias? '(' index_expr (ASC | DESC)? (',' index_expr (ASC | DESC)?)* ')' 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
+    : 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 '(' index_partitioning_values_list ')' segment_attributes_clause?
+    ;
+
+index_partitioning_values_list
+    : literal (',' literal)*
+    | TIMESTAMP literal (',' TIMESTAMP literal)*
+    ;
+
+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
+    | shrink_clause
+    ;
+
+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 | modify_index_partitions_ops)
+    ;
+
+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 (IF NOT EXISTS)? (
+        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 (IF EXISTS)? 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
+        | compute_clauses
+        | ESTIMATE SYSTEM? STATISTICS for_clause? (SAMPLE UNSIGNED_INTEGER (ROWS | PERCENT_KEYWORD))?
+        | 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
+    : {this.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
+    : {this.isVersion12()}? DIRECT_PATH auditing_by_clause
+    ;
+
+audit_container_clause
+    : {this.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
+        | {this.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
+    | {this.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 (IF EXISTS)?
+    ;
+
+// 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
+    : regular_id
+    ;
+
+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
+    : {this.isVersion12()}? (EDITIONABLE | NONEDITIONABLE)
+    ;
+
+library_debug
+    : {this.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
+    : {this.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 (
+        IF NOT EXISTS
+    )? (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 | CONSTRAINTS) constraint_name)? (
+            UNIQUE '(' column_name (',' column_name)* ')'
+            | PRIMARY KEY '(' column_name (',' column_name)* ')'
+            | foreign_key_clause
+            | CHECK '(' condition ')'
+        )
+    )
+    constraint_state?
+    parallel_clause?
+    ;
+
+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 (IF NOT EXISTS)? 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 (IF NOT EXISTS)? tempfile_specification? tablespace_group_clause? extent_management_clause?
+    ;
+
+undo_tablespace_clause
+    : UNDO TABLESPACE tablespace_name = id_expression (IF NOT EXISTS)? 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)
+    ;
+
+parallel_clause
+    : NOPARALLEL
+    | PARALLEL (
+        parallel_count = UNSIGNED_INTEGER parallel_instances_clause?
+        // Deprecated, legacy format from Oracle 8 and prior, and while this is no longer documented,
+        // the DEGREE syntax continues to be accepted by the database engine.
+        | '(' DEGREE parallel_count = UNSIGNED_INTEGER parallel_instances_clause? ')'
+    )?
+    ;
+
+// This is Oracle RAC specific.
+// In modern Oracle, parallelism is controlled by the database initialization parameter PARALLEL_DEGREE_POLICY,
+// however, the database continues to accept and record this SQL syntax if its used.
+parallel_instances_clause
+    : INSTANCES (UNSIGNED_INTEGER | DEFAULT)
+    ;
+
+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?
+    ;
+
+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 (
+        IF NOT EXISTS
+    )? 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? evaluation_edition_clause? (
+        (ENABLE | DISABLE) ON QUERY COMPUTATION
+    )? query_rewrite_clause? (
+        (ENABLE | DISABLE) CONCURRENT REFRESH
+    )? annotations_clause? 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)? (annotations_clause | scoped_table_ref_constraint)?
+    ;
+
+create_mv_refresh
+    : (
+        NEVER REFRESH
+        | REFRESH (
+            (FAST | COMPLETE | FORCE)
+            | ON (DEMAND | COMMIT | STATEMENT)
+            | (START WITH | NEXT) expression
+            | WITH (PRIMARY KEY | ROWID)
+            | USING (
+                DEFAULT (MASTER | LOCAL)? ROLLBACK SEGMENT
+                | (MASTER | LOCAL)? ROLLBACK SEGMENT rollback_segment_name
+            )
+            | USING (ENFORCED | TRUSTED) CONSTRAINTS
+        )+
+    )
+    ;
+
+query_rewrite_clause
+    : (ENABLE | DISABLE) QUERY REWRITE unusable_editions_clause?
+    ;
+
+unusable_editions_clause
+    : UNUSABLE (
+        (BEFORE | BEGINNING WITH) CURRENT EDITION
+        | (BEFORE | BEGINNING WITH) EDITION edition_name
+        | BEGINNING WITH NULL_ EDITION
+    )
+    ;
+
+drop_materialized_view
+    : DROP MATERIALIZED VIEW tableview_name (PRESERVE TABLE)?
+    ;
+
+drop_materialized_view_log
+    : DROP MATERIALIZED VIEW LOG (IF EXISTS)? ON tableview_name
+    ;
+
+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 (IF NOT EXISTS)? (
+        SHARING '=' (METADATA | EXTENDED? DATA | NONE)
+    )? (relational_table | xmltype_table | object_table) memoptimize_read_write_clause? (
+        PARENT tableview_name
+    )? (USAGE QUEUE)?
+    ;
+
+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 id_expression)? (allow_or_disallow (NONSCHEMA | 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)* ')')? relational_table_properties?
+    ;
+
+relational_table_properties
+    : relational_table_property+
+    ;
+
+relational_table_property
+    : immutable_table_clauses
+    | blockchain_table_clauses
+    | DEFAULT COLLATION collation_name
+    | ON COMMIT ((DROP | PRESERVE) DEFINITION | (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
+    ;
+
+// While Oracle's documented grammar defines an explicit order of clauses, in practice these clauses can
+// be specified in any order. This rule is designed to follow the grammar intent, and so semantic checks
+// should exist in the listeners to deal with concepts such as duplicates.
+table_properties
+    : column_properties
+    | read_only_clause
+    | indexing_clause
+    | table_partitioning_clauses
+    | attribute_clustering_clause
+    | (CACHE | NOCACHE)
+    | result_cache_clause
+    | parallel_clause
+    | monitoring_nomonitoring
+    | (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
+    | annotations_clause
+    ;
+
+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
+        | NO? PARTIAL JSON
+    )?
+    ;
+
+table_name
+    : identifier
+    ;
+
+relational_property
+    : out_of_line_constraint
+    | out_of_line_ref_constraint
+    | column_definition
+    | virtual_column_definition
+    | period_definition
+    | 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 ')' (
+        AUTOMATIC (STORE IN '(' tablespace (',' tablespace)* ')')?
+    )? (
+        '(' 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 '(' constraint_name ')' (
+        '(' 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 '(' range_values_list ')'
+    ;
+
+range_values_list
+    : literal (',' literal)*
+    | TIMESTAMP literal (',' TIMESTAMP literal)*
+    ;
+
+list_values_clause
+    : VALUES '(' (literal (',' literal)* | TIMESTAMP literal (',' TIMESTAMP literal)* | DEFAULT) ')'
+    ;
+
+table_partition_description
+    : (INTERNAL | EXTERNAL)? deferred_segment_creation? read_only_clause? indexing_clause? segment_attributes_clause? (
+        table_compression
+        | key_compression
+    )? inmemory_table_clause? ilm_clause? (
+        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
+        | inmemory_table_clause
+        | 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 ')'
+    )
+    ;
+
+// 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)?
+            | ALL OPERATIONS
+            | DIRECT_LOAD OPERATIONS
+        )
+    )?
+    | ROW STORE COMPRESS (BASIC | ADVANCED)?
+    | COLUMN STORE COMPRESS (FOR (QUERY | ARCHIVE) (LOW | HIGH)?)? (NO? ROW LEVEL LOCKING)?
+    | NOCOMPRESS
+    ;
+
+// avoid to match an empty string in
+inmemory_table_clause
+    : inmemory_column_clause+
+    | (INMEMORY inmemory_attributes? | NO INMEMORY) inmemory_column_clause*
+    ;
+
+inmemory_attributes
+    : (
+        inmemory_memcompress
+        | inmemory_priority
+        | inmemory_distribute
+        | 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
+        | 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
+    | 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 ')' parallel_clause? (
+        REJECT LIMIT (numeric | UNLIMITED)
+    )? inmemory_table_clause?
+    ;
+
+access_driver_type
+    : ORACLE_LOADER
+    | ORACLE_DATAPUMP
+    | ORACLE_HDFS
+    | ORACLE_HIVE
+    ;
+
+external_table_data_props
+    : (DEFAULT DIRECTORY external_table_directory)? (
+        ACCESS PARAMETERS (
+            '(' CHAR_STRING ')'
+            | '(' external_table_data_format+ ')'
+            | USING CLOB select_only_statement
+        )
+    )? (LOCATION '(' external_table_directory (',' external_table_directory)* ')')?
+    ;
+
+external_table_data_format
+    : RECORDS DELIMITED BY NEWLINE_
+    | COLUMN TRANSFORMS '(' external_table_transform (',' external_table_transform)* ')'
+    | external_table_records
+    | external_table_fields
+    | external_table_datapump
+    | external_table_hive
+    ;
+
+external_table_transform
+    : column_name FROM (
+        NULL_
+        | CONSTANT quoted_string
+        | (CONCAT | LOBFILE) (external_table_field | CONSTANT quoted_string)
+        | (
+            FROM '(' external_table_directory (',' external_table_directory)* ')'
+            | CLOB
+            | BLOB
+            | CHARACTERSET '=' char_set_name
+        )
+        | STARTOF external_table_field_list '(' UNSIGNED_INTEGER ')'
+    )
+    ;
+
+external_table_field
+    : column_name type_name? (NOT NULL_)? default_value_part?
+    ;
+
+external_table_field_list
+    : external_table_fields_clause (',' external_table_fields_clause)*
+    ;
+
+external_table_fields_clause
+    : external_table_field (
+        external_table_position_clause
+        | external_table_datatype_clause
+        | external_table_init_clause
+        | external_table_lls_clause
+    )*
+    ;
+
+external_table_position_clause
+    : POSITION? '(' ('*'? ('+' | '-')? UNSIGNED_INTEGER?) (BINDVAR | (':' ('+' | '-')? UNSIGNED_INTEGER)) ')'
+    ;
+
+external_table_datatype_clause
+    : UNSIGNED? INTEGER EXTERNAL? UNSIGNED_INTEGER? external_table_delimit_clause?
+    | (DECIMAL | ZONED) (
+        '(' UNSIGNED_INTEGER (',' UNSIGNED_INTEGER)? ')'
+        | EXTERNAL ('(' UNSIGNED_INTEGER ')')? external_table_delimit_clause?
+    )
+    | ORACLE_DATE
+    | ORACLE_NUMBER COUNTED?
+    | FLOAT EXTERNAL? UNSIGNED_INTEGER? external_table_delimit_clause?
+    | DOUBLE
+    | BINARY_FLOAT EXTERNAL? UNSIGNED_INTEGER? external_table_delimit_clause?
+    | BINARY_DOUBLE
+    | RAW UNSIGNED_INTEGER?
+    | CHAR EXTERNAL? ('(' UNSIGNED_INTEGER ')' )? external_table_delimit_clause? external_table_trim_clause? external_table_date_format_clause?
+    | (VARCHAR | VARRAW | VARCHARC | VARRAWC) '(' (UNSIGNED_INTEGER ',')? UNSIGNED_INTEGER ')'
+    ;
+
+external_table_delimit_clause
+    : ENCLOSED BY quoted_string (AND quoted_string)?
+    | TERMINATED BY (quoted_string | WHITESPACE) (OPTIONALLY? ENCLOSED BY quoted_string (AND quoted_string)?)?
+    ;
+
+external_table_trim_clause
+    : LRTRIM
+    | NOTRIM
+    | LTRIM
+    | RTRIM
+    | LDRTRIM
+    ;
+
+external_table_date_format_clause
+    : DATE_FORMAT? (
+        DATE
+        | TIMESTAMP (WITH LOCAL? TIME ZONE)? MASK quoted_string
+        | INTERVAL (YEAR_TO_MONTH | DAY_TO_SECOND)
+    )
+    ;
+
+external_table_init_clause
+    : (DEFAULTIF | NULLIF) external_table_condition_clause
+    ;
+
+external_table_condition_clause
+    : (field_spec | '(' UNSIGNED_INTEGER BINDVAR ')') relational_operator (quoted_string | HEX_STRING_LIT | BLANKS)
+    | external_table_condition_clause (AND | OR) external_table_condition_clause
+    ;
+
+external_table_lls_clause
+    : LLS external_table_directory
+    ;
+
+external_table_records
+    : RECORDS (
+        FIXED UNSIGNED_INTEGER
+        | VARIABLE UNSIGNED_INTEGER
+        | DELIMITED BY (DETECTED? NEWLINE_ | quoted_string)
+        | XMLTAG '('? id_expression (',' id_expression)* ')'?
+    ) external_table_record_options_clause*
+    | external_table_record_options_clause+
+    ;
+
+external_table_record_options_clause
+    : CHARACTERSET char_set_name
+    | EXTERNAL VARIABLE DATA
+    | PREPROCESSOR external_table_directory
+    | DATA IS (LITTLE | BIG) ENDIAN
+    | BYTEORDERMARK (CHECK | NOCHECK)
+    | STRING SIZES ARE IN (BYTES | CHARACTERS)
+    | LOAD WHEN external_table_condition_clause
+    | external_table_output_files
+    | READSIZE '='? UNSIGNED_INTEGER
+    | DISABLE_DIRECTORY_LINK_CHECK
+    | DATE_CACHE UNSIGNED_INTEGER
+    | SKIP_ UNSIGNED_INTEGER
+    | IO_OPTIONS (DIRECTIO | NODIRECTIO)
+    | (DNFS_ENABLE | DNFS_DISABLE)
+    | DNFS_READBUFFERS UNSIGNED_INTEGER
+    ;
+
+external_table_output_files
+    : (
+        (NOBADFILE | NODISCARDFILE | NOLOGFILE)
+        | (BADFILE | DISCARDFILE | LOGFILE) external_table_directory? filename
+    )
+    ;
+
+external_table_fields
+    : FIELDS
+        IGNORE_CHARS_AFTER_EOR?
+        (CSV (WITH | WITHOUT) EMBEDDED)?
+        external_table_delimit_clause?
+        external_table_trim_clause?
+        (ALL FIELDS OVERRIDE THESE FIELDS)?
+        (MISSING FIELD VALUES ARE NULL_)?
+        (REJECT ROWS WITH ALL NULL_ FIELDS)?
+        (DATE_FORMAT (DATE | TIMESTAMP) MASK quoted_string)?
+        (NULLIF (EQUALS_OP | NOT_EQUAL_OP) (quoted_string | HEX_STRING_LIT | BLANKS) | NONULLIF)?
+        '('? external_table_field_list? ')'?
+    ;
+
+external_table_datapump
+    : ENCRYPTION (ENABLE | DISABLED)
+    | NOLOGFILE
+    | LOGFILE external_table_directory? filename
+    | COMPRESSION (ENABLED (BASIC | LOW | MEDIUM | HIGH)? | DISABLED)?
+    | HADOOP_TRAILERS (ENABLED | DISABLED) VERSION (COMPATIBLE | LATEST | quoted_string)
+    | NOLOG
+    | DEBUG '=' '(' UNSIGNED_INTEGER ',' UNSIGNED_INTEGER ')'
+    | DATAPUMP INTERNAL TABLE tableview_name
+    | TEMPLATE_TABLE tableview_name
+    | JOB '(' schema_name ',' tableview_name ',' UNSIGNED_INTEGER ')'
+    | WORKERID UNSIGNED_INTEGER
+    | PARALLEL UNSIGNED_INTEGER
+    | VERSION quoted_string
+    | ENCRYPTPASSWORDISNULL
+    | DBLINK quoted_string
+    ;
+
+external_table_hive
+    : id_expression ('.' id_expression)* ('=' | ':') (
+        tableview_name
+        | external_table_hive_parameter_map
+        | '[' external_table_hive_parameter_map (',' external_table_hive_parameter_map)* ']'
+        | external_table_field datatype (COMMENT quoted_string)? (',' COMMENT quoted_string)*
+        | SEQUENCEFILE
+        | TEXTFILE
+        | RCFILE
+        | ORC
+        | PARQUET
+        | INPUTFORMAT quoted_string OUTPUTFORMAT quoted_string
+        | external_table_directory
+        | DELIMITED? (
+            FIELDS TERMINATED BY CHARACTER (ESCAPED BY CHARACTER)
+            | (COLLECTION ITEMS | MAP KEYS | LINES ) TERMINATED BY CHARACTER
+            | NULL_ DEFINED AS CHARACTER
+        )
+        | SERDE quoted_string (
+            WITH SERDEPROPERTIES (
+                quoted_string '=' quoted_string (',' quoted_string '=' quoted_string)*
+            )
+        )?
+    ) external_table_hive?
+    ;
+
+external_table_hive_parameter_map
+    : LEFT_CURLY_PAREN (external_table_hive_parameter_map_entry (',' external_table_hive_parameter_map_entry)*) RIGHT_CURLY_PAREN
+    ;
+
+external_table_hive_parameter_map_entry
+    : id_expression BINDVAR
+    | id_expression ':' '[' id_expression (',' id_expression)* ']'
+    | '[' id_expression (',' id_expression)* ']'
+    ;
+
+external_table_directory
+    : directory_name COLON CHAR_STRING
+    | (directory_name object_name? COLON)? CHAR_STRING
+    | quoted_string
+    | variable_name
+    ;
+
+row_movement_clause
+    : (ENABLE | DISABLE)? ROW MOVEMENT
+    ;
+
+flashback_archive_clause
+    : FLASHBACK ARCHIVE fa = id_expression?
+    | NO FLASHBACK ARCHIVE
+    ;
+
+log_grp
+    : UNSIGNED_INTEGER
+    | identifier
+    ;
+
+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 '(' column_name (NO LOG)? (',' column_name (NO LOG)?)* ')' ALWAYS?
+    ;
+
+supplemental_id_key_clause
+    : DATA '(' (','? ( ALL | PRIMARY KEY | UNIQUE INDEX? | 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)?
+    ;
+
+// CHECK is an internal, undocumented Oracle option that is allowed and sometimes specified, used to check for proper
+// segment type and segment attributes allowed to shrink.
+shrink_clause
+    : SHRINK SPACE_KEYWORD COMPACT? CASCADE? CHECK?
+    ;
+
+records_per_block_clause
+    : (MINIMIZE | NOMINIMIZE)? RECORDS_PER_BLOCK
+    ;
+
+upgrade_table_clause
+    : UPGRADE (NOT? INCLUDING DATA) column_properties
+    ;
+
+truncate_table
+    : TRUNCATE TABLE tableview_name ((PRESERVE | PURGE) (MATERIALIZED VIEW LOG)?)? ((DROP ALL? | REUSE) STORAGE)? CASCADE?
+    ;
+
+drop_table
+    : DROP TABLE tableview_name (IF EXISTS)? (AS tableview_name)? (CASCADE (CONSTRAINT | CONSTRAINTS))? PURGE? (AS table_alias)? FORCE?
+    ;
+
+// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-TABLESPACE.html
+drop_tablespace
+    : DROP TABLESPACE ts = id_expression (IF EXISTS)? ((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 (IF EXISTS)? (CASCADE CONSTRAINT)?
+    ;
+
+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 (schema_name PERIOD)? 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
+    : id_expression
+    ;
+
+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
+    : {this.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 TIME_ZONE EQUALS_OP CHAR_STRING
+    ;
+
+instance_clauses
+    : enable_or_disable INSTANCE CHAR_STRING
+    ;
+
+security_clause
+    : GUARD (ALL | STANDBY | NONE)
+    ;
+
+domain
+    : id_expression
+    ;
+
+database
+    : id_expression
+    ;
+
+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 local_link_name (
+        CONNECT TO user_object_name IDENTIFIED BY password_value link_authentication?
+        | link_authentication
+    )
+    ;
+
+password_value
+    : id_expression
+    | numeric
+    | VALUES CHAR_STRING
+    ;
+
+link_authentication
+    : AUTHENTICATED BY user_object_name IDENTIFIED BY password_value
+    ;
+
+//https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/CREATE-SCHEMA.html
+create_schema
+    : CREATE SCHEMA AUTHORIZATION schema_name (create_table | create_view | grant_statement)*
+    ;
+
+// 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 link_name (
+        CONNECT TO (
+            CURRENT_USER
+            | user_object_name IDENTIFIED BY password_value link_authentication?
+        )
+        | link_authentication
+    )* (USING CHAR_STRING)?
+    ;
+
+drop_database_link
+    : DROP PUBLIC? DATABASE LINK link_name
+    ;
+
+// 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_body?
+        | alter_table_body
+    )
+    ;
+
+alter_table_body
+    : alter_table_action enable_disable_clauses?
+    | enable_disable_clauses
+    ;
+
+alter_table_action
+    : alter_table_properties
+    | constraint_clauses
+    | column_clauses
+    | alter_table_partitioning
+    //TODO      | alter_external_table
+    | move_table_clause
+    | modify_to_partitioned
+    ;
+
+enable_disable_clauses
+    : (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
+    | NO? ROW ARCHIVAL
+    | annotations_clause
+    ;
+
+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
+    | move_table_partition
+    | rename_table_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 (PARTITION | SUBPARTITION) partition_name ((ADD | DROP) list_values_clause)? (
+        ADD range_subpartition_desc
+    )? (REBUILD? UNUSABLE LOCAL INDEXES)? shrink_clause?
+    ;
+
+split_table_partition
+    : SPLIT partition_extended_names (
+        AT '(' literal (',' literal)* ')' INTO '(' range_partition_desc (',' range_partition_desc)* ')'
+        | INTO '(' (
+            range_partition_desc (',' range_partition_desc)*
+            | list_partition_desc (',' list_partition_desc)*
+        ) ')'
+    ) (update_global_index_clause | update_index_clauses | ONLINE)?
+    ;
+
+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)? ')'
+    ;
+
+move_table_partition
+    : MOVE (
+        partition_extended_names (MAPPING TABLE)? table_partition_description
+        | subpartition_extended_names indexing_clause? partitioning_storage_clause?
+    ) (
+        filter_condition
+        | update_index_clauses
+        | parallel_clause
+        | allow_or_disallow CLUSTERING
+        | ONLINE
+    )*
+    ;
+
+filter_condition
+    : INCLUDING ROWS where_clause
+    ;
+
+rename_table_partition
+    : RENAME (partition_extended_names | subpartition_extended_names) TO partition_name
+    ;
+
+partition_extended_names
+    : (PARTITION | PARTITIONS) (
+        partition_name (',' 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
+        | logical_replication_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_properties)
+    ;
+
+index_attributes
+    : (
+        physical_attributes_clause
+        | logging_clause
+        | ONLINE
+        | TABLESPACE (tablespace | DEFAULT)
+        | key_compression
+        | sort_or_nosort
+        | REVERSE
+        | visible_or_invisible
+        | 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?
+    ;
+
+modify_to_partitioned
+    : MODIFY (table_partitioning_clauses | NONPARTITIONED) filter_condition? ONLINE? update_index_clauses?
+    ;
+
+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_properties
+    : column_name datatype? (
+        DEFAULT (ON NULL_)? expression
+        | identity_clause
+        | DROP IDENTITY
+    )? (ENCRYPT encryption_spec | DECRYPT)? inline_constraint* lob_storage_clause? annotations_clause?
+    //TODO alter_xmlschema_clause
+    ;
+
+modify_col_visibility
+    : column_name (VISIBLE | INVISIBLE)
+    ;
+
+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?
+    ;
+
+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
+    | DELIMITED_ID
+    ;
+
+lob_item
+    : regular_id
+    | quoted_string
+    | DELIMITED_ID
+    ;
+
+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 UNSIGNED_INTEGER?
+        | 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
+    : {this.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 | type_name) (COLLATE column_collation_name)?)? SORT? (
+        VISIBLE
+        | INVISIBLE
+    )? (DEFAULT (ON NULL_)? expression | identity_clause)? (ENCRYPT encryption_spec)? (
+        inline_constraint+
+        | inline_ref_constraint
+    )? annotations_clause?
+    ;
+
+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
+    | SCALE (EXTEND | NOEXTEND)
+    | NOSCALE
+    | KEEP
+    | NOKEEP
+    ;
+
+virtual_column_definition
+    : column_name (datatype (COLLATE column_collation_name)?)? (VISIBLE | INVISIBLE)? virtual_column_expression? VIRTUAL?
+        evaluation_edition_clause? (UNUSABLE BEFORE (CURRENT EDITION | EDITION edition_name))? (
+        UNUSABLE BEGINNING WITH ((CURRENT | NULL_) EDITION | EDITION edition_name)
+    )? inline_constraint* by_user_for_statistics_clause?
+    ;
+
+virtual_column_expression
+    : autogenerated_sequence_definition
+    | (GENERATED ALWAYS?)? AS '(' expression ')'
+    ;
+
+autogenerated_sequence_definition
+    : GENERATED (ALWAYS | BY DEFAULT (ON NULL_)?)? AS IDENTITY (
+        '(' (sequence_start_clause | sequence_spec)* ')'
+    )?
+    ;
+
+// Oracle tools and DBMS_METADATA can return this in some use cases
+// This is used internally by Oracle to mark the virtual column for statistics only
+by_user_for_statistics_clause
+    : BY USER FOR STATISTICS
+    ;
+
+evaluation_edition_clause
+    : EVALUATE USING ((CURRENT | NULL_) EDITION | EDITION edition_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)
+    ;
+
+object_type_col_properties
+    : COLUMN column = regular_id substitutable_column_clause
+    ;
+
+constraint_clauses
+    : ADD '(' (out_of_line_constraint (',' 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 (
+        PRIMARY KEY
+        | UNIQUE '(' column_name (',' column_name)* ')'
+        | CONSTRAINT constraint_name
+    ) CASCADE? ((KEY | DROP) INDEX)? ONLINE?
+    ;
+
+check_constraint
+    : CHECK '(' condition ')' DISABLE?
+    ;
+
+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_)
+    ;
+
+// Anonymous PL/SQL code block
+
+anonymous_block
+    : (DECLARE seq_of_declare_specs?)? BEGIN seq_of_statements (EXCEPTION exception_handler+)? END
+    ;
+
+// Common DDL Clauses
+
+invoker_rights_clause
+    : AUTHID (CURRENT_USER | DEFINER)
+    ;
+
+call_spec
+    : java_spec
+    | c_spec
+    ;
+
+// Call Spec Specific Clauses
+
+java_spec
+    : LANGUAGE JAVA NAME CHAR_STRING
+    ;
+
+c_spec
+    : (LANGUAGE C_LETTER | EXTERNAL) (
+        NAME id_expression LIBRARY identifier
+        | LIBRARY identifier (NAME id_expression)?
+    ) c_agent_in_clause? (WITH CONTEXT)? c_parameters_clause?
+    ;
+
+c_agent_in_clause
+    : AGENT IN '(' expressions_ ')'
+    ;
+
+c_parameters_clause
+    : PARAMETERS '(' c_external_parameter (',' c_external_parameter)* ')'
+    ;
+
+c_external_parameter
+    : CONTEXT
+    | SELF (TDO | c_property)?
+    | (parameter_name | RETURN) c_property? (BY REFERENCE)? external_datatype = regular_id?
+    ;
+
+c_property
+    : INDICATOR (STRUCT | TDO)?
+    | LENGTH
+    | DURATION
+    | MAXLEN
+    | CHARSETID
+    | CHARSETFORM
+    ;
+
+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
+    | procedure_spec
+    | function_spec
+    | variable_declaration
+    | subtype_declaration
+    | cursor_declaration
+    | type_declaration
+    | procedure_body
+    | function_body
+    | selection_directive
+    ;
+
+// 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)+ ')'
+        | DEPRECATE '(' identifier ( ',' CHAR_STRING)? ')'
+        | UDF
+    ) ';'
+    ;
+
+// 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 (NOT NULL_)? table_indexed_by_part?
+    ;
+
+table_indexed_by_part
+    : (idx1 = INDEXED | idx2 = INDEX) BY type_spec
+    ;
+
+//https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/collection-variable.html#GUID-89A1863C-65A1-40CF-9392-86E9FDC21BE9
+varray_type_def
+    : (VARRAY | VARYING? ARRAY) '(' expression ')' OF type_spec (NOT NULL_)?
+    ;
+
+// Statements
+
+seq_of_statements
+    : (pragma_declaration* statement (';' | EOF) | label_declaration | selection_directive)+
+    ;
+
+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
+    | call_statement
+    | pipe_row_statement
+    | grant_statement
+    ;
+
+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 ')')
+    ;
+
+//https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/FORALL-statement.html#GUID-C45B8241-F9DF-4C93-8577-C840A25963DB
+forall_statement
+    : FORALL index_name IN bounds_clause (SAVE EXCEPTIONS)? (data_manipulation_language_statements | execute_immediate)
+    ;
+
+bounds_clause
+    : lower_bound '..' upper_bound
+    | INDICES OF general_element 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? ('.' routine_name function_argument?)* (
+        INTO bind_variable
+    )?
+    ;
+
+pipe_row_statement
+    : PIPE ROW '(' expression ')'
+    ;
+
+selection_directive
+    : DOLLAR_IF condition DOLLAR_THEN selection_directive_body? (
+        DOLLAR_ELSIF condition DOLLAR_THEN selection_directive_body?
+    )* (DOLLAR_ELSE selection_directive_body?)? DOLLAR_END
+    ;
+
+error_directive
+    : DOLLAR_ERROR concatenation DOLLAR_END
+    ;
+
+selection_directive_body
+    : (
+        pragma_declaration? statement ';'
+        | variable_declaration
+        | error_directive
+        | function_body
+        | procedure_body
+    )+
+    ;
+
+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
+    ;
+
+tps_block
+    : declare_spec* body
+    ;
+
+block
+    : (DECLARE declare_spec*)? body
+    ;
+
+// SQL Statements
+
+sql_statement
+    : execute_immediate
+    | data_manipulation_language_statements
+    | cursor_manipulation_statements
+    | transaction_control_statements
+    | collection_method_call
+    ;
+
+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_or_collection (',' variable_or_collection)*
+        | BULK COLLECT INTO variable_or_collection (',' variable_or_collection)* (
+            LIMIT (numeric | variable_or_collection)
+        )?
+    )
+    ;
+
+variable_or_collection
+    : variable_name
+    | collection_expression
+    ;
+
+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? write_clause? (
+        COMMENT CHAR_STRING write_clause?
+        | FORCE (CHAR_STRING (',' numeric)? | CORRUPT_XID CHAR_STRING | CORRUPT_XID_ALL)
+    )?
+    ;
+
+write_clause
+    : WRITE (
+        (IMMEDIATE | BATCH)
+        | (WAIT | NOWAIT)
+        )*
+    ;
+
+rollback_statement
+    : ROLLBACK WORK? (TO SAVEPOINT? savepoint_name | FORCE quoted_string)?
+    ;
+
+savepoint_statement
+    : SAVEPOINT savepoint_name
+    ;
+
+// https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/collection-method.html#GUID-7AF1A3C4-D04B-4F91-9D7B-C92C75E3A300
+collection_method_call // collection methods invocation that could be used as a statement
+    : expression '.' (
+        (DELETE | EXTEND) ('(' index += expression (',' index += expression)* ')')?
+        | TRIM ('(' index += expression ')')?
+    )
+    ;
+
+// 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
+with_clause
+    : WITH (function_body | procedure_body)* with_factoring_clause (',' with_factoring_clause)*
+    | WITH (function_body | procedure_body)+ (with_factoring_clause (',' with_factoring_clause)*)?
+    ;
+
+with_factoring_clause
+    : subquery_factoring_clause
+    | subav_factoring_clause
+    ;
+
+subquery_factoring_clause
+    : query_name paren_column_list? AS '(' subquery_no_with 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
+    ;
+
+subav_factoring_clause
+    : subav_name = id_expression ANALYTIC VIEW AS '(' subav_clause ')'
+    ;
+
+subav_clause
+    : USING subav_name = object_name hierarchies_clause? filter_clauses? add_calcs_clause?
+    ;
+
+hierarchies_clause
+    : HIERARCHIES '(' hier_alias += object_name (',' hier_alias += object_name)* ')'
+    ;
+
+filter_clauses
+    : FILTER FACT '(' filter_clause (',' filter_clause)* ')'
+    ;
+
+filter_clause
+    : (MEASURES | hier_alias = object_name) TO condition
+    ;
+
+add_calcs_clause
+    : ADD MEASURES '(' add_calc_meas_clause (',' add_calc_meas_clause)* ')'
+    ;
+
+add_calc_meas_clause
+    : meas_name = id_expression AS '(' expression ')'
+    ;
+
+subquery
+    : with_clause? subquery_basic_elements subquery_operation_part*
+    ;
+
+// A subquery that must not start with (or contain, parenthesized) a WITH clause.
+// Used where Oracle rejects a CTE: inside another CTE definition and as UNION/INTERSECT/MINUS operands.
+subquery_no_with
+    : subquery_basic_elements subquery_operation_part*
+    ;
+
+subquery_basic_elements
+    : query_block
+    | '(' subquery_no_with ')'
+    ;
+
+subquery_operation_part
+    : (UNION ALL? | INTERSECT | MINUS) subquery_basic_elements
+    ;
+
+query_block
+    : SELECT (DISTINCT | UNIQUE | ALL)? selected_list into_clause? from_clause? where_clause? (
+        hierarchical_query_clause
+        | group_by_clause
+    )* model_clause? order_by_clause? offset_clause? fetch_clause?
+    ;
+
+selected_list
+    : '*'
+    | select_list_elements (',' select_list_elements)*
+    ;
+
+from_clause
+    : FROM table_ref_list
+    ;
+
+select_list_elements
+    : tableview_name '.' ASTERISK
+    | expression column_alias?
+    ;
+
+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* ({this.isNotStartOfJoin()}? 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_thre
+    ;
+
+join_clause
+    : query_partition_clause? (CROSS | NATURAL)? (INNER | outer_join_type)? JOIN table_ref_aux query_partition_clause? (
+        join_on_part
+        | join_using_part
+    )*
+    | (CROSS | OUTER) APPLY table_ref_aux
+    ;
+
+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 (PERIOD_KEYWORD FOR column_name BETWEEN | BETWEEN (SCN | TIMESTAMP)) expression AND expression
+    | AS OF ((SCN | TIMESTAMP | SNAPSHOT) expression | PERIOD_KEYWORD FOR column_name expression)
+    ;
+
+pivot_clause
+    : PIVOT XML? '(' pivot_element (',' pivot_element)* pivot_for_clause pivot_in_clause ')' table_alias?
+    ;
+
+pivot_element
+    : (numeric_function | 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 ')' table_alias?
+    ;
+
+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
+    ;
+
+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 (FIELDS)? paren_column_list?
+    ;
+
+values_clause
+    : VALUES (
+        REGULAR_ID
+        | '(' expressions_ ')' (COMMA '(' expressions_ ')')*
+        | collection_expression
+    )
+    ;
+
+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? static_returning_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_collection_expression | '(' table_collection_expression ')') 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 hierarchies_clause? sample_clause?
+    | json_table_clause (AS identifier)?
+    | LATERAL '(' subquery subquery_restriction_clause? ')'
+    // Deprecated Oracle 10/11 RELATIONAL alias for casting object-types to relational tables
+    | {this.isVersion11()}? (RELATIONAL '(' tableview_name NOT XMLTYPE ')')
+    ;
+
+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_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 unary_logical_operation?
+    ;
+
+unary_logical_operation
+    : IS NOT? logical_operation
+    ;
+
+logical_operation
+    : (
+        NULL_
+        | NAN_
+        | PRESENT
+        | INFINITE
+        | A_LETTER SET
+        | EMPTY_
+        | OF TYPE? '(' ONLY? type_spec (',' type_spec)* ')'
+        | JSON (FORMAT JSON)? (STRICT | LAX)? ((WITH | WITHOUT) UNIQUE KEYS)?
+    )
+    ;
+
+multiset_expression
+    : relational_expression (multiset_type = NOT? (MEMBER | SUBMULTISET) OF? concatenation)?
+    | multiset_expression MULTISET multiset_operator = (EXCEPT | INTERSECT | UNION) (
+        ALL
+        | DISTINCT
+    )? relational_expression
+    ;
+
+relational_expression
+    : relational_expression relational_operator relational_expression
+    | relational_expression NOT? IN in_elements
+    | 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 = DOUBLE_ASTERISK concatenation
+    | concatenation op = (ASTERISK | SOLIDUS | MOD) concatenation
+    | concatenation op = (PLUS_SIGN | MINUS_SIGN) concatenation
+    | concatenation BAR BAR concatenation
+    | concatenation COLLATE column_collation_name
+    ;
+
+interval_expression
+    : DAY ('(' concatenation ')')? TO SECOND ('(' concatenation ')')?
+    | YEAR ('(' concatenation ')')? TO MONTH
+    ;
+
+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
+    : PRIOR unary_expression_core
+    | CONNECT_BY_ROOT unary_expression_core
+    | NEW unary_expression_core
+    | OLD unary_expression_core
+    | unary_expression_core (
+        '.' (
+            (COUNT | FIRST | LAST | LIMIT)
+            | (EXISTS | NEXT | PRIOR) '(' index += expression ')'
+        )
+    )?
+    ;
+
+unary_expression_core
+    : case_expression
+    | quantified_expression
+    | standard_function
+    | {this.IsNotNumericFunction()}? atom
+    | implicit_cursor_expression
+    | selection_directive_expression
+    ;
+
+// https://docs.oracle.com/en/database/oracle/oracle-database/26/lnpls/conditional-compilation1.html
+selection_directive_expression
+    : DOLLAR_IF condition DOLLAR_THEN expression (
+        DOLLAR_ELSIF condition DOLLAR_THEN expression
+    )* (DOLLAR_ELSE expression)? DOLLAR_END
+    ;
+
+// https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-optimization-and-tuning.html#GUID-DAF46F06-EF3F-4B1A-A518-5238B80C69FA
+implicit_cursor_expression
+    : SQL (
+        PERCENT_BULK_ROWCOUNT '(' index = expression ')'
+        | PERCENT_BULK_EXCEPTIONS ('.' COUNT | '(' expression ')' '.' (ERROR_INDEX | ERROR_CODE))
+    )
+    ;
+
+collection_expression
+    : collation_name '(' expression ')' ('.' general_element_part)*
+    ;
+
+// CASE statement
+case_statement
+    : searched_case_statement
+    | simple_case_statement
+    ;
+
+simple_case_statement
+    : label_declaration? ck1 = CASE expression case_when_part_statement+ case_else_part_statement? END CASE? label_name?
+    ;
+
+searched_case_statement
+    : label_declaration? ck1 = CASE case_when_part_statement+ case_else_part_statement? END CASE? label_name?
+    ;
+
+case_when_part_statement
+    : WHEN expression THEN seq_of_statements
+    ;
+
+case_else_part_statement
+    : ELSE seq_of_statements
+    ;
+
+
+// CASE expression
+case_expression
+    : searched_case_expression
+    | simple_case_expression
+    ;
+
+simple_case_expression
+    : ck1 = CASE expression case_when_part_expression+ case_else_part_expression? END CASE?
+    ;
+
+searched_case_expression
+    : ck1 = CASE case_when_part_expression+ case_else_part_expression? END CASE?
+    ;
+
+case_when_part_expression
+    : WHEN expression THEN expression
+    ;
+
+case_else_part_expression
+    : ELSE expression
+    ;
+
+atom
+    : bind_variable
+    | constant
+    | inquiry_directive
+    | general_element outer_join_sign?
+    | '(' subquery ')' subquery_operation_part*
+    | '(' expression ')' ('.' general_element_part)*
+    | '(' expressions_ ')'
+    ;
+
+quantified_expression
+    : (SOME | EXISTS | ALL | ANY) (
+        '(' select_only_statement ')'
+        | '(' expression (',' 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)? expression? 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
+    | {this.IsNotNumericFunction()}? 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 | identifier) (
+        FORMAT JSON
+    )?
+    ;
+
+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 TIME ZONE)?
+    | 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
+    | numeric_negative
+    | MAXVALUE
+    ;
+
+numeric_function_wrapper
+    : numeric_function (single_column_for_loop | multi_column_for_loop)?
+    ;
+
+numeric_function
+    : SUM '(' (DISTINCT | ALL)? expression ')' (over_clause | keep_clause)?
+    | COUNT '(' (ASTERISK | ((DISTINCT | UNIQUE | ALL)? concatenation)?) ')' (over_clause | keep_clause)?
+    | ROUND '(' expression (',' (UNSIGNED_INTEGER | expression))? ')'
+    | AVG '(' (DISTINCT | ALL)? expression ')' (over_clause | keep_clause)?
+    | MIN '(' (DISTINCT | ALL)? expression ')' (over_clause | keep_clause)?
+    | MAX '(' (DISTINCT | ALL)? expression ')' (over_clause | keep_clause)?
+    | 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+
+    // Modified to allow expressions as delimiter to LISTAGG
+    | LISTAGG '(' (ALL | DISTINCT | UNIQUE)? argument (',' expression)? 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
+    | (LEAD | LAG) 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 ')' ('.' general_element_part)*
+    | 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_part)*
+    | (XMLCOLATTVAL | XMLFOREST) '(' xml_multiuse_expression_element (
+        ',' xml_multiuse_expression_element
+    )* ')' ('.' general_element_part)*
+    | XMLELEMENT '(' (ENTITYESCAPING | NOENTITYESCAPING)? (NAME | EVALNAME)? expression (
+        /*TODO{input.LT(2).getText().equalsIgnoreCase("xmlattributes")}?*/ ',' xml_attributes_clause
+    )? (',' expression column_alias?)* ')' ('.' general_element_part)*
+    | XMLEXISTS '(' expression xml_passing_clause? ')'
+    | XMLPARSE '(' (DOCUMENT | CONTENT) concatenation WELLFORMED? ')' ('.' general_element_part)*
+    | XMLPI '(' (NAME identifier | EVALNAME concatenation) (',' concatenation)? ')' (
+        '.' general_element_part
+    )*
+    | XMLQUERY '(' concatenation xml_passing_clause? RETURNING CONTENT (NULL_ ON EMPTY_)? ')' (
+        '.' general_element_part
+    )*
+    | XMLROOT '(' concatenation (',' xmlroot_param_version_part)? (
+        ',' xmlroot_param_standalone_part
+    )? ')' ('.' general_element_part)*
+    | XMLSERIALIZE '(' (DOCUMENT | CONTENT) concatenation (AS type_spec)? xmlserialize_param_enconding_part? xmlserialize_param_version_part?
+        xmlserialize_param_ident_part? ((HIDE | SHOW) DEFAULTS)? ')' ('.' general_element_part)?
+    | TIME CHAR_STRING
+    | xmltable
+    ;
+
+over_clause_keyword
+    : AVG
+    | CORR
+    | LAG_DIFF
+    | LAG_DIFF_PERCENT
+    | MAX
+    | MEDIAN
+    | MIN
+    | NTH_VALUE
+    | NTILE
+    | RATIO_TO_REPORT
+    | ROW_NUMBER
+    | SUM
+    | VARIANCE
+    | REGR_
+    | STDDEV
+    | VAR_
+    | VAR_POP
+    | COVAR_
+    | WM_CONCAT
+    ;
+
+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 expression
+    | IN OUT assignable_element
+    | OUT assignable_element
+    | expression
+    ;
+
+// Elemento assegnabile: usato per OUT/IN OUT
+assignable_element
+    : general_element
+    | bind_variable
+    ;
+
+collect_order_by_part
+    : ORDER BY concatenation (',' concatenation)*
+    ;
+
+within_or_over_part
+    : WITHIN GROUP '(' order_by_clause ')'
+    | over_clause
+    ;
+
+string_delimiter
+    : CHAR_STRING
+    | string_function
+    | string_delimiter BAR BAR string_delimiter
+    | '(' string_delimiter ')'
+    | id_expression
+    ;
+
+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)
+        | (AS EVALNAME expression)
+        )?
+    ;
+
+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)?
+    ;
+
+// Annotations
+
+annotations_clause
+    : ANNOTATIONS '(' annotations_list ')'
+    ;
+
+annotations_list
+    : (
+        ADD (IF NOT EXISTS | OR REPLACE)?
+        | DROP (IF EXISTS)?
+        | REPLACE
+    )? annotation (',' annotations_list)*
+    ;
+
+annotation
+    : identifier CHAR_STRING?
+    ;
+
+// SqlPlus
+
+sql_plus_command
+    : EXIT
+    | PROMPT_MESSAGE
+    | SHOW (ERR | ERRORS)
+    | whenever_command
+    | timing_command
+    | start_command
+    | set_command
+    | clear_command
+    | execute_command
+    ;
+
+// SQL*Plus EXEC[UTE] executes a single PL/SQL statement. The command word must
+// start a line so that `EXEC` used as an identifier and PL/SQL `EXECUTE
+// IMMEDIATE` keep their normal meaning.
+execute_command
+    : {this.isLineStart()}? (EXEC | EXECUTE) statement
+    ;
+
+start_command
+    : (START | AT_SIGN AT_SIGN?) sql_plus_filepath
+    ;
+
+sql_plus_filepath
+    : (id_expression COLON)? (SOLIDUS | RSOLIDUS)? (
+        id_expression (SOLIDUS | RSOLIDUS)
+    )* id_expression PERIOD (SQL | FILE_EXT)
+    ;
+
+whenever_command
+    : WHENEVER (SQLERROR | OSERROR) (
+        EXIT (SUCCESS | FAILURE | WARNING | variable_name | numeric) (COMMIT | ROLLBACK)?
+        | CONTINUE (COMMIT | ROLLBACK | NONE)?
+    )
+    ;
+
+set_command
+    : SET (
+        (regular_id (ON | OFF))+
+        | (regular_id (CHAR_STRING | ON | OFF | /*EXACT_NUM_LIT*/ numeric | regular_id))
+     )
+    ;
+
+timing_command
+    : TIMING (START timing_text = id_expression* | SHOW | STOP)?
+    ;
+
+clear_command
+    : CLEAR (COLUMN? regular_id) | ALL
+    ;
+
+// 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 | condition)
+    ;
+
+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
+    ;
+
+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
+    ;
+
+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
+    ;
+
+link_name
+    : database ('.' domain)* (AT_SIGN connection_qualifier)?
+    ;
+
+local_link_name
+    : identifier
+    ;
+
+connection_qualifier
+    : identifier
+    ;
+
+column_name
+    : identifier ('.' id_expression)*
+    ;
+
+tableview_name
+    : identifier ('.' id_expression)? (
+        AT_SIGN link_name
+        | /*TODO{!(input.LA(2) == BY)}?*/ partition_extension_clause
+    )?
+    | xmltable outer_join_sign?
+    ;
+
+xmltable
+    : XMLTABLE '(' (xml_namespaces_clause ',')? concatenation xml_passing_clause? (
+        RETURNING SEQUENCE BY REF
+    )? (
+        COLUMNS xml_table_column (',' xml_table_column)*
+    )? ')' ('.' general_element_part)?
+    ;
+
+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 <DB object name>, or rename <old DB object name> to <new DB object name>.
+// 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) (query_partition_clause | 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 VARYING?
+    | VARCHAR2
+    | VARCHAR
+    | STRING
+    | RAW
+    | BOOLEAN
+    | DATE
+    | ROWID
+    | UROWID
+    | YEAR
+    | MONTH
+    | DAY
+    | HOUR
+    | MINUTE
+    | SECOND
+    | SDO_GEOMETRY
+    | 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
+    | XMLTYPE
+    ;
+
+bind_variable
+    : (BINDVAR | ':' UNSIGNED_INTEGER)
+    // Pro*C/C++ indicator variables
+    (INDICATOR? (BINDVAR | ':' UNSIGNED_INTEGER))? ('.' general_element_part)*
+    ;
+
+general_element
+    : general_element_part
+    | general_element ('.' general_element_part)+
+    | '(' general_element ')'
+    ;
+
+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
+    | FLASHBACK ARCHIVE
+    | INDEX
+    | INHERIT PRIVILEGES
+    | INHERIT REMOTE 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
+    ;
+
+// $>
+
+// $<Lexer Mappings
+
+constant
+    : TIMESTAMP (quoted_string | bind_variable) (AT TIME ZONE quoted_string)?
+    | INTERVAL (quoted_string | bind_variable | general_element_part) (
+        YEAR
+        | MONTH
+        | DAY
+        | HOUR
+        | MINUTE
+        | SECOND
+    ) ('(' (UNSIGNED_INTEGER | bind_variable) (',' (UNSIGNED_INTEGER | bind_variable))? ')')? (
+        TO (MONTH | DAY | HOUR | MINUTE | SECOND ('(' (UNSIGNED_INTEGER | bind_variable) ')')?)
+    )?
+    | numeric
+    | DATE quoted_string
+    | quoted_string
+    | NULL_
+    | TRUE
+    | FALSE
+    | DBTIMEZONE
+    | SESSIONTIMEZONE
+    | MINVALUE
+    | MAXVALUE
+    | DEFAULT
+    ;
+
+numeric
+    : UNSIGNED_INTEGER '.'?
+    | APPROXIMATE_NUM_LIT
+    ;
+
+numeric_negative
+    : MINUS_SIGN numeric
+    ;
+
+quoted_string
+    : CHAR_STRING
+    //| CHAR_STRING_PERL
+    | NATIONAL_CHAR_STRING_LIT
+    ;
+
+identifier
+    : (INTRODUCER char_set_name)? id_expression
+    ;
+
+id_expression
+    : regular_id
+    | DELIMITED_ID
+    ;
+
+inquiry_directive
+    : INQUIRY_DIRECTIVE
+    ;
+
+outer_join_sign
+    : '(' '+' ')'
+    ;
+
+regular_id
+    : non_reserved_keywords_pre12c
+    | non_reserved_keywords_in_12c
+    | non_reserved_keywords_in_18c
+    | REGULAR_ID
+    | AUDIT
+    | ITEMS
+    | BYTES
+    | LINES
+    | RECORDS
+    | NEWLINE_
+    | FIELD
+    | MASK
+    | ABSENT
+    | A_LETTER
+    | AGENT
+    | AGGREGATE
+    | ANALYZE
+    | AUTONOMOUS_TRANSACTION
+    | BACKINGFILE
+    | BATCH
+    | BINARY_INTEGER
+    | BOOLEAN
+    | C_LETTER
+    | CHAR
+    | CHARSETID
+    | CHARSETFORM
+    | CLUSTER
+    | CONSTRUCTOR
+    | CUSTOMDATUM
+    | CASESENSITIVE
+    | COUNTED
+    | DATE
+    | DECIMAL
+    | DELETE
+    | DEPRECATE
+    | DETECTED
+    | DETERMINISTIC
+    | DISABLED
+    | DSINTERVAL_UNCONSTRAINED
+    | DURATION
+    | E_LETTER
+    | ENABLED
+    | ENCLOSED
+    | ERROR_INDEX
+    | ERROR_CODE
+    | ERR
+    | EXCEPTION
+    | EXCEPTION_INIT
+    | EXCEPTIONS
+    | EXISTS
+    | EXEC
+    | EXIT
+    | EXTEND
+    | FIELDS
+    | FILE_EXT
+    | FILESTORE
+    | FLOAT
+    | FORALL
+    | G_LETTER
+    | INDICES
+    | INOUT
+    | INTEGER
+    | INTERNAL
+    | JSON_TRANSFORM
+    | K_LETTER
+    | LANGUAGE
+    | LONG
+    | LOOP
+    | MAXLEN
+    | MOUNTPOINT
+    | M_LETTER
+    | MISSING
+    | MISMATCH
+    | NUMBER
+    | ORADATA
+    | ORC
+    | OSERROR
+    | OUT
+    | OVERRIDING
+    | P_LETTER
+    | PARALLEL_ENABLE
+    | PIPELINED
+    | PLS_INTEGER
+    | PMEM
+    | POSITIVE
+    | POSITIVEN
+    | PRAGMA
+    | PUBLIC
+    | RAISE
+    | RAW
+    | RECORD
+    | REF
+    | RENAME
+    | RESTRICT_REFERENCES
+    | RESULT
+    | SDO_GEOMETRY
+    | SELF
+    | SERIALLY_REUSABLE
+    | SET
+    | SEQ
+    | SHARDSPACE
+    | SIGNTYPE
+    | SIMPLE_INTEGER
+    | SMALLINT
+    | STRUCT
+    | SQLDATA
+    | SQLERROR
+    | SUBTYPE
+    | T_LETTER
+    | TDO
+    | TIMESTAMP_LTZ_UNCONSTRAINED
+    | TIMESTAMP_TZ_UNCONSTRAINED
+    | TIMESTAMP_UNCONSTRAINED
+    | TIMEZONE
+    | TRIGGER
+    | UDF
+    | VARCHAR
+    | VARCHAR2
+    | VARIABLE
+    | WARNING
+    | WHILE
+    | WM_CONCAT
+    | XMLAGG
+    | YMINTERVAL_UNCONSTRAINED
+    | REGR_
+    | VAR_
+    | VALUE
+    | COVAR_
+    | DATE_FORMAT
+    | CSV
+    | CHARACTERSET
+    ;
+
+non_reserved_keywords_in_18c
+    : PERSISTABLE
+    | POLYMORPHIC
+    ;
+
+non_reserved_keywords_in_12c
+    : ACL
+    | ACCESSIBLE
+    | ACROSS
+    | ACTION
+    | ACTIONS
+    | ACTIVE
+    | ACTIVE_DATA
+    | ACTIVITY
+    | ADAPTIVE_PLAN
+    | ADVANCED
+    | AFD_DISKSTRING
+    | ALTERNATE
+    | ALGORITHM
+    | ANALYTIC
+    | ANCESTOR
+    | ANOMALY
+    | ANSI_REARCH
+    | APPLICATION
+    | APPROX_COUNT_DISTINCT
+    | ARCHIVAL
+    | ARCHIVED
+    | ASIS
+    | ASSIGN
+    | AUTO_LOGIN
+    | AUTO_REOPTIMIZE
+    | AVRO
+    | BACKGROUND
+    | BACKUPS
+    | BATCHSIZE
+    | BATCH_TABLE_ACCESS_BY_ROWID
+    | BEGINNING
+    | BEQUEATH
+    | BITMAP_AND
+    | BLOCKCHAIN
+    | BSON
+    | CACHING
+    | CALCULATED
+    | CALLBACK
+    | CAPACITY
+    | CAPTION
+    | CDBDEFAULT
+    | CLASSIFICATION
+    | CLASSIFIER
+    | CLAUSE
+    | CLEAN
+    | CLEANUP
+    | CLIENT
+    | CLUSTERING
+    | CLUSTER_DETAILS
+    | CLUSTER_DISTANCE
+    | COLLATE
+    | COLLATION
+    | COMMON
+    | COMMON_DATA
+    | COMPONENT
+    | COMPONENTS
+    | CONDITION
+    | CONDITIONAL
+    | CONTAINERS
+    | CONTAINERS_DEFAULT
+    | CONTAINER_DATA
+    | CONTAINER_MAP
+    | CONVERSION
+    | CON_DBID_TO_ID
+    | CON_GUID_TO_ID
+    | CON_ID
+    | CON_NAME_TO_ID
+    | CON_UID_TO_ID
+    | COOKIE
+    | COPY
+    | CREATE_FILE_DEST
+    | CREDENTIAL
+    | CRITICAL
+    | CUBE_AJ
+    | CUBE_SJ
+    | DATAMOVEMENT
+    | DATAOBJ_TO_MAT_PARTITION
+    | DATAPUMP
+    | DATA_SECURITY_REWRITE_LIMIT
+    | DAYS
+    | DB_UNIQUE_NAME
+    | DECORRELATE
+    | DEFAULT_CREDENTIAL
+    | DEFAULT_COLLATION
+    | DEFINE
+    | DEFINITION
+    | DELEGATE
+    | DELETE_ALL
+    | DESCRIPTION
+    | DESTROY
+    | DIMENSIONS
+    | DISABLE_ALL
+    | DISABLE_PARALLEL_DML
+    | DISCARD
+    | DISTRIBUTE
+    | DUPLICATE
+    | DUPLICATED
+    | DV
+    | EDITIONABLE
+    | ELIM_GROUPBY
+    | EM
+    | ENABLE_ALL
+    | ENABLE_PARALLEL_DML
+    | EQUIPART
+    | EVAL
+    | EVALUATE
+    | EXISTING
+    | EXPRESS
+    | EXTENDED
+    | EXTRACTCLOBXML
+    | FACTOR
+    | FAILOVER
+    | FAILURE
+    | FAMILY
+    | FAR
+    | FASTSTART
+    | FEATURE
+    | FEATURE_DETAILS
+    | FETCH
+    | FILE_NAME_CONVERT
+    | FILEGROUP
+    | FIXED_VIEW_DATA
+    | FLEX
+    | FORMAT
+    | FTP
+    | GATHER_OPTIMIZER_STATISTICS
+    | GET
+    | HALF_YEARS
+    | HASHING
+    | HIER_ORDER
+    | HIERARCHICAL
+    | HOURS
+    | HTTP
+    | H_LETTER
+    | IDLE
+    | ILM
+    | IMMUTABLE
+    | INACTIVE
+    | INACTIVE_ACCOUNT_TIME
+    | INDEXING
+    | INHERIT
+    | INMEMORY
+    | INMEMORY_PRUNING
+    | INPLACE
+    | INTERLEAVED
+    | INVALIDATION
+    | ISOLATE
+    | IS_LEAF
+    | JSON
+    | JSONGET
+    | JSONPARSE
+    | JSON_ARRAY
+    | JSON_ARRAYAGG
+    | JSON_EQUAL
+    | JSON_EXISTS
+    | JSON_EXISTS2
+    | JSON_OBJECT
+    | JSON_OBJECTAGG
+    | JSON_QUERY
+    | JSON_SERIALIZE
+    | JSON_TABLE
+    | JSON_TEXTCONTAINS
+    | JSON_TEXTCONTAINS2
+    | JSON_VALUE
+    | KEYSTORE
+    | LABEL
+    | LAX
+    | LEAD_CDB
+    | LEAD_CDB_URI
+    | LEVEL_NAME
+    | LIFECYCLE
+    | LINEAR
+    | LOCKDOWN
+    | LOCKING
+    | LOGMINING
+    | LOST
+    | MANDATORY
+    | MAP
+    | MATCH
+    | MATCHES
+    | MATCH_NUMBER
+    | MATCH_RECOGNIZE
+    | MAX_SHARED_TEMP_SIZE
+    | MEMCOMPRESS
+    | METADATA
+    | MEMBER_CAPTION
+    | MEMBER_DESCRIPTION
+    | MEMBER_NAME
+    | MEMBER_UNIQUE_NAME
+    | MEMOPTIMIZE
+    | MINUTES
+    | MODEL_NB
+    | MODEL_SV
+    | MODIFICATION
+    | MODULE
+    | MONTHS
+    | MULTIDIMENSIONAL
+    | NEG
+    | NOCOPY
+    | NOKEEP
+    | NONEDITIONABLE
+    | NONPARTITIONED
+    | NOPARTITION
+    | NORELOCATE
+    | NOREPLAY
+    | NO_ADAPTIVE_PLAN
+    | NO_ANSI_REARCH
+    | NO_AUTO_REOPTIMIZE
+    | NO_BATCH_TABLE_ACCESS_BY_ROWID
+    | NO_CLUSTERING
+    | NO_COMMON_DATA
+    | NO_DATA_SECURITY_REWRITE
+    | NO_DECORRELATE
+    | NO_ELIM_GROUPBY
+    | NO_GATHER_OPTIMIZER_STATISTICS
+    | NO_INMEMORY
+    | NO_INMEMORY_PRUNING
+    | NO_OBJECT_LINK
+    | NO_PARTIAL_JOIN
+    | NO_PARTIAL_ROLLUP_PUSHDOWN
+    | NO_PQ_CONCURRENT_UNION
+    | NO_PQ_REPLICATE
+    | NO_PQ_SKEW
+    | NOPROMPT
+    | NO_PX_FAULT_TOLERANCE
+    | NO_ROOT_SW_FOR_LOCAL
+    | NO_SQL_TRANSLATION
+    | NO_USE_CUBE
+    | NO_USE_VECTOR_AGGREGATION
+    | NO_VECTOR_TRANSFORM
+    | NO_VECTOR_TRANSFORM_DIMS
+    | NO_VECTOR_TRANSFORM_FACT
+    | NO_ZONEMAP
+    | OBJ_ID
+    | OFFSET
+    | OLS
+    | OMIT
+    | ONE
+    | ORACLE_DATAPUMP
+    | ORACLE_HDFS
+    | ORACLE_HIVE
+    | ORACLE_LOADER
+    | ORA_CHECK_ACL
+    | ORA_CHECK_PRIVILEGE
+    | ORA_CLUSTERING
+    | ORA_INVOKING_USER
+    | ORA_INVOKING_USERID
+    | ORA_INVOKING_XS_USER
+    | ORA_INVOKING_XS_USER_GUID
+    | ORA_RAWCOMPARE
+    | ORA_RAWCONCAT
+    | ORA_WRITE_TIME
+    | PARENT_LEVEL_NAME
+    | PARENT_UNIQUE_NAME
+    | PASSWORD_ROLLOVER_TIME
+    | PARTIAL
+    | PARTIAL_JOIN
+    | PARTIAL_ROLLUP_PUSHDOWN
+    | PAST
+    | PATCH
+    | PATH_PREFIX
+    | PATTERN
+    | PER
+    | PERIOD
+    | PERIOD_KEYWORD
+    | PERMUTE
+    | PLUGGABLE
+    | POOL_16K
+    | POOL_2K
+    | POOL_32K
+    | POOL_4K
+    | POOL_8K
+    | PQ_CONCURRENT_UNION
+    | PQ_DISTRIBUTE_WINDOW
+    | PQ_FILTER
+    | PQ_REPLICATE
+    | PQ_SKEW
+    | PRELOAD
+    | PRETTY
+    | PREV
+    | PRINTBLOBTOCLOB
+    | PRIORITY
+    | PRIVILEGED
+    | PROPERTY
+    | PROTOCOL
+    | PROXY
+    | PRUNING
+    | PX_FAULT_TOLERANCE
+    | QUARTERS
+    | QUOTAGROUP
+    | REALM
+    | REDEFINE
+    | RELOCATE
+    | REMOTE
+    | RESTART
+    | ROLESET
+    | ROWID_MAPPING_TABLE
+    | RUNNING
+    | SAVE
+    | SCRUB
+    | SDO_GEOM_MBR
+    | SECONDS
+    | SECRET
+    | SERIAL
+    | SERVICES
+    | SERVICE_NAME_CONVERT
+    | SHARDED
+    | SHARING
+    | SHELFLIFE
+    | SITE
+    | SOURCE_FILE_DIRECTORY
+    | SOURCE_FILE_NAME_CONVERT
+    | SQL_TRANSLATION_PROFILE
+    | STANDARD
+    | STANDARD_HASH
+    | STANDBYS
+    | STATE
+    | STATEMENT
+    | STREAM
+    | SUBSCRIBE
+    | SUBSET
+    | SUCCESS
+    | SYS
+    | SYSBACKUP
+    | SYSDG
+    | SYSGUID
+    | SYSKM
+    | SYSOBJ
+    | SYS_CHECK_PRIVILEGE
+    | SYS_GET_COL_ACLIDS
+    | SYS_MKXTI
+    | SYS_OP_CYCLED_SEQ
+    | SYS_OP_HASH
+    | SYS_OP_KEY_VECTOR_CREATE
+    | SYS_OP_KEY_VECTOR_FILTER
+    | SYS_OP_KEY_VECTOR_FILTER_LIST
+    | SYS_OP_KEY_VECTOR_SUCCEEDED
+    | SYS_OP_KEY_VECTOR_USE
+    | SYS_OP_PART_ID
+    | SYS_OP_ZONE_ID
+    | SYS_RAW_TO_XSID
+    | SYS_XSID_TO_RAW
+    | SYS_ZMAP_FILTER
+    | SYS_ZMAP_REFRESH
+    | TAG
+    | TEXT
+    | TIER
+    | TIES
+    | TO_ACLID
+    | TRANSFORM
+    | TRANSLATION
+    | TRUST
+    | UCS2
+    | UNCONDITIONAL
+    | UNITE
+    | UNMATCHED
+    | UNPLUG
+    | UNSUBSCRIBE
+    | USABLE
+    | USER_DATA
+    | USER_TABLESPACES
+    | USE_CUBE
+    | USE_HIDDEN_PARTITIONS
+    | USE_VECTOR_AGGREGATION
+    | USING_NO_EXPAND
+    | USING_NLS_COMP
+    | UTF16BE
+    | UTF16LE
+    | UTF32
+    | UTF8
+    | V1
+    | V2
+    | VALIDATE_CONVERSION
+    | VALID_TIME_END
+    | VECTOR_TRANSFORM
+    | VECTOR_TRANSFORM_DIMS
+    | VECTOR_TRANSFORM_FACT
+    | VERIFIER
+    | VIOLATION
+    | VISIBILITY
+    | WEEK
+    | WEEKS
+    | WITH_PLSQL
+    | WRAPPER
+    | XS
+    | YEARS
+    | ZONEMAP
+    ;
+
+non_reserved_keywords_pre12c
+    : ABORT
+    | ABS
+    | ACCESSED
+    | ACCESS
+    | ACCOUNT
+    | ACOS
+    | ACTIVATE
+    | ACTIVE_COMPONENT
+    | ACTIVE_FUNCTION
+    | ACTIVE_TAG
+    | ADD_COLUMN
+    | ADD_GROUP
+    | ADD_MONTHS
+    | ADD
+    | ADJ_DATE
+    | ADMINISTER
+    | ADMINISTRATOR
+    | ADMIN
+    | ADVISE
+    | ADVISOR
+    | AFTER
+    | ALIAS
+    | ALLOCATE
+    | ALLOW
+    | ALL_ROWS
+    | ALWAYS
+    | ANALYZE
+    | ANCILLARY
+    | AND_EQUAL
+    | ANTIJOIN
+    | ANYSCHEMA
+    | APPENDCHILDXML
+    | APPEND
+    | APPEND_VALUES
+    | APPLY
+    | ARCHIVELOG
+    | ARCHIVE
+    | ARRAY
+    | ASCII
+    | ASCIISTR
+    | ASIN
+    | ASSEMBLY
+    | ASSOCIATE
+    | ASYNCHRONOUS
+    | ASYNC
+    | ATAN2
+    | ATAN
+    | AT
+    | ATTRIBUTE
+    | ATTRIBUTES
+    | AUTHENTICATED
+    | AUTHENTICATION
+    | AUTHID
+    | AUTHORIZATION
+    | AUTOALLOCATE
+    | AUTOEXTEND
+    | AUTOMATIC
+    | AUTO
+    | AVAILABILITY
+    | AVG
+    | BACKUP
+    | BASICFILE
+    | BASIC
+    | BATCH
+    | BECOME
+    | BEFORE
+    | BEGIN
+    | BEGIN_OUTLINE_DATA
+    | BEHALF
+    | BFILE
+    | BFILENAME
+    | BIGFILE
+    | BINARY_DOUBLE_INFINITY
+    | BINARY_DOUBLE
+    | BINARY_DOUBLE_NAN
+    | BINARY_FLOAT_INFINITY
+    | BINARY_FLOAT
+    | BINARY_FLOAT_NAN
+    | BINARY
+    | BIND_AWARE
+    | BINDING
+    | BIN_TO_NUM
+    | BITAND
+    | BITMAP
+    | BITMAPS
+    | BITMAP_TREE
+    | BITS
+    | BLOB
+    | BLOCK
+    | BLOCK_RANGE
+    | BLOCKSIZE
+    | BLOCKS
+    | BODY
+    | BOTH
+    | BOUND
+    | BRANCH
+    | BREADTH
+    | BROADCAST
+    | BUFFER_CACHE
+    | BUFFER
+    | BUFFER_POOL
+    | BUILD
+    | BULK
+    | BYPASS_RECURSIVE_CHECK
+    | BYPASS_UJVC
+    | BYTE
+    | CACHE_CB
+    | CACHE_INSTANCES
+    | CACHE
+    | CACHE_TEMP_TABLE
+    | CALL
+    | CANCEL
+    | CARDINALITY
+    | CASCADE
+    | CASE
+    | CAST
+    | CATEGORY
+    | CEIL
+    | CELL_FLASH_CACHE
+    | CERTIFICATE
+    | CFILE
+    | CHAINED
+    | CHANGE_DUPKEY_ERROR_INDEX
+    | CHANGE
+    | CHARACTER
+    | CHAR_CS
+    | CHARTOROWID
+    | CHECK_ACL_REWRITE
+    | CHECKPOINT
+    | CHILD
+    | CHOOSE
+    | CHR
+    | CHUNK
+    | CLASS
+    | CLEAR
+    | CLOB
+    | CLONE
+    | CLOSE_CACHED_OPEN_CURSORS
+    | CLOSE
+    | CLUSTER_BY_ROWID
+    | CLUSTER_ID
+    | 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
+    | COMPACT
+    | COMPATIBILITY
+    | COMPILE
+    | COMPLETE
+    | COMPLIANCE
+    | COMPOSE
+    | COMPOSITE_LIMIT
+    | COMPOSITE
+    | COMPOUND
+    | COMPUTE
+    | CONCAT
+    | CONFIRM
+    | CONFORMING
+    | 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_TIME
+    | CONSIDER
+    | CONSISTENT
+    | CONSTANT
+    | CONST
+    | CONSTRAINT
+    | CONSTRAINTS
+    | CONTAINER
+    | CONTENT
+    | CONTENTS
+    | CONTEXT
+    | CONTINUE
+    | CONTROLFILE
+    | CONVERT
+    | CORR_K
+    | CORR
+    | CORR_S
+    | CORRUPTION
+    | CORRUPT_XID_ALL
+    | CORRUPT_XID
+    | COSH
+    | COS
+    | COST
+    | COST_XML_QUERY_REWRITE
+    | COUNT
+    | COVAR_POP
+    | COVAR_SAMP
+    | CPU_COSTING
+    | CPU_PER_CALL
+    | CPU_PER_SESSION
+    | CRASH
+    | CREATE_STORED_OUTLINES
+    | CREATION
+    | CROSSEDITION
+    | CROSS
+    | CSCONVERT
+    | CUBE_GB
+    | CUBE
+    | CUME_DISTM
+    | CUME_DIST
+    | CURRENT_DATE
+    | CURRENT
+    | CURRENT_SCHEMA
+    | CURRENT_TIME
+    | CURRENT_TIMESTAMP
+    | CURRENT_USER
+    | CURRENTV
+    | CURSOR
+    | CURSOR_SHARING_EXACT
+    | CURSOR_SPECIFIC_SEGMENT
+    | CV
+    | CYCLE
+    | DANGLING
+    | DATABASE
+    | DATAFILE
+    | DATAFILES
+    | DATA
+    | DATAOBJNO
+    | DATAOBJ_TO_PARTITION
+    | DATE_MODE
+    | DAY
+    | DBA
+    | DBA_RECYCLEBIN
+    | DBLINK
+    | DBMS_STATS
+    | DB_ROLE_CHANGE
+    | DBTIMEZONE
+    | DB_VERSION
+    | DDL
+    | DEALLOCATE
+    | DEBUGGER
+    | DEBUG
+    | DECLARE
+    | DEC
+    | DECOMPOSE
+    | DECREMENT
+    | DECR
+    | DECRYPT
+    | DEDUPLICATE
+    | DEFAULTS
+    | DEFERRABLE
+    | DEFERRED
+    | DEFINED
+    | DEFINER
+    | DEGREE
+    | DELAY
+    | DELETEXML
+    | DEMAND
+    | DENSE_RANKM
+    | DENSE_RANK
+    | DEPENDENT
+    | DEPTH
+    | DEQUEUE
+    | DEREF
+    | DEREF_NO_REWRITE
+    | DETACHED
+    | DETERMINES
+    | DICTIONARY
+    | DIMENSION
+    | DIRECT_LOAD
+    | DIRECTORY
+    | DIRECT_PATH
+    | DISABLE
+    | DISABLE_PRESET
+    | DISABLE_RPKE
+    | DISALLOW
+    | DISASSOCIATE
+    | DISCONNECT
+    | DISKGROUP
+    | DISK
+    | DISKS
+    | DISMOUNT
+    | DISTINGUISHED
+    | DISTRIBUTED
+    | DML
+    | DML_UPDATE
+    | DOCFIDELITY
+    | DOCUMENT
+    | DOMAIN_INDEX_FILTER
+    | DOMAIN_INDEX_NO_SORT
+    | DOMAIN_INDEX_SORT
+    | DOUBLE
+    | DOWNGRADE
+    | DRIVING_SITE
+    | DROP_COLUMN
+    | DROP_GROUP
+    | DST_UPGRADE_INSERT_CONV
+    | DUMP
+    | DYNAMIC
+    | DYNAMIC_SAMPLING_EST_CDN
+    | DYNAMIC_SAMPLING
+    | EACH
+    | EDITIONING
+    | EDITION
+    | EDITIONS
+    | ELEMENT
+    | ELIMINATE_JOIN
+    | ELIMINATE_OBY
+    | ELIMINATE_OUTER_JOIN
+    | EMPTY_BLOB
+    | EMPTY_CLOB
+    | EMPTY_
+    | ENABLE
+    | ENABLE_PRESET
+    | ENCODING
+    | ENCRYPTION
+    | ENCRYPT
+    | END_OUTLINE_DATA
+    | ENFORCED
+    | ENFORCE
+    | ENQUEUE
+    | ENTERPRISE
+    | ENTITYESCAPING
+    | ENTRY
+    | ERROR_ARGUMENT
+    | ERROR
+    | ERROR_ON_OVERLAP_TIME
+    | ERRORS
+    | ESCAPE
+    | ESTIMATE
+    | EVALNAME
+    | EVALUATION
+    | EVENTS
+    | EVERY
+    | EXCEPTIONS
+    | EXCEPT
+    | EXCHANGE
+    | EXCLUDE
+    | EXCLUDING
+    | EXECUTE
+    | EXEMPT
+    | EXISTSNODE
+    | EXPAND_GSET_TO_UNION
+    | EXPAND_TABLE
+    | EXPIRE
+    | EXPLAIN
+    | EXPLOSION
+    | EXP
+    | EXPORT
+    | EXPR_CORR_CHECK
+    | EXTENDS
+    | EXTENT
+    | EXTENTS
+    | EXTERNALLY
+    | EXTERNAL
+    | EXTRACT
+    | EXTRACTVALUE
+    | EXTRA
+    | FACILITY
+    | FACT
+    | FACTORIZE_JOIN
+    | FAILED_LOGIN_ATTEMPTS
+    | FAILED
+    | FAILGROUP
+    | FALSE
+    | FAST
+    | FBTSCAN
+    | FEATURE_ID
+    | FEATURE_SET
+    | FEATURE_VALUE
+    | FILE
+    | FILESYSTEM_LIKE_LOGGING
+    | FILTER
+    | FINAL
+    | FINE
+    | FINISH
+    | FIRSTM
+    | FIRST
+    | FIRST_ROWS
+    | FIRST_VALUE
+    | FLAGGER
+    | FLASHBACK
+    | FLASH_CACHE
+    | FLOB
+    | FLOOR
+    | FLUSH
+    | FOLDER
+    | FOLLOWING
+    | FOLLOWS
+    | FORCE
+    | FORCE_XML_QUERY_REWRITE
+    | FOREIGN
+    | FOREVER
+    | FORWARD
+    | FRAGMENT_NUMBER
+    | FREELIST
+    | FREELISTS
+    | FREEPOOLS
+    | FRESH
+    | FROM_TZ
+    | FULL
+    | FULL_OUTER_JOIN_TO_OUTER
+    | FUNCTION
+    | FUNCTIONS
+    | GATHER_PLAN_STATISTICS
+    | GBY_CONC_ROLLUP
+    | GBY_PUSHDOWN
+    | GENERATED
+    | GLOBALLY
+    | GLOBAL
+    | GLOBAL_NAME
+    | GLOBAL_TOPIC_ENABLED
+    | GREATEST
+    | GROUP_BY
+    | GROUP_ID
+    | GROUPING_ID
+    | GROUPING
+    | GROUPS
+    | GUARANTEED
+    | GUARANTEE
+    | GUARD
+    | HASH_AJ
+    | HASHKEYS
+    | HASH
+    | HASH_SJ
+    | HEADER
+    | HEAP
+    | HELP
+    | HEXTORAW
+    | HEXTOREF
+    | HIDDEN_KEYWORD
+    | HIDE
+    | HIERARCHY
+    | HIGH
+    | HINTSET_BEGIN
+    | HINTSET_END
+    | HOT
+    | HOUR
+    | HWM_BROKERED
+    | HYBRID
+    | IDENTIFIER
+    | IDENTITY
+    | IDGENERATORS
+    | IDLE_TIME
+    | ID
+    | IF
+    | IGNORE
+    | IGNORE_OPTIM_EMBEDDED_HINTS
+    | IGNORE_ROW_ON_DUPKEY_INDEX
+    | IGNORE_WHERE_CLAUSE
+    | IMMEDIATE
+    | IMPACT
+    | IMPORT
+    | INCLUDE
+    | INCLUDE_VERSION
+    | INCLUDING
+    | INCREMENTAL
+    | INCREMENT
+    | INCR
+    | INDENT
+    | INDEX_ASC
+    | INDEX_COMBINE
+    | INDEX_DESC
+    | INDEXED
+    | INDEXES
+    | INDEX_FFS
+    | INDEX_FILTER
+    | 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
+    | INFINITE
+    | INFORMATIONAL
+    | INITCAP
+    | INITIALIZED
+    | INITIALLY
+    | INITIAL
+    | INITRANS
+    | INLINE
+    | INLINE_XMLTYPE_NT
+    | IN_MEMORY_METADATA
+    | INNER
+    | INSERTCHILDXMLAFTER
+    | INSERTCHILDXMLBEFORE
+    | INSERTCHILDXML
+    | INSERTXMLAFTER
+    | INSERTXMLBEFORE
+    | INSTANCE
+    | INSTANCES
+    | INSTANTIABLE
+    | INSTANTLY
+    | INSTEAD
+    | INSTR2
+    | INSTR4
+    | INSTRB
+    | INSTRC
+    | INSTR
+    | INTERMEDIATE
+    | INTERNAL_CONVERT
+    | INTERNAL_USE
+    | INTERPRETED
+    | INTERVAL
+    | INT
+    | INVALIDATE
+    | INVISIBLE
+    | IN_XQUERY
+    | ISOLATION_LEVEL
+    | ISOLATION
+    | ITERATE
+    | ITERATION_NUMBER
+    | JAVA
+    | JOB
+    | JOIN
+    | KEEP_DUPLICATES
+    | KEEP
+    | KERBEROS
+    | KEY_LENGTH
+    | KEY
+    | KEYSIZE
+    | KEYS
+    | KILL
+    | LAG
+    | LAST_DAY
+    | LAST
+    | LAST_VALUE
+    | LATERAL
+    | LAYER
+    | LDAP_REGISTRATION_ENABLED
+    | LDAP_REGISTRATION
+    | LDAP_REG_SYNC_INTERVAL
+    | LEADING
+    | LEAD
+    | LEAF
+    | LEAST
+    | LEFT
+    | LENGTH2
+    | LENGTH4
+    | LENGTHB
+    | LENGTHC
+    | LENGTH
+    | LESS
+    | LEVEL
+    | LEVELS
+    | LIBRARY
+    | LIFE
+    | LIFETIME
+    | LIKE2
+    | LIKE4
+    | LIKEC
+    | LIKE_EXPAND
+    | LIMIT
+    | LINK
+    | LISTAGG
+    | LIST
+    | LN
+    | LNNVL
+    | LOAD
+    | LOB
+    | LOBNVL
+    | LOBS
+    | LOCAL_INDEXES
+    | LOCAL
+    | LOCALTIME
+    | LOCALTIMESTAMP
+    | LOCATION
+    | LOCATOR
+    | LOCKED
+    | LOGFILE
+    | LOGFILES
+    | LOGGING
+    | LOGICAL
+    | LOGICAL_READS_PER_CALL
+    | LOGICAL_READS_PER_SESSION
+    | LOG
+    | LOGOFF
+    | LOGON
+    | LOG_READ_ONLY_VIOLATIONS
+    | LOWER
+    | LOW
+    | LPAD
+    | LTRIM
+    | MAIN
+    | MAKE_REF
+    | MANAGED
+    | MANAGEMENT
+    | MANAGE
+    | MANAGER
+    | MANUAL
+    | MAPPING
+    | MASTER
+    | MATCHED
+    | MATERIALIZED
+    | MATERIALIZE
+    | MAXARCHLOGS
+    | MAXDATAFILES
+    | MAXEXTENTS
+    | MAXIMIZE
+    | MAXINSTANCES
+    | MAXLOGFILES
+    | MAXLOGHISTORY
+    | MAXLOGMEMBERS
+    | MAX
+    | MAXSIZE
+    | MAXTRANS
+    | MAXVALUE
+    | MEASURE
+    | MEASURES
+    | MEDIAN
+    | MEDIUM
+    | MEMBER
+    | MEMOPTIMIZE
+    | MEMORY
+    | MERGEACTIONS
+    | MERGE_AJ
+    | MERGE_CONST_ON
+    | MERGE
+    | MERGE_SJ
+    | METHOD
+    | MIGRATE
+    | MIGRATION
+    | MINEXTENTS
+    | MINIMIZE
+    | MINIMUM
+    | MINING
+    | MIN
+    | MINUS_NULL
+    | MINUTE
+    | MINVALUE
+    | MIRRORCOLD
+    | MIRRORHOT
+    | MIRROR
+    | MLSLABEL
+    | MODEL_COMPILE_SUBQUERY
+    | MODEL_DONTVERIFY_UNIQUENESS
+    | MODEL_DYNAMIC_SUBQUERY
+    | MODEL_MIN_ANALYSIS
+    | MODEL
+    | MODEL_NO_ANALYSIS
+    | MODEL_PBY
+    | MODEL_PUSH_REF
+    | MODIFY_COLUMN_TYPE
+    | MODIFY
+    | MOD
+    | MONITORING
+    | MONITOR
+    | MONTH
+    | MONTHS_BETWEEN
+    | MOUNT
+    | MOUNTPATH
+    | MOVEMENT
+    | MOVE
+    | MULTISET
+    | MV_MERGE
+    | NAMED
+    | NAME
+    | NAMESPACE
+    | NAN_
+    | NANVL
+    | NATIONAL
+    | NATIVE_FULL_OUTER_JOIN
+    | NATIVE
+    | NATURAL
+    | NAV
+    | NCHAR_CS
+    | NCHAR
+    | NCHR
+    | NCLOB
+    | NEEDED
+    | 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
+    | NOAPPEND
+    | NOARCHIVELOG
+    | NOAUDIT
+    | NO_BASETABLE_MULTIMV_REWRITE
+    | NO_BIND_AWARE
+    | NO_BUFFER
+    | NOCACHE
+    | NO_CARTESIAN
+    | NO_CHECK_ACL_REWRITE
+    | NO_CLUSTER_BY_ROWID
+    | NO_COALESCE_SQ
+    | 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
+    | NO_COST_XML_QUERY_REWRITE
+    | NO_CPU_COSTING
+    | NOCPU_COSTING
+    | NOCYCLE
+    | NODELAY
+    | NO_DOMAIN_INDEX_FILTER
+    | NO_DST_UPGRADE_INSERT_CONV
+    | 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_GBY_PUSHDOWN
+    | NOGUARANTEE
+    | NO_INDEX_FFS
+    | NO_INDEX
+    | NO_INDEX_SS
+    | NO_LOAD
+    | NOLOCAL
+    | NOLOGGING
+    | NOMAPPING
+    | NOMAXVALUE
+    | NO_MERGE
+    | NOMINIMIZE
+    | NOMINVALUE
+    | NO_MODEL_PUSH_REF
+    | NO_MONITORING
+    | NOMONITORING
+    | NO_MONITOR
+    | NO_MULTIMV_REWRITE
+    | NO
+    | NO_NATIVE_FULL_OUTER_JOIN
+    | NONBLOCKING
+    | NONE
+    | NO_NLJ_BATCHING
+    | NO_NLJ_PREFETCH
+    | NONSCHEMA
+    | 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_PLACE_DISTINCT
+    | NO_PLACE_GROUP_BY
+    | NO_PQ_MAP
+    | NO_PRUNE_GSETS
+    | NO_PULL_PRED
+    | NO_PUSH_PRED
+    | NO_PUSH_SUBQ
+    | NO_PX_JOIN_FILTER
+    | NO_QKN_BUFF
+    | NO_QUERY_TRANSFORMATION
+    | NO_REF_CASCADE
+    | NORELY
+    | NOREPAIR
+    | NORESETLOGS
+    | NO_RESULT_CACHE
+    | NOREVERSE
+    | NO_REWRITE
+    | NOREWRITE
+    | NORMAL
+    | NOROWDEPENDENCIES
+    | NOSCHEMACHECK
+    | NOSEGMENT
+    | NO_SEMIJOIN
+    | NO_SEMI_TO_INNER
+    | NO_SET_TO_JOIN
+    | NOSORT
+    | 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
+    | NO_TRANSFORM_DISTINCT_AGG
+    | NO_UNNEST
+    | NO_USE_HASH_AGGREGATION
+    | NO_USE_HASH_GBY_FOR_PUSHDOWN
+    | NO_USE_HASH
+    | NO_USE_INVISIBLE_INDEXES
+    | NO_USE_MERGE
+    | NO_USE_NL
+    | NOVALIDATE
+    | NO_XDB_FASTPATH_INSERT
+    | NO_XML_DML_REWRITE
+    | NO_XMLINDEX_REWRITE_IN_SELECT
+    | NO_XMLINDEX_REWRITE
+    | NO_XML_QUERY_REWRITE
+    | NTH_VALUE
+    | NTILE
+    | NULLIF
+    | NULLS
+    | NUMERIC
+    | NUM_INDEX_KEYS
+    | NUMTODSINTERVAL
+    | NUMTOYMINTERVAL
+    | NVARCHAR2
+    | NVL2
+    | NVL
+    | OBJECT2XML
+    | OBJECT
+    | OBJNO
+    | OBJNO_REUSE
+    | OCCURENCES
+    | OFFLINE
+    | OFF
+    | OIDINDEX
+    | OID
+    | OLAP
+    | OLD
+    | OLD_PUSH_PRED
+    | OLTP
+    | ONLINE
+    | ONLY
+    | OPAQUE
+    | OPAQUE_TRANSFORM
+    | OPAQUE_XCANONICAL
+    | OPCODE
+    | OPEN
+    | OPERATIONS
+    | OPERATOR
+    | OPT_ESTIMATE
+    | OPTIMAL
+    | OPTIMIZE
+    | OPTIMIZER_FEATURES_ENABLE
+    | OPTIMIZER_GOAL
+    | OPT_PARAM
+    | ORA_BRANCH
+    | ORADEBUG
+    | ORA_DST_AFFECTED
+    | ORA_DST_CONVERT
+    | ORA_DST_ERROR
+    | ORA_GET_ACLIDS
+    | ORA_GET_PRIVILEGES
+    | ORA_HASH
+    | ORA_ROWSCN
+    | ORA_ROWSCN_RAW
+    | ORA_ROWVERSION
+    | ORA_TABVERSION
+    | ORDERED
+    | ORDERED_PREDICATES
+    | ORDINALITY
+    | OR_EXPAND
+    | ORGANIZATION
+    | OR_PREDICATES
+    | OTHER
+    | OUTER_JOIN_TO_ANTI
+    | OUTER_JOIN_TO_INNER
+    | OUTER
+    | OUTLINE_LEAF
+    | OUTLINE
+    | OUT_OF_LINE
+    | OVERFLOW_
+    | OVERFLOW_NOMOVE
+    | OVERLAPS
+    | OVER
+    | OVERRIDE
+    | OWNER
+    | OWNERSHIP
+    | OWN
+    | PACKAGE
+    | PACKAGES
+    | PARALLEL_INDEX
+    | PARALLEL
+    | PARAMETERS
+    | PARAM
+    | PARENT
+    | PARITY
+    | PARTIALLY
+    | 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_VERIFY_FUNCTION
+    | PATH
+    | PATHS
+    | PBL_HS_BEGIN
+    | PBL_HS_END
+    | PCTINCREASE
+    | PCTTHRESHOLD
+    | PCTUSED
+    | PCTVERSION
+    | PENDING
+    | PERCENTILE_CONT
+    | PERCENTILE_DISC
+    | PERCENT_KEYWORD
+    | PERCENT_RANKM
+    | PERCENT_RANK
+    | PERFORMANCE
+    | PERMANENT
+    | PERMISSION
+    | PFILE
+    | PHYSICAL
+    | PIKEY
+    | PIV_GB
+    | PIVOT
+    | PIV_SSF
+    | PLACE_DISTINCT
+    | PLACE_GROUP_BY
+    | PLAN
+    | PLSCOPE_SETTINGS
+    | PLSQL_CCFLAGS
+    | PLSQL_CODE_TYPE
+    | PLSQL_DEBUG
+    | PLSQL_OPTIMIZE_LEVEL
+    | PLSQL_WARNINGS
+    | POINT
+    | POLICY
+    | POST_TRANSACTION
+    | POWERMULTISET_BY_CARDINALITY
+    | POWERMULTISET
+    | POWER
+    | POSITION
+    | PQ_DISTRIBUTE
+    | PQ_MAP
+    | PQ_NOMAP
+    | PREBUILT
+    | PRECEDES
+    | PRECEDING
+    | PRECISION
+    | PRECOMPUTE_SUBQUERY
+    | PREDICATE_REORDERS
+    | PREDICTION_BOUNDS
+    | PREDICTION_COST
+    | PREDICTION_DETAILS
+    | PREDICTION
+    | PREDICTION_PROBABILITY
+    | PREDICTION_SET
+    | PREPARE
+    | PRESENT
+    | PRESENTNNV
+    | PRESENTV
+    | PRESERVE
+    | PRESERVE_OID
+    | PREVIOUS
+    | PRIMARY
+    | PRIVATE
+    | PRIVATE_SGA
+    | PRIVILEGE
+    | PRIVILEGES
+    | PROCEDURAL
+    | PROCEDURE
+    | PROCESS
+    | PROFILE
+    | PROGRAM
+    | PROJECT
+    | PROPAGATE
+    | PROTECTED
+    | PROTECTION
+    | PULL_PRED
+    | PURGE
+    | PUSH_PRED
+    | PUSH_SUBQ
+    | PX_GRANULE
+    | PX_JOIN_FILTER
+    | QB_NAME
+    | QUERY_BLOCK
+    | QUERY
+    | QUEUE_CURR
+    | QUEUE
+    | QUEUE_ROWP
+    | QUIESCE
+    | QUORUM
+    | QUOTA
+    | RANDOM_LOCAL
+    | RANDOM
+    | RANGE
+    | RANKM
+    | RANK
+    | RAPIDLY
+    | RATIO_TO_REPORT
+    | RAWTOHEX
+    | RAWTONHEX
+    | RBA
+    | RBO_OUTLINE
+    | RDBA
+    | READ
+    | READS
+    | REAL
+    | REBALANCE
+    | REBUILD
+    | RECORDS_PER_BLOCK
+    | RECOVERABLE
+    | RECOVER
+    | RECOVERY
+    | RECYCLEBIN
+    | RECYCLE
+    | REDACTION
+    | 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
+    | RELY
+    | REMAINDER
+    | REMOTE_MAPPED
+    | REMOVE
+    | REPAIR
+    | REPEAT
+    | REPLACE
+    | REPLICATION
+    | REQUIRED
+    | RESETLOGS
+    | RESET
+    | RESIZE
+    | RESOLVE
+    | RESOLVER
+    | RESPECT
+    | RESTORE_AS_INTERVALS
+    | RESTORE
+    | RESTRICT_ALL_REF_CONS
+    | RESTRICTED
+    | RESTRICT
+    | RESULT_CACHE
+    | RESUMABLE
+    | RESUME
+    | RETENTION
+    | RETRY_ON_ROW_CHANGE
+    | RETURNING
+    | RETURN
+    | REUSE
+    | REVERSE
+    | REWRITE
+    | REWRITE_OR_ERROR
+    | RIGHT
+    | ROLE
+    | ROLES
+    | ROLLBACK
+    | ROLLING
+    | ROLLUP
+    | ROOT
+    | ROUND
+    | ROWDEPENDENCIES
+    | ROWID
+    | ROWIDTOCHAR
+    | ROWIDTONCHAR
+    | ROW_LENGTH
+    | ROW
+    | ROW_NUMBER
+    | ROWNUM
+    | ROWS
+    | RPAD
+    | RTRIM
+    | RULE
+    | RULES
+    | SALT
+    | SAMPLE
+    | SAVE_AS_INTERVALS
+    | SAVEPOINT
+    | SB4
+    | SCALE
+    | SCALE_ROWS
+    | SCAN_INSTANCES
+    | SCAN
+    | SCHEDULER
+    | SCHEMACHECK
+    | SCHEMA
+    | SCN_ASCENDING
+    | SCN
+    | SCOPE
+    | SD_ALL
+    | SD_INHIBIT
+    | SD_SHOW
+    | SEARCH
+    | SECOND
+    | SECUREFILE_DBA
+    | SECUREFILE
+    | SECURITY
+    | SEED
+    | SEG_BLOCK
+    | SEG_FILE
+    | SEGMENT
+    | SELECTIVITY
+    | SEMIJOIN_DRIVER
+    | SEMIJOIN
+    | SEMI_TO_INNER
+    | SEQUENCED
+    | SEQUENCE
+    | SEQUENTIAL
+    | SERIALIZABLE
+    | SERVERERROR
+    | SERVICE
+    | SESSION_CACHED_CURSORS
+    | SESSION
+    | SESSIONS_PER_USER
+    | SESSIONTIMEZONE
+    | SESSIONTZNAME
+    | SETS
+    | SETTINGS
+    | SET_TO_JOIN
+    | SEVERE
+    | SHARED
+    | SHARED_POOL
+    | SHOW
+    | SHRINK
+    | SHUTDOWN
+    | SIBLINGS
+    | SID
+    | SIGNAL_COMPONENT
+    | SIGNAL_FUNCTION
+    | SIGN
+    | SIMPLE
+    | SINGLE
+    | SINGLETASK
+    | SINH
+    | SIN
+    | SKIP_EXT_OPTIMIZER
+    | SKIP_
+    | SKIP_UNQ_UNUSABLE_IDX
+    | SKIP_UNUSABLE_INDEXES
+    | SMALLFILE
+    | SNAPSHOT
+    | SOME
+    | SORT
+    | SOUNDEX
+    | SOURCE
+    | SPACE_KEYWORD
+    | SPECIFICATION
+    | SPFILE
+    | SPLIT
+    | SPREADSHEET
+    | SQLLDR
+    | SQL
+    | SQL_TRACE
+    | SQL_MACRO
+    | SQRT
+    | STALE
+    | STANDALONE
+    | STANDBY_MAX_DATA_DELAY
+    | STANDBY
+    | STAR
+    | STAR_TRANSFORMATION
+    | STARTUP
+    | STATEMENT_ID
+    | STATEMENT_QUEUING
+    | STATEMENTS
+    | 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
+    | STDDEV_POP
+    | STDDEV_SAMP
+    | STOP
+    | STORAGE
+    | STORE
+    | STREAMS
+    | STRICT
+    | STRING
+    | STRIPE_COLUMNS
+    | STRIPE_WIDTH
+    | STRIP
+    | STRUCTURE
+    | SUBMULTISET
+    | SUBPARTITION
+    | SUBPARTITION_REL
+    | SUBPARTITIONS
+    | SUBQUERIES
+    | SUBQUERY_PRUNING
+    | SUBSTITUTABLE
+    | SUBSTR2
+    | SUBSTR4
+    | SUBSTRB
+    | SUBSTRC
+    | SUBSTR
+    | SUCCESSFUL
+    | SUMMARY
+    | SUM
+    | SUPPLEMENTAL
+    | SUSPEND
+    | SWAP_JOIN_INPUTS
+    | SWITCH
+    | SWITCHOVER
+    | SYNCHRONOUS
+    | SYNC
+    | SYS
+    | SYSASM
+    | SYS_AUDIT
+    | SYSAUX
+    | SYS_CHECKACL
+    | SYS_CONNECT_BY_PATH
+    | SYS_CONTEXT
+    | SYSDATE
+    | SYSDBA
+    | SYS_DBURIGEN
+    | 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_PRIVILEGES
+    | SYS_GETTOKENID
+    | SYS_GETXTIVAL
+    | SYS_GUID
+    | SYS_MAKEXML
+    | SYS_MAKE_XMLNODEID
+    | SYS_MKXMLATTR
+    | 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_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_IIX
+    | SYS_OP_ITR
+    | 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_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_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_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
+    | TABLE
+    | TABLE_LOOKUP_BY_NL
+    | TABLES
+    | TABLESPACE
+    | TABLESPACE_NO
+    | TABLE_STATS
+    | TABNO
+    | TANH
+    | TAN
+    | TBLORIDXPARTNUM
+    | TEMPFILE
+    | TEMPLATE
+    | TEMPLATE_TABLE
+    | TEMPORARY
+    | TEMP_TABLE
+    | TEST
+    | THAN
+    | THE
+    | THEN
+    | THREAD
+    | THROUGH
+    | TIME
+    | TIMING
+    | TIMEOUT
+    | TIMES
+    | TIMESTAMP
+    | TIMEZONE
+    | TIMEZONE_ABBR
+    | TIMEZONE_HOUR
+    | TIMEZONE_MINUTE
+    | TIME_ZONE
+    | TIMEZONE_OFFSET
+    | TIMEZONE_REGION
+    | TIV_GB
+    | TIV_SSF
+    | TO_BINARY_DOUBLE
+    | TO_BINARY_FLOAT
+    | TO_BLOB
+    | TO_CHAR
+    | TO_CLOB
+    | TO_DATE
+    | TO_DSINTERVAL
+    | TO_LOB
+    | TO_MULTI_BYTE
+    | TO_NCHAR
+    | TO_NCLOB
+    | TO_NUMBER
+    | TOPLEVEL
+    | TO_SINGLE_BYTE
+    | TO_TIME
+    | TO_TIMESTAMP
+    | TO_TIMESTAMP_TZ
+    | TO_TIME_TZ
+    | TO_YMINTERVAL
+    | TRACE
+    | TRACING
+    | TRACKING
+    | TRAILING
+    | TRANSACTION
+    | TRANSFORM_DISTINCT_AGG
+    | TRANSITIONAL
+    | TRANSITION
+    | TRANSLATE
+    | TREAT
+    | TRIGGERS
+    | TRIM
+    | TRUE
+    | TRUNCATE
+    | TRUNC
+    | TRUSTED
+    | TUNING
+    | TX
+    | TYPE
+    | TYPES
+    | TZ_OFFSET
+    | UB2
+    | UBA
+    | UID
+    | UNARCHIVED
+    | UNBOUNDED
+    | UNBOUND
+    | UNDER
+    | UNDO
+    | UNDROP
+    | UNIFORM
+    | UNISTR
+    | UNLIMITED
+    | UNLOAD
+    | UNLOCK
+    | UNNEST_INNERJ_DISTINCT_VIEW
+    | UNNEST
+    | UNNEST_NOSEMIJ_NODISTINCTVIEW
+    | UNNEST_SEMIJ_VIEW
+    | UNPACKED
+    | UNPIVOT
+    | UNPROTECTED
+    | UNQUIESCE
+    | UNRECOVERABLE
+    | UNRESTRICTED
+    | UNTIL
+    | UNUSABLE
+    | UNUSED
+    | UPDATABLE
+    | UPDATED
+    | UPDATEXML
+    | UPD_INDEXES
+    | UPD_JOININDEX
+    | UPGRADE
+    | UPPER
+    | UPSERT
+    | UROWID
+    | USAGE
+    | USE_ANTI
+    | USE_CONCAT
+    | USE_HASH_AGGREGATION
+    | USE_HASH_GBY_FOR_PUSHDOWN
+    | USE_HASH
+    | USE_INVISIBLE_INDEXES
+    | USE_MERGE_CARTESIAN
+    | USE_MERGE
+    | USE
+    | USE_NL
+    | USE_NL_WITH_INDEX
+    | USE_PRIVATE_OUTLINES
+    | USER_DEFINED
+    | USERENV
+    | USERGROUP
+    | USER
+    | USER_RECYCLEBIN
+    | USERS
+    | USE_SEMI
+    | USE_STORED_OUTLINES
+    | USE_TTT_FOR_GSETS
+    | USE_WEAK_NAME_RESL
+    | USING
+    | VALIDATE
+    | VALIDATION
+    | VALUE
+    | VARIANCE
+    | VAR_POP
+    | VARRAY
+    | VARRAYS
+    | VAR_SAMP
+    | VARYING
+    | VECTOR_READ
+    | VECTOR_READ_TRACE
+    | VERIFY
+    | VERSIONING
+    | VERSION
+    | VERSIONS_ENDSCN
+    | VERSIONS_ENDTIME
+    | VERSIONS
+    | VERSIONS_OPERATION
+    | VERSIONS_STARTSCN
+    | VERSIONS_STARTTIME
+    | VERSIONS_XID
+    | VIRTUAL
+    | VISIBLE
+    | VOLUME
+    | VSIZE
+    | WAIT
+    | WALLET
+    | WELLFORMED
+    | WHENEVER
+    | WHEN
+    | WHITESPACE
+    | WIDTH_BUCKET
+    | WITHIN
+    | WITHOUT
+    | WORK
+    | WRAPPED
+    | WRITE
+    | XDB_FASTPATH_INSERT
+    | X_DYN_PRUNE
+    | XID
+    | XML2OBJECT
+    | XMLATTRIBUTES
+    | XMLCAST
+    | XMLCDATA
+    | XMLCOLATTVAL
+    | XMLCOMMENT
+    | XMLCONCAT
+    | XMLDIFF
+    | XML_DML_RWT_STMT
+    | XMLELEMENT
+    | XMLEXISTS2
+    | XMLEXISTS
+    | XMLFOREST
+    | XMLINDEX_REWRITE_IN_SELECT
+    | XMLINDEX_REWRITE
+    | XMLINDEX_SEL_IDX_TBL
+    | XMLISNODE
+    | XMLISVALID
+    | XML
+    | XMLNAMESPACES
+    | XMLPARSE
+    | XMLPATCH
+    | XMLPI
+    | XMLQUERY
+    | XMLQUERYVAL
+    | XMLROOT
+    | XMLSCHEMA
+    | XMLSERIALIZE
+    | XMLTABLE
+    | XMLTRANSFORMBLOB
+    | XMLTRANSFORM
+    | XMLTYPE
+    | XPATHTABLE
+    | XS_SYS_CONTEXT
+    | YEAR
+    | YES
+    | ZONE
+    ;
diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
new file mode 100644
index 000000000..66e0310e3
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -0,0 +1,167 @@
+/**
+ * ANTLR4 driver for the grammars-v4 PlSql grammar.
+ *
+ * - Source is pre-processed (SQL*Plus, conditional compilation) without moving
+ *   any line, then split into segments at lone `/` terminator lines, so a
+ *   syntax error or timeout is confined to one compilation unit.
+ * - Each segment is parsed with SLL + bail first (fast path) and re-parsed
+ *   with full LL + error recovery only when SLL fails.
+ * - A per-segment deadline aborts pathological inputs; callers fall back to
+ *   regex-level facts for that segment.
+ *
+ * Segments are parsed as the original text prefixed with blank lines, so token
+ * line numbers are file line numbers.
+ */
+
+import {
+  BailErrorStrategy,
+  BaseErrorListener,
+  CharStream,
+  CommonTokenStream,
+  DefaultErrorStrategy,
+  ParseCancellationException,
+  PredictionMode,
+  type ATNSimulator,
+  type ParseTreeListener,
+  type ParserRuleContext,
+  type RecognitionException,
+  type Recognizer,
+  type Token,
+} from 'antlr4ng';
+import { PlSqlLexer } from './generated/PlSqlLexer.js';
+import { PlSqlParser, type Sql_scriptContext } from './generated/PlSqlParser.js';
+import {
+  preprocessPlSql,
+  scriptIncludesOf,
+  type ScriptInclude,
+  type SqlPlusCommand,
+} from './preprocess.js';
+
+/** Default wall-clock budget for one segment. */
+export const DEFAULT_SEGMENT_DEADLINE_MS = 10_000;
+
+export interface PlSqlSegment {
+  /** 1-based first and last source line of the segment. */
+  readonly startLine: number;
+  readonly endLine: number;
+  /** Pre-processed segment text (same line layout as the source). */
+  readonly text: string;
+  /** Parse tree; undefined when the segment timed out. */
+  readonly tree?: Sql_scriptContext;
+  readonly syntaxErrors: number;
+  readonly firstError?: string;
+  readonly mode: 'sll' | 'll' | 'timeout';
+}
+
+export interface ParsedPlSqlSource {
+  readonly segments: readonly PlSqlSegment[];
+  readonly scriptIncludes: readonly ScriptInclude[];
+}
+
+class CountingErrorListener extends BaseErrorListener {
+  count = 0;
+  first?: string;
+  override syntaxError<S extends Token, T extends ATNSimulator>(
+    _recognizer: Recognizer<T>,
+    _offendingSymbol: S | null,
+    line: number,
+    column: number,
+    msg: string,
+    _e: RecognitionException | null,
+  ): void {
+    this.count++;
+    this.first ??= `${line}:${column} ${msg.slice(0, 160)}`;
+  }
+}
+
+class DeadlineExceeded extends Error {}
+
+/** Parse listener that aborts once the deadline passes (checked every 512 rules). */
+function deadlineListener(deadline: number): ParseTreeListener {
+  let ticks = 0;
+  return {
+    visitTerminal() {},
+    visitErrorNode() {},
+    enterEveryRule() {
+      if ((++ticks & 511) === 0 && performance.now() > deadline) throw new DeadlineExceeded();
+    },
+    exitEveryRule() {},
+  };
+}
+
+function newParser(text: string): PlSqlParser {
+  const lexer = new PlSqlLexer(CharStream.fromString(text));
+  lexer.removeErrorListeners();
+  const parser = new PlSqlParser(new CommonTokenStream(lexer));
+  parser.removeErrorListeners();
+  return parser;
+}
+
+function parseSegment(
+  text: string,
+  deadlineMs: number,
+): Omit<PlSqlSegment, 'startLine' | 'endLine' | 'text'> {
+  const deadline = performance.now() + deadlineMs;
+  try {
+    const sll = newParser(text);
+    sll.interpreter.predictionMode = PredictionMode.SLL;
+    sll.errorHandler = new BailErrorStrategy();
+    sll.addParseListener(deadlineListener(deadline));
+    try {
+      return { tree: sll.sql_script(), syntaxErrors: 0, mode: 'sll' };
+    } catch (e) {
+      if (!(e instanceof ParseCancellationException)) throw e;
+    }
+    const ll = newParser(text);
+    const errors = new CountingErrorListener();
+    ll.addErrorListener(errors);
+    ll.interpreter.predictionMode = PredictionMode.LL;
+    ll.errorHandler = new DefaultErrorStrategy();
+    ll.addParseListener(deadlineListener(deadline));
+    const tree = ll.sql_script();
+    return { tree, syntaxErrors: errors.count, firstError: errors.first, mode: 'll' };
+  } catch (e) {
+    if (e instanceof DeadlineExceeded)
+      return { syntaxErrors: 1, firstError: 'deadline exceeded', mode: 'timeout' };
+    throw e;
+  }
+}
+
+/** Split pre-processed text at lone `/` lines; each segment keeps its line offset. */
+export function splitSegments(
+  text: string,
+): Array<{ startLine: number; endLine: number; body: string }> {
+  const lines = text.split('\n');
+  const out: Array<{ startLine: number; endLine: number; body: string }> = [];
+  let start = 0;
+  const flush = (endExclusive: number) => {
+    const body = lines.slice(start, endExclusive).join('\n');
+    if (body.trim() !== '') out.push({ startLine: start + 1, endLine: endExclusive, body });
+  };
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i]!.trim() === '/') {
+      flush(i + 1);
+      start = i + 1;
+    }
+  }
+  flush(lines.length);
+  return out;
+}
+
+export function parsePlSqlSource(
+  source: string,
+  options: { segmentDeadlineMs?: number } = {},
+): ParsedPlSqlSource {
+  const commands: SqlPlusCommand[] = [];
+  const text = preprocessPlSql(source, commands);
+  const segments: PlSqlSegment[] = [];
+  for (const seg of splitSegments(text)) {
+    // Prefix blank lines so token lines are file lines.
+    const padded = '\n'.repeat(seg.startLine - 1) + seg.body;
+    const result = parseSegment(padded, options.segmentDeadlineMs ?? DEFAULT_SEGMENT_DEADLINE_MS);
+    segments.push({ startLine: seg.startLine, endLine: seg.endLine, text: seg.body, ...result });
+  }
+  return { segments, scriptIncludes: scriptIncludesOf(commands) };
+}
+
+export type { ParserRuleContext };
diff --git a/gitnexus/src/core/ingestion/plsql/preprocess.ts b/gitnexus/src/core/ingestion/plsql/preprocess.ts
new file mode 100644
index 000000000..69cc2a317
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/preprocess.ts
@@ -0,0 +1,254 @@
+/**
+ * Line-preserving PL/SQL source pre-pass.
+ *
+ * The grammar recognises SQL and PL/SQL units; real repositories also carry
+ * SQL*Plus client commands (`SET`, `DEFINE`, `@@file`, `PROMPT`, `-`
+ * continuations, `&` substitution variables) and PL/SQL conditional
+ * compilation (`$IF ... $THEN ... $END`). Both are rewritten here so the parser
+ * sees only compilable text. Every transformation keeps line breaks — and
+ * blanks in place rather than deleting — so ANTLR token positions are the
+ * original source positions.
+ */
+
+const SQLPLUS_COMMAND =
+  /^\s*(?:set|define|def|undefine|undef|prompt|pro|rem|remark|spool|spo|whenever|column|col|connect|conn|accept|acc|pause|show|sho|exit|quit|host|ttitle|btitle|break|compute|clear|var|variable|print|timing|exec|execute|start|sta|disconnect|disc|store|repheader|repfooter|attribute|copy|describe|desc|get|help|list|password|run|save|xquery)\b/i;
+
+/** Statements that start a PL/SQL unit, which only a lone `/` terminates. */
+const PLSQL_UNIT_START =
+  /^(?:create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package|procedure|function|trigger|type)\b|declare\b|begin\b)/i;
+
+const ENDS_STATEMENT = /;\s*(?:--.*)?$/;
+const CONTINUATION = /\s-\s*$/;
+
+/**
+ * Blank SQL*Plus commands. They are only recognised *between* statements:
+ * inside a PL/SQL unit `EXECUTE IMMEDIATE ...` or a column named `desc` is
+ * ordinary code and must survive.
+ */
+export interface SqlPlusCommand {
+  /** 1-based line of the command's first line. */
+  readonly line: number;
+  readonly text: string;
+}
+
+export function stripSqlPlusCommands(source: string, commands?: SqlPlusCommand[]): string {
+  const lines = source.split('\n');
+  let state: 'between' | 'plsql' | 'sql' = 'between';
+  let continuation = false;
+  let inBlockComment = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    const trimmed = line.replace(/\r$/, '').trim();
+    if (continuation) {
+      continuation = CONTINUATION.test(trimmed);
+      lines[i] = blankLine(line);
+      continue;
+    }
+    if (inBlockComment) {
+      if (trimmed.includes('*/')) inBlockComment = false;
+      continue;
+    }
+    if (state === 'plsql') {
+      if (trimmed === '/') state = 'between';
+      continue;
+    }
+    if (state === 'sql') {
+      if (trimmed === '/' || ENDS_STATEMENT.test(trimmed)) state = 'between';
+      continue;
+    }
+    if (trimmed === '' || trimmed.startsWith('--') || trimmed === '/') continue;
+    if (trimmed.startsWith('/*')) {
+      if (!trimmed.includes('*/', 2)) inBlockComment = true;
+      continue;
+    }
+    if (SQLPLUS_COMMAND.test(trimmed) || trimmed.startsWith('@')) {
+      continuation = CONTINUATION.test(trimmed);
+      commands?.push({ line: i + 1, text: line.replace(/\r$/, '') });
+      lines[i] = blankLine(line);
+      continue;
+    }
+    if (PLSQL_UNIT_START.test(trimmed)) state = 'plsql';
+    else if (!ENDS_STATEMENT.test(trimmed)) state = 'sql';
+  }
+  return lines.join('\n');
+}
+
+function blankLine(line: string): string {
+  return line.endsWith('\r') ? '\r' : '';
+}
+
+/**
+ * `&name` / `&&name` / `&name.` → an identifier of exactly the same length
+ * (`Zname`, `ZZname`), so token columns stay aligned with the original text.
+ */
+export function neutraliseSubstitutionVariables(source: string): string {
+  return source.replace(
+    /(&&?)([A-Za-z_][\w$#]*)(\.?)/g,
+    (_m, amps: string, name: string, dot: string) =>
+      `${'Z'.repeat(amps.length)}${name}${dot ? ' ' : ''}`,
+  );
+}
+
+type CcFrame = { mode: 'condition' | 'kept' | 'skipped' | 'error'; taken: boolean };
+
+const CC_DIRECTIVE = /^\$(if|then|elsif|else|end|error)\b/i;
+
+/**
+ * Resolve conditional compilation by keeping the first selected branch of
+ * every `$IF` (the condition is not evaluated) and blanking directives, the
+ * conditions and all other branches. Nesting-aware; strings, quoted
+ * identifiers and comments are skipped so `$end` inside a literal is ignored.
+ */
+export function resolveConditionalCompilation(source: string): string {
+  if (!/\$(?:if|error)\b/i.test(source)) return source;
+  const out: string[] = [];
+  const stack: CcFrame[] = [];
+  const blanking = () => stack.some((f) => f.mode !== 'kept');
+  const emit = (text: string) => {
+    out.push(blanking() ? text.replace(/[^\r\n]/g, ' ') : text);
+  };
+  const emitBlank = (text: string) => out.push(text.replace(/[^\r\n]/g, ' '));
+
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i]!;
+    const next = source[i + 1];
+    // -- line comment
+    if (ch === '-' && next === '-') {
+      const end = source.indexOf('\n', i);
+      const stop = end === -1 ? source.length : end;
+      emit(source.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    // /* block comment */
+    if (ch === '/' && next === '*') {
+      const end = source.indexOf('*/', i + 2);
+      const stop = end === -1 ? source.length : end + 2;
+      emit(source.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    // q'[...]' alternative quoting
+    if (
+      (ch === 'q' || ch === 'Q') &&
+      next === "'" &&
+      i + 2 < source.length &&
+      !isWordChar(source[i - 1])
+    ) {
+      const open = source[i + 2]!;
+      const close = { '[': ']', '(': ')', '{': '}', '<': '>' }[open] ?? open;
+      const end = source.indexOf(`${close}'`, i + 3);
+      const stop = end === -1 ? source.length : end + 2;
+      emit(source.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    // '...' string with '' escapes
+    if (ch === "'") {
+      let j = i + 1;
+      while (j < source.length) {
+        if (source[j] === "'") {
+          if (source[j + 1] === "'") j += 2;
+          else break;
+        } else j++;
+      }
+      const stop = Math.min(j + 1, source.length);
+      emit(source.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    // "quoted identifier"
+    if (ch === '"') {
+      const end = source.indexOf('"', i + 1);
+      const stop = end === -1 ? source.length : end + 1;
+      emit(source.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    if (ch === '$' && next !== '$' && !isWordChar(source[i - 1])) {
+      const m = CC_DIRECTIVE.exec(source.slice(i, i + 8));
+      if (m) {
+        const directive = m[1]!.toLowerCase();
+        const top = stack[stack.length - 1];
+        switch (directive) {
+          case 'if':
+            stack.push({ mode: 'condition', taken: false });
+            break;
+          case 'error':
+            stack.push({ mode: 'error', taken: false });
+            break;
+          case 'then':
+            if (top?.mode === 'condition') {
+              top.mode = top.taken ? 'skipped' : 'kept';
+              top.taken = true;
+            }
+            break;
+          case 'elsif':
+            if (top && top.mode !== 'error') top.mode = 'condition';
+            break;
+          case 'else':
+            if (top && top.mode !== 'error') {
+              top.mode = top.taken ? 'skipped' : 'kept';
+              top.taken = true;
+            }
+            break;
+          case 'end':
+            emitBlank(m[0]);
+            stack.pop();
+            i += m[0].length;
+            continue;
+        }
+        emitBlank(m[0]);
+        i += m[0].length;
+        continue;
+      }
+    }
+    emit(ch);
+    i++;
+  }
+  return out.join('');
+}
+
+function isWordChar(ch: string | undefined): boolean {
+  return ch !== undefined && /[\w$#]/.test(ch);
+}
+
+/** Full pre-pass in the order the constructs nest. */
+export function preprocessPlSql(source: string, commands?: SqlPlusCommand[]): string {
+  return resolveConditionalCompilation(
+    neutraliseSubstitutionVariables(stripSqlPlusCommands(source, commands)),
+  );
+}
+
+export interface ScriptInclude {
+  readonly line: number;
+  /** 0-based column of the path text. */
+  readonly column: number;
+  /** Path as written (`pkg_loan.pks`, `../common/setup`). */
+  readonly target: string;
+  /** `@@` resolves against the calling script's directory; `@`/`START` against the working directory. */
+  readonly relativeToScript: boolean;
+}
+
+const INCLUDE_COMMAND = /^(\s*)(@@|@|sta(?:rt)?\s+)("[^"]+"|\S+)/i;
+
+/** SQL*Plus script inclusion (`@@file`, `@file`, `START file`) among blanked commands. */
+export function scriptIncludesOf(commands: readonly SqlPlusCommand[]): ScriptInclude[] {
+  const out: ScriptInclude[] = [];
+  for (const command of commands) {
+    const m = INCLUDE_COMMAND.exec(command.text);
+    if (!m) continue;
+    const raw = m[3]!;
+    const target = raw.startsWith('"') ? raw.slice(1, -1) : raw;
+    // Substitution-variable paths (`@&dir/x.sql`) cannot be resolved statically.
+    if (target.includes('&')) continue;
+    out.push({
+      line: command.line,
+      column: m[1]!.length + m[2]!.length + (raw.startsWith('"') ? 1 : 0),
+      target,
+      relativeToScript: m[2] === '@@',
+    });
+  }
+  return out;
+}
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
new file mode 100644
index 000000000..5ff9febf5
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -0,0 +1,101 @@
+/**
+ * PL/SQL name resolution shared by the graph processor and the scope resolver,
+ * so structural CALLS edges and rename's source bindings make the same decision.
+ *
+ * Oracle resolves a subprogram name innermost-first:
+ *   NAME        → nested/sibling subprograms up the enclosing chain, then a
+ *                 standalone procedure/function.
+ *   A.NAME      → member NAME of package A; else standalone NAME in schema A.
+ *   S.A.NAME    → member NAME of package A in schema S.
+ * Overloads are narrowed by arity (counting defaulted parameters) and named
+ * arguments; what remains is returned as-is so callers can report ambiguity.
+ */
+
+import type { PlSqlCallSite, PlSqlDefinition } from './extract.js';
+
+export interface PlSqlIndexEntry {
+  readonly def: PlSqlDefinition;
+  readonly filePath: string;
+}
+
+const pathKey = (path: readonly string[]) => path.join('.');
+
+/** Owner path + name + parameter signature: identifies a spec declaration with its body. */
+export function plsqlSignatureKey(
+  def: Pick<PlSqlDefinition, 'ownerPath' | 'name' | 'parameters'>,
+): string {
+  return `${[...def.ownerPath, def.name].join('.')}(${def.parameters.map((p) => `${p.name} ${p.type}`.trim()).join(',')})`;
+}
+
+export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
+  private readonly members = new Map<string, Map<string, E[]>>();
+  private readonly packageNames = new Set<string>();
+
+  add(entry: E): void {
+    if (entry.def.kind === 'package') this.packageNames.add(entry.def.name);
+    const owner = pathKey(entry.def.ownerPath);
+    let byName = this.members.get(owner);
+    if (!byName) this.members.set(owner, (byName = new Map()));
+    const list = byName.get(entry.def.name);
+    if (list) list.push(entry);
+    else byName.set(entry.def.name, [entry]);
+  }
+
+  hasPackage(name: string): boolean {
+    return this.packageNames.has(name);
+  }
+
+  lookup(ownerPath: readonly string[], name: string): E[] {
+    return this.members.get(pathKey(ownerPath))?.get(name) ?? [];
+  }
+
+  /** Candidate definitions for a call, before overload narrowing. */
+  candidates(call: Pick<PlSqlCallSite, 'nameParts' | 'ownerPath'>): E[] {
+    const parts = call.nameParts;
+    const callable = (e: E) => e.def.kind === 'procedure' || e.def.kind === 'function';
+    if (parts.length === 1) {
+      const name = parts[0]!;
+      for (let depth = call.ownerPath.length; depth >= 0; depth--) {
+        const found = this.lookup(call.ownerPath.slice(0, depth), name).filter(callable);
+        if (found.length > 0) return found;
+      }
+      return [];
+    }
+    const name = parts[parts.length - 1]!;
+    const qualifier = parts[parts.length - 2]!;
+    const member = this.lookup([qualifier], name).filter(callable);
+    if (member.length > 0) return member;
+    if (parts.length === 2) return this.lookup([], name).filter(callable);
+    return [];
+  }
+
+  /** Resolve a call to its implementation(s); empty when nothing in the repository matches. */
+  resolve(call: Pick<PlSqlCallSite, 'nameParts' | 'ownerPath' | 'arity' | 'namedArguments'>): E[] {
+    return preferImplementations(narrowOverloads(this.candidates(call), call));
+  }
+}
+
+function narrowOverloads<E extends PlSqlIndexEntry>(
+  candidates: E[],
+  call: Pick<PlSqlCallSite, 'arity' | 'namedArguments'>,
+): E[] {
+  if (candidates.length <= 1 || call.arity === undefined) return candidates;
+  const arity = call.arity;
+  const fits = candidates.filter((c) => {
+    if (c.def.fromFallback) return true; // parameters unknown
+    const required = c.def.parameters.filter((p) => !p.hasDefault).length;
+    if (arity < required || arity > c.def.parameters.length) return false;
+    const names = new Set(c.def.parameters.map((p) => p.name));
+    return call.namedArguments.every((n) => names.has(n));
+  });
+  return fits.length > 0 ? fits : candidates;
+}
+
+/**
+ * A spec declaration and its body describe one subprogram; prefer the body.
+ * Spec-only entries remain when no body is indexed.
+ */
+function preferImplementations<E extends PlSqlIndexEntry>(defs: E[]): E[] {
+  const bodies = new Set(defs.filter((d) => !d.def.isSpec).map((d) => plsqlSignatureKey(d.def)));
+  return defs.filter((d) => !d.def.isSpec || !bodies.has(plsqlSignatureKey(d.def)));
+}
diff --git a/gitnexus/src/core/ingestion/plsql/script-include.ts b/gitnexus/src/core/ingestion/plsql/script-include.ts
new file mode 100644
index 000000000..38392ed2a
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/script-include.ts
@@ -0,0 +1,43 @@
+/**
+ * SQL*Plus script inclusion (`@@file`, `@file`, `START file`) → repository path.
+ *
+ * SQL*Plus looks a script up relative to the calling script (`@@`) or the
+ * working directory (`@`, `START`), appending `.sql` when the name has no
+ * extension. Statically we try the calling script's directory, then the
+ * repository root — exact paths only. There is no suffix search: a script
+ * that is not at one of those paths lives outside the repository (a vendor
+ * install, `?/rdbms/admin/...`) and must not bind to a same-named file.
+ */
+
+import path from 'node:path';
+
+function normalise(p: string): string {
+  return path.posix.normalize(p.replace(/\\/g, '/')).replace(/^\.\//, '');
+}
+
+export function resolvePlSqlScriptInclude(
+  targetRaw: string,
+  fromFile: string,
+  allFilePaths: ReadonlySet<string>,
+): string | null {
+  const target = targetRaw.trim().replace(/^["']|["']$/g, '');
+  // `?` is ORACLE_HOME; absolute paths are machine-specific.
+  if (
+    target === '' ||
+    target.startsWith('?') ||
+    path.posix.isAbsolute(target) ||
+    /^[A-Za-z]:[\\/]/.test(target)
+  ) {
+    return null;
+  }
+  const spellings = path.posix.extname(target) === '' ? [`${target}.sql`, target] : [target];
+  const dir = path.posix.dirname(fromFile.replace(/\\/g, '/'));
+  for (const base of [dir, '']) {
+    for (const spelling of spellings) {
+      const candidate = normalise(base ? `${base}/${spelling}` : spelling);
+      if (candidate.startsWith('../')) continue;
+      if (allFilePaths.has(candidate)) return candidate;
+    }
+  }
+  return null;
+}
diff --git a/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts b/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
index ee98e3807..f8a723ddf 100644
--- a/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
+++ b/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
@@ -24,6 +24,7 @@ import { javascriptScopeResolver } from '../../languages/javascript/scope-resolv
 import { kotlinScopeResolver } from '../../languages/kotlin/scope-resolver.js';
 import { rubyScopeResolver } from '../../languages/ruby/scope-resolver.js';
 import { cobolScopeResolver } from '../../languages/cobol/scope-resolver.js';
+import { plsqlScopeResolver } from '../../languages/plsql/scope-resolver.js';
 import { swiftScopeResolver } from '../../languages/swift/scope-resolver.js';
 import { dartScopeResolver } from '../../languages/dart/scope-resolver.js';
 import { vueScopeResolver } from '../../languages/vue/scope-resolver.js';
@@ -50,6 +51,7 @@ export const SCOPE_RESOLVERS: ReadonlyMap<SupportedLanguages, ScopeResolver> = n
   [SupportedLanguages.Kotlin, kotlinScopeResolver],
   [SupportedLanguages.Ruby, rubyScopeResolver],
   [SupportedLanguages.Cobol, cobolScopeResolver],
+  [SupportedLanguages.PlSql, plsqlScopeResolver],
   [SupportedLanguages.Swift, swiftScopeResolver],
   [SupportedLanguages.Dart, dartScopeResolver],
   [SupportedLanguages.Vue, vueScopeResolver],
diff --git a/gitnexus/src/core/ingestion/tree-sitter-queries.ts b/gitnexus/src/core/ingestion/tree-sitter-queries.ts
index 2e900e642..c44e54297 100644
--- a/gitnexus/src/core/ingestion/tree-sitter-queries.ts
+++ b/gitnexus/src/core/ingestion/tree-sitter-queries.ts
@@ -3087,5 +3087,6 @@ export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = {
   [SupportedLanguages.Dart]: DART_QUERIES,
   [SupportedLanguages.Vue]: TYPESCRIPT_QUERIES, // Vue <script> blocks are parsed as TypeScript
   [SupportedLanguages.Cobol]: '', // Standalone regex processor — no tree-sitter queries
+  [SupportedLanguages.PlSql]: '', // Standalone ANTLR4 processor — no tree-sitter queries
   [SupportedLanguages.Zig]: ZIG_QUERIES,
 };
diff --git a/gitnexus/src/core/parse-cache-identity.ts b/gitnexus/src/core/parse-cache-identity.ts
index 97ad25a69..018aa6801 100644
--- a/gitnexus/src/core/parse-cache-identity.ts
+++ b/gitnexus/src/core/parse-cache-identity.ts
@@ -52,6 +52,7 @@ export const PARSE_CACHE_PACKAGE_INPUTS = [
   'smol-toml',
   'glob',
   'ignore',
+  'antlr4ng',
 ] as const;
 
 // These extraction-only helpers live beside their provider. flow-source stays
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/install.sql b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/install.sql
new file mode 100644
index 000000000..5bb532c26
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/install.sql
@@ -0,0 +1,13 @@
+-- Installs the loan settlement schema objects in dependency order.
+SET DEFINE OFF
+WHENEVER SQLERROR EXIT FAILURE
+PROMPT Installing packages...
+@@packages/pkg_log.pks
+@@packages/pkg_log.pkb
+@@packages/pkg_loan_settle.pks
+@@packages/pkg_loan_settle.pkb
+@@procedures/prc_archive.prc
+@@triggers/trg_repay_plan_audit.sql
+-- Shipped by the vendor, not part of this repository.
+@@vendor_patch.sql
+EXIT
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pkb b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pkb
new file mode 100644
index 000000000..578dc1430
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pkb
@@ -0,0 +1,68 @@
+CREATE OR REPLACE PACKAGE BODY loan.pkg_loan_settle AS
+
+  g_batch_no VARCHAR2(32);
+
+  -- Private: not declared in the spec.
+  FUNCTION calc_penalty(p_loan_id IN NUMBER, p_days IN NUMBER) RETURN NUMBER IS
+    l_rate NUMBER;
+  BEGIN
+    SELECT p.penalty_rate INTO l_rate
+      FROM t_loan_product p
+     WHERE p.product_id = (SELECT c.product_id FROM t_loan_contract c WHERE c.loan_id = p_loan_id);
+    RETURN ROUND(l_rate * p_days, 2);
+  END calc_penalty;
+
+  PROCEDURE write_journal(p_loan_id NUMBER, p_amt NUMBER, p_type VARCHAR2) IS
+  BEGIN
+    INSERT INTO t_acct_journal (journal_id, loan_id, amount, journal_type, batch_no)
+    VALUES (seq_journal.NEXTVAL, p_loan_id, p_amt, p_type, g_batch_no);
+  END write_journal;
+
+  PROCEDURE settle_one(p_loan_id IN NUMBER) IS
+    l_overdue_days NUMBER;
+    l_penalty      NUMBER;
+
+    PROCEDURE mark_settled IS
+    BEGIN
+      UPDATE t_repay_plan SET status = 'SETTLED', settle_time = SYSTIMESTAMP
+       WHERE loan_id = p_loan_id AND status = 'DUE';
+    END mark_settled;
+  BEGIN
+    SELECT TRUNC(SYSDATE) - due_date INTO l_overdue_days
+      FROM t_repay_plan WHERE loan_id = p_loan_id AND status = 'DUE' AND ROWNUM = 1;
+
+    IF l_overdue_days > 0 THEN
+      l_penalty := calc_penalty(p_loan_id, l_overdue_days);
+      write_journal(p_loan_id, l_penalty, 'PENALTY');
+      pkg_acct.freeze@core_link(p_loan_id);
+    END IF;
+    mark_settled;
+
+    MERGE INTO t_loan_balance b
+    USING (SELECT loan_id, SUM(amount) amt FROM t_acct_journal WHERE loan_id = p_loan_id GROUP BY loan_id) j
+       ON (b.loan_id = j.loan_id)
+     WHEN MATCHED THEN UPDATE SET b.balance = b.balance - j.amt
+     WHEN NOT MATCHED THEN INSERT (loan_id, balance) VALUES (j.loan_id, -j.amt);
+  EXCEPTION
+    WHEN NO_DATA_FOUND THEN
+      pkg_log.warn('no due plan for ' || p_loan_id);
+  END settle_one;
+
+  PROCEDURE run_batch(p_biz_date IN DATE DEFAULT TRUNC(SYSDATE)) IS
+    CURSOR c_due IS
+      WITH due AS (SELECT loan_id FROM t_repay_plan WHERE due_date <= p_biz_date AND status = 'DUE')
+      SELECT loan_id FROM due;
+    l_today DATE;
+  BEGIN
+    SELECT SYSDATE INTO l_today FROM dual;
+    g_batch_no := TO_CHAR(p_biz_date, 'YYYYMMDD') || '_' || seq_batch.NEXTVAL;
+    FOR r IN c_due LOOP
+      settle_one(r.loan_id);
+    END LOOP;
+    EXECUTE IMMEDIATE 'TRUNCATE TABLE t_settle_stage';
+    pkg_log.log_msg('batch ' || g_batch_no || ' done');
+    DBMS_OUTPUT.PUT_LINE('done');
+  END run_batch;
+
+END pkg_loan_settle;
+/
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pks b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pks
new file mode 100644
index 000000000..b8e56fe66
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_loan_settle.pks
@@ -0,0 +1,5 @@
+CREATE OR REPLACE PACKAGE loan.pkg_loan_settle AS
+  PROCEDURE settle_one(p_loan_id IN NUMBER);
+  PROCEDURE run_batch(p_biz_date IN DATE DEFAULT TRUNC(SYSDATE));
+END pkg_loan_settle;
+/
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pkb b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pkb
new file mode 100644
index 000000000..27571c62f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pkb
@@ -0,0 +1,21 @@
+CREATE OR REPLACE PACKAGE BODY pkg_log AS
+
+  PROCEDURE log_msg(p_msg IN VARCHAR2) IS
+  BEGIN
+    log_msg(p_msg, 1);
+  END log_msg;
+
+  PROCEDURE log_msg(p_msg IN VARCHAR2, p_level IN NUMBER) IS
+    PRAGMA AUTONOMOUS_TRANSACTION;
+  BEGIN
+    INSERT INTO t_app_log (log_time, log_level, message) VALUES (SYSTIMESTAMP, p_level, p_msg);
+    COMMIT;
+  END log_msg;
+
+  PROCEDURE warn(p_msg IN VARCHAR2) IS
+  BEGIN
+    log_msg(p_msg => p_msg, p_level => 2);
+  END warn;
+
+END pkg_log;
+/
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pks b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pks
new file mode 100644
index 000000000..3b081e1c2
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/packages/pkg_log.pks
@@ -0,0 +1,6 @@
+CREATE OR REPLACE PACKAGE pkg_log AS
+  PROCEDURE log_msg(p_msg IN VARCHAR2);
+  PROCEDURE log_msg(p_msg IN VARCHAR2, p_level IN NUMBER);
+  PROCEDURE warn(p_msg IN VARCHAR2);
+END pkg_log;
+/
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/postgres/fn_pg.sql b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/postgres/fn_pg.sql
new file mode 100644
index 000000000..992ad049e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/postgres/fn_pg.sql
@@ -0,0 +1,5 @@
+CREATE OR REPLACE FUNCTION mark_items_dirty(p_id integer) RETURNS void AS $$
+BEGIN
+  UPDATE items SET dirty = true WHERE id = p_id;
+END;
+$$ LANGUAGE plpgsql;
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/procedures/prc_archive.prc b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/procedures/prc_archive.prc
new file mode 100644
index 000000000..e9aa18d44
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/procedures/prc_archive.prc
@@ -0,0 +1,8 @@
+CREATE OR REPLACE PROCEDURE prc_archive(p_before IN DATE) AS
+BEGIN
+  loan.pkg_loan_settle.run_batch(p_before);
+  INSERT INTO t_repay_plan_hist SELECT * FROM t_repay_plan WHERE settle_time < p_before;
+  DELETE FROM t_repay_plan WHERE settle_time < p_before;
+  pkg_log.log_msg('archived', 1);
+END prc_archive;
+/
diff --git a/gitnexus/test/fixtures/lang-resolution/plsql-app/db/triggers/trg_repay_plan_audit.sql b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/triggers/trg_repay_plan_audit.sql
new file mode 100644
index 000000000..2b9352128
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/plsql-app/db/triggers/trg_repay_plan_audit.sql
@@ -0,0 +1,9 @@
+CREATE OR REPLACE TRIGGER trg_repay_plan_audit
+AFTER UPDATE OF status ON t_repay_plan
+FOR EACH ROW
+BEGIN
+  INSERT INTO t_audit_log (tbl, pk, old_val, new_val)
+  VALUES ('T_REPAY_PLAN', :NEW.loan_id, :OLD.status, :NEW.status);
+  pkg_log.warn('status changed');
+END;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pkb b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pkb
new file mode 100644
index 000000000..57356b608
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pkb
@@ -0,0 +1,16 @@
+CREATE OR REPLACE PACKAGE BODY pkg_log AS
+
+  PROCEDURE info(p_msg IN VARCHAR2) IS
+  BEGIN
+    INSERT INTO t_app_log (log_level, message) VALUES ('info', p_msg);
+  END info;
+
+  -- warn writes a warning row and echoes it
+  PROCEDURE notify(p_msg IN VARCHAR2) IS
+  BEGIN
+    INSERT INTO t_app_log (log_level, message) VALUES ('warn', p_msg);
+    info('warn: ' || p_msg);
+  END notify;
+
+END pkg_log;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pks b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pks
new file mode 100644
index 000000000..05ae51ff3
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/pkg_log.pks
@@ -0,0 +1,5 @@
+CREATE OR REPLACE PACKAGE pkg_log AS
+  PROCEDURE info(p_msg IN VARCHAR2);
+  PROCEDURE notify(p_msg IN VARCHAR2);
+END pkg_log;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/prc_settle.prc b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/prc_settle.prc
new file mode 100644
index 000000000..b138994a1
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/after/prc_settle.prc
@@ -0,0 +1,8 @@
+CREATE OR REPLACE PROCEDURE prc_settle(p_loan_id IN NUMBER) AS
+BEGIN
+  UPDATE t_repay_plan SET status = 'SETTLED' WHERE loan_id = p_loan_id;
+  IF SQL%ROWCOUNT = 0 THEN
+    pkg_log.notify('nothing to settle for ' || p_loan_id);
+  END IF;
+END prc_settle;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pkb b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pkb
new file mode 100644
index 000000000..eda76cbf9
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pkb
@@ -0,0 +1,16 @@
+CREATE OR REPLACE PACKAGE BODY pkg_log AS
+
+  PROCEDURE info(p_msg IN VARCHAR2) IS
+  BEGIN
+    INSERT INTO t_app_log (log_level, message) VALUES ('info', p_msg);
+  END info;
+
+  -- warn writes a warning row and echoes it
+  PROCEDURE warn(p_msg IN VARCHAR2) IS
+  BEGIN
+    INSERT INTO t_app_log (log_level, message) VALUES ('warn', p_msg);
+    info('warn: ' || p_msg);
+  END warn;
+
+END pkg_log;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pks b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pks
new file mode 100644
index 000000000..034a4944c
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/pkg_log.pks
@@ -0,0 +1,5 @@
+CREATE OR REPLACE PACKAGE pkg_log AS
+  PROCEDURE info(p_msg IN VARCHAR2);
+  PROCEDURE warn(p_msg IN VARCHAR2);
+END pkg_log;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/prc_settle.prc b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/prc_settle.prc
new file mode 100644
index 000000000..b6c6ae8d3
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/before/prc_settle.prc
@@ -0,0 +1,8 @@
+CREATE OR REPLACE PROCEDURE prc_settle(p_loan_id IN NUMBER) AS
+BEGIN
+  UPDATE t_repay_plan SET status = 'SETTLED' WHERE loan_id = p_loan_id;
+  IF SQL%ROWCOUNT = 0 THEN
+    pkg_log.warn('nothing to settle for ' || p_loan_id);
+  END IF;
+END prc_settle;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/case.json b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/case.json
new file mode 100644
index 000000000..487d88061
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-procedure-cross-file/case.json
@@ -0,0 +1,37 @@
+{
+  "language": "plsql",
+  "description": "Rename a package procedure: its spec declaration, body, END label and a cross-file package-qualified call change together; a same-spelled string literal and comment do not.",
+  "categories": [
+    "call-graph",
+    "cross-file",
+    "package-scope"
+  ],
+  "target": {
+    "name": "WARN",
+    "kind": "Function",
+    "file": "pkg_log.pkb"
+  },
+  "newName": "notify",
+  "expectedTargetName": "NOTIFY",
+  "expect": {
+    "status": "success",
+    "edits": 4
+  },
+  "edges": [
+    {
+      "type": "CALLS",
+      "from": {
+        "name": "PRC_SETTLE",
+        "kind": "Function",
+        "file": "prc_settle.prc",
+        "startLine": 0
+      },
+      "to": {
+        "name": "WARN",
+        "kind": "Function",
+        "file": "pkg_log.pkb",
+        "startLine": 8
+      }
+    }
+  ]
+}
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/after/pkg_fee.pkb b/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/after/pkg_fee.pkb
new file mode 100644
index 000000000..7ca790580
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/after/pkg_fee.pkb
@@ -0,0 +1,15 @@
+CREATE OR REPLACE PACKAGE BODY pkg_fee AS
+
+  FUNCTION calc_fee(p_amt IN NUMBER) RETURN NUMBER IS
+  BEGIN
+    RETURN ROUND(p_amt * 0.003, 2);
+  END calc_fee;
+
+  PROCEDURE reprice(p_batch IN VARCHAR2) IS
+  BEGIN
+    -- The fee function is also invoked from a generated statement.
+    EXECUTE IMMEDIATE 'UPDATE t_txn SET fee = pkg_fee.calc_fee(amount) WHERE batch_no = :1' USING p_batch;
+  END reprice;
+
+END pkg_fee;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/before/pkg_fee.pkb b/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/before/pkg_fee.pkb
new file mode 100644
index 000000000..7ca790580
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/before/pkg_fee.pkb
@@ -0,0 +1,15 @@
+CREATE OR REPLACE PACKAGE BODY pkg_fee AS
+
+  FUNCTION calc_fee(p_amt IN NUMBER) RETURN NUMBER IS
+  BEGIN
+    RETURN ROUND(p_amt * 0.003, 2);
+  END calc_fee;
+
+  PROCEDURE reprice(p_batch IN VARCHAR2) IS
+  BEGIN
+    -- The fee function is also invoked from a generated statement.
+    EXECUTE IMMEDIATE 'UPDATE t_txn SET fee = pkg_fee.calc_fee(amount) WHERE batch_no = :1' USING p_batch;
+  END reprice;
+
+END pkg_fee;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/case.json b/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/case.json
new file mode 100644
index 000000000..8022262f4
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-dynamic-sql/case.json
@@ -0,0 +1,16 @@
+{
+  "language": "plsql",
+  "description": "Refuse to rename a function that dynamic SQL text also names: the string cannot be rewritten safely, so every source byte must stay unchanged.",
+  "categories": ["dynamic-sql", "negative", "unchanged-on-error"],
+  "target": {
+    "name": "CALC_FEE",
+    "kind": "Function",
+    "file": "pkg_fee.pkb"
+  },
+  "newName": "calc_service_fee",
+  "expect": {
+    "status": "error",
+    "code": "unsupported_occurrence",
+    "planningStatus": "unsupported"
+  }
+}
diff --git a/gitnexus/test/integration/rename-provider-plsql.test.ts b/gitnexus/test/integration/rename-provider-plsql.test.ts
new file mode 100644
index 000000000..89b890efc
--- /dev/null
+++ b/gitnexus/test/integration/rename-provider-plsql.test.ts
@@ -0,0 +1,3 @@
+import { defineRenameFixtureTests } from '../helpers/rename-integration-cases.js';
+
+defineRenameFixtureTests('plsql');
diff --git a/gitnexus/test/integration/resolvers/callable-value-flow.test.ts b/gitnexus/test/integration/resolvers/callable-value-flow.test.ts
index 1dee87a4d..cba38978d 100644
--- a/gitnexus/test/integration/resolvers/callable-value-flow.test.ts
+++ b/gitnexus/test/integration/resolvers/callable-value-flow.test.ts
@@ -41,6 +41,9 @@ const CALLABLE_FLOW_PROVIDER_COVERAGE = {
   // Objective-C message sends are resolved by its ScopeResolver. The provider
   // does not emit callable-value-flow captures in this MVP.
   [SupportedLanguages.ObjectiveC]: 'not-applicable',
+  // PL/SQL has no first-class callable values; calls are structural edges
+  // written by the PL/SQL processor.
+  [SupportedLanguages.PlSql]: 'not-applicable',
 } as const satisfies Record<SupportedLanguages, CallableFlowCoverage>;
 
 const PROVIDER_FLOW_CASES = [
diff --git a/gitnexus/test/integration/resolvers/plsql.test.ts b/gitnexus/test/integration/resolvers/plsql.test.ts
new file mode 100644
index 000000000..f1c68d4d8
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/plsql.test.ts
@@ -0,0 +1,194 @@
+/**
+ * Oracle PL/SQL: strict integration test over the plsql-app fixture.
+ *
+ * Every PL/SQL node and edge is asserted with exact sorted lists, including
+ * the negatives: built-ins, database-link calls, CTE names, DUAL, scripts
+ * outside the repository and a PostgreSQL `.sql` decoy produce nothing.
+ *
+ *   db/install.sql                       SQL*Plus install script (@@ includes)
+ *   db/packages/pkg_log.{pks,pkb}        overloaded LOG_MSG, named arguments
+ *   db/packages/pkg_loan_settle.{pks,pkb} schema-qualified package, private
+ *                                        and nested subprograms, MERGE, CTE
+ *   db/procedures/prc_archive.prc        standalone procedure, INSERT…SELECT
+ *   db/triggers/trg_repay_plan_audit.sql trigger in a .sql file
+ *   db/postgres/fn_pg.sql                PL/pgSQL decoy — must not be claimed
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, runPipelineFromRepo, type PipelineResult } from './helpers.js';
+
+const plsqlNodes = (result: PipelineResult, label: string) => {
+  const out: string[] = [];
+  result.graph.forEachNode((n) => {
+    if (n.label === label && n.properties.language === 'plsql') out.push(n.properties.name);
+  });
+  return out.sort();
+};
+
+const plsqlEdges = (result: PipelineResult, type: string) =>
+  getRelationships(result, type)
+    .filter((e) => e.rel.reason.startsWith('plsql'))
+    .map((e) => `${e.source} → ${e.target} [${e.rel.reason}]`)
+    .sort();
+
+describe('Oracle PL/SQL extraction', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'plsql-app'), () => {}, {
+      skipGraphPhases: true,
+    });
+  }, 120000);
+
+  describe('nodes', () => {
+    it('merges each package spec and body into one Module anchored at the spec', () => {
+      expect(plsqlNodes(result, 'Module')).toEqual(['PKG_LOAN_SETTLE', 'PKG_LOG']);
+      let anchor: string | undefined;
+      result.graph.forEachNode((n) => {
+        if (n.label === 'Module' && n.properties.name === 'PKG_LOAN_SETTLE')
+          anchor = n.properties.filePath;
+      });
+      expect(anchor).toBe('db/packages/pkg_loan_settle.pks');
+    });
+
+    it('creates one Function per subprogram body, overloads and nested subprograms included', () => {
+      expect(plsqlNodes(result, 'Function')).toEqual([
+        'CALC_PENALTY',
+        'LOG_MSG',
+        'LOG_MSG',
+        'MARK_SETTLED',
+        'PRC_ARCHIVE',
+        'RUN_BATCH',
+        'SETTLE_ONE',
+        'TRG_REPAY_PLAN_AUDIT',
+        'WARN',
+        'WRITE_JOURNAL',
+      ]);
+    });
+
+    it('exports package members exactly when the spec declares them', () => {
+      const exported: Record<string, boolean | undefined> = {};
+      result.graph.forEachNode((n) => {
+        if (n.label === 'Function' && n.properties.language === 'plsql')
+          exported[n.properties.name] = n.properties.isExported;
+      });
+      expect(exported).toMatchObject({
+        SETTLE_ONE: true,
+        RUN_BATCH: true,
+        CALC_PENALTY: false,
+        WRITE_JOURNAL: false,
+        MARK_SETTLED: false,
+        PRC_ARCHIVE: true,
+      });
+    });
+
+    it('creates one Record per referenced table, never for CTEs or DUAL', () => {
+      expect(plsqlNodes(result, 'Record')).toEqual([
+        'T_ACCT_JOURNAL',
+        'T_APP_LOG',
+        'T_AUDIT_LOG',
+        'T_LOAN_BALANCE',
+        'T_LOAN_CONTRACT',
+        'T_LOAN_PRODUCT',
+        'T_REPAY_PLAN',
+        'T_REPAY_PLAN_HIST',
+      ]);
+    });
+
+    it('does not claim the PL/pgSQL .sql file', () => {
+      let claimed = false;
+      result.graph.forEachNode((n) => {
+        if (n.properties.language === 'plsql' && n.properties.filePath === 'db/postgres/fn_pg.sql')
+          claimed = true;
+      });
+      expect(claimed).toBe(false);
+    });
+  });
+
+  describe('edges', () => {
+    it('CONTAINS: files → packages, packages → members, procedures → nested subprograms', () => {
+      expect(plsqlEdges(result, 'CONTAINS')).toEqual([
+        'PKG_LOAN_SETTLE → CALC_PENALTY [plsql-subprogram]',
+        'PKG_LOAN_SETTLE → RUN_BATCH [plsql-subprogram]',
+        'PKG_LOAN_SETTLE → SETTLE_ONE [plsql-subprogram]',
+        'PKG_LOAN_SETTLE → WRITE_JOURNAL [plsql-subprogram]',
+        'PKG_LOG → LOG_MSG [plsql-subprogram]',
+        'PKG_LOG → LOG_MSG [plsql-subprogram]',
+        'PKG_LOG → WARN [plsql-subprogram]',
+        'SETTLE_ONE → MARK_SETTLED [plsql-subprogram]',
+        'pkg_loan_settle.pkb → PKG_LOAN_SETTLE [plsql-package]',
+        'pkg_loan_settle.pks → PKG_LOAN_SETTLE [plsql-package]',
+        'pkg_log.pkb → PKG_LOG [plsql-package]',
+        'pkg_log.pks → PKG_LOG [plsql-package]',
+        'prc_archive.prc → PRC_ARCHIVE [plsql-subprogram]',
+        'trg_repay_plan_audit.sql → TRG_REPAY_PLAN_AUDIT [plsql-trigger]',
+      ]);
+    });
+
+    it('CALLS: local, nested, package-qualified and schema-qualified calls; no built-ins or db links', () => {
+      expect(plsqlEdges(result, 'CALLS')).toEqual([
+        'LOG_MSG → LOG_MSG [plsql-call]',
+        'PRC_ARCHIVE → LOG_MSG [plsql-call]',
+        'PRC_ARCHIVE → RUN_BATCH [plsql-call]',
+        'RUN_BATCH → LOG_MSG [plsql-call]',
+        'RUN_BATCH → SETTLE_ONE [plsql-call]',
+        'SETTLE_ONE → CALC_PENALTY [plsql-call]',
+        'SETTLE_ONE → MARK_SETTLED [plsql-call]',
+        'SETTLE_ONE → WARN [plsql-call]',
+        'SETTLE_ONE → WRITE_JOURNAL [plsql-call]',
+        'TRG_REPAY_PLAN_AUDIT → WARN [plsql-call]',
+        'WARN → LOG_MSG [plsql-call]',
+      ]);
+    });
+
+    it('CALLS: overloads are selected by arity and named arguments', () => {
+      const overloadLine = new Map<string, number>();
+      result.graph.forEachNode((n) => {
+        if (n.label === 'Function' && n.properties.name === 'LOG_MSG') {
+          overloadLine.set(n.id, n.properties.startLine! + 1);
+        }
+      });
+      const calls = getRelationships(result, 'CALLS')
+        .filter((e) => e.target === 'LOG_MSG')
+        .map((e) => `${e.source}@${e.sourceLabel} → LOG_MSG@L${overloadLine.get(e.rel.targetId)}`)
+        .sort();
+      // L3: log_msg(p_msg)   L8: log_msg(p_msg, p_level)
+      expect(calls).toEqual([
+        'LOG_MSG@Function → LOG_MSG@L8', // log_msg(p_msg, 1)
+        'PRC_ARCHIVE@Function → LOG_MSG@L8', // log_msg('archived', 1)
+        'RUN_BATCH@Function → LOG_MSG@L3', // pkg_log.log_msg('…')
+        'WARN@Function → LOG_MSG@L8', // log_msg(p_msg => …, p_level => 2)
+      ]);
+    });
+
+    it('ACCESSES: read/write per statement, MERGE target vs source, trigger target', () => {
+      expect(plsqlEdges(result, 'ACCESSES')).toEqual([
+        'CALC_PENALTY → T_LOAN_CONTRACT [plsql-select]',
+        'CALC_PENALTY → T_LOAN_PRODUCT [plsql-select]',
+        'LOG_MSG → T_APP_LOG [plsql-insert]',
+        'MARK_SETTLED → T_REPAY_PLAN [plsql-update]',
+        'PRC_ARCHIVE → T_REPAY_PLAN [plsql-delete]',
+        'PRC_ARCHIVE → T_REPAY_PLAN [plsql-select]',
+        'PRC_ARCHIVE → T_REPAY_PLAN_HIST [plsql-insert]',
+        'RUN_BATCH → T_REPAY_PLAN [plsql-select]',
+        'SETTLE_ONE → T_ACCT_JOURNAL [plsql-select]',
+        'SETTLE_ONE → T_LOAN_BALANCE [plsql-merge]',
+        'SETTLE_ONE → T_REPAY_PLAN [plsql-select]',
+        'TRG_REPAY_PLAN_AUDIT → T_AUDIT_LOG [plsql-insert]',
+        'TRG_REPAY_PLAN_AUDIT → T_REPAY_PLAN [plsql-trigger]',
+        'WRITE_JOURNAL → T_ACCT_JOURNAL [plsql-insert]',
+      ]);
+    });
+
+    it('IMPORTS: SQL*Plus @@ includes that exist in the repository', () => {
+      expect(plsqlEdges(result, 'IMPORTS')).toEqual([
+        'install.sql → pkg_loan_settle.pkb [plsql-script-include]',
+        'install.sql → pkg_loan_settle.pks [plsql-script-include]',
+        'install.sql → pkg_log.pkb [plsql-script-include]',
+        'install.sql → pkg_log.pks [plsql-script-include]',
+        'install.sql → prc_archive.prc [plsql-script-include]',
+        'install.sql → trg_repay_plan_audit.sql [plsql-script-include]',
+      ]);
+    });
+  });
+});
diff --git a/gitnexus/test/unit/ingestion/pipeline-phase-registry.test.ts b/gitnexus/test/unit/ingestion/pipeline-phase-registry.test.ts
index 8ee3dcefd..be16c6835 100644
--- a/gitnexus/test/unit/ingestion/pipeline-phase-registry.test.ts
+++ b/gitnexus/test/unit/ingestion/pipeline-phase-registry.test.ts
@@ -69,6 +69,7 @@ const FULL_ORDER = [
   'springConfig',
   'markdown',
   'cobol',
+  'plsql',
   'parse',
   'routes',
   'tools',
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
new file mode 100644
index 000000000..d3ba549a6
--- /dev/null
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -0,0 +1,172 @@
+import { describe, it, expect } from 'vitest';
+import { extractPlSqlFacts } from '../../src/core/ingestion/plsql/extract.js';
+import { isPlSqlSource, looksLikeOraclePlSql } from '../../src/core/ingestion/plsql/file-types.js';
+import { resolvePlSqlScriptInclude } from '../../src/core/ingestion/plsql/script-include.js';
+
+const BODY = `CREATE OR REPLACE PACKAGE BODY app.pkg_a AS
+  FUNCTION f(p IN NUMBER, q IN NUMBER DEFAULT 0) RETURN NUMBER IS
+  BEGIN
+    RETURN p + q;
+  END f;
+
+  PROCEDURE run IS
+    l NUMBER;
+    PROCEDURE inner_step IS BEGIN NULL; END inner_step;
+  BEGIN
+    l := f(1);
+    inner_step;
+    pkg_b.go(x => 1);
+    other_schema.pkg_c.stop@remote_db;
+    WITH w AS (SELECT id FROM t_src) SELECT COUNT(*) INTO l FROM w, dual;
+    INSERT INTO t_dst SELECT * FROM t_src;
+    UPDATE "MixedCase" SET a = 1;
+    DELETE FROM app.t_old;
+    EXECUTE IMMEDIATE 'DROP TABLE t_tmp';
+  END run;
+END pkg_a;
+/
+`;
+
+describe('extractPlSqlFacts', () => {
+  const facts = extractPlSqlFacts(BODY);
+
+  it('parses the package without errors in one segment', () => {
+    expect(facts.segments).toBe(1);
+    expect(facts.segmentsWithErrors).toBe(0);
+  });
+
+  it('extracts definitions with owner paths, parameters, positions and END labels', () => {
+    expect(facts.definitions.map((d) => `${d.kind} ${[...d.ownerPath, d.name].join('.')}`)).toEqual(
+      [
+        'package PKG_A',
+        'function PKG_A.F',
+        'procedure PKG_A.RUN',
+        'procedure PKG_A.RUN.INNER_STEP',
+      ],
+    );
+    const pkg = facts.definitions[0]!;
+    expect(pkg.schema).toBe('APP');
+    expect(pkg.endLabels.map((l) => `${l.name}@${l.line}:${l.column}`)).toEqual(['PKG_A@21:4']);
+    const f = facts.definitions[1]!;
+    expect(f.parameters).toEqual([
+      { name: 'P', hasDefault: false, type: 'NUMBER' },
+      { name: 'Q', hasDefault: true, type: 'NUMBER' },
+    ]);
+    expect({ line: f.nameLine, column: f.nameColumn, length: f.nameLength }).toEqual({
+      line: 2,
+      column: 11,
+      length: 1,
+    });
+    expect(f.endLabels.map((l) => l.line)).toEqual([5]);
+  });
+
+  it('extracts call sites with name tokens, arity, named arguments and db links', () => {
+    const describe = (c: (typeof facts.calls)[number]) =>
+      [
+        `${c.nameParts.join('.')}/${c.arity}`,
+        c.namedArguments.length > 0 ? `named=${c.namedArguments.join(',')}` : '',
+        c.dbLink ? `@${c.dbLink}` : '',
+        c.form,
+      ]
+        .filter(Boolean)
+        .join(' ');
+    // COUNT(*) is an aggregate rule, not a call; built-ins are filtered later by resolution.
+    expect(facts.calls.map(describe)).toEqual([
+      'F/1 expression',
+      'INNER_STEP/0 statement',
+      'PKG_B.GO/1 named=X statement',
+      'OTHER_SCHEMA.PKG_C.STOP/0 @REMOTE_DB statement',
+    ]);
+    const go = facts.calls.find((c) => c.nameParts.join('.') === 'PKG_B.GO')!;
+    expect(go.nameTokens.map((t) => `${t.name}@${t.line}:${t.column}`)).toEqual([
+      'PKG_B@13:4',
+      'GO@13:10',
+    ]);
+  });
+
+  it('classifies table accesses and filters CTE names and DUAL', () => {
+    expect(
+      facts.accesses.map((a) => `${a.kind} ${a.schema ? `${a.schema}.` : ''}${a.table}`),
+    ).toEqual([
+      'select T_SRC',
+      'insert T_DST',
+      'select T_SRC',
+      'update MixedCase',
+      'delete APP.T_OLD',
+    ]);
+  });
+
+  it('records dynamic SQL with its literal text', () => {
+    expect(facts.dynamicSql.map((d) => d.literal)).toEqual(['DROP TABLE t_tmp']);
+  });
+
+  it('recovers definitions the error-recovered tree lost, marked as fallback', () => {
+    const broken = `CREATE OR REPLACE PACKAGE BODY pkg_x AS
+  PROCEDURE a IS BEGIN this is not plsql at all; END a;
+  PROCEDURE b IS BEGIN NULL; END b;
+END pkg_x;
+/
+`;
+    const f = extractPlSqlFacts(broken);
+    expect(f.segmentsWithErrors).toBe(1);
+    const names = f.definitions.map(
+      (d) => `${[...d.ownerPath, d.name].join('.')}${d.fromFallback ? ' (fallback)' : ''}`,
+    );
+    expect(names).toContain('PKG_X.B');
+    expect(names.some((n) => n.startsWith('PKG_X.A'))).toBe(true);
+  });
+
+  it('keeps one segment per `/`-terminated unit so an error stays local', () => {
+    const f = extractPlSqlFacts(
+      'CREATE PROCEDURE ok1 IS BEGIN NULL; END;\n/\nCREATE PROCEDURE bad IS BEGIN ((( END;\n/\nCREATE PROCEDURE ok2 IS BEGIN NULL; END;\n/\n',
+    );
+    expect(f.segments).toBe(3);
+    expect(f.segmentsWithErrors).toBe(1);
+    expect(f.definitions.filter((d) => !d.fromFallback).map((d) => d.name)).toEqual(
+      expect.arrayContaining(['OK1', 'OK2']),
+    );
+  });
+});
+
+describe('file classification', () => {
+  it('always claims dedicated PL/SQL extensions', () => {
+    expect(isPlSqlSource('db/pkg.pkb', '')).toBe(true);
+  });
+
+  it('claims .sql only for Oracle PL/SQL units or SQL*Plus include scripts', () => {
+    expect(looksLikeOraclePlSql('CREATE OR REPLACE PROCEDURE p IS\nBEGIN NULL; END;\n/\n')).toBe(
+      true,
+    );
+    expect(looksLikeOraclePlSql('@@packages/pkg.pks\n@@packages/pkg.pkb\n')).toBe(true);
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE FUNCTION f() RETURNS void AS $$ BEGIN END; $$ LANGUAGE plpgsql;',
+      ),
+    ).toBe(false);
+    expect(looksLikeOraclePlSql('CREATE PROCEDURE p AS\nBEGIN\n  SET NOCOUNT ON;\nEND\nGO\n')).toBe(
+      false,
+    );
+    expect(looksLikeOraclePlSql('SELECT * FROM t;')).toBe(false);
+  });
+});
+
+describe('resolvePlSqlScriptInclude', () => {
+  const files = new Set(['db/install.sql', 'db/pkg/a.pks', 'db/b.sql', 'vendor/ext.pks']);
+  it('resolves relative to the calling script, then the repository root, adding .sql', () => {
+    expect(resolvePlSqlScriptInclude('pkg/a.pks', 'db/install.sql', files)).toBe('db/pkg/a.pks');
+    expect(resolvePlSqlScriptInclude('b', 'db/install.sql', files)).toBe('db/b.sql');
+    expect(resolvePlSqlScriptInclude('vendor/ext.pks', 'db/install.sql', files)).toBe(
+      'vendor/ext.pks',
+    );
+    expect(resolvePlSqlScriptInclude('../vendor/ext.pks', 'db/install.sql', files)).toBe(
+      'vendor/ext.pks',
+    );
+  });
+  it('never suffix-matches a script outside the repository', () => {
+    expect(resolvePlSqlScriptInclude('ext.pks', 'db/install.sql', files)).toBeNull();
+    expect(
+      resolvePlSqlScriptInclude('?/rdbms/admin/utlrp.sql', 'db/install.sql', files),
+    ).toBeNull();
+    expect(resolvePlSqlScriptInclude('/opt/x.sql', 'db/install.sql', files)).toBeNull();
+  });
+});
diff --git a/gitnexus/test/unit/plsql-preprocess.test.ts b/gitnexus/test/unit/plsql-preprocess.test.ts
new file mode 100644
index 000000000..fed15e5eb
--- /dev/null
+++ b/gitnexus/test/unit/plsql-preprocess.test.ts
@@ -0,0 +1,106 @@
+import { describe, it, expect } from 'vitest';
+import {
+  neutraliseSubstitutionVariables,
+  preprocessPlSql,
+  resolveConditionalCompilation,
+  scriptIncludesOf,
+  stripSqlPlusCommands,
+  type SqlPlusCommand,
+} from '../../src/core/ingestion/plsql/preprocess.js';
+
+const lines = (s: string) => s.split('\n');
+
+describe('stripSqlPlusCommands', () => {
+  it('blanks client commands between statements and keeps the line count', () => {
+    const src = [
+      'SET DEFINE OFF',
+      'PROMPT installing',
+      '@@pkg.pks',
+      'CREATE TABLE t (id NUMBER);',
+      'EXIT',
+    ].join('\n');
+    const out = stripSqlPlusCommands(src);
+    expect(lines(out)).toEqual(['', '', '', 'CREATE TABLE t (id NUMBER);', '']);
+  });
+
+  it('never touches code inside a PL/SQL unit (EXECUTE IMMEDIATE, a column named desc)', () => {
+    const src = [
+      'CREATE OR REPLACE PROCEDURE p IS',
+      'BEGIN',
+      "  execute immediate 'truncate table t';",
+      '  set_status(1);',
+      '  select desc into l_d from t;',
+      'END;',
+      '/',
+      'SET ECHO ON',
+    ].join('\n');
+    expect(lines(stripSqlPlusCommands(src))).toEqual([...lines(src).slice(0, 7), '']);
+  });
+
+  it('blanks `-` continuation lines of a command', () => {
+    const src = [
+      'EXECUTE dbms_stats.gather_schema_stats( -',
+      "  'HR', -",
+      '  cascade => TRUE)',
+      'SELECT 1 FROM dual;',
+    ].join('\n');
+    expect(lines(stripSqlPlusCommands(src))).toEqual(['', '', '', 'SELECT 1 FROM dual;']);
+  });
+
+  it('reports blanked commands to the sink', () => {
+    const commands: SqlPlusCommand[] = [];
+    stripSqlPlusCommands('REM header\n@@a.sql\n', commands);
+    expect(commands).toEqual([
+      { line: 1, text: 'REM header' },
+      { line: 2, text: '@@a.sql' },
+    ]);
+  });
+});
+
+describe('neutraliseSubstitutionVariables', () => {
+  it('replaces &var / &&var. with an identifier of the same length', () => {
+    const src = 'CREATE USER &&owner. IDENTIFIED BY &pwd;';
+    const out = neutraliseSubstitutionVariables(src);
+    expect(out).toBe('CREATE USER ZZowner  IDENTIFIED BY Zpwd;');
+    expect(out.length).toBe(src.length);
+  });
+});
+
+describe('resolveConditionalCompilation', () => {
+  it('keeps the first branch, blanks directives and other branches, preserves layout', () => {
+    const src = [
+      'x := 1;',
+      '$IF dbms_db_version.ver_le_11 $THEN',
+      '  a;',
+      '$ELSE',
+      '  b;',
+      '$END',
+      'y := 2;',
+    ].join('\n');
+    const out = resolveConditionalCompilation(src);
+    expect(out.length).toBe(src.length);
+    expect(lines(out).map((l) => l.trim())).toEqual(['x := 1;', '', 'a;', '', '', '', 'y := 2;']);
+  });
+
+  it('handles nesting and ignores directives inside strings and comments', () => {
+    const src = "$if a $then $if b $then k1; $else s1; $end $else s2; $end -- $end\nv := '$end';";
+    const out = resolveConditionalCompilation(src);
+    expect(out.replace(/\s+/g, ' ').trim()).toBe("k1; -- $end v := '$end';");
+  });
+
+  it('blanks $ERROR … $END', () => {
+    expect(resolveConditionalCompilation("$ERROR 'unsupported' $END ok;").trim()).toBe('ok;');
+  });
+});
+
+describe('scriptIncludesOf', () => {
+  it('extracts @@, @ and START targets with their column; skips substitution paths', () => {
+    const commands: SqlPlusCommand[] = [];
+    preprocessPlSql('@@pkg/a.pks\n  @b.sql\nSTART "c d.sql"\n@&dir/x.sql\n', commands);
+    expect(scriptIncludesOf(commands)).toEqual([
+      { line: 1, column: 2, target: 'pkg/a.pks', relativeToScript: true },
+      { line: 2, column: 3, target: 'b.sql', relativeToScript: false },
+      { line: 3, column: 7, target: 'c d.sql', relativeToScript: false },
+    ]);
+  });
+});
diff --git a/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts b/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts
index 0d38a1f17..4986908aa 100644
--- a/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts
+++ b/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts
@@ -417,6 +417,21 @@ const CASES: ReadonlyMap<SupportedLanguages, ConformanceCase> = new Map([
       reachesDecoy: 'std.zig',
     },
   ],
+  [
+    SupportedLanguages.PlSql,
+    {
+      // SQL*Plus `@@script` resolves against the calling script's directory or
+      // the repository root, by exact path only. A vendor script of the same
+      // name elsewhere in the tree is never suffix-matched; it IS reachable by
+      // its relative spelling, which is what the decoy arm proves.
+      files: ['db/install.sql', 'db/packages/pkg_loan.pks', 'vendor/ext_pkg.pks'],
+      fromFile: 'db/install.sql',
+      resolutionConfig: undefined,
+      external: 'ext_pkg.pks',
+      decoy: 'vendor/ext_pkg.pks',
+      reachesDecoy: '../vendor/ext_pkg.pks',
+    },
+  ],
   [
     SupportedLanguages.ObjectiveC,
     {
diff --git a/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts b/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts
index 658820f14..2699e52b5 100644
--- a/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts
+++ b/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts
@@ -504,6 +504,22 @@ const FIXTURES: ReadonlyMap<SupportedLanguages, ImportTargetFixture> = new Map<
       minimumParsedFileReads: 0,
     },
   ],
+  [
+    SupportedLanguages.PlSql,
+    {
+      files: ['db/install.sql', 'db/packages/pkg_loan.pks'],
+      fromFile: 'db/install.sql',
+      resolutionConfig: undefined,
+      // Vendor scripts live outside the repository. Resolution only probes
+      // `allFilePaths.has` for exact candidates, so there is no traversal to
+      // hoist: zero scans, like Rust.
+      missTarget: (i) => `vendor_patch_${i}.sql`,
+      hitTarget: 'packages/pkg_loan.pks',
+      parsedImport: IGNORES_CONTEXT,
+      minimumScans: 0,
+      minimumParsedFileReads: 0,
+    },
+  ],
   [
     SupportedLanguages.Swift,
     {

From 0474bf99554b971c91ea3fd043d1c591910ae89b Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Fri, 30 Oct 2026 14:06:28 +0800
Subject: [PATCH 02/17] fix(plsql): address review findings

- own calls/accesses by position (innermost enclosing definition), so
  overloads keep their own CALLS/ACCESSES edges
- recognise CREATE headers split across lines / after a block comment in
  the SQL*Plus pre-pass; PL/SQL statements such as `EXIT WHEN` and calls to
  procedures named like client commands are no longer blanked
- scale the per-segment parse deadline with segment size (10 s floor,
  15 ms/line, GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS); report timeouts
- separate public spec declarations from body forward declarations
  (`declarationOnly`), so forward-declared private subprograms stay private
- pair package specs with the nearest body and break call ties by path
  proximity; rename families stay within one package instance
- share extracted facts between the phase, scope captures and rename
  through a per-run store (each file is ANTLR-parsed once per analyze)
- classifier requires IS/AS after an Oracle unit header (MySQL negative)
- drop dead helpers; linear-time fallback line lookup

Corpus (618 files / 121k lines): 116 s -> 60 s, fallback definitions
139 -> 10, deadline timeouts 0, ambiguous call sites 3,689 -> 3,170.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/languages/plsql-ingestion-gaps.md        |  78 +++++++
 .../ingestion/languages/plsql/captures.ts     |  24 +-
 .../core/ingestion/languages/plsql/rename.ts  |  31 ++-
 .../languages/plsql/scope-resolver.ts         |  24 +-
 .../core/ingestion/pipeline-phases/plsql.ts   |   2 +-
 .../src/core/ingestion/plsql-processor.ts     | 217 +++++++++++-------
 gitnexus/src/core/ingestion/plsql/extract.ts  |  98 ++++++--
 .../src/core/ingestion/plsql/facts-store.ts   |  40 ++++
 .../src/core/ingestion/plsql/file-types.ts    |  13 +-
 gitnexus/src/core/ingestion/plsql/parse.ts    |  26 ++-
 .../src/core/ingestion/plsql/preprocess.ts    |  52 +++--
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 108 +++++++--
 .../test/integration/resolvers/plsql.test.ts  |  11 +
 gitnexus/test/unit/plsql-extract.test.ts      |  10 +
 gitnexus/test/unit/plsql-preprocess.test.ts   |  30 +++
 gitnexus/test/unit/plsql-processor.test.ts    | 144 ++++++++++++
 16 files changed, 738 insertions(+), 170 deletions(-)
 create mode 100644 docs/languages/plsql-ingestion-gaps.md
 create mode 100644 gitnexus/src/core/ingestion/plsql/facts-store.ts
 create mode 100644 gitnexus/test/unit/plsql-processor.test.ts

diff --git a/docs/languages/plsql-ingestion-gaps.md b/docs/languages/plsql-ingestion-gaps.md
new file mode 100644
index 000000000..526bcc16f
--- /dev/null
+++ b/docs/languages/plsql-ingestion-gaps.md
@@ -0,0 +1,78 @@
+# Oracle PL/SQL Ingestion Gaps
+
+Initial inventory for the `experimental` PL/SQL provider. The provider is a
+standalone ANTLR4 path (COBOL precedent): `plsql-processor.ts` owns every
+structural edge, and the registered resolver runs in
+`scopeResolutionEdgeMode: callable-flow-only`, contributing declarations and
+the source bindings rename relies on. Nothing below is a whole-language
+completeness claim.
+
+## What is modelled
+
+| Construct                                                    | Graph                                                                    | Evidence                                                                   |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------ | -------------------------------------------------------------------------- |
+| Package spec + body (`.pks`/`.pkb`/`.pck`, or `.sql`)        | One `Module`, anchored at the spec, `CONTAINS` from every defining file  | `plsql.test.ts`                                                            |
+| Package procedure/function, nested subprogram, standalone, trigger | `Function`; `isExported` = declared in the spec (package members)  | `plsql.test.ts`                                                            |
+| Calls: local, nested, `pkg.proc`, `schema.pkg.proc`          | `CALLS` (`plsql-call`); overloads narrowed by arity and named arguments  | `plsql.test.ts` (overload line check)                                      |
+| `SELECT`/`INSERT`/`UPDATE`/`DELETE`/`MERGE`/`LOCK`, trigger target | `Record` per table, `ACCESSES` with `reason: plsql-<op>`           | `plsql.test.ts`, `plsql-extract.test.ts`                                   |
+| SQL*Plus `@@script`, `@script`, `START script`               | `IMPORTS` File → File (exact paths only)                                 | `plsql.test.ts`, `external-import-conformance.test.ts`                     |
+| Rename of a package or subprogram                            | Spec, body, `END` label and qualified call sites together                | `rename-integration/plsql/`                                                |
+
+Deliberately no edge: built-ins (`TRUNC`, `DBMS_OUTPUT.PUT_LINE`) and any call
+that does not resolve to a definition in the repository; calls over a database
+link; CTE names; `DUAL`; scripts that are not at an exact repository path.
+
+## Parser robustness
+
+Grammar: grammars-v4 `sql/plsql` (Apache-2.0) generated with antlr-ng for
+antlr4ng; see `gitnexus/src/core/ingestion/plsql/generated/README.md`.
+
+- A line-preserving pre-pass blanks SQL*Plus client commands (only between
+  statements), neutralises `&` substitution variables at equal length and
+  resolves conditional compilation by keeping the first branch of every
+  `$IF` (nesting-aware). Token positions remain original source positions.
+- Files are split into `/`-terminated segments; each is parsed SLL-first,
+  falls back to LL with error recovery, and has a wall-clock deadline.
+- A segment with syntax errors keeps whatever the recovered tree yields and
+  gains regex-level definitions for any subprogram the tree lost
+  (`fromFallback`, lower edge confidence, rename refused).
+- The parse deadline scales with segment size (10 s floor, 15 ms/line;
+  `GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS` overrides the floor, 0 disables), so
+  large valid package bodies are not cut off on a cold DFA cache.
+- Sites (calls, accesses) are owned by the innermost enclosing definition by
+  position, so overloads keep their own edges.
+- Same-named packages in different folders stay separate: a body pairs with
+  the nearest spec, and call ties are broken by path proximity. Rename
+  families stay within one package instance.
+
+Spike measurement (801 files / 245k lines from utPLSQL, OraOpenSource Logger,
+Alexandria PL/SQL utils, OOS-Utils and Oracle db-sample-schemas): 97.6% of
+package/procedure/function/trigger files parse without syntax errors; about
+175 ms per 1,000 lines once the ANTLR DFA cache is warm, about 650 ms cold.
+
+## Planning candidates
+
+| ID        | Evidence                | Gap or boundary                                                                                     | Next planning step and acceptance                                                                                       |
+| --------- | ----------------------- | --------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| PLSQL-01  | Corpus measurement      | Call and table-access recall is proven on fixtures, not measured on large real package bodies.      | Hand-label a sample of real packages; report recall/precision per edge kind before promoting from `experimental`.       |
+| PLSQL-02  | Grammar gaps            | `TREAT(x AS t).m()`, newer keywords used as identifiers (`ANNOTATIONS`, `XDB`), some object-type member syntax. | Upstream grammar fixes to grammars-v4; regenerate; re-run the corpus.                                       |
+| PLSQL-03  | Ambiguity               | An argument-less function call in an expression is indistinguishable from a variable or column.     | Resolve against local declarations first; keep rename refusing until then.                                               |
+| PLSQL-04  | Dynamic SQL             | `EXECUTE IMMEDIATE` sites are recorded but produce no edges; only literal text is kept.             | Constant-fold `l_sql := '…'` assignments and parse literal statements as low-confidence edges.                          |
+| PLSQL-05  | Not modelled            | Object types (`CREATE TYPE … AS OBJECT`, `UNDER`, member methods), synonyms, views' column lineage. | Decide labels (`Class`/`Method`, `EXTENDS`) and schema impact with maintainers; separate PR.                           |
+| PLSQL-06  | Identity                | Tables are keyed by unqualified name; same-named tables in two schemas merge.                        | Key by `SCHEMA.TABLE` when written and reconcile unqualified references through synonyms / current schema.             |
+| PLSQL-07  | Performance             | The phase runs on the main thread before parse: the corpus above (618 claimed files, 121k lines) takes ~60 s cold in one process; facts are shared with scope extraction within a run but not persisted across runs. | Move segment parsing to workers (one warm ANTLR DFA each); persist extracted facts in the parse cache keyed by content hash so incremental runs skip unchanged files.                         |
+| PLSQL-09  | Overload fan-out        | Overloads that differ only by parameter type (e.g. utPLSQL `ut.expect`) cannot be narrowed by arity, so each call gets one 0.5-confidence edge per candidate (3,170 ambiguous sites on the corpus after path-proximity narrowing). | Infer argument types from literals and declared variables/parameters; narrow by declared parameter types. |
+| PLSQL-11  | Cross-language rename   | Java/Kotlin/XML code that calls procedures by string (`{call pkg.proc(?)}`, MyBatis `CALLABLE`) is not consulted by rename. | Implement the rename interop hooks, or refuse when a non-PL/SQL source mentions the qualified name.                      |
+| PLSQL-12  | Incremental identity    | Table `Record` and merged package `Module` nodes are anchored to one file although derived from several. | Add an edit-one-file incremental-analyze test; give synthetic objects a stable anchor if writeback drops them.            |
+| PLSQL-10  | Impact on tables        | `impact` adds `ACCESSES` by default only for `Class`/`Interface` targets, so a table needs `relationTypes: ['ACCESSES', …]` to list its readers and writers. | Agree with maintainers whether `Record` targets should get the same default.                                              |
+| PLSQL-08  | CFG/PDG                 | `collectSourceCfgs` returns no CFGs.                                                                | Build statement-level CFGs from the parse tree for `analyze --pdg`.                                                      |
+
+## Code and regression entry points
+
+- [Provider](../../gitnexus/src/core/ingestion/languages/plsql.ts) and [hooks](../../gitnexus/src/core/ingestion/languages/plsql/).
+- [Parser, pre-pass and extraction](../../gitnexus/src/core/ingestion/plsql/).
+- [Processor](../../gitnexus/src/core/ingestion/plsql-processor.ts) and [phase](../../gitnexus/src/core/ingestion/pipeline-phases/plsql.ts).
+- [plsql.test.ts](../../gitnexus/test/integration/resolvers/plsql.test.ts),
+  [plsql-extract.test.ts](../../gitnexus/test/unit/plsql-extract.test.ts),
+  [plsql-preprocess.test.ts](../../gitnexus/test/unit/plsql-preprocess.test.ts),
+  [rename fixtures](../../gitnexus/test/fixtures/rename-integration/plsql/).
diff --git a/gitnexus/src/core/ingestion/languages/plsql/captures.ts b/gitnexus/src/core/ingestion/languages/plsql/captures.ts
index def840910..11bbd73d8 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/captures.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/captures.ts
@@ -19,11 +19,11 @@
 
 import type { Capture, CaptureMatch, Range } from 'gitnexus-shared';
 import {
-  extractPlSqlFacts,
   type PlSqlDefinition,
   type PlSqlFileFacts,
   type PlSqlNameToken,
 } from '../../plsql/extract.js';
+import { plsqlFactsForFile } from '../../plsql/facts-store.js';
 
 function capture(name: string, range: Range, text: string): Capture {
   return { name, range, text };
@@ -59,25 +59,17 @@ export function plsqlDefinitionRange(def: PlSqlDefinition): Range {
 export const plsqlRangeKey = (r: Range): string =>
   `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
 
-/** Facts are recomputed per call site of the hook; memoise on the exact source text. */
-const factsCache = new Map<string, PlSqlFileFacts>();
-const FACTS_CACHE_LIMIT = 64;
-
-export function plsqlFactsFor(sourceText: string): PlSqlFileFacts {
-  const cached = factsCache.get(sourceText);
-  if (cached) return cached;
-  const facts = extractPlSqlFacts(sourceText);
-  if (factsCache.size >= FACTS_CACHE_LIMIT) factsCache.delete(factsCache.keys().next().value!);
-  factsCache.set(sourceText, facts);
-  return facts;
+/** Facts for a source, shared with the `plsql` phase (parsed once per run). */
+export function plsqlFactsFor(sourceText: string, filePath: string): PlSqlFileFacts {
+  return plsqlFactsForFile(filePath, sourceText);
 }
 
 export function emitPlSqlScopeCaptures(
   sourceText: string,
-  _filePath: string,
+  filePath: string,
   _cachedTree?: unknown,
 ): readonly CaptureMatch[] {
-  const facts = plsqlFactsFor(sourceText);
+  const facts = plsqlFactsFor(sourceText, filePath);
   const out: CaptureMatch[] = [];
 
   for (const def of facts.definitions) {
@@ -106,8 +98,8 @@ export function emitPlSqlScopeCaptures(
         String(required),
       );
     }
-    // A spec declaration has no body, so it opens no scope.
-    if (!def.isSpec || def.kind === 'package') {
+    // A spec or forward declaration has no body, so it opens no scope.
+    if (!def.declarationOnly) {
       const scope = def.kind === 'package' ? '@scope.module' : '@scope.function';
       match[scope] = capture(scope, range, def.name);
     }
diff --git a/gitnexus/src/core/ingestion/languages/plsql/rename.ts b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
index 199883a08..8faf033e0 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/rename.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
@@ -31,7 +31,7 @@ import {
   type PlSqlDefinition,
   type PlSqlFileFacts,
 } from '../../plsql/extract.js';
-import { plsqlSignatureKey } from '../../plsql/resolve.js';
+import { PlSqlPackageInstances, plsqlSignatureKey } from '../../plsql/resolve.js';
 import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
 
 const unsupported = (message: string): RenameIssue => ({
@@ -83,7 +83,7 @@ export const plsqlRenameProvider: RenameProvider = {
   },
 
   parseSource({ filePath, content, languageProvider }) {
-    const facts = plsqlFactsFor(content);
+    const facts = plsqlFactsFor(content, filePath);
     const parsed = extractParsedFile(languageProvider, content, filePath);
     if (!parsed)
       throw {
@@ -145,14 +145,33 @@ export const plsqlRenameProvider: RenameProvider = {
     const targetSource = context.files.get(context.target.filePath);
     const target = targetSource && definitionFor(targetSource, context.target);
     if (!target) return unsupported('The PL/SQL declaration has no source identity.');
-    const sameEntity = (d: PlSqlDefinition) =>
-      target.kind === 'package'
+    // One family per package instance: a spec, its paired body and the
+    // declarations inside them. Same-named copies elsewhere are other objects.
+    const packages: Array<{ name: string; filePath: string; isSpec: boolean }> = [];
+    for (const file of context.files.values()) {
+      for (const d of evidence.get(file)?.definitions ?? []) {
+        if (d.kind === 'package')
+          packages.push({ name: d.name, filePath: file.path, isSpec: d.isSpec });
+      }
+    }
+    const instances = new PlSqlPackageInstances(packages);
+    const definesPackage = new Set(packages.map((p) => `${p.name}\0${p.filePath}`));
+    const scopeOf = (d: PlSqlDefinition, filePath: string): string => {
+      const pkg = d.kind === 'package' ? d.name : d.ownerPath[0];
+      return pkg !== undefined && definesPackage.has(`${pkg}\0${filePath}`)
+        ? `${pkg}\0${instances.homeOf(pkg, filePath) ?? filePath}`
+        : `\0${filePath}`;
+    };
+    const targetScope = scopeOf(target, context.target.filePath);
+    const sameEntity = (d: PlSqlDefinition, filePath: string) =>
+      scopeOf(d, filePath) === targetScope &&
+      (target.kind === 'package'
         ? d.kind === 'package' && d.name === target.name
-        : d.kind === target.kind && plsqlSignatureKey(d) === plsqlSignatureKey(target);
+        : d.kind === target.kind && plsqlSignatureKey(d) === plsqlSignatureKey(target));
     return context.definitions.filter((symbol) => {
       const source = context.files.get(symbol.filePath);
       const def = source && definitionFor(source, symbol);
-      return def !== undefined && sameEntity(def);
+      return def !== undefined && sameEntity(def, symbol.filePath);
     });
   },
 
diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
index 7c456ec3e..a633d861a 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -14,7 +14,7 @@ import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
 import { SupportedLanguages } from 'gitnexus-shared';
 import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
 import { plsqlProvider } from '../plsql.js';
-import { PlSqlNameIndex, type PlSqlIndexEntry } from '../../plsql/resolve.js';
+import { PlSqlNameIndex, nearestByPath, type PlSqlIndexEntry } from '../../plsql/resolve.js';
 import { resolvePlSqlScriptInclude } from '../../plsql/script-include.js';
 import type { PlSqlCallSite, PlSqlDefinition } from '../../plsql/extract.js';
 import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
@@ -61,7 +61,7 @@ const plsqlScopeResolver: ScopeResolver = {
     const index = new PlSqlNameIndex<BoundEntry>();
     const symbolOf = new Map<PlSqlDefinition, SymbolDefinition>();
     const files = parsedFiles.map((parsed) => {
-      const facts = plsqlFactsFor(context.fileContents.get(parsed.filePath) ?? '');
+      const facts = plsqlFactsFor(context.fileContents.get(parsed.filePath) ?? '', parsed.filePath);
       const byNameRange = new Map(
         parsed.localDefs.filter((d) => d.nameRange).map((d) => [plsqlRangeKey(d.nameRange!), d]),
       );
@@ -74,12 +74,22 @@ const plsqlScopeResolver: ScopeResolver = {
       return { parsed, facts };
     });
 
-    // A package name denotes the package; its spec when indexed.
-    const packageSymbol = new Map<string, SymbolDefinition>();
+    // A package name denotes the package instance nearest the reference; its
+    // spec when indexed.
+    const packageSymbols = new Map<
+      string,
+      Array<{ filePath: string; symbol: SymbolDefinition; isSpec: boolean }>
+    >();
     for (const [def, symbol] of symbolOf) {
       if (def.kind !== 'package') continue;
-      if (!packageSymbol.has(def.name) || def.isSpec) packageSymbol.set(def.name, symbol);
+      const list = packageSymbols.get(def.name) ?? [];
+      list.push({ filePath: symbol.filePath, symbol, isSpec: def.isSpec });
+      packageSymbols.set(def.name, list);
     }
+    const packageSymbol = (name: string, fromFile: string): SymbolDefinition | undefined => {
+      const nearest = nearestByPath(packageSymbols.get(name) ?? [], fromFile);
+      return (nearest.find((p) => p.isSpec) ?? nearest[0])?.symbol;
+    };
 
     for (const { parsed, facts } of files) {
       const meaning = new Map<string, SiteMeaning>();
@@ -115,7 +125,7 @@ const plsqlScopeResolver: ScopeResolver = {
           // In `S.A.N` only `A` (the part before the callee) can name a package.
           const symbol =
             m.part === m.call.nameParts.length - 2
-              ? packageSymbol.get(m.call.nameParts[m.part]!)
+              ? packageSymbol(m.call.nameParts[m.part]!, parsed.filePath)
               : undefined;
           record(
             site,
@@ -129,7 +139,7 @@ const plsqlScopeResolver: ScopeResolver = {
           );
           continue;
         }
-        const targets = m.call.dbLink ? [] : index.resolve(m.call);
+        const targets = m.call.dbLink ? [] : index.resolve(m.call, parsed.filePath);
         const ids = targets.map((t) => t.symbol.nodeId);
         record(
           site,
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
index 44bc34e06..1bde1b91a 100644
--- a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
+++ b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
@@ -60,7 +60,7 @@ export const plsqlPhase: PipelinePhase<PlSqlOutput> = {
       );
       if (result.segmentsWithErrors > 0) {
         logger.info(
-          `  PL/SQL degraded: ${result.segmentsWithErrors} segments with syntax errors, ${result.fallbackDefinitions} fallback definitions`,
+          `  PL/SQL degraded: ${result.segmentsWithErrors} segments with syntax errors (${result.segmentsTimedOut} at the parse deadline), ${result.fallbackDefinitions} fallback definitions`,
         );
       }
     }
diff --git a/gitnexus/src/core/ingestion/plsql-processor.ts b/gitnexus/src/core/ingestion/plsql-processor.ts
index 7c2d7aec3..70d7d9c80 100644
--- a/gitnexus/src/core/ingestion/plsql-processor.ts
+++ b/gitnexus/src/core/ingestion/plsql-processor.ts
@@ -26,10 +26,16 @@ import { SupportedLanguages } from 'gitnexus-shared';
 import { generateId } from '../../lib/utils.js';
 import type { KnowledgeGraph } from '../graph/types.js';
 import { toZeroBasedLine } from './utils/line-base.js';
-import { extractPlSqlFacts, type PlSqlDefinition, type PlSqlFileFacts } from './plsql/extract.js';
+import type { PlSqlDefinition, PlSqlFileFacts } from './plsql/extract.js';
+import { plsqlFactsForFile, resetPlSqlFactsStore } from './plsql/facts-store.js';
 import { isPlSqlSource } from './plsql/file-types.js';
 import { resolvePlSqlScriptInclude } from './plsql/script-include.js';
-import { PlSqlNameIndex, plsqlSignatureKey, type PlSqlIndexEntry } from './plsql/resolve.js';
+import {
+  PlSqlNameIndex,
+  PlSqlPackageInstances,
+  plsqlSignatureKey,
+  type PlSqlIndexEntry,
+} from './plsql/resolve.js';
 
 export interface PlSqlFile {
   readonly path: string;
@@ -49,6 +55,8 @@ export interface PlSqlProcessResult {
   readonly scriptIncludes: number;
   readonly dynamicSqlSites: number;
   readonly segmentsWithErrors: number;
+  /** Segments abandoned at the parse deadline (a subset of `segmentsWithErrors`). */
+  readonly segmentsTimedOut: number;
   readonly fallbackDefinitions: number;
 }
 
@@ -77,7 +85,7 @@ export function plsqlTableNodeId(tableName: string): string {
 }
 
 interface Entry extends PlSqlIndexEntry {
-  /** Graph node of this definition (a spec declaration with a body maps to the body). */
+  /** Graph node of this definition (a declaration with a body maps to the body). */
   nodeId?: string;
 }
 
@@ -88,8 +96,9 @@ export function processPlSql(
   files: readonly PlSqlFile[],
   allPaths: ReadonlySet<string> = new Set(files.map((f) => f.path)),
 ): PlSqlProcessResult {
+  resetPlSqlFactsStore(files.length);
   const facts = new Map<string, PlSqlFileFacts>();
-  for (const file of files) facts.set(file.path, extractPlSqlFacts(file.content));
+  for (const file of files) facts.set(file.path, plsqlFactsForFile(file.path, file.content));
 
   const index = new PlSqlNameIndex<Entry>();
   const entryOf = new Map<PlSqlDefinition, Entry>();
@@ -101,56 +110,79 @@ export function processPlSql(
     }
   }
 
-  // ── packages: one Module per name, anchored at the spec when indexed ──
-  const packageHome = new Map<string, { file: string; def: PlSqlDefinition; files: Set<string> }>();
-  for (const [filePath, f] of facts) {
-    for (const def of f.definitions) {
-      if (def.kind !== 'package') continue;
-      const home = packageHome.get(def.name);
-      if (!home) packageHome.set(def.name, { file: filePath, def, files: new Set([filePath]) });
-      else {
-        home.files.add(filePath);
-        if (def.isSpec && !home.def.isSpec) Object.assign(home, { file: filePath, def });
-      }
+  // ── package instances: each spec paired with its nearest body ──
+  const packageDefs = [...entryOf.values()].filter((e) => e.def.kind === 'package');
+  const instances = new PlSqlPackageInstances(
+    packageDefs.map((e) => ({ name: e.def.name, filePath: e.filePath, isSpec: e.def.isSpec })),
+  );
+  const filesDefiningPackage = new Set(packageDefs.map((e) => `${e.def.name}\0${e.filePath}`));
+  const instanceKey = (name: string, filePath: string) =>
+    `${name}\0${instances.homeOf(name, filePath) ?? filePath}`;
+  /** The package instance a definition in `filePath` belongs to, if it is a package member. */
+  const memberInstance = (def: PlSqlDefinition, filePath: string): string | undefined => {
+    const pkg = def.ownerPath[0];
+    return pkg !== undefined && filesDefiningPackage.has(`${pkg}\0${filePath}`)
+      ? instanceKey(pkg, filePath)
+      : undefined;
+  };
+  /** Pairs a spec/forward declaration with its body inside one package instance (or one file). */
+  const pairingKey = (def: PlSqlDefinition, filePath: string) =>
+    `${memberInstance(def, filePath) ?? `\0${filePath}`}|${plsqlSignatureKey(def)}`;
+
+  const packageNodeByInstance = new Map<string, string>();
+  const instanceFiles = new Map<string, { home: string; anchor: Entry; files: Set<string> }>();
+  for (const entry of packageDefs) {
+    const key = instanceKey(entry.def.name, entry.filePath);
+    const instance = instanceFiles.get(key);
+    if (!instance) {
+      instanceFiles.set(key, {
+        home: instances.homeOf(entry.def.name, entry.filePath) ?? entry.filePath,
+        anchor: entry,
+        files: new Set([entry.filePath]),
+      });
+    } else {
+      instance.files.add(entry.filePath);
+      if (entry.def.isSpec && !instance.anchor.def.isSpec) instance.anchor = entry;
     }
   }
-  const packageNode = new Map<string, string>();
-  for (const [name, home] of packageHome) {
-    const nodeId = plsqlPackageNodeId(home.file, name);
-    packageNode.set(name, nodeId);
-    const bodyFiles = [...home.files].filter((f) => f !== home.file);
+  for (const [key, instance] of instanceFiles) {
+    const { name } = instance.anchor.def;
+    const nodeId = plsqlPackageNodeId(instance.home, name);
+    packageNodeByInstance.set(key, nodeId);
+    const others = [...instance.files].filter((f) => f !== instance.home).sort();
     graph.addNode({
       id: nodeId,
       label: 'Module',
       properties: {
         name,
-        filePath: home.file,
-        startLine: toZeroBasedLine(home.def.startLine),
-        endLine: toZeroBasedLine(home.def.endLine),
+        filePath: instance.home,
+        startLine: toZeroBasedLine(instance.anchor.def.startLine),
+        endLine: toZeroBasedLine(instance.anchor.def.endLine),
         language: SupportedLanguages.PlSql,
         isExported: true,
         description:
-          bodyFiles.length > 0
-            ? `PL/SQL package; also defined in ${bodyFiles.join(', ')}`
+          others.length > 0
+            ? `PL/SQL package; also defined in ${others.join(', ')}`
             : 'PL/SQL package',
       },
     });
-    for (const file of home.files) {
+    for (const file of instance.files) {
       addEdge(graph, 'CONTAINS', generateId('File', file), nodeId, 1.0, 'plsql-package');
     }
   }
-  for (const entry of entryOf.values()) {
-    if (entry.def.kind === 'package') entry.nodeId = packageNode.get(entry.def.name);
+  for (const entry of packageDefs) {
+    entry.nodeId = packageNodeByInstance.get(instanceKey(entry.def.name, entry.filePath));
   }
 
   // ── subprograms and triggers ──
-  const bodySignatures = new Set<string>();
-  const specSignatures = new Set<string>();
-  for (const entry of entryOf.values()) {
-    if (entry.def.kind === 'package') continue;
-    (entry.def.isSpec ? specSignatures : bodySignatures).add(plsqlSignatureKey(entry.def));
+  const bodyKeys = new Set<string>();
+  const publicKeys = new Set<string>();
+  for (const { def, filePath } of entryOf.values()) {
+    if (def.kind === 'package') continue;
+    if (!def.declarationOnly) bodyKeys.add(pairingKey(def, filePath));
+    if (def.isSpec) publicKeys.add(pairingKey(def, filePath));
   }
-  const bodyNodeBySignature = new Map<string, string>();
+  const bodyNodeByKey = new Map<string, string>();
   let subprograms = 0;
   let triggers = 0;
   let fallbackDefinitions = 0;
@@ -158,13 +190,14 @@ export function processPlSql(
     const { def, filePath } = entry;
     if (def.kind === 'package') continue;
     if (def.fromFallback) fallbackDefinitions++;
-    // A spec declaration with an indexed body is the same subprogram.
-    if (def.isSpec && bodySignatures.has(plsqlSignatureKey(def))) continue;
+    const key = pairingKey(def, filePath);
+    // A spec/forward declaration with an indexed body is the same subprogram.
+    if (def.declarationOnly && bodyKeys.has(key)) continue;
     entry.nodeId = plsqlSubprogramNodeId(filePath, def);
-    if (!def.isSpec) bodyNodeBySignature.set(plsqlSignatureKey(def), entry.nodeId);
+    if (!def.declarationOnly) bodyNodeByKey.set(key, entry.nodeId);
     if (def.kind === 'trigger') triggers++;
     else subprograms++;
-    const packageMember = def.ownerPath.length === 1 && packageNode.has(def.ownerPath[0]!);
+    const packageMember = def.ownerPath.length === 1 && memberInstance(def, filePath) !== undefined;
     graph.addNode({
       id: entry.nodeId,
       label: 'Function',
@@ -174,50 +207,62 @@ export function processPlSql(
         startLine: toZeroBasedLine(def.startLine),
         endLine: toZeroBasedLine(def.endLine),
         language: SupportedLanguages.PlSql,
-        // Package members are public exactly when the spec declares them.
-        isExported: packageMember
-          ? specSignatures.has(plsqlSignatureKey(def))
-          : def.ownerPath.length === 0,
+        // Package members are public exactly when the package spec declares them.
+        isExported: packageMember ? publicKeys.has(key) : def.ownerPath.length === 0,
         parameterCount: def.parameters.length,
         description: describeDefinition(def),
       },
     });
   }
   for (const entry of entryOf.values()) {
-    if (entry.def.isSpec && entry.def.kind !== 'package' && !entry.nodeId) {
-      entry.nodeId = bodyNodeBySignature.get(plsqlSignatureKey(entry.def));
+    if (entry.def.declarationOnly && !entry.nodeId) {
+      entry.nodeId = bodyNodeByKey.get(pairingKey(entry.def, entry.filePath));
     }
   }
 
-  /** Graph node of the innermost definition enclosing `ownerPath` in `filePath`. */
-  const ownerNode = (filePath: string, ownerPath: readonly string[]): string | undefined => {
-    if (ownerPath.length === 0) return undefined;
-    const name = ownerPath[ownerPath.length - 1]!;
-    const parent = ownerPath.slice(0, -1);
-    const local = index
-      .lookup(parent, name)
-      .find((e) => e.filePath === filePath && !e.def.isSpec && e.nodeId !== undefined);
-    if (local) return local.nodeId;
-    return ownerPath.length === 1 ? packageNode.get(name) : undefined;
+  /**
+   * Graph node that owns a site or definition: the definition at `ownerIndex`
+   * (by position, so overloads keep their own sites), or — for fallback
+   * definitions, which carry no index — the file's package instance.
+   */
+  const ownerNode = (
+    filePath: string,
+    fileFacts: PlSqlFileFacts,
+    site: { readonly ownerIndex?: number; readonly ownerPath: readonly string[] },
+  ): string | undefined => {
+    if (site.ownerIndex !== undefined) {
+      const owner = fileFacts.definitions[site.ownerIndex]!;
+      return entryOf.get(owner)?.nodeId;
+    }
+    const pkg = site.ownerPath[0];
+    if (site.ownerPath.length === 1 && filesDefiningPackage.has(`${pkg}\0${filePath}`)) {
+      return packageNodeByInstance.get(instanceKey(pkg!, filePath));
+    }
+    return undefined;
   };
 
+  for (const [filePath, f] of facts) {
+    for (const def of f.definitions) {
+      const nodeId = entryOf.get(def)?.nodeId;
+      if (def.kind === 'package' || !nodeId || def.declarationOnly) continue;
+      const owner = ownerNode(filePath, f, def) ?? generateId('File', filePath);
+      addEdge(
+        graph,
+        'CONTAINS',
+        owner,
+        nodeId,
+        1.0,
+        def.kind === 'trigger' ? 'plsql-trigger' : 'plsql-subprogram',
+      );
+    }
+  }
+  // Spec-only subprograms (no body indexed) hang off their package.
   for (const entry of entryOf.values()) {
     const { def, filePath, nodeId } = entry;
-    if (
-      def.kind === 'package' ||
-      !nodeId ||
-      (def.isSpec && bodySignatures.has(plsqlSignatureKey(def)))
-    )
-      continue;
-    const owner = ownerNode(filePath, def.ownerPath) ?? generateId('File', filePath);
-    addEdge(
-      graph,
-      'CONTAINS',
-      owner,
-      nodeId,
-      1.0,
-      def.kind === 'trigger' ? 'plsql-trigger' : 'plsql-subprogram',
-    );
+    if (!def.declarationOnly || !nodeId || bodyKeys.has(pairingKey(def, filePath))) continue;
+    const facts0 = facts.get(filePath)!;
+    const owner = ownerNode(filePath, facts0, def) ?? generateId('File', filePath);
+    addEdge(graph, 'CONTAINS', owner, nodeId, 1.0, 'plsql-subprogram');
   }
 
   // ── calls ──
@@ -227,22 +272,26 @@ export function processPlSql(
   for (const [filePath, f] of facts) {
     const degraded = f.segmentsWithErrors > 0;
     for (const call of f.calls) {
-      const sourceId = ownerNode(filePath, call.ownerPath);
+      const sourceId = ownerNode(filePath, f, call);
       if (!sourceId) continue; // top-level script statements have no callable owner
-      const targets = call.dbLink ? [] : index.resolve(call).filter((t) => t.nodeId !== undefined);
-      if (targets.length === 0) {
+      const targets = call.dbLink
+        ? []
+        : index.resolve(call, filePath).filter((t) => t.nodeId !== undefined);
+      const targetIds = [...new Set(targets.map((t) => t.nodeId!))];
+      if (targetIds.length === 0) {
         if (call.form === 'statement') unresolvedCalls++;
         continue;
       }
-      const ambiguous = targets.length > 1;
+      const ambiguous = targetIds.length > 1;
       if (ambiguous) ambiguousCalls++;
-      for (const target of targets) {
+      const fallbackTarget = targets.some((t) => t.def.fromFallback);
+      for (const targetId of targetIds) {
         graph.addRelationship({
-          id: generateId('CALLS', `${sourceId}->${target.nodeId}:L${call.line}:${call.column}`),
+          id: generateId('CALLS', `${sourceId}->${targetId}:L${call.line}:${call.column}`),
           type: 'CALLS',
           sourceId,
-          targetId: target.nodeId!,
-          confidence: ambiguous ? 0.5 : degraded || target.def.fromFallback ? 0.7 : 1.0,
+          targetId,
+          confidence: ambiguous ? 0.5 : degraded || fallbackTarget ? 0.7 : 1.0,
           reason: ambiguous ? 'plsql-call-ambiguous' : 'plsql-call',
         });
         calls++;
@@ -255,7 +304,7 @@ export function processPlSql(
   let accesses = 0;
   for (const [filePath, f] of facts) {
     for (const access of f.accesses) {
-      const sourceId = ownerNode(filePath, access.ownerPath);
+      const sourceId = ownerNode(filePath, f, access);
       if (!sourceId) continue;
       const tableId = plsqlTableNodeId(access.table);
       if (!tables.has(access.table)) {
@@ -310,15 +359,17 @@ export function processPlSql(
   }
 
   let segmentsWithErrors = 0;
+  let segmentsTimedOut = 0;
   let dynamicSqlSites = 0;
   for (const f of facts.values()) {
     segmentsWithErrors += f.segmentsWithErrors;
+    segmentsTimedOut += f.segmentsTimedOut;
     dynamicSqlSites += f.dynamicSql.length;
   }
 
   return {
     files: files.length,
-    packages: packageNode.size,
+    packages: packageNodeByInstance.size,
     subprograms,
     triggers,
     tables: tables.size,
@@ -329,6 +380,7 @@ export function processPlSql(
     scriptIncludes,
     dynamicSqlSites,
     segmentsWithErrors,
+    segmentsTimedOut,
     fallbackDefinitions,
   };
 }
@@ -355,7 +407,12 @@ function addEdge(
 function describeDefinition(def: PlSqlDefinition): string | undefined {
   const parts: string[] = [];
   if (def.kind === 'trigger' && def.triggerTable) parts.push(`trigger on ${def.triggerTable}`);
-  if (def.isSpec) parts.push('declared in package spec (no body indexed)');
+  if (def.declarationOnly)
+    parts.push(
+      def.isSpec
+        ? 'declared in package spec (no body indexed)'
+        : 'forward declaration (no body indexed)',
+    );
   if (def.fromFallback) parts.push('recovered by fallback; parameters unknown');
   return parts.length > 0 ? parts.join('; ') : undefined;
 }
diff --git a/gitnexus/src/core/ingestion/plsql/extract.ts b/gitnexus/src/core/ingestion/plsql/extract.ts
index c0faff0ce..beb488a5f 100644
--- a/gitnexus/src/core/ingestion/plsql/extract.ts
+++ b/gitnexus/src/core/ingestion/plsql/extract.ts
@@ -52,6 +52,8 @@ export interface PlSqlDefinition {
   readonly schema?: string;
   /** Enclosing definition names, outermost first (package, then subprograms). */
   readonly ownerPath: readonly string[];
+  /** Index into `definitions` of the enclosing definition (by position); absent at top level and for fallback definitions. */
+  readonly ownerIndex?: number;
   readonly startLine: number;
   /** 0-based column of the first token of the definition. */
   readonly startColumn: number;
@@ -64,8 +66,16 @@ export interface PlSqlDefinition {
   /** `END <name>` closing labels, which must be renamed with the definition. */
   readonly endLabels: readonly PlSqlNameToken[];
   readonly parameters: readonly PlSqlParameter[];
-  /** Package spec, or a subprogram declared (not implemented) in a package spec. */
+  /**
+   * Package spec, or a subprogram declared in a package spec — i.e. public.
+   * Forward declarations inside a package body are NOT spec declarations.
+   */
   readonly isSpec: boolean;
+  /**
+   * Declaration without a body at this position: a package-spec declaration
+   * or a forward declaration in a package body. Never owns call sites.
+   */
+  readonly declarationOnly: boolean;
   /** Trigger only: the table the trigger fires on. */
   readonly triggerTable?: string;
   /** True when the definition was recovered by the regex fallback. */
@@ -74,6 +84,8 @@ export interface PlSqlDefinition {
 
 export interface PlSqlCallSite {
   readonly ownerPath: readonly string[];
+  /** Index into `definitions` of the innermost enclosing definition (by position). */
+  readonly ownerIndex?: number;
   readonly line: number;
   readonly column: number;
   /** Dotted name parts (`PKG_LOG`, `WARN`); optional schema first. */
@@ -89,6 +101,8 @@ export interface PlSqlCallSite {
 
 export interface PlSqlTableAccess {
   readonly ownerPath: readonly string[];
+  /** Index into `definitions` of the innermost enclosing definition (by position). */
+  readonly ownerIndex?: number;
   readonly line: number;
   readonly column: number;
   readonly table: string;
@@ -99,6 +113,8 @@ export interface PlSqlTableAccess {
 
 export interface PlSqlDynamicSqlSite {
   readonly ownerPath: readonly string[];
+  /** Index into `definitions` of the innermost enclosing definition (by position). */
+  readonly ownerIndex?: number;
   readonly line: number;
   /** Literal statement text when the argument is a string literal. */
   readonly literal?: string;
@@ -159,14 +175,6 @@ function childRules(ctx: ParserRuleContext, rule: number): ParserRuleContext[] {
   );
 }
 
-function hasTerminal(ctx: ParserRuleContext, tokenType: number): boolean {
-  return ctx.children.some(
-    (c) =>
-      !(c instanceof ParserRuleContext) &&
-      (c as { symbol?: { type: number } }).symbol?.type === tokenType,
-  );
-}
-
 function textOf(tree: ParseTree | undefined): string {
   return tree ? tree.getText() : '';
 }
@@ -302,6 +310,15 @@ function cteNamesAbove(ctx: ParserRuleContext): Set<string> {
 
 const PSEUDO_TABLES = new Set(['DUAL']);
 
+/** True for a subprogram spec inside `CREATE PACKAGE` (public), false for a body forward declaration. */
+function insidePackageSpec(ctx: ParserRuleContext): boolean {
+  for (let a = ctx.parent; a; a = a.parent) {
+    if (a.ruleIndex === P.RULE_create_package) return true;
+    if (a.ruleIndex === P.RULE_create_package_body) return false;
+  }
+  return false;
+}
+
 // ─── tree walk ────────────────────────────────────────────────────────────
 
 const SCOPE_RULES = new Set([
@@ -326,12 +343,21 @@ function extractSegment(
 ): void {
   if (!segment.tree) return;
   const scope: string[] = [];
+  /** Definition indices parallel to `scope`: sites record the innermost owner by position. */
+  const owners: number[] = [];
+  const ownerIndex = () => owners[owners.length - 1];
 
   const define = (
     ctx: ParserRuleContext,
     kind: PlSqlDefKind,
     nameCtx: ParserRuleContext | undefined,
-    extra: { schema?: string; isSpec?: boolean; triggerTable?: string; push?: boolean } = {},
+    extra: {
+      schema?: string;
+      isSpec?: boolean;
+      declarationOnly?: boolean;
+      triggerTable?: string;
+      push?: boolean;
+    } = {},
   ) => {
     const parts = splitDotted(textOf(nameCtx));
     const name = parts[parts.length - 1] ?? '?';
@@ -343,6 +369,7 @@ function extractSegment(
       name,
       schema,
       ownerPath: [...scope],
+      ownerIndex: ownerIndex(),
       startLine: ctx.start!.line,
       startColumn: ctx.start!.column,
       endLine: stop.line,
@@ -353,10 +380,14 @@ function extractSegment(
       endLabels: endLabelsOf(ctx),
       parameters: parametersOf(ctx),
       isSpec: extra.isSpec ?? false,
+      declarationOnly: extra.declarationOnly ?? false,
       triggerTable: extra.triggerTable,
       fromFallback: false,
     });
-    if (extra.push !== false) scope.push(name);
+    if (extra.push !== false) {
+      scope.push(name);
+      owners.push(out.definitions.length - 1);
+    }
   };
 
   const listener: ParseTreeListener = {
@@ -374,13 +405,13 @@ function extractSegment(
           break;
         }
         case P.RULE_procedure_spec:
-          define(ctx, 'procedure', childRule(ctx, P.RULE_identifier), {
-            isSpec: true,
-            push: false,
-          });
-          break;
         case P.RULE_function_spec:
-          define(ctx, 'function', childRule(ctx, P.RULE_identifier), { isSpec: true, push: false });
+          define(
+            ctx,
+            ctx.ruleIndex === P.RULE_procedure_spec ? 'procedure' : 'function',
+            childRule(ctx, P.RULE_identifier),
+            { isSpec: insidePackageSpec(ctx), declarationOnly: true, push: false },
+          );
           break;
         case P.RULE_procedure_body:
           define(ctx, 'procedure', childRule(ctx, P.RULE_identifier));
@@ -424,6 +455,7 @@ function extractSegment(
           const { arity, named } = argumentsOf(fnArgs[0]);
           out.calls.push({
             ownerPath: [...scope],
+            ownerIndex: ownerIndex(),
             line: routine.start!.line,
             column: routine.start!.column,
             nameParts: splitDotted(at >= 0 ? raw.slice(0, at) : raw),
@@ -457,6 +489,7 @@ function extractSegment(
           const { arity, named } = argumentsOf(fnArg);
           out.calls.push({
             ownerPath: [...scope],
+            ownerIndex: ownerIndex(),
             line: ctx.start!.line,
             column: ctx.start!.column,
             nameParts: names,
@@ -478,6 +511,7 @@ function extractSegment(
           if (parts.length === 1 && cteNamesAbove(ctx).has(table)) break;
           out.accesses.push({
             ownerPath: [...scope],
+            ownerIndex: ownerIndex(),
             line: ctx.start!.line,
             column: ctx.start!.column,
             table,
@@ -492,6 +526,7 @@ function extractSegment(
           const text = expr?.getText() ?? '';
           out.dynamicSql.push({
             ownerPath: [...scope],
+            ownerIndex: ownerIndex(),
             line: ctx.start!.line,
             literal: /^'[\s\S]*'$/.test(text) ? text.slice(1, -1).replace(/''/g, "'") : undefined,
           });
@@ -500,7 +535,10 @@ function extractSegment(
       }
     },
     exitEveryRule(ctx: ParserRuleContext) {
-      if (SCOPE_RULES.has(ctx.ruleIndex)) scope.pop();
+      if (SCOPE_RULES.has(ctx.ruleIndex)) {
+        scope.pop();
+        owners.pop();
+      }
     },
   };
   ParseTreeWalker.DEFAULT.walk(listener, segment.tree);
@@ -523,10 +561,20 @@ const FALLBACK_UNIT =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(package\s+body|package|procedure|function|trigger)\s+((?:"[^"]+"|[\w$#]+)(?:\.(?:"[^"]+"|[\w$#]+))?)/gim;
 const FALLBACK_SUBPROGRAM = /^[ \t]*(procedure|function)\s+("[^"]+"|[\w$#]+)/gim;
 
-function lineAt(text: string, offset: number, firstLine: number): number {
-  let line = firstLine;
-  for (let i = 0; i < offset; i++) if (text.charCodeAt(i) === 10) line++;
-  return line;
+/** Offset → line lookup built once per segment (binary search over line starts). */
+function lineLocator(text: string, firstLine: number): (offset: number) => number {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+  return (offset) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (starts[mid]! <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return firstLine + lo;
+  };
 }
 
 /**
@@ -536,6 +584,7 @@ function lineAt(text: string, offset: number, firstLine: number): number {
 function fallbackDefinitions(segment: PlSqlSegment, known: ReadonlySet<string>): PlSqlDefinition[] {
   const out: PlSqlDefinition[] = [];
   const text = segment.text;
+  const lineAt = lineLocator(text, segment.startLine);
   let unit: { name: string; kind: PlSqlDefKind; isSpec: boolean } | undefined;
   for (const m of text.matchAll(FALLBACK_UNIT)) {
     const kindText = m[1]!.toLowerCase().replace(/\s+/g, ' ');
@@ -544,7 +593,7 @@ function fallbackDefinitions(segment: PlSqlSegment, known: ReadonlySet<string>):
       ? 'package'
       : (kindText as PlSqlDefKind);
     const name = parts[parts.length - 1]!;
-    const line = lineAt(text, m.index!, segment.startLine);
+    const line = lineAt(m.index!);
     if (!known.has(`|${name}`)) {
       out.push(
         makeFallback(
@@ -565,7 +614,7 @@ function fallbackDefinitions(segment: PlSqlSegment, known: ReadonlySet<string>):
   for (const m of text.matchAll(FALLBACK_SUBPROGRAM)) {
     const name = normaliseIdentifier(m[2]!);
     if (known.has(`${unit.name}|${name}`)) continue;
-    const line = lineAt(text, m.index!, segment.startLine);
+    const line = lineAt(m.index!);
     out.push(
       makeFallback(
         m[1]!.toLowerCase() as PlSqlDefKind,
@@ -605,6 +654,7 @@ function makeFallback(
     endLabels: [],
     parameters: [],
     isSpec,
+    declarationOnly: isSpec && kind !== 'package',
     fromFallback: true,
   };
 }
diff --git a/gitnexus/src/core/ingestion/plsql/facts-store.ts b/gitnexus/src/core/ingestion/plsql/facts-store.ts
new file mode 100644
index 000000000..20a34bab4
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/facts-store.ts
@@ -0,0 +1,40 @@
+/**
+ * Per-run store of extracted PL/SQL facts, so each file is ANTLR-parsed once
+ * per analyze: the `plsql` phase extracts every file, and the scope phase's
+ * `emitScopeCaptures` (plus rename's `parseSource`) reuse those facts.
+ *
+ * Entries are keyed by path and content hash, so an edited or renamed source
+ * can never be served stale facts. The store holds one run: the processor
+ * resets it at the start of each run with room for every PL/SQL file, and
+ * other callers add misses under a small bounded budget. Facts are not
+ * persisted across runs (see PLSQL-07 in docs/languages/plsql-ingestion-gaps.md).
+ */
+
+import { createHash } from 'node:crypto';
+import { extractPlSqlFacts, type PlSqlFileFacts } from './extract.js';
+
+/** Head-room for extractions outside the phase (rename re-parses edited sources). */
+const EXTRA_ENTRIES = 64;
+
+let capacity = EXTRA_ENTRIES;
+let store = new Map<string, PlSqlFileFacts>();
+
+const keyOf = (filePath: string, content: string) =>
+  `${filePath}\0${createHash('sha1').update(content).digest('hex')}`;
+
+/** Start a run sized for `fileCount` PL/SQL files; drops the previous run's facts. */
+export function resetPlSqlFactsStore(fileCount: number): void {
+  store = new Map();
+  capacity = fileCount + EXTRA_ENTRIES;
+}
+
+/** Facts for `content` at `filePath`, extracted at most once per run. */
+export function plsqlFactsForFile(filePath: string, content: string): PlSqlFileFacts {
+  const key = keyOf(filePath, content);
+  const cached = store.get(key);
+  if (cached) return cached;
+  const facts = extractPlSqlFacts(content);
+  if (store.size >= capacity) store.delete(store.keys().next().value!);
+  store.set(key, facts);
+  return facts;
+}
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 9a50b0957..115e214fa 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -37,14 +37,15 @@ export function isSqlFile(filePath: string): boolean {
 }
 
 /**
- * `CREATE [OR REPLACE] [EDITIONABLE|NONEDITIONABLE] PACKAGE|PROCEDURE|FUNCTION|TRIGGER|TYPE <name> ... IS|AS`
- * at the start of a line. `IS`/`AS` (or a trigger timing keyword) must follow
- * within the header, which rules out PostgreSQL's `CREATE FUNCTION ... AS $$`
- * (handled by `POSTGRES_DOLLAR_BODY`) and T-SQL's `CREATE PROCEDURE ... AS BEGIN`
- * without Oracle markers.
+ * An Oracle unit header at the start of a line:
+ *   `CREATE [OR REPLACE] [EDITIONABLE|NONEDITIONABLE] PACKAGE|PROCEDURE|FUNCTION|TYPE <name> … IS|AS`
+ *   `CREATE [OR REPLACE] … TRIGGER <name> BEFORE|AFTER|INSTEAD OF|FOR`
+ * `IS`/`AS` must follow the name (after an optional parameter list / RETURN
+ * clause) before any `BEGIN`, which rules out MySQL's `CREATE PROCEDURE p() BEGIN`.
+ * PostgreSQL's `AS $$` and T-SQL are excluded separately below.
  */
 const ORACLE_UNIT_HEADER =
-  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package(?:\s+body)?|procedure|function|trigger|type(?:\s+body)?)\s+[\w$#."]+/im;
+  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\bbegin\b)[\s\S]){0,4000}?\b(?:is|as)\b|trigger\s+[\w$#."]+\s+(?:before|after|instead\s+of|for)\b)/im;
 const POSTGRES_DOLLAR_BODY = /\bas\s+\$[\w]*\$|\blanguage\s+plpgsql\b/i;
 const TSQL_MARKERS = /^\s*go\s*$|\bnvarchar\s*\(\s*max\s*\)|@@identity|\bset\s+nocount\s+on\b/im;
 /** Constructs that only appear in Oracle PL/SQL. */
diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
index 66e0310e3..72a0ebff9 100644
--- a/gitnexus/src/core/ingestion/plsql/parse.ts
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -37,8 +37,26 @@ import {
   type SqlPlusCommand,
 } from './preprocess.js';
 
-/** Default wall-clock budget for one segment. */
-export const DEFAULT_SEGMENT_DEADLINE_MS = 10_000;
+/**
+ * Wall-clock budget for one segment: a floor plus a per-line allowance.
+ * A cold ANTLR DFA cache needs ~5 ms/line on large package bodies (a valid
+ * 3.4k-line body took ~18 s in the spike), so a flat budget would drop the
+ * largest — usually most important — packages to the regex fallback.
+ * `GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS` overrides the floor; 0 disables.
+ */
+export const SEGMENT_DEADLINE_FLOOR_MS = 10_000;
+export const SEGMENT_DEADLINE_PER_LINE_MS = 15;
+
+export function segmentDeadlineMs(lines: number, floorMs = configuredFloorMs()): number {
+  if (floorMs <= 0) return Number.POSITIVE_INFINITY;
+  return Math.max(floorMs, lines * SEGMENT_DEADLINE_PER_LINE_MS);
+}
+
+function configuredFloorMs(): number {
+  const raw = process.env.GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS;
+  const value = raw === undefined || raw.trim() === '' ? NaN : Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : SEGMENT_DEADLINE_FLOOR_MS;
+}
 
 export interface PlSqlSegment {
   /** 1-based first and last source line of the segment. */
@@ -150,6 +168,7 @@ export function splitSegments(
 
 export function parsePlSqlSource(
   source: string,
+  /** `segmentDeadlineMs` replaces the size-scaled budget (tests). */
   options: { segmentDeadlineMs?: number } = {},
 ): ParsedPlSqlSource {
   const commands: SqlPlusCommand[] = [];
@@ -158,7 +177,8 @@ export function parsePlSqlSource(
   for (const seg of splitSegments(text)) {
     // Prefix blank lines so token lines are file lines.
     const padded = '\n'.repeat(seg.startLine - 1) + seg.body;
-    const result = parseSegment(padded, options.segmentDeadlineMs ?? DEFAULT_SEGMENT_DEADLINE_MS);
+    const lines = seg.endLine - seg.startLine + 1;
+    const result = parseSegment(padded, options.segmentDeadlineMs ?? segmentDeadlineMs(lines));
     segments.push({ startLine: seg.startLine, endLine: seg.endLine, text: seg.body, ...result });
   }
   return { segments, scriptIncludes: scriptIncludesOf(commands) };
diff --git a/gitnexus/src/core/ingestion/plsql/preprocess.ts b/gitnexus/src/core/ingestion/plsql/preprocess.ts
index 69cc2a317..cbc24d6aa 100644
--- a/gitnexus/src/core/ingestion/plsql/preprocess.ts
+++ b/gitnexus/src/core/ingestion/plsql/preprocess.ts
@@ -13,24 +13,45 @@
 const SQLPLUS_COMMAND =
   /^\s*(?:set|define|def|undefine|undef|prompt|pro|rem|remark|spool|spo|whenever|column|col|connect|conn|accept|acc|pause|show|sho|exit|quit|host|ttitle|btitle|break|compute|clear|var|variable|print|timing|exec|execute|start|sta|disconnect|disc|store|repheader|repfooter|attribute|copy|describe|desc|get|help|list|password|run|save|xquery)\b/i;
 
-/** Statements that start a PL/SQL unit, which only a lone `/` terminates. */
+/**
+ * Statements that start a PL/SQL unit, which only a lone `/` terminates.
+ * Tested against a header joined across lines, so `CREATE OR REPLACE` on its
+ * own line followed by `PACKAGE BODY …` is still recognised.
+ */
 const PLSQL_UNIT_START =
-  /^(?:create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package|procedure|function|trigger|type)\b|declare\b|begin\b)/i;
+  /^(?:create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:and\s+(?:compile|resolve)\s+(?:noforce\s+)?java\b|package|procedure|function|trigger|type|library)\b|declare\b|begin\b)/i;
+
+/** A `CREATE` whose object keyword may still be on a following line. */
+const CREATE_PREFIX = /^create\b/i;
+/** Lines looked ahead to complete a split `CREATE` header. */
+const HEADER_LOOKAHEAD_LINES = 6;
 
 const ENDS_STATEMENT = /;\s*(?:--.*)?$/;
 const CONTINUATION = /\s-\s*$/;
+const LEADING_BLOCK_COMMENTS = /^(?:\/\*[\s\S]*?\*\/\s*)+/;
 
-/**
- * Blank SQL*Plus commands. They are only recognised *between* statements:
- * inside a PL/SQL unit `EXECUTE IMMEDIATE ...` or a column named `desc` is
- * ordinary code and must survive.
- */
 export interface SqlPlusCommand {
   /** 1-based line of the command's first line. */
   readonly line: number;
   readonly text: string;
 }
 
+/** `CREATE` header text joined with the next few code lines (comments skipped). */
+function joinedHeader(lines: readonly string[], index: number, first: string): string {
+  const parts = [first];
+  for (let j = index + 1; j < lines.length && parts.length <= HEADER_LOOKAHEAD_LINES; j++) {
+    const t = lines[j]!.replace(/\r$/, '').trim().replace(LEADING_BLOCK_COMMENTS, '');
+    if (t === '' || t.startsWith('--')) continue;
+    parts.push(t);
+  }
+  return parts.join(' ');
+}
+
+/**
+ * Blank SQL*Plus commands. They are only recognised *between* statements:
+ * inside a PL/SQL unit `EXECUTE IMMEDIATE ...`, `EXIT WHEN …` or a call to a
+ * procedure named `run` is ordinary code and must survive.
+ */
 export function stripSqlPlusCommands(source: string, commands?: SqlPlusCommand[]): string {
   const lines = source.split('\n');
   let state: 'between' | 'plsql' | 'sql' = 'between';
@@ -56,19 +77,22 @@ export function stripSqlPlusCommands(source: string, commands?: SqlPlusCommand[]
       if (trimmed === '/' || ENDS_STATEMENT.test(trimmed)) state = 'between';
       continue;
     }
-    if (trimmed === '' || trimmed.startsWith('--') || trimmed === '/') continue;
-    if (trimmed.startsWith('/*')) {
-      if (!trimmed.includes('*/', 2)) inBlockComment = true;
+    // Code after any leading `/* … */` on the same line.
+    const code = trimmed.replace(LEADING_BLOCK_COMMENTS, '');
+    if (code.startsWith('/*')) {
+      inBlockComment = true;
       continue;
     }
-    if (SQLPLUS_COMMAND.test(trimmed) || trimmed.startsWith('@')) {
-      continuation = CONTINUATION.test(trimmed);
+    if (code === '' || code.startsWith('--') || code === '/') continue;
+    if (code === trimmed && (SQLPLUS_COMMAND.test(code) || code.startsWith('@'))) {
+      continuation = CONTINUATION.test(code);
       commands?.push({ line: i + 1, text: line.replace(/\r$/, '') });
       lines[i] = blankLine(line);
       continue;
     }
-    if (PLSQL_UNIT_START.test(trimmed)) state = 'plsql';
-    else if (!ENDS_STATEMENT.test(trimmed)) state = 'sql';
+    const header = CREATE_PREFIX.test(code) ? joinedHeader(lines, i, code) : code;
+    if (PLSQL_UNIT_START.test(header)) state = 'plsql';
+    else if (!ENDS_STATEMENT.test(code)) state = 'sql';
   }
   return lines.join('\n');
 }
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index 5ff9febf5..5352fcd89 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -9,6 +9,12 @@
  *   S.A.NAME    → member NAME of package A in schema S.
  * Overloads are narrowed by arity (counting defaulted parameters) and named
  * arguments; what remains is returned as-is so callers can report ambiguity.
+ *
+ * Names are global in a database schema but not in a repository: the same
+ * package often exists several times (release folders, rollback scripts,
+ * fixtures). Ties between same-named definitions in different files are
+ * therefore broken by path proximity to the caller, and a package spec is
+ * paired with the nearest body (`PlSqlPackageInstances`).
  */
 
 import type { PlSqlCallSite, PlSqlDefinition } from './extract.js';
@@ -27,12 +33,32 @@ export function plsqlSignatureKey(
   return `${[...def.ownerPath, def.name].join('.')}(${def.parameters.map((p) => `${p.name} ${p.type}`.trim()).join(',')})`;
 }
 
+/** Number of leading directory segments two repository paths share. */
+export function sharedDirectoryDepth(a: string, b: string): number {
+  const da = a.split('/').slice(0, -1);
+  const db = b.split('/').slice(0, -1);
+  let depth = 0;
+  while (depth < da.length && depth < db.length && da[depth] === db[depth]) depth++;
+  return depth;
+}
+
+/** Keep only the candidates whose file is nearest to `fromFile`. */
+export function nearestByPath<E extends { readonly filePath: string }>(
+  candidates: readonly E[],
+  fromFile: string,
+): E[] {
+  if (candidates.length <= 1) return [...candidates];
+  const depths = candidates.map((c) =>
+    c.filePath === fromFile ? Number.MAX_SAFE_INTEGER : sharedDirectoryDepth(c.filePath, fromFile),
+  );
+  const best = Math.max(...depths);
+  return candidates.filter((_, i) => depths[i] === best);
+}
+
 export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
   private readonly members = new Map<string, Map<string, E[]>>();
-  private readonly packageNames = new Set<string>();
 
   add(entry: E): void {
-    if (entry.def.kind === 'package') this.packageNames.add(entry.def.name);
     const owner = pathKey(entry.def.ownerPath);
     let byName = this.members.get(owner);
     if (!byName) this.members.set(owner, (byName = new Map()));
@@ -41,10 +67,6 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
     else byName.set(entry.def.name, [entry]);
   }
 
-  hasPackage(name: string): boolean {
-    return this.packageNames.has(name);
-  }
-
   lookup(ownerPath: readonly string[], name: string): E[] {
     return this.members.get(pathKey(ownerPath))?.get(name) ?? [];
   }
@@ -69,9 +91,18 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
     return [];
   }
 
-  /** Resolve a call to its implementation(s); empty when nothing in the repository matches. */
-  resolve(call: Pick<PlSqlCallSite, 'nameParts' | 'ownerPath' | 'arity' | 'namedArguments'>): E[] {
-    return preferImplementations(narrowOverloads(this.candidates(call), call));
+  /**
+   * Resolve a call written in `fromFile` to its implementation(s): overloads,
+   * then path proximity, then spec/forward declaration vs body. Empty when
+   * nothing in the repository matches.
+   */
+  resolve(
+    call: Pick<PlSqlCallSite, 'nameParts' | 'ownerPath' | 'arity' | 'namedArguments'>,
+    fromFile: string,
+  ): E[] {
+    return preferImplementations(
+      nearestByPath(narrowOverloads(this.candidates(call), call), fromFile),
+    );
   }
 }
 
@@ -92,10 +123,61 @@ function narrowOverloads<E extends PlSqlIndexEntry>(
 }
 
 /**
- * A spec declaration and its body describe one subprogram; prefer the body.
- * Spec-only entries remain when no body is indexed.
+ * A spec (or forward) declaration and its body describe one subprogram; prefer
+ * the body. Declaration-only entries remain when no body is a candidate.
  */
 function preferImplementations<E extends PlSqlIndexEntry>(defs: E[]): E[] {
-  const bodies = new Set(defs.filter((d) => !d.def.isSpec).map((d) => plsqlSignatureKey(d.def)));
-  return defs.filter((d) => !d.def.isSpec || !bodies.has(plsqlSignatureKey(d.def)));
+  const bodies = new Set(
+    defs.filter((d) => !d.def.declarationOnly).map((d) => plsqlSignatureKey(d.def)),
+  );
+  return defs.filter((d) => !d.def.declarationOnly || !bodies.has(plsqlSignatureKey(d.def)));
+}
+
+/**
+ * Pairs every package spec/body file with one package instance, keyed by its
+ * home file: a spec is its own home; a body joins the nearest spec of the
+ * same name (shared directory depth, then path order), or is its own home when
+ * no spec is indexed. Copies of a package in unrelated folders stay separate.
+ */
+export class PlSqlPackageInstances {
+  private readonly home = new Map<string, string>();
+
+  constructor(
+    packages: ReadonlyArray<{
+      readonly name: string;
+      readonly filePath: string;
+      readonly isSpec: boolean;
+    }>,
+  ) {
+    const specFiles = new Map<string, string[]>();
+    for (const p of packages) {
+      if (!p.isSpec) continue;
+      const list = specFiles.get(p.name) ?? [];
+      list.push(p.filePath);
+      specFiles.set(p.name, list);
+    }
+    for (const files of specFiles.values()) files.sort();
+    for (const p of packages) {
+      const key = `${p.name}\0${p.filePath}`;
+      if (p.isSpec || this.home.has(key)) {
+        if (p.isSpec) this.home.set(key, p.filePath);
+        continue;
+      }
+      const specs = specFiles.get(p.name);
+      this.home.set(
+        key,
+        specs
+          ? nearestByPath(
+              specs.map((filePath) => ({ filePath })),
+              p.filePath,
+            )[0]!.filePath
+          : p.filePath,
+      );
+    }
+  }
+
+  /** Home file of the instance of package `name` defined (spec or body) in `filePath`. */
+  homeOf(name: string, filePath: string): string | undefined {
+    return this.home.get(`${name}\0${filePath}`);
+  }
 }
diff --git a/gitnexus/test/integration/resolvers/plsql.test.ts b/gitnexus/test/integration/resolvers/plsql.test.ts
index f1c68d4d8..09f4d30e7 100644
--- a/gitnexus/test/integration/resolvers/plsql.test.ts
+++ b/gitnexus/test/integration/resolvers/plsql.test.ts
@@ -161,6 +161,17 @@ describe('Oracle PL/SQL extraction', () => {
       ]);
     });
 
+    it('CALLS/ACCESSES: sites belong to the overload whose body contains them', () => {
+      const line = (id: string) => result.graph.getNode(id)!.properties.startLine! + 1;
+      const fromLogMsg = [...result.graph.iterRelationships()]
+        .filter((r) => result.graph.getNode(r.sourceId)?.properties.name === 'LOG_MSG')
+        .filter((r) => r.type === 'CALLS' || r.type === 'ACCESSES')
+        .map((r) => `${r.type} LOG_MSG@L${line(r.sourceId)}`)
+        .sort();
+      // L3 log_msg(p_msg) calls the 2-arg overload; L8's body does the INSERT.
+      expect(fromLogMsg).toEqual(['ACCESSES LOG_MSG@L8', 'CALLS LOG_MSG@L3']);
+    });
+
     it('ACCESSES: read/write per statement, MERGE target vs source, trigger target', () => {
       expect(plsqlEdges(result, 'ACCESSES')).toEqual([
         'CALC_PENALTY → T_LOAN_CONTRACT [plsql-select]',
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index d3ba549a6..a151476be 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -147,6 +147,16 @@ describe('file classification', () => {
       false,
     );
     expect(looksLikeOraclePlSql('SELECT * FROM t;')).toBe(false);
+    // MySQL: no IS/AS before BEGIN, even with an Oracle-looking marker in a comment.
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE PROCEDURE p()\nBEGIN\n  -- nvl( is not MySQL\n  SELECT 1;\nEND\n/\n',
+      ),
+    ).toBe(false);
+    // Oracle header split across lines still counts.
+    expect(
+      looksLikeOraclePlSql('CREATE OR REPLACE\nPACKAGE BODY p\nAS\n  x VARCHAR2(1);\nEND p;\n/\n'),
+    ).toBe(true);
   });
 });
 
diff --git a/gitnexus/test/unit/plsql-preprocess.test.ts b/gitnexus/test/unit/plsql-preprocess.test.ts
index fed15e5eb..a2e254ce8 100644
--- a/gitnexus/test/unit/plsql-preprocess.test.ts
+++ b/gitnexus/test/unit/plsql-preprocess.test.ts
@@ -37,6 +37,36 @@ describe('stripSqlPlusCommands', () => {
     expect(lines(stripSqlPlusCommands(src))).toEqual([...lines(src).slice(0, 7), '']);
   });
 
+  it('recognises a CREATE header split across lines (EXIT, calls named like commands survive)', () => {
+    const src = [
+      'CREATE OR REPLACE',
+      '/* generated */',
+      'PACKAGE BODY p AS',
+      '  PROCEDURE run IS BEGIN',
+      '    FETCH c INTO r;',
+      '    exit when c%NOTFOUND;',
+      '    run_step;',
+      '    list := 1;',
+      '  END run;',
+      'END p;',
+      '/',
+      'SHOW ERRORS',
+    ].join('\n');
+    expect(lines(stripSqlPlusCommands(src))).toEqual([...lines(src).slice(0, 11), '']);
+  });
+
+  it('tracks a unit that follows a closed block comment on the same line', () => {
+    const src = [
+      '/* v2 */ CREATE OR REPLACE PROCEDURE q IS',
+      'BEGIN',
+      '  x := 1;',
+      '  exit;',
+      'END;',
+      '/',
+    ].join('\n');
+    expect(stripSqlPlusCommands(src)).toBe(src);
+  });
+
   it('blanks `-` continuation lines of a command', () => {
     const src = [
       'EXECUTE dbms_stats.gather_schema_stats( -',
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
new file mode 100644
index 000000000..84c40665a
--- /dev/null
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -0,0 +1,144 @@
+import { describe, it, expect } from 'vitest';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import type { KnowledgeGraph } from '../../src/core/graph/types.js';
+import { processPlSql } from '../../src/core/ingestion/plsql-processor.js';
+import {
+  plsqlFactsForFile,
+  resetPlSqlFactsStore,
+} from '../../src/core/ingestion/plsql/facts-store.js';
+import {
+  segmentDeadlineMs,
+  SEGMENT_DEADLINE_FLOOR_MS,
+} from '../../src/core/ingestion/plsql/parse.js';
+
+const run = (files: Record<string, string>) => {
+  const graph = createKnowledgeGraph();
+  const result = processPlSql(
+    graph,
+    Object.entries(files).map(([path, content]) => ({ path, content })),
+  );
+  return { graph, result };
+};
+
+/** `TYPE source@line -> target@file` for every edge of `type`, sorted. */
+const edges = (graph: KnowledgeGraph, type: string) => {
+  const out: string[] = [];
+  for (const r of graph.iterRelationships()) {
+    if (r.type !== type) continue;
+    const s = graph.getNode(r.sourceId)!;
+    const t = graph.getNode(r.targetId)!;
+    out.push(
+      `${s.properties.name}@L${s.properties.startLine! + 1} -> ${t.properties.name}@${t.properties.filePath}`,
+    );
+  }
+  return out.sort();
+};
+
+describe('processPlSql', () => {
+  it('attributes calls and accesses to the overload that contains them', () => {
+    const { graph } = run({
+      'db/pkg_log.pkb': `CREATE OR REPLACE PACKAGE BODY pkg_log AS
+  PROCEDURE log_msg(p_msg IN VARCHAR2) IS
+  BEGIN
+    log_msg(p_msg, 1);
+  END log_msg;
+  PROCEDURE log_msg(p_msg IN VARCHAR2, p_level IN NUMBER) IS
+  BEGIN
+    INSERT INTO t_app_log (lvl, msg) VALUES (p_level, p_msg);
+  END log_msg;
+END pkg_log;
+/
+`,
+    });
+    expect(edges(graph, 'ACCESSES')).toEqual(['LOG_MSG@L6 -> T_APP_LOG@db/pkg_log.pkb']);
+    expect(edges(graph, 'CALLS')).toEqual(['LOG_MSG@L2 -> LOG_MSG@db/pkg_log.pkb']);
+  });
+
+  it('keeps forward-declared private subprograms private', () => {
+    const { graph } = run({
+      'p.pkb': `CREATE OR REPLACE PACKAGE BODY p AS
+  PROCEDURE helper;
+  PROCEDURE run IS BEGIN helper; END run;
+  PROCEDURE helper IS BEGIN NULL; END helper;
+END p;
+/
+`,
+      'p.pks': 'CREATE OR REPLACE PACKAGE p AS\n  PROCEDURE run;\nEND p;\n/\n',
+    });
+    const exported: Record<string, boolean | undefined> = {};
+    graph.forEachNode((n) => {
+      if (n.label === 'Function') exported[n.properties.name] = n.properties.isExported;
+    });
+    expect(exported).toEqual({ RUN: true, HELPER: false });
+    expect(edges(graph, 'CALLS')).toEqual(['RUN@L3 -> HELPER@p.pkb']);
+  });
+
+  it('keeps same-named packages in different folders apart and calls the nearest copy', () => {
+    const spec =
+      'CREATE OR REPLACE PACKAGE pkg_fee AS\n  FUNCTION fee RETURN NUMBER;\nEND pkg_fee;\n/\n';
+    const body =
+      'CREATE OR REPLACE PACKAGE BODY pkg_fee AS\n  FUNCTION fee RETURN NUMBER IS BEGIN RETURN 1; END fee;\nEND pkg_fee;\n/\n';
+    const caller =
+      'CREATE OR REPLACE PROCEDURE settle IS\n  x NUMBER;\nBEGIN\n  x := pkg_fee.fee();\nEND settle;\n/\n';
+    const { graph } = run({
+      'release/v1/pkg_fee.pks': spec,
+      'release/v1/pkg_fee.pkb': body,
+      'release/v1/settle.prc': caller,
+      'release/v2/pkg_fee.pks': spec,
+      'release/v2/pkg_fee.pkb': body,
+      'release/v2/settle.prc': caller,
+    });
+    const modules: string[] = [];
+    graph.forEachNode((n) => {
+      if (n.label === 'Module') modules.push(`${n.properties.name}@${n.properties.filePath}`);
+    });
+    expect(modules.sort()).toEqual([
+      'PKG_FEE@release/v1/pkg_fee.pks',
+      'PKG_FEE@release/v2/pkg_fee.pks',
+    ]);
+    expect(edges(graph, 'CALLS')).toEqual([
+      'SETTLE@L1 -> FEE@release/v1/pkg_fee.pkb',
+      'SETTLE@L1 -> FEE@release/v2/pkg_fee.pkb',
+    ]);
+    for (const r of graph.iterRelationships()) {
+      if (r.type === 'CALLS') expect(r.reason).toBe('plsql-call');
+    }
+  });
+
+  it('does not lose PL/SQL statements when the CREATE header is split across lines', () => {
+    const { graph } = run({
+      'p.pkb': `CREATE OR REPLACE
+PACKAGE BODY p AS
+  PROCEDURE run IS
+  BEGIN
+    FETCH c INTO r;
+    exit when r.id IS NULL;
+    get(r.id);
+  END run;
+  PROCEDURE get(p_id NUMBER) IS BEGIN DELETE FROM t_x WHERE id = p_id; END get;
+END p;
+/
+`,
+    });
+    expect(edges(graph, 'CALLS')).toEqual(['RUN@L3 -> GET@p.pkb']);
+  });
+});
+
+describe('segment deadline', () => {
+  it('scales with segment size above the floor', () => {
+    expect(segmentDeadlineMs(10)).toBe(SEGMENT_DEADLINE_FLOOR_MS);
+    expect(segmentDeadlineMs(4_000)).toBeGreaterThan(30_000);
+    expect(segmentDeadlineMs(4_000, 0)).toBe(Number.POSITIVE_INFINITY);
+  });
+});
+
+describe('facts store', () => {
+  it('extracts a source once per run and never serves facts for different content', () => {
+    resetPlSqlFactsStore(2);
+    const a = plsqlFactsForFile('a.prc', 'CREATE PROCEDURE a IS BEGIN NULL; END;\n/\n');
+    expect(plsqlFactsForFile('a.prc', 'CREATE PROCEDURE a IS BEGIN NULL; END;\n/\n')).toBe(a);
+    const edited = plsqlFactsForFile('a.prc', 'CREATE PROCEDURE b IS BEGIN NULL; END;\n/\n');
+    expect(edited).not.toBe(a);
+    expect(edited.definitions.map((d) => d.name)).toEqual(['B']);
+  });
+});

From 7cc19789128a82cf3b3c3a2c69e93a9ec91681cf Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Fri, 30 Oct 2026 15:46:00 +0800
Subject: [PATCH 03/17] fix(plsql): address nexus-check review comments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- generate-plsql-parser.mjs runs npx through the platform shell so it
  works on Windows (same constraint as scripts/build-web.js)
- rename safety regex escapes every metacharacter of quoted identifiers
- S.A.N calls and package qualifiers prefer packages of the written schema
- package instances and node ids distinguish same-named packages of
  different schemas (e.g. a.pkg and b.pkg in one file)
- the plsql phase reads .sql candidates in 16 MiB batches and keeps only
  Oracle sources; it resets the facts store when a run has no PL/SQL
- regex fallback nests subprograms using their `END <name>;` spans
- `CREATE … IS` headers are Oracle-only and classify without other markers
- lexer errors count as syntax errors, so unlexable input degrades a segment
- positional SQL*Plus substitutions (&1, &&2) are neutralised
- deadline test no longer depends on GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS
- provider comment documents that SQL*Plus include scripts are claimed

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gitnexus/scripts/generate-plsql-parser.mjs    |  26 ++--
 .../src/core/ingestion/languages/plsql.ts     |   3 +-
 .../core/ingestion/languages/plsql/rename.ts  |  18 +--
 .../languages/plsql/scope-resolver.ts         |  36 ++++--
 .../core/ingestion/pipeline-phases/plsql.ts   |  53 ++++++--
 .../src/core/ingestion/plsql-processor.ts     |  76 ++++++++----
 gitnexus/src/core/ingestion/plsql/extract.ts  |  46 ++++---
 .../src/core/ingestion/plsql/file-types.ts    |   7 +-
 gitnexus/src/core/ingestion/plsql/parse.ts    |  42 +++++--
 .../src/core/ingestion/plsql/preprocess.ts    |   7 +-
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 117 +++++++++++++-----
 gitnexus/test/unit/plsql-extract.test.ts      |  28 +++++
 gitnexus/test/unit/plsql-preprocess.test.ts   |   9 ++
 gitnexus/test/unit/plsql-processor.test.ts    |  30 ++++-
 14 files changed, 365 insertions(+), 133 deletions(-)

diff --git a/gitnexus/scripts/generate-plsql-parser.mjs b/gitnexus/scripts/generate-plsql-parser.mjs
index 1782e45cc..289cda486 100644
--- a/gitnexus/scripts/generate-plsql-parser.mjs
+++ b/gitnexus/scripts/generate-plsql-parser.mjs
@@ -9,7 +9,7 @@
  * The grammar's C++ header placeholders are replaced with the antlr4ng base-class
  * imports, exactly as grammars-v4's `Antlr4ng/transformGrammar.py` does.
  */
-import { execFileSync } from 'node:child_process';
+import { execSync } from 'node:child_process';
 import {
   mkdtempSync,
   readFileSync,
@@ -40,21 +40,17 @@ try {
       );
     writeFileSync(path.join(work, name), text);
   }
-  execFileSync(
-    'npx',
+  // String form runs through the platform shell (cmd.exe / sh) so `npx`
+  // resolves to npx.cmd on Windows — execFileSync('npx') without a shell
+  // fails there (same constraint as scripts/build-web.js).
+  const quote = (arg) => `"${arg}"`;
+  execSync(
     [
-      '--yes',
-      'antlr-ng@1.0.10',
-      '-Dlanguage=TypeScript',
-      '-l',
-      'true',
-      '-v',
-      'false',
-      '-o',
-      work,
-      path.join(work, 'PlSqlLexer.g4'),
-      path.join(work, 'PlSqlParser.g4'),
-    ],
+      'npx --yes antlr-ng@1.0.10 -Dlanguage=TypeScript -l true -v false',
+      `-o ${quote(work)}`,
+      quote(path.join(work, 'PlSqlLexer.g4')),
+      quote(path.join(work, 'PlSqlParser.g4')),
+    ].join(' '),
     { stdio: 'inherit' },
   );
   for (const file of readdirSync(work)) {
diff --git a/gitnexus/src/core/ingestion/languages/plsql.ts b/gitnexus/src/core/ingestion/languages/plsql.ts
index d7adc9aa6..ef0146a5c 100644
--- a/gitnexus/src/core/ingestion/languages/plsql.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql.ts
@@ -7,7 +7,8 @@
  *
  * Dedicated extensions (.pks, .pkb, .pck, …) are always PL/SQL. `.sql` is
  * claimed through `classifyFileContent` only when the file holds an Oracle
- * PL/SQL unit, leaving other SQL dialects alone.
+ * PL/SQL unit or is a SQL*Plus script that includes other scripts
+ * (`@@file`, `@file.ext`, `START file.ext`), leaving other SQL dialects alone.
  */
 import { SupportedLanguages } from 'gitnexus-shared';
 import { defineLanguage } from '../language-provider.js';
diff --git a/gitnexus/src/core/ingestion/languages/plsql/rename.ts b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
index 8faf033e0..7d911df7b 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/rename.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
@@ -31,7 +31,7 @@ import {
   type PlSqlDefinition,
   type PlSqlFileFacts,
 } from '../../plsql/extract.js';
-import { PlSqlPackageInstances, plsqlSignatureKey } from '../../plsql/resolve.js';
+import { PlSqlPackageInstances, plsqlSignatureKey, rootPackageOf } from '../../plsql/resolve.js';
 import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
 
 const unsupported = (message: string): RenameIssue => ({
@@ -147,20 +147,19 @@ export const plsqlRenameProvider: RenameProvider = {
     if (!target) return unsupported('The PL/SQL declaration has no source identity.');
     // One family per package instance: a spec, its paired body and the
     // declarations inside them. Same-named copies elsewhere are other objects.
-    const packages: Array<{ name: string; filePath: string; isSpec: boolean }> = [];
+    const packages: Array<{ name: string; schema?: string; filePath: string; isSpec: boolean }> =
+      [];
     for (const file of context.files.values()) {
       for (const d of evidence.get(file)?.definitions ?? []) {
         if (d.kind === 'package')
-          packages.push({ name: d.name, filePath: file.path, isSpec: d.isSpec });
+          packages.push({ name: d.name, schema: d.schema, filePath: file.path, isSpec: d.isSpec });
       }
     }
     const instances = new PlSqlPackageInstances(packages);
-    const definesPackage = new Set(packages.map((p) => `${p.name}\0${p.filePath}`));
     const scopeOf = (d: PlSqlDefinition, filePath: string): string => {
-      const pkg = d.kind === 'package' ? d.name : d.ownerPath[0];
-      return pkg !== undefined && definesPackage.has(`${pkg}\0${filePath}`)
-        ? `${pkg}\0${instances.homeOf(pkg, filePath) ?? filePath}`
-        : `\0${filePath}`;
+      const defs = evidence.get(context.files.get(filePath)!)?.definitions ?? [];
+      const pkg = rootPackageOf(d, defs);
+      return pkg ? instances.instanceOf(pkg.name, pkg.schema, filePath) : `\0${filePath}`;
     };
     const targetScope = scopeOf(target, context.target.filePath);
     const sameEntity = (d: PlSqlDefinition, filePath: string) =>
@@ -183,7 +182,8 @@ export const plsqlRenameProvider: RenameProvider = {
       return unsupported(
         'The declaration was recovered without a full parse; rename cannot prove its references.',
       );
-    const word = new RegExp(`(^|[^\\w$#])${target.name.replace(/[$#]/g, '\\$&')}($|[^\\w$#])`, 'i');
+    const escaped = target.name.replace(/[.*+?^${}()|[\]\\$#]/g, '\\$&');
+    const word = new RegExp(`(^|[^\\w$#])${escaped}($|[^\\w$#])`, 'i');
     for (const file of context.files.values()) {
       const facts = evidence.get(file);
       if (!facts) continue;
diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
index a633d861a..3dddaa1b2 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -14,7 +14,12 @@ import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
 import { SupportedLanguages } from 'gitnexus-shared';
 import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
 import { plsqlProvider } from '../plsql.js';
-import { PlSqlNameIndex, nearestByPath, type PlSqlIndexEntry } from '../../plsql/resolve.js';
+import {
+  PlSqlNameIndex,
+  nearestByPath,
+  rootPackageOf,
+  type PlSqlIndexEntry,
+} from '../../plsql/resolve.js';
 import { resolvePlSqlScriptInclude } from '../../plsql/script-include.js';
 import type { PlSqlCallSite, PlSqlDefinition } from '../../plsql/extract.js';
 import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
@@ -69,7 +74,13 @@ const plsqlScopeResolver: ScopeResolver = {
         const symbol = byNameRange.get(plsqlRangeKey(plsqlNameRange(def)));
         if (!symbol) continue;
         symbolOf.set(def, symbol);
-        index.add({ def, filePath: parsed.filePath, symbol });
+        index.add({
+          def,
+          filePath: parsed.filePath,
+          symbol,
+          packageSchema:
+            def.kind === 'package' ? undefined : rootPackageOf(def, facts.definitions)?.schema,
+        });
       }
       return { parsed, facts };
     });
@@ -78,16 +89,23 @@ const plsqlScopeResolver: ScopeResolver = {
     // spec when indexed.
     const packageSymbols = new Map<
       string,
-      Array<{ filePath: string; symbol: SymbolDefinition; isSpec: boolean }>
+      Array<{ filePath: string; symbol: SymbolDefinition; isSpec: boolean; schema?: string }>
     >();
     for (const [def, symbol] of symbolOf) {
       if (def.kind !== 'package') continue;
       const list = packageSymbols.get(def.name) ?? [];
-      list.push({ filePath: symbol.filePath, symbol, isSpec: def.isSpec });
+      list.push({ filePath: symbol.filePath, symbol, isSpec: def.isSpec, schema: def.schema });
       packageSymbols.set(def.name, list);
     }
-    const packageSymbol = (name: string, fromFile: string): SymbolDefinition | undefined => {
-      const nearest = nearestByPath(packageSymbols.get(name) ?? [], fromFile);
+    /** In `S.A.N` the written schema `S` narrows same-named packages first. */
+    const packageSymbol = (
+      name: string,
+      fromFile: string,
+      schema: string | undefined,
+    ): SymbolDefinition | undefined => {
+      const all = packageSymbols.get(name) ?? [];
+      const inSchema = schema === undefined ? [] : all.filter((p) => p.schema === schema);
+      const nearest = nearestByPath(inSchema.length > 0 ? inSchema : all, fromFile);
       return (nearest.find((p) => p.isSpec) ?? nearest[0])?.symbol;
     };
 
@@ -125,7 +143,11 @@ const plsqlScopeResolver: ScopeResolver = {
           // In `S.A.N` only `A` (the part before the callee) can name a package.
           const symbol =
             m.part === m.call.nameParts.length - 2
-              ? packageSymbol(m.call.nameParts[m.part]!, parsed.filePath)
+              ? packageSymbol(
+                  m.call.nameParts[m.part]!,
+                  parsed.filePath,
+                  m.part > 0 ? m.call.nameParts[m.part - 1] : undefined,
+                )
               : undefined;
           record(
             site,
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
index 1bde1b91a..002b3e265 100644
--- a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
+++ b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
@@ -15,12 +15,33 @@ import type { PipelinePhase, PipelineContext, PhaseResult } from './types.js';
 import { getPhaseOutput } from './types.js';
 import { processPlSql, isPlSqlSource } from '../plsql-processor.js';
 import { hasPlSqlExtension, isSqlFile } from '../plsql/file-types.js';
+import { resetPlSqlFactsStore } from '../plsql/facts-store.js';
 import { readFileContents } from '../filesystem-walker.js';
 import type { StructureOutput } from './structure.js';
 import { isDev } from '../utils/env.js';
 
 import { logger } from '../../logger.js';
 
+/** Bytes of candidate source read at once while classifying `.sql` files. */
+const READ_BATCH_BYTES = 16 * 1024 * 1024;
+
+function byteBudgetBatches<T extends { size: number }>(items: readonly T[], budget: number): T[][] {
+  const batches: T[][] = [];
+  let current: T[] = [];
+  let bytes = 0;
+  for (const item of items) {
+    if (current.length > 0 && bytes + item.size > budget) {
+      batches.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(item);
+    bytes += item.size;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+
 export interface PlSqlOutput {
   files: number;
   packages: number;
@@ -38,16 +59,30 @@ export const plsqlPhase: PipelinePhase<PlSqlOutput> = {
     const { scannedFiles, allPathSet } = getPhaseOutput<StructureOutput>(deps, 'structure');
 
     const candidates = scannedFiles.filter((f) => hasPlSqlExtension(f.path) || isSqlFile(f.path));
-    if (candidates.length === 0) return { files: 0, packages: 0, subprograms: 0 };
+    if (candidates.length === 0) {
+      resetPlSqlFactsStore(0); // drop a previous run's facts in long-lived processes
+      return { files: 0, packages: 0, subprograms: 0 };
+    }
 
-    const contents = await readFileContents(
-      ctx.repoPath,
-      candidates.map((f) => f.path),
-    );
-    const files = candidates
-      .filter((f) => contents.has(f.path) && isPlSqlSource(f.path, contents.get(f.path)!))
-      .map((f) => ({ path: f.path, content: contents.get(f.path)! }));
-    if (files.length === 0) return { files: 0, packages: 0, subprograms: 0 };
+    // Read in byte-budgeted batches and keep only Oracle sources, so a repo
+    // full of other-dialect `.sql` files never holds them all in memory.
+    const files: Array<{ path: string; content: string }> = [];
+    for (const batch of byteBudgetBatches(candidates, READ_BATCH_BYTES)) {
+      const contents = await readFileContents(
+        ctx.repoPath,
+        batch.map((f) => f.path),
+      );
+      for (const f of batch) {
+        const content = contents.get(f.path);
+        if (content !== undefined && isPlSqlSource(f.path, content)) {
+          files.push({ path: f.path, content });
+        }
+      }
+    }
+    if (files.length === 0) {
+      resetPlSqlFactsStore(0);
+      return { files: 0, packages: 0, subprograms: 0 };
+    }
 
     const result = processPlSql(ctx.graph, files, allPathSet);
 
diff --git a/gitnexus/src/core/ingestion/plsql-processor.ts b/gitnexus/src/core/ingestion/plsql-processor.ts
index 70d7d9c80..a7db39ff0 100644
--- a/gitnexus/src/core/ingestion/plsql-processor.ts
+++ b/gitnexus/src/core/ingestion/plsql-processor.ts
@@ -34,6 +34,7 @@ import {
   PlSqlNameIndex,
   PlSqlPackageInstances,
   plsqlSignatureKey,
+  rootPackageOf,
   type PlSqlIndexEntry,
 } from './plsql/resolve.js';
 
@@ -64,19 +65,28 @@ export { isPlSqlSource };
 
 // ─── node identity ────────────────────────────────────────────────────────
 
-/** A package is one node for spec and body, keyed by the file that declares it. */
-export function plsqlPackageNodeId(homeFile: string, packageName: string): string {
-  return generateId('Module', `${homeFile}:${packageName}`);
+/**
+ * A package is one node for spec and body, keyed by the file that declares it.
+ * The schema joins the key only when one file declares same-named packages of
+ * several schemas, so ordinary ids stay `Module:<file>:<name>`.
+ */
+export function plsqlPackageNodeId(homeFile: string, packageName: string, schema?: string): string {
+  return generateId('Module', `${homeFile}:${schema ? `${schema}.` : ''}${packageName}`);
 }
 
 /**
  * Subprograms are keyed by owner path plus the normalised parameter signature,
  * so overloads get distinct ids that survive edits elsewhere in the file.
  */
-export function plsqlSubprogramNodeId(filePath: string, def: PlSqlDefinition): string {
+export function plsqlSubprogramNodeId(
+  filePath: string,
+  def: PlSqlDefinition,
+  packageSchema?: string,
+): string {
+  const schema = packageSchema ? `${packageSchema}.` : '';
   return generateId(
     'Function',
-    `${filePath}:${plsqlSignatureKey(def)}${def.kind === 'trigger' ? ':trigger' : ''}`,
+    `${filePath}:${schema}${plsqlSignatureKey(def)}${def.kind === 'trigger' ? ':trigger' : ''}`,
   );
 }
 
@@ -104,26 +114,34 @@ export function processPlSql(
   const entryOf = new Map<PlSqlDefinition, Entry>();
   for (const [filePath, f] of facts) {
     for (const def of f.definitions) {
-      const entry: Entry = { def, filePath };
+      const entry: Entry = {
+        def,
+        filePath,
+        packageSchema:
+          def.kind === 'package' ? undefined : rootPackageOf(def, f.definitions)?.schema,
+      };
       entryOf.set(def, entry);
       index.add(entry);
     }
   }
 
-  // ── package instances: each spec paired with its nearest body ──
+  // ── package instances: each spec paired with its nearest compatible body ──
   const packageDefs = [...entryOf.values()].filter((e) => e.def.kind === 'package');
   const instances = new PlSqlPackageInstances(
-    packageDefs.map((e) => ({ name: e.def.name, filePath: e.filePath, isSpec: e.def.isSpec })),
+    packageDefs.map((e) => ({
+      name: e.def.name,
+      schema: e.def.schema,
+      filePath: e.filePath,
+      isSpec: e.def.isSpec,
+    })),
   );
-  const filesDefiningPackage = new Set(packageDefs.map((e) => `${e.def.name}\0${e.filePath}`));
-  const instanceKey = (name: string, filePath: string) =>
-    `${name}\0${instances.homeOf(name, filePath) ?? filePath}`;
+  const instanceOfPackage = (pkg: PlSqlDefinition, filePath: string) =>
+    instances.instanceOf(pkg.name, pkg.schema, filePath);
   /** The package instance a definition in `filePath` belongs to, if it is a package member. */
   const memberInstance = (def: PlSqlDefinition, filePath: string): string | undefined => {
-    const pkg = def.ownerPath[0];
-    return pkg !== undefined && filesDefiningPackage.has(`${pkg}\0${filePath}`)
-      ? instanceKey(pkg, filePath)
-      : undefined;
+    if (def.kind === 'package') return undefined;
+    const pkg = rootPackageOf(def, facts.get(filePath)!.definitions);
+    return pkg ? instanceOfPackage(pkg, filePath) : undefined;
   };
   /** Pairs a spec/forward declaration with its body inside one package instance (or one file). */
   const pairingKey = (def: PlSqlDefinition, filePath: string) =>
@@ -132,11 +150,11 @@ export function processPlSql(
   const packageNodeByInstance = new Map<string, string>();
   const instanceFiles = new Map<string, { home: string; anchor: Entry; files: Set<string> }>();
   for (const entry of packageDefs) {
-    const key = instanceKey(entry.def.name, entry.filePath);
+    const key = instanceOfPackage(entry.def, entry.filePath);
     const instance = instanceFiles.get(key);
     if (!instance) {
       instanceFiles.set(key, {
-        home: instances.homeOf(entry.def.name, entry.filePath) ?? entry.filePath,
+        home: instances.homeOf(key) ?? entry.filePath,
         anchor: entry,
         files: new Set([entry.filePath]),
       });
@@ -145,9 +163,15 @@ export function processPlSql(
       if (entry.def.isSpec && !instance.anchor.def.isSpec) instance.anchor = entry;
     }
   }
+  const homeClashes = new Map<string, number>();
+  for (const instance of instanceFiles.values()) {
+    const k = `${instance.home}\0${instance.anchor.def.name}`;
+    homeClashes.set(k, (homeClashes.get(k) ?? 0) + 1);
+  }
   for (const [key, instance] of instanceFiles) {
-    const { name } = instance.anchor.def;
-    const nodeId = plsqlPackageNodeId(instance.home, name);
+    const { name, schema } = instance.anchor.def;
+    const clash = (homeClashes.get(`${instance.home}\0${name}`) ?? 0) > 1;
+    const nodeId = plsqlPackageNodeId(instance.home, name, clash ? schema : undefined);
     packageNodeByInstance.set(key, nodeId);
     const others = [...instance.files].filter((f) => f !== instance.home).sort();
     graph.addNode({
@@ -171,7 +195,7 @@ export function processPlSql(
     }
   }
   for (const entry of packageDefs) {
-    entry.nodeId = packageNodeByInstance.get(instanceKey(entry.def.name, entry.filePath));
+    entry.nodeId = packageNodeByInstance.get(instanceOfPackage(entry.def, entry.filePath));
   }
 
   // ── subprograms and triggers ──
@@ -193,7 +217,7 @@ export function processPlSql(
     const key = pairingKey(def, filePath);
     // A spec/forward declaration with an indexed body is the same subprogram.
     if (def.declarationOnly && bodyKeys.has(key)) continue;
-    entry.nodeId = plsqlSubprogramNodeId(filePath, def);
+    entry.nodeId = plsqlSubprogramNodeId(filePath, def, entry.packageSchema);
     if (!def.declarationOnly) bodyNodeByKey.set(key, entry.nodeId);
     if (def.kind === 'trigger') triggers++;
     else subprograms++;
@@ -234,10 +258,12 @@ export function processPlSql(
       const owner = fileFacts.definitions[site.ownerIndex]!;
       return entryOf.get(owner)?.nodeId;
     }
-    const pkg = site.ownerPath[0];
-    if (site.ownerPath.length === 1 && filesDefiningPackage.has(`${pkg}\0${filePath}`)) {
-      return packageNodeByInstance.get(instanceKey(pkg!, filePath));
-    }
+    const pkgName = site.ownerPath[0];
+    const pkg =
+      site.ownerPath.length === 1
+        ? fileFacts.definitions.find((d) => d.kind === 'package' && d.name === pkgName)
+        : undefined;
+    if (pkg) return packageNodeByInstance.get(instanceOfPackage(pkg, filePath));
     return undefined;
   };
 
diff --git a/gitnexus/src/core/ingestion/plsql/extract.ts b/gitnexus/src/core/ingestion/plsql/extract.ts
index beb488a5f..005acb95d 100644
--- a/gitnexus/src/core/ingestion/plsql/extract.ts
+++ b/gitnexus/src/core/ingestion/plsql/extract.ts
@@ -611,22 +611,38 @@ function fallbackDefinitions(segment: PlSqlSegment, known: ReadonlySet<string>):
     break; // one top-level unit per segment
   }
   if (unit?.kind !== 'package') return out;
-  for (const m of text.matchAll(FALLBACK_SUBPROGRAM)) {
+  // Nesting from `END <name>;` spans: a routine that starts inside another
+  // routine's span is local to it, not a package member. Spec declarations
+  // have no bodies, so everything in a spec is package-level.
+  const routines = [...text.matchAll(FALLBACK_SUBPROGRAM)].map((m) => {
     const name = normaliseIdentifier(m[2]!);
-    if (known.has(`${unit.name}|${name}`)) continue;
-    const line = lineAt(m.index!);
-    out.push(
-      makeFallback(
-        m[1]!.toLowerCase() as PlSqlDefKind,
-        name,
-        [unit.name],
-        line,
-        line,
-        undefined,
-        unit.isSpec,
-      ),
-    );
-  }
+    let end = -1;
+    if (!unit!.isSpec) {
+      const label = m[2]!.startsWith('"') ? m[2]!.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : name;
+      const close = new RegExp(
+        `^[ \\t]*end[ \\t]+${label.replace(/[$#]/g, '\\$&')}[ \\t]*;`,
+        'gim',
+      );
+      close.lastIndex = m.index!;
+      end = close.exec(text)?.index ?? -1;
+    }
+    return { name, kind: m[1]!.toLowerCase() as PlSqlDefKind, start: m.index!, end };
+  });
+  const pathOf = (i: number): string[] => {
+    const r = routines[i]!;
+    let parent = -1;
+    for (let j = 0; j < i; j++) {
+      const p = routines[j]!;
+      if (p.end > r.start && (parent < 0 || p.start > routines[parent]!.start)) parent = j;
+    }
+    return parent < 0 ? [unit!.name] : [...pathOf(parent), routines[parent]!.name];
+  };
+  routines.forEach((r, i) => {
+    const ownerPath = pathOf(i);
+    if (known.has(`${ownerPath.join('.')}|${r.name}`)) return;
+    const line = lineAt(r.start);
+    out.push(makeFallback(r.kind, r.name, ownerPath, line, line, undefined, unit!.isSpec));
+  });
   return out;
 }
 
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 115e214fa..2ec3914d9 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -46,6 +46,8 @@ export function isSqlFile(filePath: string): boolean {
  */
 const ORACLE_UNIT_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\bbegin\b)[\s\S]){0,4000}?\b(?:is|as)\b|trigger\s+[\w$#."]+\s+(?:before|after|instead\s+of|for)\b)/im;
+const ORACLE_IS_HEADER =
+  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\b(?:begin|as)\b)[\s\S]){0,4000}?\bis\b/im;
 const POSTGRES_DOLLAR_BODY = /\bas\s+\$[\w]*\$|\blanguage\s+plpgsql\b/i;
 const TSQL_MARKERS = /^\s*go\s*$|\bnvarchar\s*\(\s*max\s*\)|@@identity|\bset\s+nocount\s+on\b/im;
 /** Constructs that only appear in Oracle PL/SQL. */
@@ -68,7 +70,10 @@ export function looksLikeOraclePlSql(content: string): boolean {
   if (SQLPLUS_INCLUDE.test(content) && !TSQL_MARKERS.test(content)) return true;
   if (!ORACLE_UNIT_HEADER.test(content)) return false;
   if (POSTGRES_DOLLAR_BODY.test(content) || TSQL_MARKERS.test(content)) return false;
-  return ORACLE_MARKERS.test(content);
+  // `IS` after a unit header is Oracle-only syntax (T-SQL, PostgreSQL and
+  // MySQL write `AS` or `BEGIN`), so a plain `CREATE PROCEDURE p IS …` needs
+  // no further marker; an `AS` header still does.
+  return ORACLE_IS_HEADER.test(content) || ORACLE_MARKERS.test(content);
 }
 
 /** File-level predicate used by the PL/SQL phase. */
diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
index 72a0ebff9..5ac792503 100644
--- a/gitnexus/src/core/ingestion/plsql/parse.ts
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -107,12 +107,19 @@ function deadlineListener(deadline: number): ParseTreeListener {
   };
 }
 
-function newParser(text: string): PlSqlParser {
+/**
+ * Parser over `text`. Lexer errors (characters no token rule matches) are
+ * counted too: the lexer skips them and the parser may then succeed, so they
+ * must still mark the segment as degraded.
+ */
+function newParser(text: string): { parser: PlSqlParser; lexerErrors: CountingErrorListener } {
   const lexer = new PlSqlLexer(CharStream.fromString(text));
   lexer.removeErrorListeners();
+  const lexerErrors = new CountingErrorListener();
+  lexer.addErrorListener(lexerErrors);
   const parser = new PlSqlParser(new CommonTokenStream(lexer));
   parser.removeErrorListeners();
-  return parser;
+  return { parser, lexerErrors };
 }
 
 function parseSegment(
@@ -122,22 +129,33 @@ function parseSegment(
   const deadline = performance.now() + deadlineMs;
   try {
     const sll = newParser(text);
-    sll.interpreter.predictionMode = PredictionMode.SLL;
-    sll.errorHandler = new BailErrorStrategy();
-    sll.addParseListener(deadlineListener(deadline));
+    sll.parser.interpreter.predictionMode = PredictionMode.SLL;
+    sll.parser.errorHandler = new BailErrorStrategy();
+    sll.parser.addParseListener(deadlineListener(deadline));
     try {
-      return { tree: sll.sql_script(), syntaxErrors: 0, mode: 'sll' };
+      const tree = sll.parser.sql_script();
+      return {
+        tree,
+        syntaxErrors: sll.lexerErrors.count,
+        firstError: sll.lexerErrors.first,
+        mode: 'sll',
+      };
     } catch (e) {
       if (!(e instanceof ParseCancellationException)) throw e;
     }
     const ll = newParser(text);
     const errors = new CountingErrorListener();
-    ll.addErrorListener(errors);
-    ll.interpreter.predictionMode = PredictionMode.LL;
-    ll.errorHandler = new DefaultErrorStrategy();
-    ll.addParseListener(deadlineListener(deadline));
-    const tree = ll.sql_script();
-    return { tree, syntaxErrors: errors.count, firstError: errors.first, mode: 'll' };
+    ll.parser.addErrorListener(errors);
+    ll.parser.interpreter.predictionMode = PredictionMode.LL;
+    ll.parser.errorHandler = new DefaultErrorStrategy();
+    ll.parser.addParseListener(deadlineListener(deadline));
+    const tree = ll.parser.sql_script();
+    return {
+      tree,
+      syntaxErrors: errors.count + ll.lexerErrors.count,
+      firstError: ll.lexerErrors.first ?? errors.first,
+      mode: 'll',
+    };
   } catch (e) {
     if (e instanceof DeadlineExceeded)
       return { syntaxErrors: 1, firstError: 'deadline exceeded', mode: 'timeout' };
diff --git a/gitnexus/src/core/ingestion/plsql/preprocess.ts b/gitnexus/src/core/ingestion/plsql/preprocess.ts
index cbc24d6aa..9b405ac2a 100644
--- a/gitnexus/src/core/ingestion/plsql/preprocess.ts
+++ b/gitnexus/src/core/ingestion/plsql/preprocess.ts
@@ -102,12 +102,13 @@ function blankLine(line: string): string {
 }
 
 /**
- * `&name` / `&&name` / `&name.` → an identifier of exactly the same length
- * (`Zname`, `ZZname`), so token columns stay aligned with the original text.
+ * `&name` / `&&name` / `&name.` / positional `&1` → an identifier of exactly
+ * the same length (`Zname`, `ZZname`, `Z1`), so token columns stay aligned
+ * with the original text.
  */
 export function neutraliseSubstitutionVariables(source: string): string {
   return source.replace(
-    /(&&?)([A-Za-z_][\w$#]*)(\.?)/g,
+    /(&&?)([A-Za-z_][\w$#]*|\d+)(\.?)/g,
     (_m, amps: string, name: string, dot: string) =>
       `${'Z'.repeat(amps.length)}${name}${dot ? ' ' : ''}`,
   );
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index 5352fcd89..9781988df 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -22,6 +22,25 @@ import type { PlSqlCallSite, PlSqlDefinition } from './extract.js';
 export interface PlSqlIndexEntry {
   readonly def: PlSqlDefinition;
   readonly filePath: string;
+  /** Schema written on the enclosing package (`CREATE PACKAGE loan.pkg`), if any. */
+  readonly packageSchema?: string;
+}
+
+/**
+ * The package a definition belongs to: the root of its `ownerIndex` chain,
+ * or — for fallback definitions without an index — the first package of
+ * that name in the same file.
+ */
+export function rootPackageOf(
+  def: PlSqlDefinition,
+  defs: readonly PlSqlDefinition[],
+): PlSqlDefinition | undefined {
+  if (def.kind === 'package') return def;
+  let current: PlSqlDefinition | undefined = def;
+  while (current?.ownerIndex !== undefined) current = defs[current.ownerIndex];
+  if (current && current !== def && current.kind === 'package') return current;
+  const pkg = def.ownerPath[0];
+  return pkg === undefined ? undefined : defs.find((d) => d.kind === 'package' && d.name === pkg);
 }
 
 const pathKey = (path: readonly string[]) => path.join('.');
@@ -100,12 +119,22 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
     call: Pick<PlSqlCallSite, 'nameParts' | 'ownerPath' | 'arity' | 'namedArguments'>,
     fromFile: string,
   ): E[] {
-    return preferImplementations(
-      nearestByPath(narrowOverloads(this.candidates(call), call), fromFile),
-    );
+    const narrowed = preferWrittenSchema(narrowOverloads(this.candidates(call), call), call);
+    return preferImplementations(nearestByPath(narrowed, fromFile));
   }
 }
 
+/** In `S.A.N`, keep members of packages declared in schema `S` when any are indexed. */
+function preferWrittenSchema<E extends PlSqlIndexEntry>(
+  candidates: E[],
+  call: Pick<PlSqlCallSite, 'nameParts'>,
+): E[] {
+  if (call.nameParts.length !== 3) return candidates;
+  const schema = call.nameParts[0];
+  const inSchema = candidates.filter((c) => c.packageSchema === schema);
+  return inSchema.length > 0 ? inSchema : candidates;
+}
+
 function narrowOverloads<E extends PlSqlIndexEntry>(
   candidates: E[],
   call: Pick<PlSqlCallSite, 'arity' | 'namedArguments'>,
@@ -134,50 +163,70 @@ function preferImplementations<E extends PlSqlIndexEntry>(defs: E[]): E[] {
 }
 
 /**
- * Pairs every package spec/body file with one package instance, keyed by its
- * home file: a spec is its own home; a body joins the nearest spec of the
- * same name (shared directory depth, then path order), or is its own home when
- * no spec is indexed. Copies of a package in unrelated folders stay separate.
+ * Pairs every package spec/body definition with one package instance: a spec
+ * is its own instance; a body joins the nearest spec of the same name whose
+ * schema is compatible (equal, or unwritten on either side), or is its own
+ * instance when no such spec is indexed. Copies of a package in unrelated
+ * folders, and same-named packages of different schemas, stay separate.
  */
 export class PlSqlPackageInstances {
+  private readonly instance = new Map<string, string>();
   private readonly home = new Map<string, string>();
 
   constructor(
     packages: ReadonlyArray<{
       readonly name: string;
+      readonly schema?: string;
       readonly filePath: string;
       readonly isSpec: boolean;
     }>,
   ) {
-    const specFiles = new Map<string, string[]>();
-    for (const p of packages) {
-      if (!p.isSpec) continue;
-      const list = specFiles.get(p.name) ?? [];
-      list.push(p.filePath);
-      specFiles.set(p.name, list);
-    }
-    for (const files of specFiles.values()) files.sort();
-    for (const p of packages) {
-      const key = `${p.name}\0${p.filePath}`;
-      if (p.isSpec || this.home.has(key)) {
-        if (p.isSpec) this.home.set(key, p.filePath);
-        continue;
-      }
-      const specs = specFiles.get(p.name);
-      this.home.set(
-        key,
-        specs
-          ? nearestByPath(
-              specs.map((filePath) => ({ filePath })),
-              p.filePath,
-            )[0]!.filePath
-          : p.filePath,
-      );
+    const specs = packages.filter((p) => p.isSpec);
+    for (const p of [...specs, ...packages.filter((q) => !q.isSpec)]) {
+      const key = entryKey(p.name, p.schema, p.filePath);
+      if (this.instance.has(key)) continue;
+      const spec = p.isSpec
+        ? p
+        : pickSpec(
+            specs.filter(
+              (s) =>
+                s.name === p.name &&
+                (s.schema === undefined || p.schema === undefined || s.schema === p.schema),
+            ),
+            p.filePath,
+            p.schema,
+          );
+      const owner = spec ?? p;
+      const id = entryKey(owner.name, owner.schema, owner.filePath);
+      this.instance.set(key, id);
+      this.home.set(id, owner.filePath);
     }
   }
 
-  /** Home file of the instance of package `name` defined (spec or body) in `filePath`. */
-  homeOf(name: string, filePath: string): string | undefined {
-    return this.home.get(`${name}\0${filePath}`);
+  /** Opaque instance id of package `name` (written schema `schema`) defined in `filePath`. */
+  instanceOf(name: string, schema: string | undefined, filePath: string): string {
+    return this.instance.get(entryKey(name, schema, filePath)) ?? entryKey(name, schema, filePath);
+  }
+
+  /** File that anchors an instance (its spec when indexed). */
+  homeOf(instanceId: string): string | undefined {
+    return this.home.get(instanceId);
   }
 }
+
+function entryKey(name: string, schema: string | undefined, filePath: string): string {
+  return `${name}\0${schema ?? ''}\0${filePath}`;
+}
+
+/** Nearest compatible spec; an exact schema match wins a distance tie, then path order. */
+function pickSpec<S extends { filePath: string; schema?: string }>(
+  specs: readonly S[],
+  fromFile: string,
+  schema: string | undefined,
+): S | undefined {
+  const nearest = nearestByPath(specs, fromFile);
+  const exact = nearest.filter((s) => s.schema === schema);
+  return [...(exact.length > 0 ? exact : nearest)].sort((a, b) =>
+    a.filePath < b.filePath ? -1 : a.filePath > b.filePath ? 1 : 0,
+  )[0];
+}
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index a151476be..fff3c5c7c 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -116,6 +116,28 @@ END pkg_x;
     expect(names.some((n) => n.startsWith('PKG_X.A'))).toBe(true);
   });
 
+  it('counts lexer errors, so a segment with an unlexable character is degraded', () => {
+    const f = extractPlSqlFacts('CREATE PROCEDURE p IS BEGIN x := 1 ` 2; END;\n/\n');
+    expect(f.segmentsWithErrors).toBe(1);
+  });
+
+  it('places fallback subprograms under the routine whose END span contains them', () => {
+    const f = extractPlSqlFacts(`CREATE OR REPLACE PACKAGE BODY pkg_x AS
+  PROCEDURE outer_p IS
+    PROCEDURE inner_p IS BEGIN this is not plsql; END inner_p;
+  BEGIN
+    inner_p;
+  END outer_p;
+  PROCEDURE other_p IS BEGIN NULL; END other_p;
+END pkg_x;
+/
+`);
+    expect(f.segmentsWithErrors).toBe(1);
+    const paths = f.definitions.map((d) => [...d.ownerPath, d.name].join('.'));
+    expect(paths).toContain('PKG_X.OUTER_P.INNER_P');
+    expect(paths).not.toContain('PKG_X.INNER_P');
+  });
+
   it('keeps one segment per `/`-terminated unit so an error stays local', () => {
     const f = extractPlSqlFacts(
       'CREATE PROCEDURE ok1 IS BEGIN NULL; END;\n/\nCREATE PROCEDURE bad IS BEGIN ((( END;\n/\nCREATE PROCEDURE ok2 IS BEGIN NULL; END;\n/\n',
@@ -147,6 +169,12 @@ describe('file classification', () => {
       false,
     );
     expect(looksLikeOraclePlSql('SELECT * FROM t;')).toBe(false);
+    // `IS` after the header is Oracle-only, no other marker needed.
+    expect(looksLikeOraclePlSql('CREATE PROCEDURE p IS BEGIN NULL; END;')).toBe(true);
+    // T-SQL without GO: `AS` header, `IS NULL` only inside the body.
+    expect(
+      looksLikeOraclePlSql('CREATE PROCEDURE p @x int AS\nBEGIN\n  IF @x IS NULL RETURN;\nEND'),
+    ).toBe(false);
     // MySQL: no IS/AS before BEGIN, even with an Oracle-looking marker in a comment.
     expect(
       looksLikeOraclePlSql(
diff --git a/gitnexus/test/unit/plsql-preprocess.test.ts b/gitnexus/test/unit/plsql-preprocess.test.ts
index a2e254ce8..6cb744101 100644
--- a/gitnexus/test/unit/plsql-preprocess.test.ts
+++ b/gitnexus/test/unit/plsql-preprocess.test.ts
@@ -96,6 +96,15 @@ describe('neutraliseSubstitutionVariables', () => {
   });
 });
 
+describe('positional substitution', () => {
+  it('neutralises &1 / &&2 at equal length', () => {
+    const src = 'SELECT * FROM t WHERE id = &1 AND d = &&2.;';
+    const out = neutraliseSubstitutionVariables(src);
+    expect(out).toBe('SELECT * FROM t WHERE id = Z1 AND d = ZZ2 ;');
+    expect(out.length).toBe(src.length);
+  });
+});
+
 describe('resolveConditionalCompilation', () => {
   it('keeps the first branch, blanks directives and other branches, preserves layout', () => {
     const src = [
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index 84c40665a..257c5f9d5 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -105,6 +105,32 @@ END p;
     }
   });
 
+  it('keeps same-named packages of different schemas apart and honours S.A.N calls', () => {
+    const { graph } = run({
+      'db/schemas.pck': `CREATE OR REPLACE PACKAGE a.pkg AS PROCEDURE f; END pkg;
+/
+CREATE OR REPLACE PACKAGE BODY a.pkg AS PROCEDURE f IS BEGIN NULL; END f; END pkg;
+/
+CREATE OR REPLACE PACKAGE b.pkg AS PROCEDURE f; END pkg;
+/
+CREATE OR REPLACE PACKAGE BODY b.pkg AS PROCEDURE f IS BEGIN NULL; END f; END pkg;
+/
+CREATE OR REPLACE PROCEDURE caller IS BEGIN b.pkg.f; END caller;
+/
+`,
+    });
+    let modules = 0;
+    graph.forEachNode((n) => {
+      if (n.label === 'Module') modules++;
+    });
+    expect(modules).toBe(2);
+    const targets: number[] = [];
+    for (const r of graph.iterRelationships()) {
+      if (r.type === 'CALLS') targets.push(graph.getNode(r.targetId)!.properties.startLine! + 1);
+    }
+    expect(targets).toEqual([7]); // b.pkg body, not a.pkg
+  });
+
   it('does not lose PL/SQL statements when the CREATE header is split across lines', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE
@@ -126,8 +152,8 @@ END p;
 
 describe('segment deadline', () => {
   it('scales with segment size above the floor', () => {
-    expect(segmentDeadlineMs(10)).toBe(SEGMENT_DEADLINE_FLOOR_MS);
-    expect(segmentDeadlineMs(4_000)).toBeGreaterThan(30_000);
+    expect(segmentDeadlineMs(10, SEGMENT_DEADLINE_FLOOR_MS)).toBe(SEGMENT_DEADLINE_FLOOR_MS);
+    expect(segmentDeadlineMs(4_000, SEGMENT_DEADLINE_FLOOR_MS)).toBeGreaterThan(30_000);
     expect(segmentDeadlineMs(4_000, 0)).toBe(Number.POSITIVE_INFINITY);
   });
 });

From dc27703e9ad8e5cab39d0f8ba5617c185a4e98b4 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Fri, 30 Oct 2026 18:51:36 +0800
Subject: [PATCH 04/17] fix(plsql): lazy-load the parser and address third
 review round

Performance
- load the ANTLR parser and fact extractor on demand: nothing the provider
  registry, parse workers or scope resolver import reaches the ~14 MB
  generated parser any more (registry load 568 ms / 241 MB -> 426 ms /
  104 MB in every process). The plsql phase loads it only when a repo holds
  PL/SQL; rename awaits it; other sync callers fall back to require(esm).
  A structural test keeps those modules type-only importers.

Review fixes
- rename refuses when a SQL*Plus command (`EXEC pkg.proc`) names the target
- Oracle triggers are recognised by Oracle-only bodies (:NEW./:OLD.,
  COMPOUND TRIGGER, `/`), not by the header PostgreSQL and MySQL share
- a `;` followed by a block comment ends a statement in the SQL*Plus pass
- overload fitting maps positional + named arguments onto parameters and
  requires every non-defaulted parameter; known mismatches yield no edge
- UNC and drive paths are rejected as script includes; `@@` resolves
  against the calling script only, `@`/START against the repo root first
- owner-path keys and signature keys stay distinct for quoted names that
  contain a dot

CI coverage found while re-checking
- bench/import-target gains a plsql arm and baseline (the inventory guard
  fails for a registered language without one)
- rename-provider-plsql joins the cross-platform test list
- ARCHITECTURE.md language count

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 ARCHITECTURE.md                               |  2 +-
 docs/languages/plsql-ingestion-gaps.md        |  1 +
 gitnexus/bench/import-target/baselines.json   | 67 +++++++++++++++++--
 gitnexus/bench/import-target/measure.mjs      | 47 +++++++++++++
 gitnexus/scripts/cross-platform-tests.ts      |  1 +
 .../ingestion/languages/plsql/captures.ts     | 13 ++--
 .../ingestion/languages/plsql/interpret.ts    |  3 +-
 .../core/ingestion/languages/plsql/rename.ts  | 34 +++++-----
 .../core/ingestion/pipeline-phases/plsql.ts   |  4 +-
 .../src/core/ingestion/plsql-processor.ts     |  7 +-
 gitnexus/src/core/ingestion/plsql/extract.ts  | 47 ++++++++++---
 .../src/core/ingestion/plsql/facts-store.ts   | 54 ++++++++++++---
 .../src/core/ingestion/plsql/file-types.ts    |  9 ++-
 gitnexus/src/core/ingestion/plsql/names.ts    | 11 +++
 gitnexus/src/core/ingestion/plsql/parse.ts    |  4 +-
 .../src/core/ingestion/plsql/preprocess.ts    |  3 +-
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 40 ++++++++---
 .../core/ingestion/plsql/script-include.ts    | 34 ++++++----
 .../refuse-sqlplus-exec/after/deploy.sql      |  7 ++
 .../refuse-sqlplus-exec/after/pkg_job.pkb     |  9 +++
 .../refuse-sqlplus-exec/before/deploy.sql     |  7 ++
 .../refuse-sqlplus-exec/before/pkg_job.pkb    |  9 +++
 .../plsql/refuse-sqlplus-exec/case.json       | 16 +++++
 gitnexus/test/unit/plsql-extract.test.ts      | 25 +++++++
 gitnexus/test/unit/plsql-lazy-parser.test.ts  | 55 +++++++++++++++
 gitnexus/test/unit/plsql-preprocess.test.ts   |  9 +++
 gitnexus/test/unit/plsql-processor.test.ts    | 57 +++++++++++++++-
 27 files changed, 500 insertions(+), 75 deletions(-)
 create mode 100644 gitnexus/src/core/ingestion/plsql/names.ts
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/deploy.sql
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/pkg_job.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/deploy.sql
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/pkg_job.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/case.json
 create mode 100644 gitnexus/test/unit/plsql-lazy-parser.test.ts

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index f4b9be85b..84635f3b0 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -515,7 +515,7 @@ CI auto-discovers the set via `tsx`. No workflow edit required.
 
 ## Language-agnostic graph feeding
 
-18 languages → single unified graph. Four abstraction layers:
+19 languages → single unified graph. Four abstraction layers:
 
 ```
  Unified Graph Schema (44 node types, 21 relationship types)
diff --git a/docs/languages/plsql-ingestion-gaps.md b/docs/languages/plsql-ingestion-gaps.md
index 526bcc16f..87857bcc5 100644
--- a/docs/languages/plsql-ingestion-gaps.md
+++ b/docs/languages/plsql-ingestion-gaps.md
@@ -62,6 +62,7 @@ package/procedure/function/trigger files parse without syntax errors; about
 | PLSQL-06  | Identity                | Tables are keyed by unqualified name; same-named tables in two schemas merge.                        | Key by `SCHEMA.TABLE` when written and reconcile unqualified references through synonyms / current schema.             |
 | PLSQL-07  | Performance             | The phase runs on the main thread before parse: the corpus above (618 claimed files, 121k lines) takes ~60 s cold in one process; facts are shared with scope extraction within a run but not persisted across runs. | Move segment parsing to workers (one warm ANTLR DFA each); persist extracted facts in the parse cache keyed by content hash so incremental runs skip unchanged files.                         |
 | PLSQL-09  | Overload fan-out        | Overloads that differ only by parameter type (e.g. utPLSQL `ut.expect`) cannot be narrowed by arity, so each call gets one 0.5-confidence edge per candidate (3,170 ambiguous sites on the corpus after path-proximity narrowing). | Infer argument types from literals and declared variables/parameters; narrow by declared parameter types. |
+| PLSQL-13  | SQL*Plus-only scripts   | A `.sql` file holding only SQL*Plus commands (e.g. `EXEC pkg.proc;`), with no Oracle unit or include, is not claimed because `EXEC` is also T-SQL; rename cannot see such a caller. Rename does refuse when a claimed file's SQL*Plus command names the target. | Claim such scripts when they sit in a tree that holds Oracle sources, or parse `EXEC` bodies as call sites. |
 | PLSQL-11  | Cross-language rename   | Java/Kotlin/XML code that calls procedures by string (`{call pkg.proc(?)}`, MyBatis `CALLABLE`) is not consulted by rename. | Implement the rename interop hooks, or refuse when a non-PL/SQL source mentions the qualified name.                      |
 | PLSQL-12  | Incremental identity    | Table `Record` and merged package `Module` nodes are anchored to one file although derived from several. | Add an edit-one-file incremental-analyze test; give synthetic objects a stable anchor if writeback drops them.            |
 | PLSQL-10  | Impact on tables        | `impact` adds `ACCESSES` by default only for `Class`/`Interface` targets, so a table needs `relationTypes: ['ACCESSES', …]` to list its readers and writers. | Agree with maintainers whether `Record` targets should get the same default.                                              |
diff --git a/gitnexus/bench/import-target/baselines.json b/gitnexus/bench/import-target/baselines.json
index ab34328ac..d59255f4b 100644
--- a/gitnexus/bench/import-target/baselines.json
+++ b/gitnexus/bench/import-target/baselines.json
@@ -2,6 +2,7 @@
   "_what": "Baselines for bench/import-target/measure.mjs cover every import-target resolver registered in SCOPE_RESOLVERS on a shared corpus, plus a configured C# arm for the branch the default call cannot reach. measure.mjs derives its arm inventory from LANG_REGISTRY and --check reconciles the registered languages in both directions. The single PHP arm supplies its production PSR-4 Composer mapping; csharp_csproj supplies csproj configuration. C and C++ also receive their production resolutionConfig header corpus. The timing, shape, fingerprint, context, and retained-heap gates therefore cover each production resolver path without splitting PHP into configured and unconfigured identities.",
   "_rebaselined_2960_kotlin_declared_packages": "Kotlin now resolves only from parsed package facts and local module bindings. This deliberately changes its five fingerprints, removes path-depth sensitivity, adds the context probe, and reduces the 32000-file retained index from 40.82 MiB to 4.31 MiB. External same-name path decoys now remain unresolved.",
   "_zig_arm_1432": "zig was registered in SCOPE_RESOLVERS by PR #1432 with no arm here, which is the exact hole the inventory arm exists for, and it reported it. The arm passes NO build config: resolveZigImportInternal walks an importer-relative @import path component by component and probes allFiles.has() twice (as spelled, then + '.zig'), so its fingerprints pin that walk alone and do not move when build.zig / build.zig.zon parsing (the bare-name legs, gated by test/unit/zig-import-resolver.test.ts) changes. Same corpus proportions as rust — 979 of 3200 resolve at 400 files — and rust's collide design, a deep tree whose spellings carry thirteen components against the unique arm's three, because component count is the only axis the cost has. Measured on one box: small 1.036 ms, collide 1.700 ms, scaling 1.050, collide scaling 1.011, depth 1.573; budgets take the file's usual ~1.5x on ratios (2.4 depth) and ~4x on absolute ms (4 / 7). Heap reads 16 B at both 8000 and 32000 files — it builds nothing, exactly rust's reading — so it sits in heap_bound_bytes at rust's absolute 1048576 B.",
+  "_plsql_arm_3772": "plsql was registered in SCOPE_RESOLVERS by PR #3772. Its import sites are SQL*Plus script includes: resolvePlSqlScriptInclude probes allFilePaths.has() on at most four exact candidates (repository root, then the calling script's directory; as spelled, then + '.sql') and never searches, so it takes zig's corpus proportions and collide design (a deep tree, thirteen components against three). ORACLE_HOME scripts (?/rdbms/admin/...) are rejected before any probe. Measured on one box: small 1.379 ms, collide 2.354 ms, scaling 1.015, collide scaling 1.018, depth 1.687; budgets take the file's usual ~1.5x on ratios (2.6 depth) and ~4x on absolute ms (6 / 10). Heap reads 16 B at both 8000 and 32000 files - it builds nothing - so it sits in heap_bound_bytes at zig's absolute 1048576 B.",
   "_objc_arm_3179": "Objective-C resolves local header and source imports through a cached suffix map. The map preserves the previous first-path tie-break, which is covered directly in objective-c-provider.test.ts. This arm covers the registered resolver's five dispatch paths, including the depth-sensitive index construction and a collision layout. Measured on this branch: small 1.844 ms, collide 1.861 ms, scaling 1.111, collide scaling 1.067, depth 2.779, and 44101944 retained bytes. The 3.6 depth budget allows normal timing variation while remaining below a full per-import file scan; collision scaling stays at the shared linear 1.8 budget because suffix lookup is keyed.",
   "_cobol_copybook_dir_preference_2967": "COBOL now prefers well-known copybook directories (copybooks/, cpy/, copy/, plus importer dir) over vendor paths when resolving COPY statements, so COPY EXTERNAL no longer hits same-named decoys outside the project structure. This intentional behavior change moves the resolver from depth-free (prior measured ~0.885) to depth-sensitive (measured 1.751 on CI), because the new preferredCopybookDirs check walks path components. The 2.4 depth budget is ~1.37x the measured ratio, consistent with the ~1.5x convention for depth arms. The unique-arm fingerprints and resolved counts change to reflect the new target set: small/deep drop from 1153 to 442 resolved because files outside preferred directories are now correctly filtered. The collide arm (svc${d}/copybooks layout) keeps 1153 resolved because ALL its files are in preferred copybook directories, so the filter does not change its resolution outcomes — the collide arm now measures collision behavior within the preferred class rather than across mixed layouts. Fixes #2967.",
   "_php_composer_gate_2962": "The canonical PHP arm supplies an authoritative App PSR-4 mapping. A deterministic Vendor0 suffix decoy makes deletion of the external gate change every timing fingerprint, while the heap arm separately pins a mapped miss, the rendered mapping, and the external null result. Three serial samples measured depth ratios 1.058, 1.114, and 1.158; the 1.8 budget is 1.55x the observed maximum. The mapped-miss heap reading peaked at 39607216 retained bytes at 32000 files.",
@@ -31,7 +32,8 @@
     "c": 3.8,
     "cpp": 4,
     "objc": 1.8,
-    "zig": 1.8
+    "zig": 1.8,
+    "plsql": 1.8
   },
   "depth_budget": {
     "go": 1.4,
@@ -52,7 +54,8 @@
     "c": 3,
     "cpp": 3,
     "objc": 3.6,
-    "zig": 2.4
+    "zig": 2.4,
+    "plsql": 2.6
   },
   "small_ms_ceiling": {
     "go": 7,
@@ -73,7 +76,8 @@
     "c": 7,
     "cpp": 7,
     "objc": 8,
-    "zig": 4
+    "zig": 4,
+    "plsql": 6
   },
   "collide_ms_ceiling": {
     "go": 28,
@@ -94,7 +98,8 @@
     "c": 11,
     "cpp": 12,
     "objc": 8,
-    "zig": 7
+    "zig": 7,
+    "plsql": 10
   },
   "heap_ceiling_bytes": {
     "rust": 31300000,
@@ -135,7 +140,8 @@
     "javascript": 1048576,
     "typescript": 1048576,
     "vue": 1048576,
-    "zig": 1048576
+    "zig": 1048576,
+    "plsql": 1048576
   },
   "heap_floor_fraction": 0.5,
   "heap_ratio_budget": 1.25,
@@ -1162,6 +1168,57 @@
         "scaling_ratio": 1.05,
         "small_ms": 1.036
       }
+    },
+    "plsql": {
+      "small": {
+        "files": 400,
+        "imports": 3200,
+        "resolved": 979,
+        "distinct_outcomes": 2997,
+        "fingerprint": "dcf564b77271c71148ce5e93d29c3f35a378a6c28a659f8f85cbaa703dcba783"
+      },
+      "large": {
+        "files": 1600,
+        "imports": 12800,
+        "resolved": 4064,
+        "distinct_outcomes": 11934,
+        "fingerprint": "d1a44689c312e5ebb911cda66ee7a813a308c0e8eecc369248b8f74cf108b93a"
+      },
+      "deep": {
+        "files": 400,
+        "imports": 3200,
+        "resolved": 979,
+        "distinct_outcomes": 2997,
+        "fingerprint": "0ccb52824580a94f0ee27d5398b0a696059781086375fb9a4bfafc51690a71ec"
+      },
+      "collide": {
+        "files": 400,
+        "imports": 3200,
+        "resolved": 979,
+        "distinct_outcomes": 2997,
+        "fingerprint": "0211995236c0c561e2d2d87c235cba2a7fab95c6dcdde4689ad67908b9e8bd41"
+      },
+      "collide_large": {
+        "files": 1600,
+        "imports": 12800,
+        "resolved": 4064,
+        "distinct_outcomes": 11934,
+        "fingerprint": "a9e28b724981fdf0312d90ca9ccc6f070f02dfa1ac7c8552c9febd3cd3dacbdc"
+      },
+      "fingerprint": "d1a44689c312e5ebb911cda66ee7a813a308c0e8eecc369248b8f74cf108b93a",
+      "heap": {
+        "files_small": 8000,
+        "files_large": 32000,
+        "path_segments": 11,
+        "probe": "../vendor0/missing.sql"
+      },
+      "_measured": {
+        "collide_ms": 2.354,
+        "collide_scaling_ratio": 1.018,
+        "depth_ratio": 1.687,
+        "scaling_ratio": 1.015,
+        "small_ms": 1.379
+      }
     }
   },
   "_blind_spot": "MEASURED, so nobody has to rediscover it: a full workspace scan reintroduced on 1-in-32 imports passes EVERY arm here \u2014 dart scored 1.458 scaling and 1.736 ms against the 1.8 budget and 4 ms ceiling of an earlier revision. At 1-in-8 the scaling arm catches it (2.414). The gate that NARROWS this is not a timing gate at all: test/unit/scope-resolution/import-target-index-parity.test.ts counts iterations of the file-set Set and reads 14 instead of 1 for that same 1-in-32 mutation, deterministically and for all five languages. It does NOT close it. The counter watches the Set, and the resolvers no longer read the Set \u2014 they read materialized copies of the same file list: WorkspaceFileIndex.normalized and .all (C#, Ruby), Dart's byBasename buckets, and PackageDirIndex.filesByDir (Go, C#). A 1-in-32 scan over any of those three touches the Set zero extra times, so it passes the parity test AND passes --check. Closing it would take an iteration counter on the materialized arrays themselves. Read the two gates together; tightening these ceilings toward the noise floor to chase that case would only buy flaky CI. CONFIRMED THE HARD WAY by PR #2911: JavaScript resolution was scanning ImportPassCache.normalizedFileList on every import \u2014 a materialized array, not the Set \u2014 at 25972 us per import at 8000 files, and no instrument on the #2901-#2909 branch could see it. It took a differential parity test over 211200 old-vs-new pairs to find. The arms added here would have caught THAT one on absolute ms (85 ms budget against a 20 ms arm; the unindexed resolver costs ~83000 ms on the same corpus), which is the argument for gating every registered language rather than only the ones a PR happens to touch. THE SECOND BLIND SPOT IS CLOSED, and this records what closing it changed. This harness used to call the inner resolvers with the NO-CONTEXT shape: run.ts calls provider.resolveImportTarget with five arguments, the fifth being { parsedFiles, parsedImport }, and resolveOne supplied three. resolveOne now makes the production call, newPass mints the ParsedFile[] FIRST and derives the path set from it exactly as run.ts does, and both legs behind the argument run on every import of their arms \u2014 PHP's named/alias function-or-const leg over filesByDirectory(context.parsedFiles), whose memo defeated measures 197.0 us -> 9976.2 us per import (50.6x), and Python's from-import submodule-precedence branch, the only spelling that reads context.parsedFiles at all. Fifteen of the seventeen arms cannot observe a context (their hooks declare three or four parameters) and are handed none, so their numbers did not move; which two CAN is now reconciled against SCOPE_RESOLVERS' hook arity rather than asserted in prose. NOTHING ELSE IN THIS FILE COULD HAVE GATED IT, which is why the context arm exists: fingerprints and shape can remain unchanged while dropping context only makes timing faster. The deterministic context arm is therefore the guard for this wiring. The arm is one import per language resolved through resolveOne twice, with and without the pass's parsedFiles, whose two answers must DIFFER and must both match what is recorded. WHAT REMAINS UNMEASURED, narrowed rather than deleted: Python's parsedFileByPath memo is exercised by the five timing arms and cannot be reached by the heap arm at all, because retainedPassBytes requires a probe that MISSES while every path that builds that memo returns a non-null packageTarget \u2014 so no ceiling bounds that Map (one pointer per parsed file, O(files), no depth term) and the contract test's count gate is what holds it to one build per pass. PHP's sole arm carries a representative Composer PSR-4 map, so mapped hits and authoritative misses exercise that production branch directly. And the const tail of PHP's leg is a different ANSWER at the same cost \u2014 it runs the identical candidate gather and localDefs filter and diverges in the last two lines \u2014 so it is gated by count in test/unit/scope-resolution/import-target-index-reuse.contract.test.ts, which stays the gate to read alongside this file.",
diff --git a/gitnexus/bench/import-target/measure.mjs b/gitnexus/bench/import-target/measure.mjs
index a4d87ba38..be0a2ee65 100644
--- a/gitnexus/bench/import-target/measure.mjs
+++ b/gitnexus/bench/import-target/measure.mjs
@@ -486,6 +486,7 @@ import { cobolScopeResolver } from '../../src/core/ingestion/languages/cobol/sco
 import { resolveSwiftImportTarget } from '../../src/core/ingestion/languages/swift/import-target.ts';
 import { resolveRustImportTarget } from '../../src/core/ingestion/languages/rust/import-target.ts';
 import { resolveZigImportInternal } from '../../src/core/ingestion/languages/zig/import-helpers.ts';
+import { resolvePlSqlScriptInclude } from '../../src/core/ingestion/plsql/script-include.ts';
 import { resolvePythonImportTarget } from '../../src/core/ingestion/languages/python/import-target.ts';
 import { makeJsResolveImportTarget } from '../../src/core/ingestion/languages/javascript/import-target.ts';
 import { makeVueResolveImportTarget } from '../../src/core/ingestion/languages/vue/import-target.ts';
@@ -788,6 +789,7 @@ const EXTENSION = {
   cpp: '.cpp',
   objc: '.m',
   zig: '.zig',
+  plsql: '.sql',
 };
 /** C and C++ resolve `#include` against HEADERS, which reach the resolver
  *  through `resolutionConfig` rather than through `allFilePaths` — see
@@ -920,6 +922,9 @@ function uniqueDir(lang, d, i) {
   // share the other unique arms take from a nested directory comes from the
   // target instead (see `uniqueTarget`).
   if (lang === 'zig') return `src/mod${d}`;
+  // SQL*Plus install trees: one folder per component under `db/`, so a
+  // script reaches a sibling through one `..` (see `uniqueTarget`).
+  if (lang === 'plsql') return `db/mod${d}`;
   throw unwiredLanguage('uniqueDir', lang);
 }
 
@@ -1015,6 +1020,10 @@ function collideDir(lang, d, i) {
   // axis that CAN grow — `collideTarget` spells its imports up through the
   // tree and back down, ~4x the components of the unique arm.
   if (lang === 'zig') return `src/l0/l1/l2/l3/l4/mod${d}`;
+  // zig's reasoning: the resolver probes `.has()` on at most four candidates
+  // (two bases × with/without `.sql`) and never searches, so path depth is
+  // the only axis its cost can grow along.
+  if (lang === 'plsql') return `db/l0/l1/l2/l3/l4/mod${d}`;
   throw unwiredLanguage('collideDir', lang);
 }
 
@@ -1467,6 +1476,25 @@ function uniqueTarget(lang, { local, r, d, j, dirs }) {
     if (miss === 1) return `ghost${(r >>> 4) % 97}`;
     return `../vendor${(r >>> 4) % 97}/missing.zig`;
   }
+  if (lang === 'plsql') {
+    // SQL*Plus `@file` / `START file`: tried against the repository root, then
+    // the calling script's directory. Every script sits in `db/mod{d}/`, so
+    // `../mod{n}/…` misses at the root (it climbs out of the repo) and hits
+    // from the caller — both bases are walked for every local include. The
+    // `d % 7` slice names an `inner/` that exists nowhere and misses; one
+    // spelling in three drops `.sql`, which is the appended-extension leg.
+    // Misses: ORACLE_HOME scripts (`?/rdbms/admin/…`, rejected before any
+    // probe), a bare vendor script that is in neither base, and a relative
+    // path to a vendored script outside the corpus.
+    if (local) {
+      if (d % 7 === 0) return `../mod${d}/inner/file${j}.sql`;
+      return (r >>> 3) % 3 === 0 ? `../mod${j % dirs}/file${j}` : `../mod${j % dirs}/file${j}.sql`;
+    }
+    const miss = (r >>> 3) % 3;
+    if (miss === 0) return ['?/rdbms/admin/utlrp.sql', '?/rdbms/admin/catproc.sql'][(r >>> 4) % 2];
+    if (miss === 1) return `vendor_patch${(r >>> 4) % 97}`;
+    return `../vendor${(r >>> 4) % 97}/missing.sql`;
+  }
   throw unwiredLanguage('uniqueTarget', lang);
 }
 
@@ -1700,6 +1728,21 @@ function collideTarget(lang, { local, r, d, j, dirs }) {
     if (miss === 1) return `ghost${(r >>> 4) % 97}`;
     return `${up}/vendor${(r >>> 4) % 97}/missing.zig`;
   }
+  if (lang === 'plsql') {
+    // zig's collide design: the same families in the same proportions, spelled
+    // up to `db/` and back down through `l0/…/l4`.
+    const up = '../../../../../../l0/l1/l2/l3/l4';
+    if (local) {
+      if (d % 7 === 0) return `${up}/mod${d}/inner/file${j}.sql`;
+      return (r >>> 3) % 3 === 0
+        ? `${up}/mod${j % dirs}/file${j}`
+        : `${up}/mod${j % dirs}/file${j}.sql`;
+    }
+    const miss = (r >>> 3) % 3;
+    if (miss === 0) return ['?/rdbms/admin/utlrp.sql', '?/rdbms/admin/catproc.sql'][(r >>> 4) % 2];
+    if (miss === 1) return `vendor_patch${(r >>> 4) % 97}`;
+    return `${up}/vendor${(r >>> 4) % 97}/missing.sql`;
+  }
   throw unwiredLanguage('collideTarget', lang);
 }
 
@@ -1931,6 +1974,7 @@ function resolveOne(lang, from, target, pass) {
   // `null` build config: this arm pins the path walk alone
   // (see the header); the config legs are gated by their own unit tests.
   if (lang === 'zig') return resolveZigImportInternal(from, target, allFilePaths, null);
+  if (lang === 'plsql') return resolvePlSqlScriptInclude(target, from, allFilePaths);
   if (lang === 'python') {
     // `from <target> import X` — the spelling the orchestrator actually hands
     // the provider, and the ONLY one that reads `context.parsedFiles`: a
@@ -2243,6 +2287,8 @@ const HEAP_PROBE_TARGET = {
   // miss after the full component walk, which is the longest leg the resolver
   // has (a by-name miss returns before any walk).
   zig: '../vendor0/missing.zig',
+  // Both bases and both spellings probed and missed — the longest leg.
+  plsql: '../vendor0/missing.sql',
   typescript: 'vendor0/lib/missing',
   vue: 'vendor0/lib/Missing.vue',
   cpp: 'vendor0/missing.hpp',
@@ -2662,6 +2708,7 @@ const LANG_REGISTRY = {
   cpp: SupportedLanguages.CPlusPlus,
   objc: SupportedLanguages.ObjectiveC,
   zig: SupportedLanguages.Zig,
+  plsql: SupportedLanguages.PlSql,
 };
 const LANGS = Object.keys(LANG_REGISTRY);
 /**
diff --git a/gitnexus/scripts/cross-platform-tests.ts b/gitnexus/scripts/cross-platform-tests.ts
index f12441517..4194d23aa 100644
--- a/gitnexus/scripts/cross-platform-tests.ts
+++ b/gitnexus/scripts/cross-platform-tests.ts
@@ -184,6 +184,7 @@ const LBUG_NATIVE = [
   'test/integration/rename-provider-kotlin.test.ts',
   'test/integration/rename-provider-objective-c.test.ts',
   'test/integration/rename-provider-php.test.ts',
+  'test/integration/rename-provider-plsql.test.ts',
   'test/integration/rename-provider-python.test.ts',
   'test/integration/rename-provider-ruby.test.ts',
   'test/integration/rename-provider-rust.test.ts',
diff --git a/gitnexus/src/core/ingestion/languages/plsql/captures.ts b/gitnexus/src/core/ingestion/languages/plsql/captures.ts
index 11bbd73d8..253fd70af 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/captures.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/captures.ts
@@ -18,11 +18,7 @@
  */
 
 import type { Capture, CaptureMatch, Range } from 'gitnexus-shared';
-import {
-  type PlSqlDefinition,
-  type PlSqlFileFacts,
-  type PlSqlNameToken,
-} from '../../plsql/extract.js';
+import type { PlSqlDefinition, PlSqlFileFacts, PlSqlNameToken } from '../../plsql/extract.js';
 import { plsqlFactsForFile } from '../../plsql/facts-store.js';
 
 function capture(name: string, range: Range, text: string): Capture {
@@ -137,7 +133,12 @@ export function emitPlSqlScopeCaptures(
     };
     out.push({
       '@import.statement': capture('@import.statement', r, include.target),
-      '@import.name': capture('@import.name', r, include.target),
+      // `@@` marks a script-relative include for resolveImportTarget.
+      '@import.name': capture(
+        '@import.name',
+        r,
+        include.relativeToScript ? `@@${include.target}` : include.target,
+      ),
     });
   }
 
diff --git a/gitnexus/src/core/ingestion/languages/plsql/interpret.ts b/gitnexus/src/core/ingestion/languages/plsql/interpret.ts
index 812d7ae14..b36436638 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/interpret.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/interpret.ts
@@ -20,7 +20,8 @@ import type {
 export function interpretPlSqlImport(match: CaptureMatch): ParsedImport | null {
   const name = match['@import.name']?.text;
   if (!name) return null;
-  return { kind: 'named', localName: name, importedName: name, targetRaw: name };
+  const bare = name.replace(/^@@/, '');
+  return { kind: 'named', localName: bare, importedName: bare, targetRaw: name };
 }
 
 /** Script inclusion is file-level: it binds in the file's Module scope. */
diff --git a/gitnexus/src/core/ingestion/languages/plsql/rename.ts b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
index 7d911df7b..7efdeff9d 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/rename.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/rename.ts
@@ -15,7 +15,6 @@
  * appears in dynamic SQL text or in a segment the grammar could not parse.
  */
 
-import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import type { Range, SymbolDefinition } from 'gitnexus-shared';
 import type {
   RenameIssue,
@@ -24,13 +23,10 @@ import type {
   RenameSource,
 } from '../../rename-provider.js';
 import { extractParsedFile } from '../../scope-extractor-bridge.js';
-import { PlSqlLexer } from '../../plsql/generated/PlSqlLexer.js';
 import { preprocessPlSql } from '../../plsql/preprocess.js';
-import {
-  normaliseIdentifier,
-  type PlSqlDefinition,
-  type PlSqlFileFacts,
-} from '../../plsql/extract.js';
+import type { PlSqlDefinition, PlSqlFileFacts } from '../../plsql/extract.js';
+import { loadPlSqlParser, plsqlLexTokens } from '../../plsql/facts-store.js';
+import { normaliseIdentifier } from '../../plsql/names.js';
 import { PlSqlPackageInstances, plsqlSignatureKey, rootPackageOf } from '../../plsql/resolve.js';
 import { plsqlFactsFor, plsqlNameRange, plsqlRangeKey, plsqlTokenRange } from './captures.js';
 
@@ -82,7 +78,8 @@ export const plsqlRenameProvider: RenameProvider = {
     );
   },
 
-  parseSource({ filePath, content, languageProvider }) {
+  async parseSource({ filePath, content, languageProvider }) {
+    await loadPlSqlParser();
     const facts = plsqlFactsFor(content, filePath);
     const parsed = extractParsedFile(languageProvider, content, filePath);
     if (!parsed)
@@ -104,14 +101,9 @@ export const plsqlRenameProvider: RenameProvider = {
 
     // Pre-processing keeps every line and column of the remaining text, so
     // token positions map straight back onto the original content.
-    const lexer = new PlSqlLexer(CharStream.fromString(preprocessPlSql(content)));
-    lexer.removeErrorListeners();
-    const stream = new CommonTokenStream(lexer);
-    stream.fill();
     const occurrences = new Map<string, RenameOccurrence>();
-    for (const token of stream.getTokens()) {
-      if (token.channel !== Token.DEFAULT_CHANNEL || token.type === Token.EOF) continue;
-      const text = token.text ?? '';
+    for (const token of plsqlLexTokens(preprocessPlSql(content))) {
+      const text = token.text;
       if (!IDENTIFIER_TOKEN.test(text)) continue;
       const range: Range = {
         startLine: token.line,
@@ -194,6 +186,18 @@ export const plsqlRenameProvider: RenameProvider = {
         return unsupported(
           `${target.name} appears in dynamic SQL at ${file.path}:${dynamic.line}; rename cannot rewrite it safely.`,
         );
+      // SQL*Plus client commands (`EXEC pkg.proc(…)`) are removed before
+      // parsing, so the names they mention are invisible to the occurrence
+      // inventory; refuse instead of leaving them stale.
+      // Script includes name files, not identifiers (`@@pkg_log.pks`).
+      const includeLines = new Set(facts.scriptIncludes.map((inc) => inc.line));
+      const command = facts.sqlplusCommands.find(
+        (c) => !includeLines.has(c.line) && word.test(c.text),
+      );
+      if (command)
+        return unsupported(
+          `${target.name} appears in a SQL*Plus command at ${file.path}:${command.line}; rename cannot rewrite client commands.`,
+        );
       if (facts.segmentsWithErrors > 0 && word.test(file.content)) {
         return unsupported(
           `${file.path} has PL/SQL the grammar could not fully parse and mentions ${target.name}.`,
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
index 002b3e265..fee9e7acd 100644
--- a/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
+++ b/gitnexus/src/core/ingestion/pipeline-phases/plsql.ts
@@ -15,7 +15,7 @@ import type { PipelinePhase, PipelineContext, PhaseResult } from './types.js';
 import { getPhaseOutput } from './types.js';
 import { processPlSql, isPlSqlSource } from '../plsql-processor.js';
 import { hasPlSqlExtension, isSqlFile } from '../plsql/file-types.js';
-import { resetPlSqlFactsStore } from '../plsql/facts-store.js';
+import { loadPlSqlParser, resetPlSqlFactsStore } from '../plsql/facts-store.js';
 import { readFileContents } from '../filesystem-walker.js';
 import type { StructureOutput } from './structure.js';
 import { isDev } from '../utils/env.js';
@@ -84,6 +84,8 @@ export const plsqlPhase: PipelinePhase<PlSqlOutput> = {
       return { files: 0, packages: 0, subprograms: 0 };
     }
 
+    // The ANTLR parser is loaded only now that the repository is known to hold PL/SQL.
+    await loadPlSqlParser();
     const result = processPlSql(ctx.graph, files, allPathSet);
 
     if (isDev) {
diff --git a/gitnexus/src/core/ingestion/plsql-processor.ts b/gitnexus/src/core/ingestion/plsql-processor.ts
index a7db39ff0..78651c811 100644
--- a/gitnexus/src/core/ingestion/plsql-processor.ts
+++ b/gitnexus/src/core/ingestion/plsql-processor.ts
@@ -369,7 +369,12 @@ export function processPlSql(
   let scriptIncludes = 0;
   for (const [filePath, f] of facts) {
     for (const include of f.scriptIncludes) {
-      const target = resolvePlSqlScriptInclude(include.target, filePath, allPaths);
+      const target = resolvePlSqlScriptInclude(
+        include.target,
+        filePath,
+        allPaths,
+        include.relativeToScript,
+      );
       if (!target) continue;
       addEdge(
         graph,
diff --git a/gitnexus/src/core/ingestion/plsql/extract.ts b/gitnexus/src/core/ingestion/plsql/extract.ts
index 005acb95d..d14333818 100644
--- a/gitnexus/src/core/ingestion/plsql/extract.ts
+++ b/gitnexus/src/core/ingestion/plsql/extract.ts
@@ -10,14 +10,19 @@
  */
 
 import {
+  CharStream,
+  CommonTokenStream,
   ParseTreeWalker,
   ParserRuleContext,
+  Token,
   type ParseTree,
   type ParseTreeListener,
 } from 'antlr4ng';
 import { PlSqlParser as P } from './generated/PlSqlParser.js';
+import { PlSqlLexer } from './generated/PlSqlLexer.js';
 import { parsePlSqlSource, type PlSqlSegment } from './parse.js';
-import type { ScriptInclude } from './preprocess.js';
+import { normaliseIdentifier } from './names.js';
+import type { ScriptInclude, SqlPlusCommand } from './preprocess.js';
 
 export type PlSqlDefKind = 'package' | 'procedure' | 'function' | 'trigger';
 export type PlSqlAccessKind =
@@ -122,6 +127,11 @@ export interface PlSqlDynamicSqlSite {
 
 export interface PlSqlFileFacts {
   readonly scriptIncludes: readonly ScriptInclude[];
+  /**
+   * SQL*Plus client commands removed before parsing. `EXEC pkg.proc(…)` lines
+   * name subprograms the parse tree never sees, so rename must consult them.
+   */
+  readonly sqlplusCommands: readonly SqlPlusCommand[];
   /**
    * Identifiers in expression positions that are not recorded call sites:
    * variables, columns, record fields — or argument-less function calls the
@@ -141,11 +151,7 @@ export interface PlSqlFileFacts {
 
 // ─── helpers ──────────────────────────────────────────────────────────────
 
-export function normaliseIdentifier(text: string): string {
-  return text.startsWith('"') && text.endsWith('"') && text.length >= 2
-    ? text.slice(1, -1)
-    : text.toUpperCase();
-}
+export { normaliseIdentifier };
 
 function splitDotted(text: string): string[] {
   // `"a.b".c` keeps the quoted part intact.
@@ -639,7 +645,7 @@ function fallbackDefinitions(segment: PlSqlSegment, known: ReadonlySet<string>):
   };
   routines.forEach((r, i) => {
     const ownerPath = pathOf(i);
-    if (known.has(`${ownerPath.join('.')}|${r.name}`)) return;
+    if (known.has(`${ownerPath.join('\0')}|${r.name}`)) return;
     const line = lineAt(r.start);
     out.push(makeFallback(r.kind, r.name, ownerPath, line, line, undefined, unit!.isSpec));
   });
@@ -700,7 +706,7 @@ export function extractPlSqlFacts(
       if (segment.mode === 'timeout') segmentsTimedOut++;
       firstError ??= segment.firstError;
       const known = new Set(
-        out.definitions.slice(before).map((d) => `${d.ownerPath.join('.')}|${d.name}`),
+        out.definitions.slice(before).map((d) => `${d.ownerPath.join('\0')}|${d.name}`),
       );
       out.definitions.push(...fallbackDefinitions(segment, known));
     }
@@ -708,9 +714,34 @@ export function extractPlSqlFacts(
   return {
     ...out,
     scriptIncludes: parsed.scriptIncludes,
+    sqlplusCommands: parsed.sqlplusCommands,
     segments: parsed.segments.length,
     segmentsWithErrors,
     segmentsTimedOut,
     firstError,
   };
 }
+
+// ─── tokens for rename ────────────────────────────────────────────────────
+
+export interface PlSqlLexedToken {
+  readonly text: string;
+  readonly line: number;
+  readonly column: number;
+}
+
+/**
+ * Default-channel tokens of pre-processed text (comments, whitespace and EOF
+ * excluded). Lives here so rename reaches the lexer through the lazily loaded
+ * parser module rather than importing it at start-up.
+ */
+export function lexPlSqlTokens(preprocessed: string): PlSqlLexedToken[] {
+  const lexer = new PlSqlLexer(CharStream.fromString(preprocessed));
+  lexer.removeErrorListeners();
+  const stream = new CommonTokenStream(lexer);
+  stream.fill();
+  return stream
+    .getTokens()
+    .filter((t) => t.channel === Token.DEFAULT_CHANNEL && t.type !== Token.EOF)
+    .map((t) => ({ text: t.text ?? '', line: t.line, column: t.column }));
+}
diff --git a/gitnexus/src/core/ingestion/plsql/facts-store.ts b/gitnexus/src/core/ingestion/plsql/facts-store.ts
index 20a34bab4..0c4ee406e 100644
--- a/gitnexus/src/core/ingestion/plsql/facts-store.ts
+++ b/gitnexus/src/core/ingestion/plsql/facts-store.ts
@@ -1,17 +1,46 @@
 /**
- * Per-run store of extracted PL/SQL facts, so each file is ANTLR-parsed once
- * per analyze: the `plsql` phase extracts every file, and the scope phase's
- * `emitScopeCaptures` (plus rename's `parseSource`) reuse those facts.
+ * Per-run store of extracted PL/SQL facts, and the lazy entry point to the
+ * ANTLR parser.
  *
- * Entries are keyed by path and content hash, so an edited or renamed source
- * can never be served stale facts. The store holds one run: the processor
- * resets it at the start of each run with room for every PL/SQL file, and
- * other callers add misses under a small bounded budget. Facts are not
- * persisted across runs (see PLSQL-07 in docs/languages/plsql-ingestion-gaps.md).
+ * The generated parser is large (~14 MB of JS, ~120 MB resident), so nothing
+ * that every analysis loads — the provider registry, parse workers, the scope
+ * resolver — imports it. The `plsql` phase calls `loadPlSqlParser()` only when
+ * the repository holds PL/SQL, and rename awaits it before parsing; other
+ * synchronous callers fall back to a synchronous load.
+ *
+ * Facts are keyed by path and content hash, so an edited or renamed source can
+ * never be served stale facts. The store holds one run: the processor resets
+ * it at the start of each run with room for every PL/SQL file, and other
+ * callers add misses under a small bounded budget. Facts are not persisted
+ * across runs (see PLSQL-07 in docs/languages/plsql-ingestion-gaps.md).
  */
 
 import { createHash } from 'node:crypto';
-import { extractPlSqlFacts, type PlSqlFileFacts } from './extract.js';
+import { createRequire } from 'node:module';
+import type * as ExtractModule from './extract.js';
+import type { PlSqlFileFacts, PlSqlLexedToken } from './extract.js';
+
+type Extractor = typeof ExtractModule;
+
+let extractor: Extractor | undefined;
+
+/** Load the ANTLR parser and fact extractor; idempotent. */
+export async function loadPlSqlParser(): Promise<void> {
+  extractor ??= await import('./extract.js');
+}
+
+function loadedExtractor(): Extractor {
+  if (extractor) return extractor;
+  try {
+    // Synchronous fallback for callers that cannot await (require(esm), Node >= 22.12).
+    extractor = createRequire(import.meta.url)('./extract.js') as Extractor;
+  } catch (cause) {
+    throw new Error('PL/SQL parser is not loaded: await loadPlSqlParser() before extracting', {
+      cause,
+    });
+  }
+  return extractor;
+}
 
 /** Head-room for extractions outside the phase (rename re-parses edited sources). */
 const EXTRA_ENTRIES = 64;
@@ -33,8 +62,13 @@ export function plsqlFactsForFile(filePath: string, content: string): PlSqlFileF
   const key = keyOf(filePath, content);
   const cached = store.get(key);
   if (cached) return cached;
-  const facts = extractPlSqlFacts(content);
+  const facts = loadedExtractor().extractPlSqlFacts(content);
   if (store.size >= capacity) store.delete(store.keys().next().value!);
   store.set(key, facts);
   return facts;
 }
+
+/** Identifier-candidate tokens of pre-processed text, for rename. */
+export function plsqlLexTokens(preprocessed: string): PlSqlLexedToken[] {
+  return loadedExtractor().lexPlSqlTokens(preprocessed);
+}
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 2ec3914d9..83d54194f 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -50,9 +50,14 @@ const ORACLE_IS_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\b(?:begin|as)\b)[\s\S]){0,4000}?\bis\b/im;
 const POSTGRES_DOLLAR_BODY = /\bas\s+\$[\w]*\$|\blanguage\s+plpgsql\b/i;
 const TSQL_MARKERS = /^\s*go\s*$|\bnvarchar\s*\(\s*max\s*\)|@@identity|\bset\s+nocount\s+on\b/im;
-/** Constructs that only appear in Oracle PL/SQL. */
+/**
+ * Constructs that only appear in Oracle PL/SQL. A trigger header alone is
+ * not one — PostgreSQL and MySQL write `CREATE TRIGGER t BEFORE …` too — so
+ * triggers are recognised by Oracle-only bodies: `:NEW.` / `:OLD.` bind
+ * references, `COMPOUND TRIGGER`, or the SQL*Plus `/` terminator.
+ */
 const ORACLE_MARKERS =
-  /%(?:row)?type\b|^\s*\/\s*$|\bpragma\s+(?:autonomous_transaction|exception_init|serially_reusable|restrict_references)\b|\bexecute\s+immediate\b|\bdbms_\w+\.|\braise_application_error\b|\bsys_refcursor\b|\bvarchar2\b|\bnvl\s*\(/im;
+  /%(?:row)?type\b|^\s*\/\s*$|\bpragma\s+(?:autonomous_transaction|exception_init|serially_reusable|restrict_references)\b|\bexecute\s+immediate\b|\bdbms_\w+\.|\braise_application_error\b|\bsys_refcursor\b|\bvarchar2\b|\bnvl\s*\(|:(?:new|old)\.|\bcompound\s+trigger\b/im;
 
 /**
  * A SQL*Plus script inclusion of a PL/SQL or SQL file on its own line. `@@`,
diff --git a/gitnexus/src/core/ingestion/plsql/names.ts b/gitnexus/src/core/ingestion/plsql/names.ts
new file mode 100644
index 000000000..8f216c131
--- /dev/null
+++ b/gitnexus/src/core/ingestion/plsql/names.ts
@@ -0,0 +1,11 @@
+/**
+ * Oracle identifier normalisation, kept free of the ANTLR runtime so the
+ * provider, resolver and rename modules can use it without loading the parser.
+ */
+
+/** Unquoted identifiers are upper-case; quoted identifiers keep their spelling without quotes. */
+export function normaliseIdentifier(text: string): string {
+  return text.startsWith('"') && text.endsWith('"') && text.length >= 2
+    ? text.slice(1, -1)
+    : text.toUpperCase();
+}
diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
index 5ac792503..6f7321392 100644
--- a/gitnexus/src/core/ingestion/plsql/parse.ts
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -74,6 +74,8 @@ export interface PlSqlSegment {
 export interface ParsedPlSqlSource {
   readonly segments: readonly PlSqlSegment[];
   readonly scriptIncludes: readonly ScriptInclude[];
+  /** SQL*Plus client commands blanked by the pre-pass (EXEC, SET, @@, …). */
+  readonly sqlplusCommands: readonly SqlPlusCommand[];
 }
 
 class CountingErrorListener extends BaseErrorListener {
@@ -199,7 +201,7 @@ export function parsePlSqlSource(
     const result = parseSegment(padded, options.segmentDeadlineMs ?? segmentDeadlineMs(lines));
     segments.push({ startLine: seg.startLine, endLine: seg.endLine, text: seg.body, ...result });
   }
-  return { segments, scriptIncludes: scriptIncludesOf(commands) };
+  return { segments, scriptIncludes: scriptIncludesOf(commands), sqlplusCommands: commands };
 }
 
 export type { ParserRuleContext };
diff --git a/gitnexus/src/core/ingestion/plsql/preprocess.ts b/gitnexus/src/core/ingestion/plsql/preprocess.ts
index 9b405ac2a..6a79787a3 100644
--- a/gitnexus/src/core/ingestion/plsql/preprocess.ts
+++ b/gitnexus/src/core/ingestion/plsql/preprocess.ts
@@ -26,7 +26,8 @@ const CREATE_PREFIX = /^create\b/i;
 /** Lines looked ahead to complete a split `CREATE` header. */
 const HEADER_LOOKAHEAD_LINES = 6;
 
-const ENDS_STATEMENT = /;\s*(?:--.*)?$/;
+/** `;` at line end, optionally followed by closed block comments and/or a `--` comment. */
+const ENDS_STATEMENT = /;\s*(?:\/\*.*?\*\/\s*)*(?:--.*)?$/;
 const CONTINUATION = /\s-\s*$/;
 const LEADING_BLOCK_COMMENTS = /^(?:\/\*[\s\S]*?\*\/\s*)+/;
 
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index 9781988df..d7ebbe774 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -43,13 +43,19 @@ export function rootPackageOf(
   return pkg === undefined ? undefined : defs.find((d) => d.kind === 'package' && d.name === pkg);
 }
 
-const pathKey = (path: readonly string[]) => path.join('.');
+/** NUL-separated: a quoted identifier may itself contain `.` (`"A.B"` ≠ `A`.`B`). */
+const pathKey = (path: readonly string[]) => path.join('\0');
+
+/** Join name parts with `.`, re-quoting any part that itself contains a dot. */
+export function dottedName(parts: readonly string[]): string {
+  return parts.map((p) => (p.includes('.') ? `"${p}"` : p)).join('.');
+}
 
 /** Owner path + name + parameter signature: identifies a spec declaration with its body. */
 export function plsqlSignatureKey(
   def: Pick<PlSqlDefinition, 'ownerPath' | 'name' | 'parameters'>,
 ): string {
-  return `${[...def.ownerPath, def.name].join('.')}(${def.parameters.map((p) => `${p.name} ${p.type}`.trim()).join(',')})`;
+  return `${dottedName([...def.ownerPath, def.name])}(${def.parameters.map((p) => `${p.name} ${p.type}`.trim()).join(',')})`;
 }
 
 /** Number of leading directory segments two repository paths share. */
@@ -135,20 +141,34 @@ function preferWrittenSchema<E extends PlSqlIndexEntry>(
   return inSchema.length > 0 ? inSchema : candidates;
 }
 
+/**
+ * Keep the candidates a call can bind to. With a known argument list, a
+ * candidate fits when the positional arguments fill its leading parameters,
+ * every named argument names one of the remaining parameters, and every
+ * parameter left unfilled has a default. A known mismatch is dropped — even a
+ * sole candidate — so it yields no edge rather than a wrong one. Candidates
+ * with unknown parameters (regex fallback) always fit.
+ */
 function narrowOverloads<E extends PlSqlIndexEntry>(
   candidates: E[],
   call: Pick<PlSqlCallSite, 'arity' | 'namedArguments'>,
 ): E[] {
-  if (candidates.length <= 1 || call.arity === undefined) return candidates;
-  const arity = call.arity;
-  const fits = candidates.filter((c) => {
+  if (call.arity === undefined) return candidates;
+  const positional = call.arity - call.namedArguments.length;
+  return candidates.filter((c) => {
     if (c.def.fromFallback) return true; // parameters unknown
-    const required = c.def.parameters.filter((p) => !p.hasDefault).length;
-    if (arity < required || arity > c.def.parameters.length) return false;
-    const names = new Set(c.def.parameters.map((p) => p.name));
-    return call.namedArguments.every((n) => names.has(n));
+    const params = c.def.parameters;
+    if (positional < 0 || positional > params.length) return false;
+    const named = new Set(call.namedArguments);
+    if (named.size !== call.namedArguments.length) return false; // duplicate name
+    const supplied = new Set(params.slice(0, positional).map((p) => p.name));
+    for (const name of named) {
+      const param = params.find((p) => p.name === name);
+      if (!param || supplied.has(name)) return false;
+      supplied.add(name);
+    }
+    return params.every((p) => p.hasDefault || supplied.has(p.name));
   });
-  return fits.length > 0 ? fits : candidates;
 }
 
 /**
diff --git a/gitnexus/src/core/ingestion/plsql/script-include.ts b/gitnexus/src/core/ingestion/plsql/script-include.ts
index 38392ed2a..3d1303a3f 100644
--- a/gitnexus/src/core/ingestion/plsql/script-include.ts
+++ b/gitnexus/src/core/ingestion/plsql/script-include.ts
@@ -1,12 +1,18 @@
 /**
  * SQL*Plus script inclusion (`@@file`, `@file`, `START file`) → repository path.
  *
- * SQL*Plus looks a script up relative to the calling script (`@@`) or the
- * working directory (`@`, `START`), appending `.sql` when the name has no
- * extension. Statically we try the calling script's directory, then the
- * repository root — exact paths only. There is no suffix search: a script
- * that is not at one of those paths lives outside the repository (a vendor
- * install, `?/rdbms/admin/...`) and must not bind to a same-named file.
+ * SQL*Plus resolves `@@` against the directory of the calling script and
+ * `@` / `START` against the working directory, appending `.sql` when the name
+ * has no extension. The working directory is unknown statically, so `@` /
+ * `START` try the repository root first and then the calling script's
+ * directory (the two directories install scripts are run from); `@@` uses only
+ * the calling script's directory. Exact paths only — there is no suffix
+ * search: a script that is not at one of those paths lives outside the
+ * repository (a vendor install, `?/rdbms/admin/...`, a UNC share) and must not
+ * bind to a same-named file.
+ *
+ * `targetRaw` may carry a leading `@@` (how scope captures encode a
+ * script-relative include); `relativeToScript` overrides it when given.
  */
 
 import path from 'node:path';
@@ -19,22 +25,26 @@ export function resolvePlSqlScriptInclude(
   targetRaw: string,
   fromFile: string,
   allFilePaths: ReadonlySet<string>,
+  relativeToScript?: boolean,
 ): string | null {
-  const target = targetRaw.trim().replace(/^["']|["']$/g, '');
-  // `?` is ORACLE_HOME; absolute paths are machine-specific.
+  let target = targetRaw.trim();
+  const scriptRelative = relativeToScript ?? target.startsWith('@@');
+  target = target.replace(/^@@?/, '').replace(/^["']|["']$/g, '');
+  // `?` is ORACLE_HOME; absolute, drive-letter and UNC paths are machine-specific.
   if (
     target === '' ||
     target.startsWith('?') ||
-    path.posix.isAbsolute(target) ||
-    /^[A-Za-z]:[\\/]/.test(target)
+    /^[\\/]/.test(target) ||
+    /^[A-Za-z]:/.test(target)
   ) {
     return null;
   }
   const spellings = path.posix.extname(target) === '' ? [`${target}.sql`, target] : [target];
   const dir = path.posix.dirname(fromFile.replace(/\\/g, '/'));
-  for (const base of [dir, '']) {
+  const bases = scriptRelative ? [dir] : ['', dir];
+  for (const base of bases) {
     for (const spelling of spellings) {
-      const candidate = normalise(base ? `${base}/${spelling}` : spelling);
+      const candidate = normalise(base && base !== '.' ? `${base}/${spelling}` : spelling);
       if (candidate.startsWith('../')) continue;
       if (allFilePaths.has(candidate)) return candidate;
     }
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/deploy.sql b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/deploy.sql
new file mode 100644
index 000000000..428309ec9
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/deploy.sql
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PROCEDURE prc_deploy_marker IS
+BEGIN
+  NULL;
+END prc_deploy_marker;
+/
+-- Run the daily job once right after deployment.
+EXEC pkg_job.run_daily;
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/pkg_job.pkb b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/pkg_job.pkb
new file mode 100644
index 000000000..503373084
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/after/pkg_job.pkb
@@ -0,0 +1,9 @@
+CREATE OR REPLACE PACKAGE BODY pkg_job AS
+
+  PROCEDURE run_daily IS
+  BEGIN
+    DELETE FROM t_job_log WHERE log_date < TRUNC(SYSDATE) - 30;
+  END run_daily;
+
+END pkg_job;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/deploy.sql b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/deploy.sql
new file mode 100644
index 000000000..428309ec9
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/deploy.sql
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PROCEDURE prc_deploy_marker IS
+BEGIN
+  NULL;
+END prc_deploy_marker;
+/
+-- Run the daily job once right after deployment.
+EXEC pkg_job.run_daily;
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/pkg_job.pkb b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/pkg_job.pkb
new file mode 100644
index 000000000..503373084
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/before/pkg_job.pkb
@@ -0,0 +1,9 @@
+CREATE OR REPLACE PACKAGE BODY pkg_job AS
+
+  PROCEDURE run_daily IS
+  BEGIN
+    DELETE FROM t_job_log WHERE log_date < TRUNC(SYSDATE) - 30;
+  END run_daily;
+
+END pkg_job;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/case.json b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/case.json
new file mode 100644
index 000000000..9a70a949e
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-sqlplus-exec/case.json
@@ -0,0 +1,16 @@
+{
+  "language": "plsql",
+  "description": "Refuse to rename a procedure that a SQL*Plus EXEC command invokes: client commands are not part of the parsed PL/SQL, so the call could not be rewritten and every source byte must stay unchanged.",
+  "categories": ["sqlplus", "negative", "unchanged-on-error"],
+  "target": {
+    "name": "RUN_DAILY",
+    "kind": "Function",
+    "file": "pkg_job.pkb"
+  },
+  "newName": "run_nightly",
+  "expect": {
+    "status": "error",
+    "code": "unsupported_occurrence",
+    "planningStatus": "unsupported"
+  }
+}
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index fff3c5c7c..012eaf527 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -169,6 +169,17 @@ describe('file classification', () => {
       false,
     );
     expect(looksLikeOraclePlSql('SELECT * FROM t;')).toBe(false);
+    // Triggers: Oracle-only bodies qualify; a PostgreSQL trigger does not.
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR REPLACE TRIGGER t BEFORE UPDATE ON x FOR EACH ROW\nBEGIN\n  :NEW.ts := SYSDATE;\nEND;',
+      ),
+    ).toBe(true);
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE TRIGGER t BEFORE INSERT ON x FOR EACH ROW EXECUTE FUNCTION f();',
+      ),
+    ).toBe(false);
     // `IS` after the header is Oracle-only, no other marker needed.
     expect(looksLikeOraclePlSql('CREATE PROCEDURE p IS BEGIN NULL; END;')).toBe(true);
     // T-SQL without GO: `AS` header, `IS NULL` only inside the body.
@@ -200,11 +211,25 @@ describe('resolvePlSqlScriptInclude', () => {
       'vendor/ext.pks',
     );
   });
+  it('resolves @@ against the calling script and @ / START against the repository root first', () => {
+    const paths = new Set(['db/install.sql', 'db/foo.sql', 'foo.sql']);
+    expect(resolvePlSqlScriptInclude('foo', 'db/install.sql', paths, false)).toBe('foo.sql');
+    expect(resolvePlSqlScriptInclude('foo', 'db/install.sql', paths, true)).toBe('db/foo.sql');
+    expect(resolvePlSqlScriptInclude('@@foo', 'db/install.sql', paths)).toBe('db/foo.sql');
+    expect(
+      resolvePlSqlScriptInclude('ext.pks', 'db/install.sql', new Set(['ext.pks']), true),
+    ).toBeNull();
+  });
+
   it('never suffix-matches a script outside the repository', () => {
     expect(resolvePlSqlScriptInclude('ext.pks', 'db/install.sql', files)).toBeNull();
     expect(
       resolvePlSqlScriptInclude('?/rdbms/admin/utlrp.sql', 'db/install.sql', files),
     ).toBeNull();
     expect(resolvePlSqlScriptInclude('/opt/x.sql', 'db/install.sql', files)).toBeNull();
+    expect(
+      resolvePlSqlScriptInclude('\\\\server\\share\\x.sql', 'db/install.sql', files),
+    ).toBeNull();
+    expect(resolvePlSqlScriptInclude('C:\\deploy\\x.sql', 'db/install.sql', files)).toBeNull();
   });
 });
diff --git a/gitnexus/test/unit/plsql-lazy-parser.test.ts b/gitnexus/test/unit/plsql-lazy-parser.test.ts
new file mode 100644
index 000000000..5e6532c52
--- /dev/null
+++ b/gitnexus/test/unit/plsql-lazy-parser.test.ts
@@ -0,0 +1,55 @@
+/**
+ * The generated PL/SQL parser is ~14 MB of JS (~120 MB resident). Every
+ * analysis process and parse worker loads the provider registry, so the
+ * modules it reaches must not import the parser, its runtime or the fact
+ * extractor at evaluation time — only `plsql/facts-store.ts` loads them, on
+ * demand. A value import slipping into one of these files would put that cost
+ * back on every repository, PL/SQL or not.
+ */
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const INGESTION = path.resolve(__dirname, '../../src/core/ingestion');
+
+/** Modules reachable from the provider registry, the scope resolver and the pipeline phase. */
+const LIGHT_MODULES = [
+  'languages/plsql.ts',
+  'languages/plsql/index.ts',
+  'languages/plsql/captures.ts',
+  'languages/plsql/interpret.ts',
+  'languages/plsql/flow.ts',
+  'languages/plsql/rename.ts',
+  'languages/plsql/scope-resolver.ts',
+  'pipeline-phases/plsql.ts',
+  'plsql-processor.ts',
+  'plsql/facts-store.ts',
+  'plsql/file-types.ts',
+  'plsql/names.ts',
+  'plsql/preprocess.ts',
+  'plsql/resolve.ts',
+  'plsql/script-include.ts',
+];
+
+const HEAVY = /(?:^|\/)(?:extract|parse)\.js$|\/generated\/|^antlr4ng$/;
+
+/** Every `import … from '…'` whose clause is not `import type`. */
+function valueImports(source: string): string[] {
+  const out: string[] = [];
+  for (const m of source.matchAll(/^import\s+(type\s+)?[\s\S]*?\s+from\s+'([^']+)';/gm)) {
+    if (!m[1]) out.push(m[2]!);
+  }
+  return out;
+}
+
+describe('PL/SQL parser loads lazily', () => {
+  it.each(LIGHT_MODULES)('%s imports the parser and extractor by type only', (file) => {
+    const source = readFileSync(path.join(INGESTION, file), 'utf8');
+    expect(valueImports(source).filter((spec) => HEAVY.test(spec))).toEqual([]);
+  });
+
+  it('facts-store reaches the extractor only through dynamic loading', () => {
+    const source = readFileSync(path.join(INGESTION, 'plsql/facts-store.ts'), 'utf8');
+    expect(source).toMatch(/await import\('\.\/extract\.js'\)/);
+  });
+});
diff --git a/gitnexus/test/unit/plsql-preprocess.test.ts b/gitnexus/test/unit/plsql-preprocess.test.ts
index 6cb744101..cc82b9a45 100644
--- a/gitnexus/test/unit/plsql-preprocess.test.ts
+++ b/gitnexus/test/unit/plsql-preprocess.test.ts
@@ -77,6 +77,15 @@ describe('stripSqlPlusCommands', () => {
     expect(lines(stripSqlPlusCommands(src))).toEqual(['', '', '', 'SELECT 1 FROM dual;']);
   });
 
+  it('ends a statement whose `;` is followed by a block comment', () => {
+    const src = ['SELECT 1 FROM dual; /* note */', 'SET ECHO ON', 'SELECT 2 FROM dual;'].join('\n');
+    expect(lines(stripSqlPlusCommands(src))).toEqual([
+      'SELECT 1 FROM dual; /* note */',
+      '',
+      'SELECT 2 FROM dual;',
+    ]);
+  });
+
   it('reports blanked commands to the sink', () => {
     const commands: SqlPlusCommand[] = [];
     stripSqlPlusCommands('REM header\n@@a.sql\n', commands);
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index 257c5f9d5..328847815 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -1,8 +1,9 @@
-import { describe, it, expect } from 'vitest';
+import { beforeAll, describe, it, expect } from 'vitest';
 import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
 import type { KnowledgeGraph } from '../../src/core/graph/types.js';
 import { processPlSql } from '../../src/core/ingestion/plsql-processor.js';
 import {
+  loadPlSqlParser,
   plsqlFactsForFile,
   resetPlSqlFactsStore,
 } from '../../src/core/ingestion/plsql/facts-store.js';
@@ -11,6 +12,9 @@ import {
   SEGMENT_DEADLINE_FLOOR_MS,
 } from '../../src/core/ingestion/plsql/parse.js';
 
+// The parser loads lazily (the phase awaits it); tests calling the processor directly preload it.
+beforeAll(loadPlSqlParser);
+
 const run = (files: Record<string, string>) => {
   const graph = createKnowledgeGraph();
   const result = processPlSql(
@@ -54,6 +58,57 @@ END pkg_log;
     expect(edges(graph, 'CALLS')).toEqual(['LOG_MSG@L2 -> LOG_MSG@db/pkg_log.pkb']);
   });
 
+  it('binds named-argument calls only to overloads whose required parameters are supplied', () => {
+    const { graph } = run({
+      'p.pkb': `CREATE OR REPLACE PACKAGE BODY p AS
+  PROCEDURE q(a IN NUMBER, b IN NUMBER DEFAULT 0) IS BEGIN NULL; END q;
+  PROCEDURE q(b IN NUMBER) IS BEGIN NULL; END q;
+  PROCEDURE r(a IN NUMBER) IS BEGIN NULL; END r;
+  PROCEDURE run IS
+  BEGIN
+    q(b => 1);
+    r(1, 2);
+  END run;
+END p;
+/
+`,
+    });
+    const targets: string[] = [];
+    for (const rel of graph.iterRelationships()) {
+      if (rel.type !== 'CALLS') continue;
+      const t = graph.getNode(rel.targetId)!;
+      targets.push(`${t.properties.name}@L${t.properties.startLine! + 1} ${rel.reason}`);
+    }
+    // q(b => 1) cannot bind q(a, b) (a is required); r(1, 2) has too many arguments.
+    expect(targets).toEqual(['Q@L3 plsql-call']);
+  });
+
+  it('keeps a quoted dotted package name apart from nested names', () => {
+    const { graph } = run({
+      'p.pkb': `CREATE OR REPLACE PACKAGE BODY "A.B" AS
+  PROCEDURE f IS BEGIN NULL; END f;
+END "A.B";
+/
+CREATE OR REPLACE PACKAGE BODY a AS
+  PROCEDURE b IS
+    PROCEDURE f IS BEGIN NULL; END f;
+  BEGIN
+    f;
+  END b;
+END a;
+/
+`,
+    });
+    const calls: string[] = [];
+    for (const rel of graph.iterRelationships()) {
+      if (rel.type === 'CALLS') {
+        const t = graph.getNode(rel.targetId)!;
+        calls.push(`${t.properties.name}@L${t.properties.startLine! + 1}`);
+      }
+    }
+    expect(calls).toEqual(['F@L7']);
+  });
+
   it('keeps forward-declared private subprograms private', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE PACKAGE BODY p AS

From 1204d3c13c2409d26e7fe6e92836dc2a79d62e7a Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Fri, 30 Oct 2026 18:55:55 +0800
Subject: [PATCH 05/17] fix(plsql): claim plain Oracle trigger bodies in .sql
 files
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A trigger header is shared with PostgreSQL and MySQL/MariaDB, so a `.sql`
trigger without an Oracle-only marker was not claimed. Recognise a trigger
whose body is a `BEGIN|DECLARE … END;` block when nothing the other dialects
must write is present: `DELIMITER`, backticks, colon-less `NEW.`/`OLD.`, or
PostgreSQL's `EXECUTE FUNCTION|PROCEDURE`. Positive and MySQL negatives added;
the open-source corpus claims the same 618 files as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/core/ingestion/plsql/file-types.ts    | 25 ++++++++++++++++++-
 gitnexus/test/unit/plsql-extract.test.ts      | 15 +++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 83d54194f..33e12f8a8 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -48,6 +48,25 @@ const ORACLE_UNIT_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\bbegin\b)[\s\S]){0,4000}?\b(?:is|as)\b|trigger\s+[\w$#."]+\s+(?:before|after|instead\s+of|for)\b)/im;
 const ORACLE_IS_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\b(?:begin|as)\b)[\s\S]){0,4000}?\bis\b/im;
+/**
+ * A trigger whose body is a PL/SQL block. The header is shared with
+ * PostgreSQL and MySQL/MariaDB, so the dialects are told apart by what they
+ * cannot write: PostgreSQL triggers call `EXECUTE FUNCTION|PROCEDURE` instead
+ * of carrying a body, and a MySQL/MariaDB body can only hold `;` inside a
+ * `DELIMITER` script and refers to `NEW.col` / `OLD.col` without a colon.
+ */
+const TRIGGER_HEADER =
+  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?trigger\s+[\w$#."]+\s+(?:before|after|instead\s+of|for)\b/im;
+const PLSQL_BLOCK = /\b(?:begin|declare)\b[\s\S]*\bend\b[^;]*;/i;
+const NON_ORACLE_TRIGGER =
+  /^\s*delimiter\b|`|(?<![:\w])(?:new|old)\.\w|\bexecute\s+(?:function|procedure)\b/im;
+
+function looksLikeOracleTrigger(content: string): boolean {
+  return (
+    TRIGGER_HEADER.test(content) && PLSQL_BLOCK.test(content) && !NON_ORACLE_TRIGGER.test(content)
+  );
+}
+
 const POSTGRES_DOLLAR_BODY = /\bas\s+\$[\w]*\$|\blanguage\s+plpgsql\b/i;
 const TSQL_MARKERS = /^\s*go\s*$|\bnvarchar\s*\(\s*max\s*\)|@@identity|\bset\s+nocount\s+on\b/im;
 /**
@@ -78,7 +97,11 @@ export function looksLikeOraclePlSql(content: string): boolean {
   // `IS` after a unit header is Oracle-only syntax (T-SQL, PostgreSQL and
   // MySQL write `AS` or `BEGIN`), so a plain `CREATE PROCEDURE p IS …` needs
   // no further marker; an `AS` header still does.
-  return ORACLE_IS_HEADER.test(content) || ORACLE_MARKERS.test(content);
+  return (
+    ORACLE_IS_HEADER.test(content) ||
+    looksLikeOracleTrigger(content) ||
+    ORACLE_MARKERS.test(content)
+  );
 }
 
 /** File-level predicate used by the PL/SQL phase. */
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index 012eaf527..5b639f2dd 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -180,6 +180,21 @@ describe('file classification', () => {
         'CREATE TRIGGER t BEFORE INSERT ON x FOR EACH ROW EXECUTE FUNCTION f();',
       ),
     ).toBe(false);
+    // A plain PL/SQL trigger body with no Oracle-only marker still qualifies…
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR REPLACE TRIGGER t BEFORE INSERT ON x FOR EACH ROW\nBEGIN\n  NULL;\nEND;',
+      ),
+    ).toBe(true);
+    // …while MySQL/MariaDB trigger scripts do not.
+    expect(
+      looksLikeOraclePlSql(
+        'DELIMITER $$\nCREATE TRIGGER t BEFORE INSERT ON x FOR EACH ROW\nBEGIN\n  SET NEW.a = 1;\nEND$$\nDELIMITER ;',
+      ),
+    ).toBe(false);
+    expect(
+      looksLikeOraclePlSql('CREATE TRIGGER t BEFORE INSERT ON `x` FOR EACH ROW SET NEW.a = 1;'),
+    ).toBe(false);
     // `IS` after the header is Oracle-only, no other marker needed.
     expect(looksLikeOraclePlSql('CREATE PROCEDURE p IS BEGIN NULL; END;')).toBe(true);
     // T-SQL without GO: `AS` header, `IS NULL` only inside the body.

From abfb58bcba583269cc4e43b35ea1ee1569a6338c Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 09:43:42 +0800
Subject: [PATCH 06/17] fix(plsql): address fourth review round

- `.sql` units with an `AS` header (shared with T-SQL) qualify through
  PL/SQL statement syntax T-SQL lacks: `:=`, `END IF|LOOP|CASE;`, `ELSIF`,
  a `NULL;` statement, `EXCEPTION WHEN`, `RETURN <type> IS|AS`
- a lone `/` inside a block comment or a (q-)string literal no longer
  splits a compilation unit
- `SET TRANSACTION`, `SET ROLE` and `SET CONSTRAINTS` are kept as SQL
- `S.P` binds only to standalone P of schema S (or of an unwritten schema);
  standalone node ids carry their written schema
- rootPackageOf documents and names its same-file contract
- the lazy-parser guard also scans side-effect imports and re-exports
- import-target's plsql heap probe exercises both bases and both spellings

Corpus unchanged: 618 files claimed, 8,829 call sites with targets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gitnexus/bench/import-target/baselines.json   |  2 +-
 gitnexus/bench/import-target/measure.mjs      |  6 +-
 .../src/core/ingestion/plsql-processor.ts     |  5 +-
 .../src/core/ingestion/plsql/file-types.ts    | 10 ++-
 gitnexus/src/core/ingestion/plsql/parse.ts    | 69 ++++++++++++++++++-
 .../src/core/ingestion/plsql/preprocess.ts    |  2 +-
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 25 +++++--
 gitnexus/test/unit/plsql-extract.test.ts      | 32 +++++++++
 gitnexus/test/unit/plsql-lazy-parser.test.ts  | 20 +++++-
 gitnexus/test/unit/plsql-preprocess.test.ts   | 15 ++++
 gitnexus/test/unit/plsql-processor.test.ts    | 23 +++++++
 11 files changed, 191 insertions(+), 18 deletions(-)

diff --git a/gitnexus/bench/import-target/baselines.json b/gitnexus/bench/import-target/baselines.json
index d59255f4b..dd4b81fc5 100644
--- a/gitnexus/bench/import-target/baselines.json
+++ b/gitnexus/bench/import-target/baselines.json
@@ -1210,7 +1210,7 @@
         "files_small": 8000,
         "files_large": 32000,
         "path_segments": 11,
-        "probe": "../vendor0/missing.sql"
+        "probe": "vendor0/missing"
       },
       "_measured": {
         "collide_ms": 2.354,
diff --git a/gitnexus/bench/import-target/measure.mjs b/gitnexus/bench/import-target/measure.mjs
index be0a2ee65..1bbee5401 100644
--- a/gitnexus/bench/import-target/measure.mjs
+++ b/gitnexus/bench/import-target/measure.mjs
@@ -2287,8 +2287,10 @@ const HEAP_PROBE_TARGET = {
   // miss after the full component walk, which is the longest leg the resolver
   // has (a by-name miss returns before any walk).
   zig: '../vendor0/missing.zig',
-  // Both bases and both spellings probed and missed — the longest leg.
-  plsql: '../vendor0/missing.sql',
+  // No extension and no `..`: the repository root and the caller's directory
+  // are each probed with `.sql` appended and as written — four misses, the
+  // longest leg the resolver has.
+  plsql: 'vendor0/missing',
   typescript: 'vendor0/lib/missing',
   vue: 'vendor0/lib/Missing.vue',
   cpp: 'vendor0/missing.hpp',
diff --git a/gitnexus/src/core/ingestion/plsql-processor.ts b/gitnexus/src/core/ingestion/plsql-processor.ts
index 78651c811..a30888ac1 100644
--- a/gitnexus/src/core/ingestion/plsql-processor.ts
+++ b/gitnexus/src/core/ingestion/plsql-processor.ts
@@ -217,7 +217,10 @@ export function processPlSql(
     const key = pairingKey(def, filePath);
     // A spec/forward declaration with an indexed body is the same subprogram.
     if (def.declarationOnly && bodyKeys.has(key)) continue;
-    entry.nodeId = plsqlSubprogramNodeId(filePath, def, entry.packageSchema);
+    // Package members carry their package's schema; standalone subprograms
+    // their own (`CREATE PROCEDURE a.p` and `b.p` in one file are two objects).
+    const schema = entry.packageSchema ?? (def.ownerPath.length === 0 ? def.schema : undefined);
+    entry.nodeId = plsqlSubprogramNodeId(filePath, def, schema);
     if (!def.declarationOnly) bodyNodeByKey.set(key, entry.nodeId);
     if (def.kind === 'trigger') triggers++;
     else subprograms++;
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 33e12f8a8..1ad30aba6 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -70,13 +70,16 @@ function looksLikeOracleTrigger(content: string): boolean {
 const POSTGRES_DOLLAR_BODY = /\bas\s+\$[\w]*\$|\blanguage\s+plpgsql\b/i;
 const TSQL_MARKERS = /^\s*go\s*$|\bnvarchar\s*\(\s*max\s*\)|@@identity|\bset\s+nocount\s+on\b/im;
 /**
- * Constructs that only appear in Oracle PL/SQL. A trigger header alone is
+ * Constructs that only appear in Oracle PL/SQL — among them PL/SQL statement
+ * syntax T-SQL does not have (`:=`, `END IF;`, `ELSIF`, a `NULL;` statement,
+ * `EXCEPTION WHEN`, a function's `RETURN <type> IS|AS`), which is what tells an
+ * Oracle `CREATE PROCEDURE p AS …` from a T-SQL one. A trigger header alone is
  * not one — PostgreSQL and MySQL write `CREATE TRIGGER t BEFORE …` too — so
  * triggers are recognised by Oracle-only bodies: `:NEW.` / `:OLD.` bind
  * references, `COMPOUND TRIGGER`, or the SQL*Plus `/` terminator.
  */
 const ORACLE_MARKERS =
-  /%(?:row)?type\b|^\s*\/\s*$|\bpragma\s+(?:autonomous_transaction|exception_init|serially_reusable|restrict_references)\b|\bexecute\s+immediate\b|\bdbms_\w+\.|\braise_application_error\b|\bsys_refcursor\b|\bvarchar2\b|\bnvl\s*\(|:(?:new|old)\.|\bcompound\s+trigger\b/im;
+  /%(?:row)?type\b|^\s*\/\s*$|\bpragma\s+(?:autonomous_transaction|exception_init|serially_reusable|restrict_references)\b|\bexecute\s+immediate\b|\bdbms_\w+\.|\braise_application_error\b|\bsys_refcursor\b|\bvarchar2\b|\bnvl\s*\(|:(?:new|old)\.|\bcompound\s+trigger\b|:=|\bend\s+(?:if|loop|case)\s*;|\belsif\b|(?:^|\bbegin|\bthen|\belse|\bloop|;)\s*null\s*;|\bexception\s+when\b|\breturn\s+[\w.%]+\s+(?:is|as)\b/im;
 
 /**
  * A SQL*Plus script inclusion of a PL/SQL or SQL file on its own line. `@@`,
@@ -96,7 +99,8 @@ export function looksLikeOraclePlSql(content: string): boolean {
   if (POSTGRES_DOLLAR_BODY.test(content) || TSQL_MARKERS.test(content)) return false;
   // `IS` after a unit header is Oracle-only syntax (T-SQL, PostgreSQL and
   // MySQL write `AS` or `BEGIN`), so a plain `CREATE PROCEDURE p IS …` needs
-  // no further marker; an `AS` header still does.
+  // no further marker; an `AS` header (shared with T-SQL) needs PL/SQL syntax
+  // from ORACLE_MARKERS in its body.
   return (
     ORACLE_IS_HEADER.test(content) ||
     looksLikeOracleTrigger(content) ||
diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
index 6f7321392..ffbecb1c8 100644
--- a/gitnexus/src/core/ingestion/plsql/parse.ts
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -165,7 +165,68 @@ function parseSegment(
   }
 }
 
-/** Split pre-processed text at lone `/` lines; each segment keeps its line offset. */
+/**
+ * Lexical state carried from one line to the next while looking for `/`
+ * terminators: a lone `/` inside a block comment or a (multi-line) string
+ * literal is text, not a terminator.
+ */
+type CarryState =
+  | { kind: 'code' }
+  | { kind: 'block-comment' }
+  | { kind: 'string' }
+  | { kind: 'q-string'; close: string };
+
+const Q_CLOSE: Record<string, string> = { '[': ']', '(': ')', '{': '}', '<': '>' };
+
+/** Scan one line from `state`; returns the state at the end of the line. */
+function scanLine(line: string, state: CarryState): CarryState {
+  let i = 0;
+  let st = state;
+  while (i < line.length) {
+    if (st.kind === 'block-comment') {
+      const end = line.indexOf('*/', i);
+      if (end < 0) return st;
+      i = end + 2;
+      st = { kind: 'code' };
+    } else if (st.kind === 'string') {
+      const end = line.indexOf("'", i);
+      if (end < 0) return st;
+      if (line[end + 1] === "'") {
+        i = end + 2; // '' escape
+        continue;
+      }
+      i = end + 1;
+      st = { kind: 'code' };
+    } else if (st.kind === 'q-string') {
+      const end = line.indexOf(`${st.close}'`, i);
+      if (end < 0) return st;
+      i = end + 2;
+      st = { kind: 'code' };
+    } else {
+      const ch = line[i]!;
+      const next = line[i + 1];
+      if (ch === '-' && next === '-') return st; // line comment
+      if (ch === '/' && next === '*') {
+        st = { kind: 'block-comment' };
+        i += 2;
+      } else if ((ch === 'q' || ch === 'Q') && next === "'" && !/[\w$#]/.test(line[i - 1] ?? '')) {
+        const open = line[i + 2] ?? '';
+        st = { kind: 'q-string', close: Q_CLOSE[open] ?? open };
+        i += 3;
+      } else if (ch === "'") {
+        st = { kind: 'string' };
+        i += 1;
+      } else i += 1;
+    }
+  }
+  return st;
+}
+
+/**
+ * Split pre-processed text at lone `/` terminator lines; each segment keeps
+ * its line offset. A `/` line inside a block comment or a string literal does
+ * not split.
+ */
 export function splitSegments(
   text: string,
 ): Array<{ startLine: number; endLine: number; body: string }> {
@@ -176,11 +237,15 @@ export function splitSegments(
     const body = lines.slice(start, endExclusive).join('\n');
     if (body.trim() !== '') out.push({ startLine: start + 1, endLine: endExclusive, body });
   };
+  let state: CarryState = { kind: 'code' };
   for (let i = 0; i < lines.length; i++) {
-    if (lines[i]!.trim() === '/') {
+    const line = lines[i]!;
+    if (state.kind === 'code' && line.trim() === '/') {
       flush(i + 1);
       start = i + 1;
+      continue;
     }
+    state = scanLine(line, state);
   }
   flush(lines.length);
   return out;
diff --git a/gitnexus/src/core/ingestion/plsql/preprocess.ts b/gitnexus/src/core/ingestion/plsql/preprocess.ts
index 6a79787a3..a912af291 100644
--- a/gitnexus/src/core/ingestion/plsql/preprocess.ts
+++ b/gitnexus/src/core/ingestion/plsql/preprocess.ts
@@ -11,7 +11,7 @@
  */
 
 const SQLPLUS_COMMAND =
-  /^\s*(?:set|define|def|undefine|undef|prompt|pro|rem|remark|spool|spo|whenever|column|col|connect|conn|accept|acc|pause|show|sho|exit|quit|host|ttitle|btitle|break|compute|clear|var|variable|print|timing|exec|execute|start|sta|disconnect|disc|store|repheader|repfooter|attribute|copy|describe|desc|get|help|list|password|run|save|xquery)\b/i;
+  /^\s*(?:set(?!\s+(?:transaction|role|constraints?)\b)|define|def|undefine|undef|prompt|pro|rem|remark|spool|spo|whenever|column|col|connect|conn|accept|acc|pause|show|sho|exit|quit|host|ttitle|btitle|break|compute|clear|var|variable|print|timing|exec|execute|start|sta|disconnect|disc|store|repheader|repfooter|attribute|copy|describe|desc|get|help|list|password|run|save|xquery)\b/i;
 
 /**
  * Statements that start a PL/SQL unit, which only a lone `/` terminates.
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index d7ebbe774..ff90a52f6 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -28,19 +28,25 @@ export interface PlSqlIndexEntry {
 
 /**
  * The package a definition belongs to: the root of its `ownerIndex` chain,
- * or — for fallback definitions without an index — the first package of
- * that name in the same file.
+ * or — for fallback definitions without an index — the first package of that
+ * name among `fileDefs`.
+ *
+ * `fileDefs` must be the definitions of the file `def` was extracted from (one
+ * `PlSqlFileFacts.definitions` array): `ownerIndex` indexes into it, and the
+ * fallback lookup is then same-file by construction.
  */
 export function rootPackageOf(
   def: PlSqlDefinition,
-  defs: readonly PlSqlDefinition[],
+  fileDefs: readonly PlSqlDefinition[],
 ): PlSqlDefinition | undefined {
   if (def.kind === 'package') return def;
   let current: PlSqlDefinition | undefined = def;
-  while (current?.ownerIndex !== undefined) current = defs[current.ownerIndex];
+  while (current?.ownerIndex !== undefined) current = fileDefs[current.ownerIndex];
   if (current && current !== def && current.kind === 'package') return current;
   const pkg = def.ownerPath[0];
-  return pkg === undefined ? undefined : defs.find((d) => d.kind === 'package' && d.name === pkg);
+  return pkg === undefined
+    ? undefined
+    : fileDefs.find((d) => d.kind === 'package' && d.name === pkg);
 }
 
 /** NUL-separated: a quoted identifier may itself contain `.` (`"A.B"` ≠ `A`.`B`). */
@@ -112,7 +118,14 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
     const qualifier = parts[parts.length - 2]!;
     const member = this.lookup([qualifier], name).filter(callable);
     if (member.length > 0) return member;
-    if (parts.length === 2) return this.lookup([], name).filter(callable);
+    if (parts.length === 2) {
+      // `S.NAME`: a standalone subprogram in schema S. Definitions that wrote
+      // another schema are excluded; ones that wrote none (current schema) stay
+      // candidates, behind any that name S explicitly.
+      const standalone = this.lookup([], name).filter(callable);
+      const exact = standalone.filter((e) => e.def.schema === qualifier);
+      return exact.length > 0 ? exact : standalone.filter((e) => e.def.schema === undefined);
+    }
     return [];
   }
 
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index 5b639f2dd..0c071790d 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -138,6 +138,27 @@ END pkg_x;
     expect(paths).not.toContain('PKG_X.INNER_P');
   });
 
+  it('does not split at a lone `/` inside a block comment or a string literal', () => {
+    const src = [
+      'CREATE OR REPLACE PROCEDURE p IS',
+      '  /* usage:',
+      '/',
+      '  */',
+      "  l VARCHAR2(10) := 'a",
+      '/',
+      "b';",
+      "  m VARCHAR2(10) := q'[x",
+      '/',
+      "]';",
+      'BEGIN NULL; END;',
+      '/',
+    ].join('\n');
+    const f = extractPlSqlFacts(src);
+    expect(f.segments).toBe(1);
+    expect(f.segmentsWithErrors).toBe(0);
+    expect(f.definitions.map((d) => d.name)).toEqual(['P']);
+  });
+
   it('keeps one segment per `/`-terminated unit so an error stays local', () => {
     const f = extractPlSqlFacts(
       'CREATE PROCEDURE ok1 IS BEGIN NULL; END;\n/\nCREATE PROCEDURE bad IS BEGIN ((( END;\n/\nCREATE PROCEDURE ok2 IS BEGIN NULL; END;\n/\n',
@@ -195,6 +216,17 @@ describe('file classification', () => {
     expect(
       looksLikeOraclePlSql('CREATE TRIGGER t BEFORE INSERT ON `x` FOR EACH ROW SET NEW.a = 1;'),
     ).toBe(false);
+    // `AS` headers are shared with T-SQL: PL/SQL statement syntax decides.
+    expect(looksLikeOraclePlSql('CREATE PROCEDURE p AS BEGIN NULL; END;')).toBe(true);
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR REPLACE FUNCTION f RETURN NUMBER AS\nBEGIN\n  RETURN 1;\nEND;',
+      ),
+    ).toBe(true);
+    expect(looksLikeOraclePlSql('CREATE PROCEDURE p AS\nBEGIN\n  SELECT 1;\nEND;')).toBe(false);
+    expect(
+      looksLikeOraclePlSql('CREATE PROCEDURE p AS\nBEGIN\n  SET @x = NULL;\n  SELECT @x;\nEND;'),
+    ).toBe(false);
     // `IS` after the header is Oracle-only, no other marker needed.
     expect(looksLikeOraclePlSql('CREATE PROCEDURE p IS BEGIN NULL; END;')).toBe(true);
     // T-SQL without GO: `AS` header, `IS NULL` only inside the body.
diff --git a/gitnexus/test/unit/plsql-lazy-parser.test.ts b/gitnexus/test/unit/plsql-lazy-parser.test.ts
index 5e6532c52..6d4c05d71 100644
--- a/gitnexus/test/unit/plsql-lazy-parser.test.ts
+++ b/gitnexus/test/unit/plsql-lazy-parser.test.ts
@@ -33,10 +33,18 @@ const LIGHT_MODULES = [
 
 const HEAVY = /(?:^|\/)(?:extract|parse)\.js$|\/generated\/|^antlr4ng$/;
 
-/** Every `import … from '…'` whose clause is not `import type`. */
+/**
+ * Every module specifier this file evaluates at load: `import … from '…'`
+ * (not `import type`), side-effect `import '…'`, and `export … from '…'`
+ * (not `export type`) — a re-export evaluates its target too.
+ */
 function valueImports(source: string): string[] {
   const out: string[] = [];
-  for (const m of source.matchAll(/^import\s+(type\s+)?[\s\S]*?\s+from\s+'([^']+)';/gm)) {
+  for (const m of source.matchAll(/^import\s+(type\s+)?[^;']*?\s+from\s+'([^']+)';/gm)) {
+    if (!m[1]) out.push(m[2]!);
+  }
+  for (const m of source.matchAll(/^import\s+'([^']+)';/gm)) out.push(m[1]!);
+  for (const m of source.matchAll(/^export\s+(type\s+)?(?:\*|\{[^}]*\})\s+from\s+'([^']+)';/gm)) {
     if (!m[1]) out.push(m[2]!);
   }
   return out;
@@ -48,6 +56,14 @@ describe('PL/SQL parser loads lazily', () => {
     expect(valueImports(source).filter((spec) => HEAVY.test(spec))).toEqual([]);
   });
 
+  it('the scanner sees side-effect imports and re-exports', () => {
+    expect(
+      valueImports(
+        "import './generated/PlSqlParser.js';\nexport { extractPlSqlFacts } from './extract.js';\nexport type { X } from './extract.js';\n",
+      ),
+    ).toEqual(['./generated/PlSqlParser.js', './extract.js']);
+  });
+
   it('facts-store reaches the extractor only through dynamic loading', () => {
     const source = readFileSync(path.join(INGESTION, 'plsql/facts-store.ts'), 'utf8');
     expect(source).toMatch(/await import\('\.\/extract\.js'\)/);
diff --git a/gitnexus/test/unit/plsql-preprocess.test.ts b/gitnexus/test/unit/plsql-preprocess.test.ts
index cc82b9a45..b71f9d95e 100644
--- a/gitnexus/test/unit/plsql-preprocess.test.ts
+++ b/gitnexus/test/unit/plsql-preprocess.test.ts
@@ -86,6 +86,21 @@ describe('stripSqlPlusCommands', () => {
     ]);
   });
 
+  it('keeps SET TRANSACTION / SET ROLE / SET CONSTRAINTS, which are SQL statements', () => {
+    const src = [
+      'SET TRANSACTION READ ONLY;',
+      'SET ROLE app_role;',
+      'SET CONSTRAINTS ALL DEFERRED;',
+      'SET ECHO ON',
+    ].join('\n');
+    expect(lines(stripSqlPlusCommands(src))).toEqual([
+      'SET TRANSACTION READ ONLY;',
+      'SET ROLE app_role;',
+      'SET CONSTRAINTS ALL DEFERRED;',
+      '',
+    ]);
+  });
+
   it('reports blanked commands to the sink', () => {
     const commands: SqlPlusCommand[] = [];
     stripSqlPlusCommands('REM header\n@@a.sql\n', commands);
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index 328847815..1dd63623a 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -109,6 +109,29 @@ END a;
     expect(calls).toEqual(['F@L7']);
   });
 
+  it('binds `S.P` to the standalone subprogram of schema S, never one of another schema', () => {
+    const { graph } = run({
+      'db/procs.sql': `CREATE OR REPLACE PROCEDURE a.p IS BEGIN NULL; END p;
+/
+CREATE OR REPLACE PROCEDURE b.p IS BEGIN NULL; END p;
+/
+CREATE OR REPLACE PROCEDURE caller IS
+BEGIN
+  b.p;
+  c.p;
+END caller;
+/
+`,
+    });
+    const targets: number[] = [];
+    for (const rel of graph.iterRelationships()) {
+      if (rel.type === 'CALLS')
+        targets.push(graph.getNode(rel.targetId)!.properties.startLine! + 1);
+    }
+    // b.p resolves to line 3; c.p names a schema with no indexed P and stays unresolved.
+    expect(targets).toEqual([3]);
+  });
+
   it('keeps forward-declared private subprograms private', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE PACKAGE BODY p AS

From 59ec3033a51ccb79f92cebabeec8ddb701a51874 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 10:10:01 +0800
Subject: [PATCH 07/17] fix(plsql): address fifth review round
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- a table read over a database link (`t@link`) is its own Record, never the
  local table of the same name
- the parse deadline now covers lexing (tokens are lexed once, under the
  deadline, and shared by the SLL and LL passes), every consumed token and
  every adaptive prediction, besides rule entry
- proximity picks between entities, not entries: a spec declaration and its
  body (same package instance and signature) are weighed together, so a body
  in another folder is not discarded when the caller sits next to the spec;
  the processor and scope resolver tag index entries with package instances
- the lazy-parser guard reads either quote style and multi-line imports, and
  its last test names both loading paths facts-store owns
- T-SQL trigger negatives pin that `CREATE TRIGGER t ON … AFTER …` is never
  classified as Oracle (the Oracle header requires the timing right after
  the name)

Corpus unchanged: 618 files, 8,829 call sites with targets, 54 degraded
segments, 0 timeouts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../languages/plsql/scope-resolver.ts         | 25 ++++-
 .../src/core/ingestion/plsql-processor.ts     | 19 +++-
 gitnexus/src/core/ingestion/plsql/parse.ts    | 93 ++++++++++++-------
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 37 +++++++-
 gitnexus/test/unit/plsql-extract.test.ts      | 24 +++++
 gitnexus/test/unit/plsql-lazy-parser.test.ts  | 37 ++++++--
 gitnexus/test/unit/plsql-processor.test.ts    | 32 +++++++
 7 files changed, 218 insertions(+), 49 deletions(-)

diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
index 3dddaa1b2..9676bee7d 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -16,6 +16,7 @@ import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolv
 import { plsqlProvider } from '../plsql.js';
 import {
   PlSqlNameIndex,
+  PlSqlPackageInstances,
   nearestByPath,
   rootPackageOf,
   type PlSqlIndexEntry,
@@ -64,6 +65,7 @@ const plsqlScopeResolver: ScopeResolver = {
     const record = context.recordSourceBinding;
 
     const index = new PlSqlNameIndex<BoundEntry>();
+    const entries: Array<{ entry: BoundEntry; fileDefs: readonly PlSqlDefinition[] }> = [];
     const symbolOf = new Map<PlSqlDefinition, SymbolDefinition>();
     const files = parsedFiles.map((parsed) => {
       const facts = plsqlFactsFor(context.fileContents.get(parsed.filePath) ?? '', parsed.filePath);
@@ -74,17 +76,36 @@ const plsqlScopeResolver: ScopeResolver = {
         const symbol = byNameRange.get(plsqlRangeKey(plsqlNameRange(def)));
         if (!symbol) continue;
         symbolOf.set(def, symbol);
-        index.add({
+        const entry: BoundEntry = {
           def,
           filePath: parsed.filePath,
           symbol,
           packageSchema:
             def.kind === 'package' ? undefined : rootPackageOf(def, facts.definitions)?.schema,
-        });
+        };
+        entries.push({ entry, fileDefs: facts.definitions });
+        index.add(entry);
       }
       return { parsed, facts };
     });
 
+    // Same package instances as the processor, so a declaration and its body
+    // are weighed as one entity (see `PlSqlNameIndex.resolve`).
+    const instances = new PlSqlPackageInstances(
+      entries
+        .filter(({ entry }) => entry.def.kind === 'package')
+        .map(({ entry }) => ({
+          name: entry.def.name,
+          schema: entry.def.schema,
+          filePath: entry.filePath,
+          isSpec: entry.def.isSpec,
+        })),
+    );
+    for (const { entry, fileDefs } of entries) {
+      const pkg = rootPackageOf(entry.def, fileDefs);
+      if (pkg) entry.instance = instances.instanceOf(pkg.name, pkg.schema, entry.filePath);
+    }
+
     // A package name denotes the package instance nearest the reference; its
     // spec when indexed.
     const packageSymbols = new Map<
diff --git a/gitnexus/src/core/ingestion/plsql-processor.ts b/gitnexus/src/core/ingestion/plsql-processor.ts
index a30888ac1..0c7cae905 100644
--- a/gitnexus/src/core/ingestion/plsql-processor.ts
+++ b/gitnexus/src/core/ingestion/plsql-processor.ts
@@ -196,6 +196,10 @@ export function processPlSql(
   }
   for (const entry of packageDefs) {
     entry.nodeId = packageNodeByInstance.get(instanceOfPackage(entry.def, entry.filePath));
+    entry.instance = instanceOfPackage(entry.def, entry.filePath);
+  }
+  for (const entry of entryOf.values()) {
+    if (entry.def.kind !== 'package') entry.instance = memberInstance(entry.def, entry.filePath);
   }
 
   // ── subprograms and triggers ──
@@ -335,21 +339,26 @@ export function processPlSql(
     for (const access of f.accesses) {
       const sourceId = ownerNode(filePath, f, access);
       if (!sourceId) continue;
-      const tableId = plsqlTableNodeId(access.table);
-      if (!tables.has(access.table)) {
-        tables.add(access.table);
+      // A table over a database link is a remote object, not the local table
+      // of the same name: its identity keeps the link.
+      const tableName = access.dbLink ? `${access.table}@${access.dbLink}` : access.table;
+      const tableId = plsqlTableNodeId(tableName);
+      if (!tables.has(tableName)) {
+        tables.add(tableName);
         graph.addNode({
           id: tableId,
           label: 'Record',
           properties: {
-            name: access.table,
+            name: tableName,
             // A table is a database object, not source; anchor it at its first
             // reference so it stays navigable.
             filePath,
             startLine: toZeroBasedLine(access.line),
             endLine: toZeroBasedLine(access.line),
             language: SupportedLanguages.PlSql,
-            description: 'database table or view referenced from PL/SQL',
+            description: access.dbLink
+              ? `remote table or view over database link ${access.dbLink}, referenced from PL/SQL`
+              : 'database table or view referenced from PL/SQL',
           },
         });
       }
diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
index ffbecb1c8..651c792f7 100644
--- a/gitnexus/src/core/ingestion/plsql/parse.ts
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -19,6 +19,8 @@ import {
   CharStream,
   CommonTokenStream,
   DefaultErrorStrategy,
+  ListTokenSource,
+  Token,
   ParseCancellationException,
   PredictionMode,
   type ATNSimulator,
@@ -26,7 +28,6 @@ import {
   type ParserRuleContext,
   type RecognitionException,
   type Recognizer,
-  type Token,
 } from 'antlr4ng';
 import { PlSqlLexer } from './generated/PlSqlLexer.js';
 import { PlSqlParser, type Sql_scriptContext } from './generated/PlSqlParser.js';
@@ -96,66 +97,92 @@ class CountingErrorListener extends BaseErrorListener {
 
 class DeadlineExceeded extends Error {}
 
-/** Parse listener that aborts once the deadline passes (checked every 512 rules). */
-function deadlineListener(deadline: number): ParseTreeListener {
+/** Throws once `deadline` has passed; checked on every 256th call to stay cheap. */
+function deadlineGuard(deadline: number): () => void {
   let ticks = 0;
+  return () => {
+    if ((++ticks & 255) === 0 && performance.now() > deadline) throw new DeadlineExceeded();
+  };
+}
+
+/** Parse listener that runs the guard on every rule entry and every consumed token. */
+function deadlineListener(check: () => void): ParseTreeListener {
   return {
-    visitTerminal() {},
+    visitTerminal: check,
     visitErrorNode() {},
-    enterEveryRule() {
-      if ((++ticks & 511) === 0 && performance.now() > deadline) throw new DeadlineExceeded();
-    },
+    enterEveryRule: check,
     exitEveryRule() {},
   };
 }
 
 /**
- * Parser over `text`. Lexer errors (characters no token rule matches) are
- * counted too: the lexer skips them and the parser may then succeed, so they
- * must still mark the segment as degraded.
+ * Tokens of `text`, lexed once under the deadline (SLL and LL re-use them).
+ * Lexer errors (characters no token rule matches) are counted: the lexer
+ * skips them and the parser may then succeed, so they must still mark the
+ * segment as degraded.
  */
-function newParser(text: string): { parser: PlSqlParser; lexerErrors: CountingErrorListener } {
+function lex(
+  text: string,
+  check: () => void,
+): { tokens: Token[]; lexerErrors: CountingErrorListener } {
   const lexer = new PlSqlLexer(CharStream.fromString(text));
   lexer.removeErrorListeners();
   const lexerErrors = new CountingErrorListener();
   lexer.addErrorListener(lexerErrors);
-  const parser = new PlSqlParser(new CommonTokenStream(lexer));
+  const tokens: Token[] = [];
+  for (;;) {
+    check();
+    const token = lexer.nextToken();
+    tokens.push(token);
+    if (token.type === Token.EOF) break;
+  }
+  return { tokens, lexerErrors };
+}
+
+/**
+ * Parser over pre-lexed tokens with the deadline checked on rule entry, on
+ * every consumed token and before every adaptive prediction. A single
+ * prediction cannot be interrupted (ANTLR exposes no hook inside one).
+ */
+function newParser(tokens: Token[], check: () => void): PlSqlParser {
+  const parser = new PlSqlParser(new CommonTokenStream(new ListTokenSource(tokens)));
   parser.removeErrorListeners();
-  return { parser, lexerErrors };
+  parser.addParseListener(deadlineListener(check));
+  const interpreter = parser.interpreter;
+  const predict = interpreter.adaptivePredict.bind(interpreter);
+  interpreter.adaptivePredict = (...args: Parameters<typeof predict>) => {
+    check();
+    return predict(...args);
+  };
+  return parser;
 }
 
 function parseSegment(
   text: string,
   deadlineMs: number,
 ): Omit<PlSqlSegment, 'startLine' | 'endLine' | 'text'> {
-  const deadline = performance.now() + deadlineMs;
+  const check = deadlineGuard(performance.now() + deadlineMs);
   try {
-    const sll = newParser(text);
-    sll.parser.interpreter.predictionMode = PredictionMode.SLL;
-    sll.parser.errorHandler = new BailErrorStrategy();
-    sll.parser.addParseListener(deadlineListener(deadline));
+    const { tokens, lexerErrors } = lex(text, check);
+    const sll = newParser(tokens, check);
+    sll.interpreter.predictionMode = PredictionMode.SLL;
+    sll.errorHandler = new BailErrorStrategy();
     try {
-      const tree = sll.parser.sql_script();
-      return {
-        tree,
-        syntaxErrors: sll.lexerErrors.count,
-        firstError: sll.lexerErrors.first,
-        mode: 'sll',
-      };
+      const tree = sll.sql_script();
+      return { tree, syntaxErrors: lexerErrors.count, firstError: lexerErrors.first, mode: 'sll' };
     } catch (e) {
       if (!(e instanceof ParseCancellationException)) throw e;
     }
-    const ll = newParser(text);
+    const ll = newParser(tokens, check);
     const errors = new CountingErrorListener();
-    ll.parser.addErrorListener(errors);
-    ll.parser.interpreter.predictionMode = PredictionMode.LL;
-    ll.parser.errorHandler = new DefaultErrorStrategy();
-    ll.parser.addParseListener(deadlineListener(deadline));
-    const tree = ll.parser.sql_script();
+    ll.addErrorListener(errors);
+    ll.interpreter.predictionMode = PredictionMode.LL;
+    ll.errorHandler = new DefaultErrorStrategy();
+    const tree = ll.sql_script();
     return {
       tree,
-      syntaxErrors: errors.count + ll.lexerErrors.count,
-      firstError: ll.lexerErrors.first ?? errors.first,
+      syntaxErrors: errors.count + lexerErrors.count,
+      firstError: lexerErrors.first ?? errors.first,
       mode: 'll',
     };
   } catch (e) {
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index ff90a52f6..33eb5e5fb 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -24,6 +24,12 @@ export interface PlSqlIndexEntry {
   readonly filePath: string;
   /** Schema written on the enclosing package (`CREATE PACKAGE loan.pkg`), if any. */
   readonly packageSchema?: string;
+  /**
+   * Package instance (`PlSqlPackageInstances.instanceOf`) of a package member,
+   * so a spec declaration and its body — often in different folders — are
+   * weighed as one entity when proximity picks between copies.
+   */
+  instance?: string;
 }
 
 /**
@@ -139,10 +145,39 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
     fromFile: string,
   ): E[] {
     const narrowed = preferWrittenSchema(narrowOverloads(this.candidates(call), call), call);
-    return preferImplementations(nearestByPath(narrowed, fromFile));
+    return preferImplementations(nearestEntities(narrowed, fromFile));
   }
 }
 
+/**
+ * Proximity over entities, not entries: a spec declaration and its body (same
+ * package instance and signature) form one entity whose distance is that of
+ * its nearest member, so a body in another folder is not discarded because
+ * the caller sits next to the spec. Standalone subprograms are one entity per
+ * file.
+ */
+function nearestEntities<E extends PlSqlIndexEntry>(candidates: E[], fromFile: string): E[] {
+  if (candidates.length <= 1) return candidates;
+  const groups = new Map<string, E[]>();
+  for (const c of candidates) {
+    const key = `${c.instance ?? c.filePath}\0${plsqlSignatureKey(c.def)}`;
+    const group = groups.get(key);
+    if (group) group.push(c);
+    else groups.set(key, [c]);
+  }
+  const distance = (group: E[]) =>
+    Math.max(
+      ...group.map((c) =>
+        c.filePath === fromFile
+          ? Number.MAX_SAFE_INTEGER
+          : sharedDirectoryDepth(c.filePath, fromFile),
+      ),
+    );
+  const scored = [...groups.values()].map((g) => ({ g, d: distance(g) }));
+  const best = Math.max(...scored.map((s) => s.d));
+  return scored.filter((s) => s.d === best).flatMap((s) => s.g);
+}
+
 /** In `S.A.N`, keep members of packages declared in schema `S` when any are indexed. */
 function preferWrittenSchema<E extends PlSqlIndexEntry>(
   candidates: E[],
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index 0c071790d..77de18b4f 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -159,6 +159,18 @@ END pkg_x;
     expect(f.definitions.map((d) => d.name)).toEqual(['P']);
   });
 
+  it('abandons a segment at the deadline, including while lexing, and falls back', () => {
+    const body = Array.from(
+      { length: 200 },
+      (_, i) => `  PROCEDURE p${i} IS BEGIN x := ${i}; END p${i};`,
+    ).join('\n');
+    const f = extractPlSqlFacts(`CREATE OR REPLACE PACKAGE BODY big AS\n${body}\nEND big;\n/\n`, {
+      segmentDeadlineMs: 0,
+    });
+    expect(f.segmentsTimedOut).toBe(1);
+    expect(f.definitions.filter((d) => d.fromFallback).length).toBeGreaterThan(100);
+  });
+
   it('keeps one segment per `/`-terminated unit so an error stays local', () => {
     const f = extractPlSqlFacts(
       'CREATE PROCEDURE ok1 IS BEGIN NULL; END;\n/\nCREATE PROCEDURE bad IS BEGIN ((( END;\n/\nCREATE PROCEDURE ok2 IS BEGIN NULL; END;\n/\n',
@@ -227,6 +239,18 @@ describe('file classification', () => {
     expect(
       looksLikeOraclePlSql('CREATE PROCEDURE p AS\nBEGIN\n  SET @x = NULL;\n  SELECT @x;\nEND;'),
     ).toBe(false);
+    // T-SQL triggers name the table (`ON …`) before the timing keyword, so the
+    // Oracle trigger header never matches them.
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE TRIGGER t ON dbo.x AFTER INSERT AS BEGIN UPDATE dbo.x SET a = 1; END;',
+      ),
+    ).toBe(false);
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR ALTER TRIGGER t ON dbo.v INSTEAD OF INSERT AS BEGIN SELECT 1; END;',
+      ),
+    ).toBe(false);
     // `IS` after the header is Oracle-only, no other marker needed.
     expect(looksLikeOraclePlSql('CREATE PROCEDURE p IS BEGIN NULL; END;')).toBe(true);
     // T-SQL without GO: `AS` header, `IS NULL` only inside the body.
diff --git a/gitnexus/test/unit/plsql-lazy-parser.test.ts b/gitnexus/test/unit/plsql-lazy-parser.test.ts
index 6d4c05d71..186f0ca6d 100644
--- a/gitnexus/test/unit/plsql-lazy-parser.test.ts
+++ b/gitnexus/test/unit/plsql-lazy-parser.test.ts
@@ -40,12 +40,15 @@ const HEAVY = /(?:^|\/)(?:extract|parse)\.js$|\/generated\/|^antlr4ng$/;
  */
 function valueImports(source: string): string[] {
   const out: string[] = [];
-  for (const m of source.matchAll(/^import\s+(type\s+)?[^;']*?\s+from\s+'([^']+)';/gm)) {
-    if (!m[1]) out.push(m[2]!);
+  // Either quote style; clauses may span lines but never cross a `;`.
+  for (const m of source.matchAll(/^import\s+(type\s+)?[^;'"]*?\s+from\s+(['"])([^'"]+)\2/gm)) {
+    if (!m[1]) out.push(m[3]!);
   }
-  for (const m of source.matchAll(/^import\s+'([^']+)';/gm)) out.push(m[1]!);
-  for (const m of source.matchAll(/^export\s+(type\s+)?(?:\*|\{[^}]*\})\s+from\s+'([^']+)';/gm)) {
-    if (!m[1]) out.push(m[2]!);
+  for (const m of source.matchAll(/^import\s+(['"])([^'"]+)\1/gm)) out.push(m[2]!);
+  for (const m of source.matchAll(
+    /^export\s+(type\s+)?(?:\*(?:\s+as\s+[\w$]+)?|\{[^}]*\})\s+from\s+(['"])([^'"]+)\2/gm,
+  )) {
+    if (!m[1]) out.push(m[3]!);
   }
   return out;
 }
@@ -59,13 +62,31 @@ describe('PL/SQL parser loads lazily', () => {
   it('the scanner sees side-effect imports and re-exports', () => {
     expect(
       valueImports(
-        "import './generated/PlSqlParser.js';\nexport { extractPlSqlFacts } from './extract.js';\nexport type { X } from './extract.js';\n",
+        [
+          "import './generated/PlSqlParser.js';",
+          "export { extractPlSqlFacts } from './extract.js';",
+          "export type { X } from './extract.js';",
+          'import { PlSqlLexer } from "./generated/PlSqlLexer.js";',
+          'import {',
+          '  ParseTreeWalker,',
+          '  ParserRuleContext,',
+          "} from 'antlr4ng';",
+          "import type { Y } from './extract.js';",
+          "export * as all from './parse.js';",
+        ].join('\n'),
       ),
-    ).toEqual(['./generated/PlSqlParser.js', './extract.js']);
+    ).toEqual([
+      './generated/PlSqlLexer.js',
+      'antlr4ng',
+      './generated/PlSqlParser.js',
+      './extract.js',
+      './parse.js',
+    ]);
   });
 
-  it('facts-store reaches the extractor only through dynamic loading', () => {
+  it('facts-store is the one place the extractor is loaded: dynamically, or by its require fallback', () => {
     const source = readFileSync(path.join(INGESTION, 'plsql/facts-store.ts'), 'utf8');
     expect(source).toMatch(/await import\('\.\/extract\.js'\)/);
+    expect(source).toMatch(/createRequire\(import\.meta\.url\)\('\.\/extract\.js'\)/);
   });
 });
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index 1dd63623a..2bfe72160 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -132,6 +132,38 @@ END caller;
     expect(targets).toEqual([3]);
   });
 
+  it('keeps a table over a database link apart from the local table of the same name', () => {
+    const { graph } = run({
+      'p.prc': `CREATE OR REPLACE PROCEDURE p IS
+BEGIN
+  INSERT INTO t_orders SELECT * FROM t_orders@core_link;
+END p;
+/
+`,
+    });
+    const records: string[] = [];
+    graph.forEachNode((n) => {
+      if (n.label === 'Record') records.push(n.properties.name);
+    });
+    expect(records.sort()).toEqual(['T_ORDERS', 'T_ORDERS@CORE_LINK']);
+  });
+
+  it('binds to the body when the caller sits next to the spec and the body lives elsewhere', () => {
+    const { graph } = run({
+      'db/api/pkg_fee.pks':
+        'CREATE OR REPLACE PACKAGE pkg_fee AS\n  FUNCTION fee RETURN NUMBER;\nEND pkg_fee;\n/\n',
+      'db/api/settle.prc':
+        'CREATE OR REPLACE PROCEDURE settle IS\n  x NUMBER;\nBEGIN\n  x := pkg_fee.fee();\nEND settle;\n/\n',
+      'db/impl/pkg_fee.pkb':
+        'CREATE OR REPLACE PACKAGE BODY pkg_fee AS\n  FUNCTION fee RETURN NUMBER IS BEGIN RETURN 1; END fee;\nEND pkg_fee;\n/\n',
+    });
+    const targets: string[] = [];
+    for (const rel of graph.iterRelationships()) {
+      if (rel.type === 'CALLS') targets.push(graph.getNode(rel.targetId)!.properties.filePath);
+    }
+    expect(targets).toEqual(['db/impl/pkg_fee.pkb']);
+  });
+
   it('keeps forward-declared private subprograms private', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE PACKAGE BODY p AS

From e00b4e9560d5225e541c38f6147d13577a8eb6c6 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 10:18:03 +0800
Subject: [PATCH 08/17] fix(plsql): read the clock after every prediction and
 before accepting a tree

The throttled guard reads the clock on every 256th tick, so a single
prediction that overran the segment budget could be followed by too few
ticks to notice before the parse returned a tree. Check unthrottled right
after each adaptive prediction and before an SLL or LL tree is accepted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gitnexus/src/core/ingestion/plsql/parse.ts | 57 ++++++++++++++--------
 gitnexus/test/unit/plsql-extract.test.ts   | 11 +++++
 2 files changed, 49 insertions(+), 19 deletions(-)

diff --git a/gitnexus/src/core/ingestion/plsql/parse.ts b/gitnexus/src/core/ingestion/plsql/parse.ts
index 651c792f7..bada141e8 100644
--- a/gitnexus/src/core/ingestion/plsql/parse.ts
+++ b/gitnexus/src/core/ingestion/plsql/parse.ts
@@ -97,20 +97,32 @@ class CountingErrorListener extends BaseErrorListener {
 
 class DeadlineExceeded extends Error {}
 
-/** Throws once `deadline` has passed; checked on every 256th call to stay cheap. */
-function deadlineGuard(deadline: number): () => void {
+interface DeadlineGuard {
+  /** Throws once the deadline has passed; reads the clock on every 256th call to stay cheap. */
+  tick(): void;
+  /** Throws once the deadline has passed; always reads the clock. */
+  now(): void;
+}
+
+function deadlineGuard(deadline: number): DeadlineGuard {
   let ticks = 0;
-  return () => {
-    if ((++ticks & 255) === 0 && performance.now() > deadline) throw new DeadlineExceeded();
+  const now = () => {
+    if (performance.now() > deadline) throw new DeadlineExceeded();
+  };
+  return {
+    tick: () => {
+      if ((++ticks & 255) === 0) now();
+    },
+    now,
   };
 }
 
 /** Parse listener that runs the guard on every rule entry and every consumed token. */
-function deadlineListener(check: () => void): ParseTreeListener {
+function deadlineListener(guard: DeadlineGuard): ParseTreeListener {
   return {
-    visitTerminal: check,
+    visitTerminal: () => guard.tick(),
     visitErrorNode() {},
-    enterEveryRule: check,
+    enterEveryRule: () => guard.tick(),
     exitEveryRule() {},
   };
 }
@@ -123,7 +135,7 @@ function deadlineListener(check: () => void): ParseTreeListener {
  */
 function lex(
   text: string,
-  check: () => void,
+  guard: DeadlineGuard,
 ): { tokens: Token[]; lexerErrors: CountingErrorListener } {
   const lexer = new PlSqlLexer(CharStream.fromString(text));
   lexer.removeErrorListeners();
@@ -131,7 +143,7 @@ function lex(
   lexer.addErrorListener(lexerErrors);
   const tokens: Token[] = [];
   for (;;) {
-    check();
+    guard.tick();
     const token = lexer.nextToken();
     tokens.push(token);
     if (token.type === Token.EOF) break;
@@ -141,18 +153,22 @@ function lex(
 
 /**
  * Parser over pre-lexed tokens with the deadline checked on rule entry, on
- * every consumed token and before every adaptive prediction. A single
- * prediction cannot be interrupted (ANTLR exposes no hook inside one).
+ * every consumed token and around every adaptive prediction. A single
+ * prediction cannot be interrupted (ANTLR exposes no hook inside one), so the
+ * clock is read unthrottled right after each one: a prediction that overran
+ * the budget ends the parse there instead of being followed by a result.
  */
-function newParser(tokens: Token[], check: () => void): PlSqlParser {
+function newParser(tokens: Token[], guard: DeadlineGuard): PlSqlParser {
   const parser = new PlSqlParser(new CommonTokenStream(new ListTokenSource(tokens)));
   parser.removeErrorListeners();
-  parser.addParseListener(deadlineListener(check));
+  parser.addParseListener(deadlineListener(guard));
   const interpreter = parser.interpreter;
   const predict = interpreter.adaptivePredict.bind(interpreter);
   interpreter.adaptivePredict = (...args: Parameters<typeof predict>) => {
-    check();
-    return predict(...args);
+    guard.tick();
+    const alt = predict(...args);
+    guard.now();
+    return alt;
   };
   return parser;
 }
@@ -161,24 +177,27 @@ function parseSegment(
   text: string,
   deadlineMs: number,
 ): Omit<PlSqlSegment, 'startLine' | 'endLine' | 'text'> {
-  const check = deadlineGuard(performance.now() + deadlineMs);
+  const guard = deadlineGuard(performance.now() + deadlineMs);
   try {
-    const { tokens, lexerErrors } = lex(text, check);
-    const sll = newParser(tokens, check);
+    const { tokens, lexerErrors } = lex(text, guard);
+    const sll = newParser(tokens, guard);
     sll.interpreter.predictionMode = PredictionMode.SLL;
     sll.errorHandler = new BailErrorStrategy();
     try {
       const tree = sll.sql_script();
+      // A tree finished past the budget is still a timeout.
+      guard.now();
       return { tree, syntaxErrors: lexerErrors.count, firstError: lexerErrors.first, mode: 'sll' };
     } catch (e) {
       if (!(e instanceof ParseCancellationException)) throw e;
     }
-    const ll = newParser(tokens, check);
+    const ll = newParser(tokens, guard);
     const errors = new CountingErrorListener();
     ll.addErrorListener(errors);
     ll.interpreter.predictionMode = PredictionMode.LL;
     ll.errorHandler = new DefaultErrorStrategy();
     const tree = ll.sql_script();
+    guard.now();
     return {
       tree,
       syntaxErrors: errors.count + lexerErrors.count,
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index 77de18b4f..09f63cf0e 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -171,6 +171,17 @@ END pkg_x;
     expect(f.definitions.filter((d) => d.fromFallback).length).toBeGreaterThan(100);
   });
 
+  it('reports a timeout when the budget runs out with fewer than 256 guard ticks', () => {
+    // Too small for the throttled checks to read the clock: only the
+    // unthrottled checks after each prediction and before accepting the tree
+    // can notice the deadline.
+    const f = extractPlSqlFacts('CREATE PROCEDURE p IS BEGIN NULL; END;\n/\n', {
+      segmentDeadlineMs: -1,
+    });
+    expect(f.segmentsTimedOut).toBe(1);
+    expect(f.definitions.map((d) => [d.name, d.fromFallback])).toEqual([['P', true]]);
+  });
+
   it('keeps one segment per `/`-terminated unit so an error stays local', () => {
     const f = extractPlSqlFacts(
       'CREATE PROCEDURE ok1 IS BEGIN NULL; END;\n/\nCREATE PROCEDURE bad IS BEGIN ((( END;\n/\nCREATE PROCEDURE ok2 IS BEGIN NULL; END;\n/\n',

From ca8d1b90ffb43d39f076b57b8a1e1926be674ce9 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 10:35:37 +0800
Subject: [PATCH 09/17] fix(plsql): pair spec and body within one package
 instance

- preferImplementations keys bodies by package instance + signature, so the
  body of one package copy no longer hides the declaration of another
  equally near copy (which turned an ambiguous call into a resolved one).
- Package qualifiers measure proximity per package instance (nearest spec
  or body file) and bind to that instance's spec, even when its body is
  nearer to the reference than the spec.
- generated/README: state that the generated parser is committed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../languages/plsql/scope-resolver.ts         | 28 +++++++++++++----
 .../core/ingestion/plsql/generated/README.md  |  4 ++-
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 31 ++++++++++++++-----
 gitnexus/test/unit/plsql-processor.test.ts    | 31 +++++++++++++++++++
 4 files changed, 80 insertions(+), 14 deletions(-)

diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
index 9676bee7d..f169ea3b7 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -17,7 +17,7 @@ import { plsqlProvider } from '../plsql.js';
 import {
   PlSqlNameIndex,
   PlSqlPackageInstances,
-  nearestByPath,
+  nearestGroups,
   rootPackageOf,
   type PlSqlIndexEntry,
 } from '../../plsql/resolve.js';
@@ -106,16 +106,28 @@ const plsqlScopeResolver: ScopeResolver = {
       if (pkg) entry.instance = instances.instanceOf(pkg.name, pkg.schema, entry.filePath);
     }
 
-    // A package name denotes the package instance nearest the reference; its
-    // spec when indexed.
+    // A package name denotes the package instance nearest the reference (as
+    // near as its nearest spec or body file); its spec when indexed.
     const packageSymbols = new Map<
       string,
-      Array<{ filePath: string; symbol: SymbolDefinition; isSpec: boolean; schema?: string }>
+      Array<{
+        filePath: string;
+        symbol: SymbolDefinition;
+        isSpec: boolean;
+        schema?: string;
+        instance: string;
+      }>
     >();
     for (const [def, symbol] of symbolOf) {
       if (def.kind !== 'package') continue;
       const list = packageSymbols.get(def.name) ?? [];
-      list.push({ filePath: symbol.filePath, symbol, isSpec: def.isSpec, schema: def.schema });
+      list.push({
+        filePath: symbol.filePath,
+        symbol,
+        isSpec: def.isSpec,
+        schema: def.schema,
+        instance: instances.instanceOf(def.name, def.schema, symbol.filePath),
+      });
       packageSymbols.set(def.name, list);
     }
     /** In `S.A.N` the written schema `S` narrows same-named packages first. */
@@ -126,7 +138,11 @@ const plsqlScopeResolver: ScopeResolver = {
     ): SymbolDefinition | undefined => {
       const all = packageSymbols.get(name) ?? [];
       const inSchema = schema === undefined ? [] : all.filter((p) => p.schema === schema);
-      const nearest = nearestByPath(inSchema.length > 0 ? inSchema : all, fromFile);
+      const nearest = nearestGroups(
+        inSchema.length > 0 ? inSchema : all,
+        fromFile,
+        (p) => p.instance,
+      );
       return (nearest.find((p) => p.isSpec) ?? nearest[0])?.symbol;
     };
 
diff --git a/gitnexus/src/core/ingestion/plsql/generated/README.md b/gitnexus/src/core/ingestion/plsql/generated/README.md
index ae1ac6eab..7cf0d7c85 100644
--- a/gitnexus/src/core/ingestion/plsql/generated/README.md
+++ b/gitnexus/src/core/ingestion/plsql/generated/README.md
@@ -3,7 +3,9 @@
 `PlSqlLexer.ts`, `PlSqlParser.ts` and `PlSqlParserListener.ts` are generated by
 [antlr-ng](https://www.npmjs.com/package/antlr-ng) 1.0.10 for the
 [antlr4ng](https://www.npmjs.com/package/antlr4ng) runtime from the grammars in
-`../grammar/`. Regenerate with:
+`../grammar/`. They are committed, so a clean checkout builds with plain `tsc`
+and no Java or ANTLR tool at build time. Regenerate after changing the grammar
+with:
 
 ```sh
 cd gitnexus && node scripts/generate-plsql-parser.mjs
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index 33eb5e5fb..bfcf345c1 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -157,10 +157,27 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
  * file.
  */
 function nearestEntities<E extends PlSqlIndexEntry>(candidates: E[], fromFile: string): E[] {
-  if (candidates.length <= 1) return candidates;
+  return nearestGroups<E>(candidates, fromFile, entityKey);
+}
+
+/** One subprogram of one package instance (or of one standalone file). */
+function entityKey(e: PlSqlIndexEntry): string {
+  return `${e.instance ?? e.filePath}\0${plsqlSignatureKey(e.def)}`;
+}
+
+/**
+ * Keep the candidates of the nearest group(s), where a group (all entries
+ * sharing `keyOf`) is as near to `fromFile` as its nearest member.
+ */
+export function nearestGroups<E extends { readonly filePath: string }>(
+  candidates: readonly E[],
+  fromFile: string,
+  keyOf: (candidate: E) => string,
+): E[] {
+  if (candidates.length <= 1) return [...candidates];
   const groups = new Map<string, E[]>();
   for (const c of candidates) {
-    const key = `${c.instance ?? c.filePath}\0${plsqlSignatureKey(c.def)}`;
+    const key = keyOf(c);
     const group = groups.get(key);
     if (group) group.push(c);
     else groups.set(key, [c]);
@@ -221,13 +238,13 @@ function narrowOverloads<E extends PlSqlIndexEntry>(
 
 /**
  * A spec (or forward) declaration and its body describe one subprogram; prefer
- * the body. Declaration-only entries remain when no body is a candidate.
+ * the body. Pairing is per package instance, so a body in one copy of a
+ * package never hides the declaration of another copy. Declaration-only
+ * entries remain when their own instance has no body among the candidates.
  */
 function preferImplementations<E extends PlSqlIndexEntry>(defs: E[]): E[] {
-  const bodies = new Set(
-    defs.filter((d) => !d.def.declarationOnly).map((d) => plsqlSignatureKey(d.def)),
-  );
-  return defs.filter((d) => !d.def.declarationOnly || !bodies.has(plsqlSignatureKey(d.def)));
+  const bodies = new Set(defs.filter((d) => !d.def.declarationOnly).map(entityKey));
+  return defs.filter((d) => !d.def.declarationOnly || !bodies.has(entityKey(d)));
 }
 
 /**
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index 2bfe72160..953986f23 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -7,6 +7,7 @@ import {
   plsqlFactsForFile,
   resetPlSqlFactsStore,
 } from '../../src/core/ingestion/plsql/facts-store.js';
+import { nearestGroups } from '../../src/core/ingestion/plsql/resolve.js';
 import {
   segmentDeadlineMs,
   SEGMENT_DEADLINE_FLOOR_MS,
@@ -164,6 +165,36 @@ END p;
     expect(targets).toEqual(['db/impl/pkg_fee.pkb']);
   });
 
+  it('never lets the body of one package copy hide the declaration of another', () => {
+    const spec =
+      'CREATE OR REPLACE PACKAGE pkg_fee AS\n  FUNCTION fee RETURN NUMBER;\nEND pkg_fee;\n/\n';
+    const { graph, result } = run({
+      'a/pkg_fee.pks': spec,
+      'a/pkg_fee.pkb':
+        'CREATE OR REPLACE PACKAGE BODY pkg_fee AS\n  FUNCTION fee RETURN NUMBER IS BEGIN RETURN 1; END fee;\nEND pkg_fee;\n/\n',
+      'b/pkg_fee.pks': spec,
+      'settle.prc':
+        'CREATE OR REPLACE PROCEDURE settle IS\n  x NUMBER;\nBEGIN\n  x := pkg_fee.fee();\nEND settle;\n/\n',
+    });
+    // Both copies are equally near: the body of `a` and the spec of `b` stay candidates.
+    expect(edges(graph, 'CALLS')).toEqual([
+      'SETTLE@L1 -> FEE@a/pkg_fee.pkb',
+      'SETTLE@L1 -> FEE@b/pkg_fee.pks',
+    ]);
+    expect(result.ambiguousCalls).toBe(1);
+  });
+
+  it('measures a package instance by its nearest spec or body file', () => {
+    const pkg = [
+      { filePath: 'db/api/pkg_fee.pks', instance: 'A', isSpec: true },
+      { filePath: 'db/impl/pkg_fee.pkb', instance: 'A', isSpec: false },
+      { filePath: 'other/pkg_fee.pks', instance: 'B', isSpec: true },
+    ];
+    const nearest = nearestGroups(pkg, 'db/impl/settle.prc', (p) => p.instance);
+    // The whole instance is kept, so a qualifier binds to its spec, not just the nearer body.
+    expect(nearest.map((p) => p.filePath)).toEqual(['db/api/pkg_fee.pks', 'db/impl/pkg_fee.pkb']);
+  });
+
   it('keeps forward-declared private subprograms private', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE PACKAGE BODY p AS

From 47ee17c7cca91abdc6bd798352fd120fe06ac99d Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 10:52:10 +0800
Subject: [PATCH 10/17] docs(plsql): explain why parameter names are part of
 the signature key

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gitnexus/src/core/ingestion/plsql/resolve.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index bfcf345c1..8b5a68520 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -63,7 +63,13 @@ export function dottedName(parts: readonly string[]): string {
   return parts.map((p) => (p.includes('.') ? `"${p}"` : p)).join('.');
 }
 
-/** Owner path + name + parameter signature: identifies a spec declaration with its body. */
+/**
+ * Owner path + name + parameter signature: identifies a spec declaration with
+ * its body. Oracle requires the two headings to match word for word apart from
+ * white space (PLS-00323 otherwise), so parameter names are part of the key —
+ * which also keeps apart overloads that differ only in parameter names, told
+ * apart by named-argument calls. Type text is whitespace-free and upper-cased.
+ */
 export function plsqlSignatureKey(
   def: Pick<PlSqlDefinition, 'ownerPath' | 'name' | 'parameters'>,
 ): string {

From 43c2b2ebd210f3d1ca9860b30896553becf2154d Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 10:54:44 +0800
Subject: [PATCH 11/17] test(plsql): cover overloads that differ only in
 parameter names

Named-argument calls bind each names-only overload to its own body; the
test fails if parameter names are dropped from the signature key. Cite the
Oracle reference for the spec/body heading rule.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gitnexus/src/core/ingestion/plsql/resolve.ts |  3 +++
 gitnexus/test/unit/plsql-processor.test.ts   | 26 ++++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index 8b5a68520..31e67da45 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -69,6 +69,9 @@ export function dottedName(parts: readonly string[]): string {
  * white space (PLS-00323 otherwise), so parameter names are part of the key —
  * which also keeps apart overloads that differ only in parameter names, told
  * apart by named-argument calls. Type text is whitespace-free and upper-cased.
+ * See the Oracle 19c PL/SQL Language Reference, "Package Body"
+ * (lnpls/package-body.html) and "Overloaded Subprograms"
+ * (lnpls/overloaded-subprograms.html).
  */
 export function plsqlSignatureKey(
   def: Pick<PlSqlDefinition, 'ownerPath' | 'name' | 'parameters'>,
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index 953986f23..b73d4746f 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -84,6 +84,32 @@ END p;
     expect(targets).toEqual(['Q@L3 plsql-call']);
   });
 
+  it('keeps overloads that differ only in parameter names apart and binds named calls', () => {
+    const { graph, result } = run({
+      'pkg_fee.pks':
+        'CREATE OR REPLACE PACKAGE pkg_fee AS\n  PROCEDURE p(x NUMBER);\n  PROCEDURE p(y NUMBER);\nEND pkg_fee;\n/\n',
+      'pkg_fee.pkb': [
+        'CREATE OR REPLACE PACKAGE BODY pkg_fee AS',
+        '  PROCEDURE p(x NUMBER) IS BEGIN NULL; END p;',
+        '  PROCEDURE p(y NUMBER) IS BEGIN NULL; END p;',
+        'END pkg_fee;',
+        '/',
+        '',
+      ].join('\n'),
+      'settle.prc':
+        'CREATE OR REPLACE PROCEDURE settle IS\nBEGIN\n  pkg_fee.p(x => 1);\n  pkg_fee.p(y => 2);\nEND settle;\n/\n',
+    });
+    const targets: string[] = [];
+    for (const r of graph.iterRelationships()) {
+      if (r.type !== 'CALLS') continue;
+      const t = graph.getNode(r.targetId)!;
+      targets.push(`${t.properties.filePath}:L${t.properties.startLine! + 1}`);
+    }
+    // Each named call binds to its own body, never to the spec declarations.
+    expect(targets.sort()).toEqual(['pkg_fee.pkb:L2', 'pkg_fee.pkb:L3']);
+    expect(result.ambiguousCalls).toBe(0);
+  });
+
   it('keeps a quoted dotted package name apart from nested names', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE PACKAGE BODY "A.B" AS

From 94dedca49e27180efd6c5a01f78aa15c49332fdf Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 10:59:50 +0800
Subject: [PATCH 12/17] fix(plsql): never bind S.A.N to a package declared in
 another schema

S.A.N previously fell back to every same-named package when none was
declared in S, so a package written as T.A could receive the call. Share
the S.P rule (inWrittenSchema): packages declared in S, else packages
declared without a schema; never one naming another schema. The package
qualifier binding uses the same rule.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../languages/plsql/scope-resolver.ts         |  4 +--
 gitnexus/src/core/ingestion/plsql/resolve.ts  | 30 ++++++++++++++-----
 gitnexus/test/unit/plsql-processor.test.ts    | 19 ++++++++++++
 3 files changed, 44 insertions(+), 9 deletions(-)

diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
index f169ea3b7..b33013ec0 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -17,6 +17,7 @@ import { plsqlProvider } from '../plsql.js';
 import {
   PlSqlNameIndex,
   PlSqlPackageInstances,
+  inWrittenSchema,
   nearestGroups,
   rootPackageOf,
   type PlSqlIndexEntry,
@@ -137,9 +138,8 @@ const plsqlScopeResolver: ScopeResolver = {
       schema: string | undefined,
     ): SymbolDefinition | undefined => {
       const all = packageSymbols.get(name) ?? [];
-      const inSchema = schema === undefined ? [] : all.filter((p) => p.schema === schema);
       const nearest = nearestGroups(
-        inSchema.length > 0 ? inSchema : all,
+        inWrittenSchema(all, schema, (p) => p.schema),
         fromFile,
         (p) => p.instance,
       );
diff --git a/gitnexus/src/core/ingestion/plsql/resolve.ts b/gitnexus/src/core/ingestion/plsql/resolve.ts
index 31e67da45..f91273c68 100644
--- a/gitnexus/src/core/ingestion/plsql/resolve.ts
+++ b/gitnexus/src/core/ingestion/plsql/resolve.ts
@@ -137,9 +137,11 @@ export class PlSqlNameIndex<E extends PlSqlIndexEntry> {
       // `S.NAME`: a standalone subprogram in schema S. Definitions that wrote
       // another schema are excluded; ones that wrote none (current schema) stay
       // candidates, behind any that name S explicitly.
-      const standalone = this.lookup([], name).filter(callable);
-      const exact = standalone.filter((e) => e.def.schema === qualifier);
-      return exact.length > 0 ? exact : standalone.filter((e) => e.def.schema === undefined);
+      return inWrittenSchema(
+        this.lookup([], name).filter(callable),
+        qualifier,
+        (e) => e.def.schema,
+      );
     }
     return [];
   }
@@ -204,15 +206,29 @@ export function nearestGroups<E extends { readonly filePath: string }>(
   return scored.filter((s) => s.d === best).flatMap((s) => s.g);
 }
 
-/** In `S.A.N`, keep members of packages declared in schema `S` when any are indexed. */
+/** In `S.A.N`, only members of package `A` that may live in schema `S`. */
 function preferWrittenSchema<E extends PlSqlIndexEntry>(
   candidates: E[],
   call: Pick<PlSqlCallSite, 'nameParts'>,
 ): E[] {
   if (call.nameParts.length !== 3) return candidates;
-  const schema = call.nameParts[0];
-  const inSchema = candidates.filter((c) => c.packageSchema === schema);
-  return inSchema.length > 0 ? inSchema : candidates;
+  return inWrittenSchema(candidates, call.nameParts[0], (c) => c.packageSchema);
+}
+
+/**
+ * Candidates a reference qualified by schema `schema` can denote: those
+ * declared in that schema when any are indexed, otherwise those declared
+ * without a schema (created in whatever schema ran the script). A definition
+ * that names another schema never qualifies. No written schema keeps all.
+ */
+export function inWrittenSchema<E>(
+  candidates: readonly E[],
+  schema: string | undefined,
+  schemaOf: (candidate: E) => string | undefined,
+): E[] {
+  if (schema === undefined) return [...candidates];
+  const exact = candidates.filter((c) => schemaOf(c) === schema);
+  return exact.length > 0 ? exact : candidates.filter((c) => schemaOf(c) === undefined);
 }
 
 /**
diff --git a/gitnexus/test/unit/plsql-processor.test.ts b/gitnexus/test/unit/plsql-processor.test.ts
index b73d4746f..c0939140e 100644
--- a/gitnexus/test/unit/plsql-processor.test.ts
+++ b/gitnexus/test/unit/plsql-processor.test.ts
@@ -298,6 +298,25 @@ CREATE OR REPLACE PROCEDURE caller IS BEGIN b.pkg.f; END caller;
     expect(targets).toEqual([7]); // b.pkg body, not a.pkg
   });
 
+  it('never binds `S.A.N` to package A of another schema; an unqualified package may serve', () => {
+    const pkg = (schema: string) =>
+      `CREATE OR REPLACE PACKAGE ${schema}pkg AS PROCEDURE f; END pkg;\n/\n` +
+      `CREATE OR REPLACE PACKAGE BODY ${schema}pkg AS PROCEDURE f IS BEGIN NULL; END f; END pkg;\n/\n`;
+    const caller = 'CREATE OR REPLACE PROCEDURE caller IS BEGIN c.pkg.f; END caller;\n/\n';
+    const callTargets = (files: Record<string, string>) => {
+      const { graph } = run(files);
+      const out: string[] = [];
+      for (const r of graph.iterRelationships()) {
+        if (r.type === 'CALLS') out.push(graph.getNode(r.targetId)!.properties.filePath);
+      }
+      return out;
+    };
+    expect(callTargets({ 't.pck': pkg('t.'), 'caller.prc': caller })).toEqual([]);
+    expect(callTargets({ 't.pck': pkg('t.'), 'any.pck': pkg(''), 'caller.prc': caller })).toEqual([
+      'any.pck',
+    ]);
+  });
+
   it('does not lose PL/SQL statements when the CREATE header is split across lines', () => {
     const { graph } = run({
       'p.pkb': `CREATE OR REPLACE

From 0e6324aa5c9a0934e484fac23abba779e5d9126c Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sat, 31 Oct 2026 11:21:40 +0800
Subject: [PATCH 13/17] fix(plsql): claim .sql package headers written with AS
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A .sql file holding only `CREATE PACKAGE p AS …` with no other Oracle
marker was not classified as PL/SQL, so the package was never indexed.
T-SQL, PostgreSQL and MySQL have no CREATE PACKAGE, so a package header
needs no further marker whether it writes IS or AS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 gitnexus/src/core/ingestion/plsql/file-types.ts | 12 ++++++++++--
 gitnexus/test/unit/plsql-extract.test.ts        |  7 +++++++
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 1ad30aba6..3d3e17c25 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -48,6 +48,13 @@ const ORACLE_UNIT_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\bbegin\b)[\s\S]){0,4000}?\b(?:is|as)\b|trigger\s+[\w$#."]+\s+(?:before|after|instead\s+of|for)\b)/im;
 const ORACLE_IS_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?(?:package(?:\s+body)?|procedure|function|type(?:\s+body)?)\s+[\w$#."]+(?:(?!\b(?:begin|as)\b)[\s\S]){0,4000}?\bis\b/im;
+/**
+ * `CREATE PACKAGE [BODY] <name> … IS|AS`: packages exist only in Oracle (and
+ * Oracle-compatible PL/SQL dialects) — T-SQL, PostgreSQL and MySQL have no
+ * `CREATE PACKAGE` — so a package header needs no further marker, even with `AS`.
+ */
+const ORACLE_PACKAGE_HEADER =
+  /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?package(?:\s+body)?\s+[\w$#."]+(?:(?!\bbegin\b)[\s\S]){0,4000}?\b(?:is|as)\b/im;
 /**
  * A trigger whose body is a PL/SQL block. The header is shared with
  * PostgreSQL and MySQL/MariaDB, so the dialects are told apart by what they
@@ -99,10 +106,11 @@ export function looksLikeOraclePlSql(content: string): boolean {
   if (POSTGRES_DOLLAR_BODY.test(content) || TSQL_MARKERS.test(content)) return false;
   // `IS` after a unit header is Oracle-only syntax (T-SQL, PostgreSQL and
   // MySQL write `AS` or `BEGIN`), so a plain `CREATE PROCEDURE p IS …` needs
-  // no further marker; an `AS` header (shared with T-SQL) needs PL/SQL syntax
-  // from ORACLE_MARKERS in its body.
+  // no further marker, nor does any package header; a procedure or function
+  // `AS` header (shared with T-SQL) needs PL/SQL syntax from ORACLE_MARKERS.
   return (
     ORACLE_IS_HEADER.test(content) ||
+    ORACLE_PACKAGE_HEADER.test(content) ||
     looksLikeOracleTrigger(content) ||
     ORACLE_MARKERS.test(content)
   );
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index 09f63cf0e..bfbcb18f1 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -274,6 +274,13 @@ describe('file classification', () => {
         'CREATE PROCEDURE p()\nBEGIN\n  -- nvl( is not MySQL\n  SELECT 1;\nEND\n/\n',
       ),
     ).toBe(false);
+    // A package header is Oracle-only even with `AS` and no other marker.
+    expect(looksLikeOraclePlSql('CREATE PACKAGE p AS PROCEDURE q(x NUMBER); END p;')).toBe(true);
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR REPLACE PACKAGE BODY p AS\n  PROCEDURE q IS BEGIN NULL; END;\nEND p;',
+      ),
+    ).toBe(true);
     // Oracle header split across lines still counts.
     expect(
       looksLikeOraclePlSql('CREATE OR REPLACE\nPACKAGE BODY p\nAS\n  x VARCHAR2(1);\nEND p;\n/\n'),

From da76c7129b45c5a49b7966e4aae0837b67c6573e Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sun, 1 Nov 2026 08:47:28 +0800
Subject: [PATCH 14/17] fix(plsql): address first maintainer review

- Test typecheck: add the PL/SQL entry to LANGUAGE_FIXTURES. The test now
  preloads the lazily loaded parser and, like COBOL, requires a real
  profile instead of the grammar-unavailable branch.
- Classification: take dialect evidence from code only. Comments and
  string literals (incl. q'[...]') are blanked before header and marker
  tests, so `-- :=` in a T-SQL file no longer claims it.
- Rename: derive a package qualifier's binding from the resolved callee.
  `A` in `A.N` / `S.A.N` binds to package A only when N resolves to
  members of exactly one instance of A; schemas, db links, unresolved
  callees and multi-instance results stay unproven. New rename fixtures
  refuse-schema-qualifier and package-rename.
- Bench: add bench/plsql-parse (facts fingerprint + scaling guard, wired
  into ci-tests.yml) as promised in #3771, and a PL/SQL arm with
  baselines for bench/scope-resolution's language inventory.
- Docs: document GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS in the CLI reference
  environment-variable table.
---
 .github/workflows/ci-tests.yml                |   8 +
 docs/cli-reference.md                         |   1 +
 gitnexus/bench/plsql-parse/README.md          |  38 ++++
 gitnexus/bench/plsql-parse/baselines.json     |   5 +
 gitnexus/bench/plsql-parse/measure.mjs        | 165 ++++++++++++++++++
 gitnexus/bench/scope-resolution/README.md     |   4 +-
 .../bench/scope-resolution/baselines.json     |  16 ++
 gitnexus/bench/scope-resolution/corpus.mts    |  21 ++-
 gitnexus/bench/scope-resolution/measure.mts   |   7 +
 .../languages/plsql/scope-resolver.ts         |  75 ++++----
 .../src/core/ingestion/plsql/file-types.ts    |  19 +-
 .../plsql/package-rename/after/caller.prc     |   7 +
 .../plsql/package-rename/after/pkg_app.pkb    |   7 +
 .../plsql/package-rename/after/pkg_app.pks    |   4 +
 .../plsql/package-rename/before/caller.prc    |   7 +
 .../plsql/package-rename/before/pkg_app.pkb   |   7 +
 .../plsql/package-rename/before/pkg_app.pks   |   4 +
 .../plsql/package-rename/case.json            |  16 ++
 .../refuse-schema-qualifier/after/caller.prc  |   7 +
 .../plsql/refuse-schema-qualifier/after/n.prc |   5 +
 .../refuse-schema-qualifier/after/pkg_app.pkb |   7 +
 .../refuse-schema-qualifier/after/pkg_app.pks |   4 +
 .../refuse-schema-qualifier/before/caller.prc |   7 +
 .../refuse-schema-qualifier/before/n.prc      |   5 +
 .../before/pkg_app.pkb                        |   7 +
 .../before/pkg_app.pks                        |   4 +
 .../plsql/refuse-schema-qualifier/case.json   |  16 ++
 gitnexus/test/unit/plsql-extract.test.ts      |  17 ++
 .../scenario-map/fixture-similarity.test.ts   |  14 +-
 29 files changed, 458 insertions(+), 46 deletions(-)
 create mode 100644 gitnexus/bench/plsql-parse/README.md
 create mode 100644 gitnexus/bench/plsql-parse/baselines.json
 create mode 100644 gitnexus/bench/plsql-parse/measure.mjs
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/caller.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pks
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/caller.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pks
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/package-rename/case.json
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/caller.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/n.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pks
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/caller.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/n.prc
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pkb
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pks
 create mode 100644 gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/case.json

diff --git a/.github/workflows/ci-tests.yml b/.github/workflows/ci-tests.yml
index a0326aa24..c384e1ed4 100644
--- a/.github/workflows/ci-tests.yml
+++ b/.github/workflows/ci-tests.yml
@@ -955,6 +955,14 @@ jobs:
         run: node --import tsx bench/scope-capture/measure.mjs --check
         working-directory: gitnexus
 
+      - name: PL/SQL parse fingerprint + scaling guard
+        if: ${{ !cancelled() }}
+        # Build-free: asserts extractPlSqlFacts output over the plsql-* fixtures
+        # is unchanged (fingerprint) and the warmed ANTLR parse stays linear in
+        # package-body size (scaling < 1.5). Timings are reported, not gated.
+        run: node --import tsx bench/plsql-parse/measure.mjs --check
+        working-directory: gitnexus
+
       - name: Rename output construction scaling guard
         if: ${{ !cancelled() }}
         run: node --import tsx bench/rename/measure.mjs --check
diff --git a/docs/cli-reference.md b/docs/cli-reference.md
index c2d691e46..db6aea480 100644
--- a/docs/cli-reference.md
+++ b/docs/cli-reference.md
@@ -273,6 +273,7 @@ Most `analyze` knobs are also CLI flags (`--workers`, `--worker-timeout`, `--max
 | `GITNEXUS_CHUNK_BYTE_BUDGET`                    | `2097152` (2 MB)                                                | Per-bucket byte budget for parse-cache packing. Files are grouped by `(language, hash(path) mod 128)`; packs inside a bucket are cut at this limit. Smaller = finer-grained invalidation and more dispatch. Default is always 2 MiB and no longer scales with worker count.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Tuning incremental-analyze cache invalidation on monorepos without changing `--workers`.                                                                                                                                                                                                  |
 | `GITNEXUS_NO_GITIGNORE`                         | unset                                                           | When set, skips `.gitignore` parsing. `.gitnexusignore` is still honored.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Indexing a repo whose `.gitignore` excludes files you actually want indexed (e.g., generated code committed for cross-repo lookup).                                                                                                                                                       |
 | `GITNEXUS_SKIP_OPTIONAL_GRAMMARS`               | unset                                                           | When exactly `1`, skips optional vendored Dart, Proto, Swift, Kotlin and Zig grammar setup. The C grammar and other native dependencies remain required.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Skipping optional language parsers when their prebuilds are unavailable and no source-build toolchain is installed.                                                                                                                                                                       |
+| `GITNEXUS_PLSQL_SEGMENT_DEADLINE_MS` | `10000` | Floor, in ms, of the wall-clock budget for parsing one `/`-terminated PL/SQL segment; the budget grows by 15 ms per line above it. A segment that runs out is recorded as timed out and its definitions come from the regex fallback (low confidence; rename refuses on them). `0` disables the deadline; blank, invalid or negative values use the default. | PL/SQL repositories with very large package bodies on slow or loaded machines, where segments hit the deadline (the `PL/SQL degraded: … at the parse deadline` line `analyze` logs with `NODE_ENV=development`) and lose call edges to the fallback. |
 | `GITNEXUS_MCP_READ_ONLY`                        | unset                                                           | Set to `1` to expose only proven single-repository read tools and resources; `0` disables the policy and any other value fails startup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | The MCP server runs in an environment where graph mutation, raw Cypher, and cross-repository group routing must be unavailable.                                                                                                                                                           |
 | `GITNEXUS_MCP_ALLOWED_REPOS`                    | unset                                                           | Comma-separated allowlist of canonical indexed repository names or absolute paths. Invalid, ambiguous, or blank entries fail startup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | One MCP process must expose only a bounded subset of the repositories in the global registry.                                                                                                                                                                                             |
 | `GITNEXUS_MCP_DEFAULT_REPO`                     | unset                                                           | Canonical indexed repository name or absolute path used when a tool or resource omits its repository. Must belong to the allowlist when one is set.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Several repositories are available but unqualified MCP calls should resolve deterministically.                                                                                                                                                                                            |
diff --git a/gitnexus/bench/plsql-parse/README.md b/gitnexus/bench/plsql-parse/README.md
new file mode 100644
index 000000000..ddcc94830
--- /dev/null
+++ b/gitnexus/bench/plsql-parse/README.md
@@ -0,0 +1,38 @@
+# PL/SQL parse-throughput bench
+
+`measure.mjs` times `extractPlSqlFacts` (SQL\*Plus/conditional-compilation
+pre-pass, `/` segment split, ANTLR SLL→LL parse, fact extraction) on a
+synthetic package body of 60 and 240 subprograms, after one warm-up pass.
+
+```sh
+node --import tsx bench/plsql-parse/measure.mjs          # print JSON
+node --import tsx bench/plsql-parse/measure.mjs --check  # CI guard
+```
+
+`--check` gates correctness and shape, not absolute speed:
+
+- **fingerprint**: sha256 over the facts of every `lang-resolution/plsql-*`
+  fixture file plus a 20-subprogram synthetic body. Re-baseline
+  `baselines.json` only for an intended facts change.
+- **synthetic bodies** parse with no erroneous or timed-out segment.
+- **scaling ratio** `(t_240 / t_60) / (lines ratio)` stays under 1.5. About
+  1.0 is linear; a quadratic regression shows up near 4.0.
+
+## Measurements
+
+Apple Silicon laptop, Node 25, single thread.
+
+| Input                                                                                                                  | Lines   | Result                                                                                    |
+| ---------------------------------------------------------------------------------------------------------------------- | ------- | ----------------------------------------------------------------------------------------- |
+| Synthetic body, 60 subprograms, cold (first parse in the process)                                                      | 783     | 677 ms                                                                                    |
+| Synthetic body, 60 subprograms, warm                                                                                   | 783     | 125 ms/kLOC                                                                               |
+| Synthetic body, 240 subprograms, warm                                                                                  | 3,123   | 116 ms/kLOC (scaling ratio 0.93)                                                          |
+| Corpus: utPLSQL, Logger, Alexandria, OOS-Utils, Oracle sample schemas (618 claimed files, one process, one cold start) | 121,292 | 58–62 s end to end through `processPlSql` (about 490 ms/kLOC), 0 segments at the deadline |
+
+The corpus is not vendored; the processor-level number is a manual
+measurement to compare against. It roughly doubles on a machine under memory
+pressure, so compare runs taken back to back. Real code costs more per line than the
+synthetic body: deeper expressions, more SQL and more LL fallbacks.
+
+Parsing runs on the main thread inside the `plsql` phase and facts are not
+cached across runs (PLSQL-07 in `docs/languages/plsql-ingestion-gaps.md`).
diff --git a/gitnexus/bench/plsql-parse/baselines.json b/gitnexus/bench/plsql-parse/baselines.json
new file mode 100644
index 000000000..c51fddfd2
--- /dev/null
+++ b/gitnexus/bench/plsql-parse/baselines.json
@@ -0,0 +1,5 @@
+{
+  "_comment": "Baseline for bench/plsql-parse/measure.mjs --check. fingerprint = order-independent sha256 over extractPlSqlFacts output for every lang-resolution/plsql-* fixture file plus a 20-subprogram synthetic package body (correctness gate; re-baseline intentionally on a legitimate facts change). scaling_budget = max allowed (t_large/t_small)/(lines ratio) for 60 vs 240 synthetic subprograms after a DFA warm-up; ~1.0 is linear (0.95 measured), ~4.0 quadratic.",
+  "fingerprint": "0ccc2c62f8747bb91a8fb34dc73b1335600a629ce92160ae539b851f4e1d4637",
+  "scaling_budget": 1.5
+}
diff --git a/gitnexus/bench/plsql-parse/measure.mjs b/gitnexus/bench/plsql-parse/measure.mjs
new file mode 100644
index 000000000..cf9cd6586
--- /dev/null
+++ b/gitnexus/bench/plsql-parse/measure.mjs
@@ -0,0 +1,165 @@
+/**
+ * Build-free PL/SQL parse-throughput harness (#3771 acceptance criterion).
+ *
+ * Times `extractPlSqlFacts` — pre-pass, segment split, ANTLR SLL/LL parse and
+ * fact extraction — on a synthetic package body at two sizes, after one
+ * warm-up pass so the ANTLR DFA cache is populated (each analyze pays the
+ * cold cost once per process; see README.md for corpus numbers). It reports
+ * ms/kLOC for each size and a scaling ratio `(t_large/t_small)/(lines ratio)`:
+ * ~1.0 is linear, ~4.0 is quadratic at these sizes.
+ *
+ * The correctness gate is an order-independent sha256 fingerprint over the
+ * facts of every `lang-resolution/plsql-*` fixture file plus a fixed
+ * 20-subprogram synthetic body.
+ *
+ * Run: `node --import tsx bench/plsql-parse/measure.mjs` (prints JSON).
+ * `--check` asserts the fingerprint equals baselines.json, the synthetic
+ * bodies parse without syntax errors or timeouts, and the scaling ratio stays
+ * under budget; exits non-zero otherwise. Absolute timings are reported, not
+ * gated: they depend on the machine.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+import { extractPlSqlFacts } from '../../src/core/ingestion/plsql/extract.ts';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURE_ROOT = path.resolve(__dirname, '..', '..', 'test', 'fixtures', 'lang-resolution');
+const BASELINE_PATH = path.resolve(__dirname, 'baselines.json');
+const PLSQL_EXTENSIONS = ['.sql', '.pks', '.pkb', '.pck', '.pls', '.plb', '.prc', '.fnc', '.trg'];
+
+/** No deadline: the bench measures the parse, not the fallback. */
+const OPTIONS = { segmentDeadlineMs: Number.POSITIVE_INFINITY };
+
+const SMALL = 60;
+const LARGE = 240;
+const REPEATS = 3;
+
+/** One package body with `n` subprograms that call, branch, read and write. */
+function syntheticBody(n) {
+  const units = [];
+  for (let i = 0; i < n; i++) {
+    const callee = i === 0 ? 'NULL' : `p${i - 1}(p_id => p_id, p_amount => v_total)`;
+    units.push(
+      [
+        `  PROCEDURE p${i}(p_id IN NUMBER, p_amount IN NUMBER DEFAULT 0) IS`,
+        `    v_total t_orders.amount%TYPE;`,
+        `  BEGIN`,
+        `    SELECT NVL(SUM(amount), 0) INTO v_total FROM t_orders WHERE customer_id = p_id;`,
+        `    IF v_total > p_amount THEN`,
+        `      UPDATE t_orders SET status = 'HELD' WHERE customer_id = p_id;`,
+        `    ELSIF v_total = 0 THEN`,
+        `      INSERT INTO t_audit (customer_id, note) VALUES (p_id, 'empty ${i}');`,
+        `    END IF;`,
+        `    ${callee};`,
+        `    pkg_log.info('p${i} done');`,
+        `  END p${i};`,
+      ].join('\n'),
+    );
+  }
+  return `CREATE OR REPLACE PACKAGE BODY pkg_bench AS\n${units.join('\n\n')}\nEND pkg_bench;\n/\n`;
+}
+
+function lineCount(text) {
+  return text.split('\n').length;
+}
+
+function digest(facts) {
+  const { firstError: _firstError, ...stable } = facts;
+  return crypto.createHash('sha256').update(JSON.stringify(stable)).digest('hex');
+}
+
+function collectFixtures() {
+  const out = [];
+  for (const entry of fs.readdirSync(FIXTURE_ROOT, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith('plsql-')) continue;
+    const stack = [path.join(FIXTURE_ROOT, entry.name)];
+    while (stack.length) {
+      const dir = stack.pop();
+      for (const c of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, c.name);
+        if (c.isDirectory()) stack.push(p);
+        else if (PLSQL_EXTENSIONS.some((e) => c.name.toLowerCase().endsWith(e)))
+          out.push({ key: path.relative(FIXTURE_ROOT, p).split(path.sep).join('/'), absPath: p });
+      }
+    }
+  }
+  return out.sort((a, b) => a.key.localeCompare(b.key));
+}
+
+function fingerprint() {
+  const parts = collectFixtures().map(
+    (f) => `${f.key}|${digest(extractPlSqlFacts(fs.readFileSync(f.absPath, 'utf8'), OPTIONS))}`,
+  );
+  parts.push(`synthetic-20|${digest(extractPlSqlFacts(syntheticBody(20), OPTIONS))}`);
+  return crypto.createHash('sha256').update(parts.sort().join('\n')).digest('hex');
+}
+
+function timeExtract(source) {
+  let best = Number.POSITIVE_INFINITY;
+  let facts;
+  for (let i = 0; i < REPEATS; i++) {
+    const t0 = performance.now();
+    facts = extractPlSqlFacts(source, OPTIONS);
+    best = Math.min(best, performance.now() - t0);
+  }
+  return { ms: best, facts };
+}
+
+function measure() {
+  const small = syntheticBody(SMALL);
+  const large = syntheticBody(LARGE);
+  const coldStart = performance.now();
+  extractPlSqlFacts(small, OPTIONS);
+  const coldMs = performance.now() - coldStart;
+  const s = timeExtract(small);
+  const l = timeExtract(large);
+  const smallLines = lineCount(small);
+  const largeLines = lineCount(large);
+  const perKloc = (ms, lines) => +((ms * 1000) / lines).toFixed(1);
+  return {
+    fingerprint: fingerprint(),
+    cold_ms_small: +coldMs.toFixed(1),
+    small: {
+      subprograms: SMALL,
+      lines: smallLines,
+      ms: +s.ms.toFixed(1),
+      ms_per_kloc: perKloc(s.ms, smallLines),
+    },
+    large: {
+      subprograms: LARGE,
+      lines: largeLines,
+      ms: +l.ms.toFixed(1),
+      ms_per_kloc: perKloc(l.ms, largeLines),
+    },
+    scaling_ratio: +(l.ms / s.ms / (largeLines / smallLines)).toFixed(3),
+    synthetic_errors: s.facts.segmentsWithErrors + l.facts.segmentsWithErrors,
+    synthetic_calls: l.facts.calls.length,
+    synthetic_accesses: l.facts.accesses.length,
+  };
+}
+
+const result = measure();
+console.log(JSON.stringify(result, null, 2));
+
+if (process.argv.includes('--check')) {
+  const baseline = JSON.parse(fs.readFileSync(BASELINE_PATH, 'utf8'));
+  const failures = [];
+  if (result.fingerprint !== baseline.fingerprint)
+    failures.push(
+      `fingerprint drift: ${result.fingerprint} != baseline ${baseline.fingerprint} (re-baseline only for an intended facts change)`,
+    );
+  if (result.synthetic_errors !== 0)
+    failures.push(`synthetic bodies parsed with ${result.synthetic_errors} erroneous segments`);
+  if (result.scaling_ratio >= baseline.scaling_budget)
+    failures.push(
+      `scaling ratio ${result.scaling_ratio} >= budget ${baseline.scaling_budget} (super-linear parse)`,
+    );
+  if (failures.length > 0) {
+    for (const f of failures) console.error(`plsql-parse: ${f}`);
+    process.exit(1);
+  }
+  console.error('plsql-parse: fingerprint and scaling within baseline');
+}
diff --git a/gitnexus/bench/scope-resolution/README.md b/gitnexus/bench/scope-resolution/README.md
index 86a1615f9..7488f3e44 100644
--- a/gitnexus/bench/scope-resolution/README.md
+++ b/gitnexus/bench/scope-resolution/README.md
@@ -13,12 +13,12 @@ plus callers and helpers. Rust also needs a root
 module file; Objective-C has a header and implementation per entity. Java adds an
 isolated producer file and exercises transitive factory returns and repeated
 unreachable return-name lookups. Swift uses same-module visibility; COBOL exercises
-program references and procedure pointers. Other arms import the preceding file and call through its
+program references and procedure pointers; PL/SQL exercises package-qualified calls. Other arms import the preceding file and call through its
 return value. These generated sources exercise the analyzer; they are not builds
 or representative application benchmarks.
 
 Every sample runs in a fresh process through real parsing with one worker and the
-production scope-resolution pass. COBOL also runs its standalone structural parser.
+production scope-resolution pass. COBOL and PL/SQL also run their standalone structural parsers.
 Configuration files are written to a temporary workspace and loaded through the resolver's normal
 configuration hook. No production heap, file-count, or propagation limit is imposed.
 
diff --git a/gitnexus/bench/scope-resolution/baselines.json b/gitnexus/bench/scope-resolution/baselines.json
index 5d13bfa00..7f6fa118e 100644
--- a/gitnexus/bench/scope-resolution/baselines.json
+++ b/gitnexus/bench/scope-resolution/baselines.json
@@ -175,6 +175,22 @@
     "moduleTypeBindings": 10010999,
     "typeBindings": 10032997
   },
+  "plsql/100/20": {
+    "fingerprint": "908f30ebfe4287bbb4d4553a869da52708dbf92b0e99548dd58d73f8664bdf3b",
+    "nodes": 2300,
+    "edges": 2398,
+    "crossFileCalls": 198,
+    "moduleTypeBindings": 0,
+    "typeBindings": 0
+  },
+  "plsql/1000/20": {
+    "fingerprint": "600a7dc54fdf793e40b66c47551215ad5cb4aa3af9d432c283750fd882224dd8",
+    "nodes": 23000,
+    "edges": 23998,
+    "crossFileCalls": 1998,
+    "moduleTypeBindings": 0,
+    "typeBindings": 0
+  },
   "python/100/20": {
     "fingerprint": "58adb2bc6b7ac24ab3dcd500ec3cd577d3e6853fd1a8e84f658f423677d6df50",
     "nodes": 2299,
diff --git a/gitnexus/bench/scope-resolution/corpus.mts b/gitnexus/bench/scope-resolution/corpus.mts
index 5f38eb3ec..df5636ee2 100644
--- a/gitnexus/bench/scope-resolution/corpus.mts
+++ b/gitnexus/bench/scope-resolution/corpus.mts
@@ -18,7 +18,8 @@ ${previous(i, (p) => `  usePrevious() { return new C${p}().make${p}_0().make${p}
 }`;
 
 // Each arm has one chain of cross-file uses and distinct method names. Swift
-// uses same-module visibility; COBOL uses program calls and procedure pointers.
+// uses same-module visibility; COBOL uses program calls and procedure pointers;
+// PL/SQL uses package-qualified calls.
 export const generators = {
   javascript: (i, n) => ({ path: `src/C${i}.js`, content: script(i, n, false, 'js') }),
   typescript: (i, n) => ({ path: `src/C${i}.ts`, content: script(i, n, true, 'js') }),
@@ -175,6 +176,24 @@ ${previous(i, (p) => `           SET TARGET-PTR TO ENTRY 'C${p}'\n           CAL
            PERFORM MAKE-${i}-0
            GOBACK.
 ${members(n, (j) => `       MAKE-${i}-${j}.\n           CONTINUE.`)}
+`,
+  }),
+  plsql: (i, n) => ({
+    path: `src/pkg_c${i}.pck`,
+    content: `CREATE OR REPLACE PACKAGE pkg_c${i} AS
+${members(n, (j) => `  PROCEDURE make${i}_${j};`)}
+  PROCEDURE use_previous;
+END pkg_c${i};
+/
+CREATE OR REPLACE PACKAGE BODY pkg_c${i} AS
+${members(n, (j) => `  PROCEDURE make${i}_${j} IS BEGIN NULL; END make${i}_${j};`)}
+  PROCEDURE use_previous IS
+  BEGIN
+${previous(i, (p) => `    pkg_c${p}.make${p}_0;\n    pkg_c${p}.make${p}_1;`)}
+    NULL;
+  END use_previous;
+END pkg_c${i};
+/
 `,
   }),
   zig: (i, n) => ({
diff --git a/gitnexus/bench/scope-resolution/measure.mts b/gitnexus/bench/scope-resolution/measure.mts
index 0ff4fd9e2..1d46d65b1 100644
--- a/gitnexus/bench/scope-resolution/measure.mts
+++ b/gitnexus/bench/scope-resolution/measure.mts
@@ -18,6 +18,8 @@ import { SupportedLanguages } from 'gitnexus-shared';
 import { SCOPE_RESOLVERS } from '../../src/core/ingestion/scope-resolution/pipeline/registry.js';
 import { runScopeResolution } from '../../src/core/ingestion/scope-resolution/pipeline/run.js';
 import { processCobol } from '../../src/core/ingestion/cobol-processor.js';
+import { processPlSql } from '../../src/core/ingestion/plsql-processor.js';
+import { loadPlSqlParser } from '../../src/core/ingestion/plsql/facts-store.js';
 import { generateId } from '../../src/lib/utils.js';
 import { parseFilesWithWorkers } from '../../test/helpers/worker-parse.js';
 import { corpus, generators } from './corpus.mjs';
@@ -54,6 +56,11 @@ async function sample(language: SupportedLanguages, count: number, methods: numb
     if (language === SupportedLanguages.Cobol) {
       processCobol(graph, files, new Set(files.map((file) => file.path)));
     }
+    // PL/SQL's structural graph is emitted by its standalone ANTLR parser, loaded on demand.
+    if (language === SupportedLanguages.PlSql) {
+      await loadPlSqlParser();
+      processPlSql(graph, files, new Set(files.map((file) => file.path)));
+    }
     const parseMs = performance.now() - parseStarted;
     const heapAfterParse = process.memoryUsage().heapUsed;
     let parsedFileCount = 0;
diff --git a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
index b33013ec0..c416d14dc 100644
--- a/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
+++ b/gitnexus/src/core/ingestion/languages/plsql/scope-resolver.ts
@@ -17,8 +17,6 @@ import { plsqlProvider } from '../plsql.js';
 import {
   PlSqlNameIndex,
   PlSqlPackageInstances,
-  inWrittenSchema,
-  nearestGroups,
   rootPackageOf,
   type PlSqlIndexEntry,
 } from '../../plsql/resolve.js';
@@ -107,43 +105,45 @@ const plsqlScopeResolver: ScopeResolver = {
       if (pkg) entry.instance = instances.instanceOf(pkg.name, pkg.schema, entry.filePath);
     }
 
-    // A package name denotes the package instance nearest the reference (as
-    // near as its nearest spec or body file); its spec when indexed.
-    const packageSymbols = new Map<
-      string,
-      Array<{
-        filePath: string;
-        symbol: SymbolDefinition;
-        isSpec: boolean;
-        schema?: string;
-        instance: string;
-      }>
-    >();
+    // The symbol a package instance is known by: its spec when indexed.
+    const packageOfInstance = new Map<string, { symbol: SymbolDefinition; isSpec: boolean }>();
     for (const [def, symbol] of symbolOf) {
       if (def.kind !== 'package') continue;
-      const list = packageSymbols.get(def.name) ?? [];
-      list.push({
-        filePath: symbol.filePath,
-        symbol,
-        isSpec: def.isSpec,
-        schema: def.schema,
-        instance: instances.instanceOf(def.name, def.schema, symbol.filePath),
-      });
-      packageSymbols.set(def.name, list);
+      const instance = instances.instanceOf(def.name, def.schema, symbol.filePath);
+      const known = packageOfInstance.get(instance);
+      if (!known || (def.isSpec && !known.isSpec))
+        packageOfInstance.set(instance, { symbol, isSpec: def.isSpec });
     }
-    /** In `S.A.N` the written schema `S` narrows same-named packages first. */
-    const packageSymbol = (
-      name: string,
+
+    const resolved = new Map<PlSqlCallSite, BoundEntry[]>();
+    const resolveCall = (call: PlSqlCallSite, fromFile: string): BoundEntry[] => {
+      let targets = resolved.get(call);
+      if (!targets) {
+        targets = call.dbLink ? [] : index.resolve(call, fromFile);
+        resolved.set(call, targets);
+      }
+      return targets;
+    };
+    /**
+     * The package a qualifier names, read off the resolved callee: `A` in
+     * `A.N` / `S.A.N` denotes a package only when `N` resolves to members of
+     * exactly one instance of package `A`. A schema (`S.N` reaching a
+     * standalone subprogram), a database link, an unresolved callee or members
+     * of several instances leave the qualifier unproven.
+     */
+    const qualifierPackage = (
+      call: PlSqlCallSite,
+      qualifier: string,
       fromFile: string,
-      schema: string | undefined,
     ): SymbolDefinition | undefined => {
-      const all = packageSymbols.get(name) ?? [];
-      const nearest = nearestGroups(
-        inWrittenSchema(all, schema, (p) => p.schema),
-        fromFile,
-        (p) => p.instance,
+      const owners = new Set<string | undefined>(
+        resolveCall(call, fromFile).map((t) =>
+          t.def.ownerPath.length === 1 && t.def.ownerPath[0] === qualifier ? t.instance : undefined,
+        ),
       );
-      return (nearest.find((p) => p.isSpec) ?? nearest[0])?.symbol;
+      if (owners.size !== 1) return undefined;
+      const [instance] = owners;
+      return instance === undefined ? undefined : packageOfInstance.get(instance)?.symbol;
     };
 
     for (const { parsed, facts } of files) {
@@ -180,11 +180,7 @@ const plsqlScopeResolver: ScopeResolver = {
           // In `S.A.N` only `A` (the part before the callee) can name a package.
           const symbol =
             m.part === m.call.nameParts.length - 2
-              ? packageSymbol(
-                  m.call.nameParts[m.part]!,
-                  parsed.filePath,
-                  m.part > 0 ? m.call.nameParts[m.part - 1] : undefined,
-                )
+              ? qualifierPackage(m.call, m.call.nameParts[m.part]!, parsed.filePath)
               : undefined;
           record(
             site,
@@ -198,8 +194,7 @@ const plsqlScopeResolver: ScopeResolver = {
           );
           continue;
         }
-        const targets = m.call.dbLink ? [] : index.resolve(m.call, parsed.filePath);
-        const ids = targets.map((t) => t.symbol.nodeId);
+        const ids = resolveCall(m.call, parsed.filePath).map((t) => t.symbol.nodeId);
         record(
           site,
           ids.length === 1
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 3d3e17c25..8f3ec394c 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -96,11 +96,28 @@ const ORACLE_MARKERS =
 const SQLPLUS_INCLUDE =
   /^[ \t]*(?:@@|@|sta(?:rt)?[ \t]+)[\w./\\-]+\.(?:sql|pks|pkb|pck|pls|plb|prc|fnc|trg|tps|tpb)[ \t]*\r?$/im;
 
+/**
+ * Comments, then string literals (`'…'` with `''` escapes, and `q'[…]'`
+ * alternative quoting), whichever starts first.
+ */
+const COMMENT_OR_STRING =
+  /--[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|(?<![\w$#])[qQ]'(?:\[[\s\S]*?\]|\([\s\S]*?\)|\{[\s\S]*?\}|<[\s\S]*?>|(\S)[\s\S]*?\1)'|'(?:[^']|'')*(?:'|$)/g;
+
+/**
+ * `content` with comments and string literals blanked, line breaks kept, so
+ * dialect evidence comes from code only: `-- :=` in a T-SQL comment or
+ * `'END IF;'` in a literal says nothing about the dialect.
+ */
+function codeOf(content: string): string {
+  return content.replace(COMMENT_OR_STRING, (text) => text.replace(/[^\n]/g, ' '));
+}
+
 /**
  * True when `.sql` content holds at least one Oracle PL/SQL compilation unit,
  * or is a SQL*Plus script that includes other scripts.
  */
-export function looksLikeOraclePlSql(content: string): boolean {
+export function looksLikeOraclePlSql(source: string): boolean {
+  const content = codeOf(source);
   if (SQLPLUS_INCLUDE.test(content) && !TSQL_MARKERS.test(content)) return true;
   if (!ORACLE_UNIT_HEADER.test(content)) return false;
   if (POSTGRES_DOLLAR_BODY.test(content) || TSQL_MARKERS.test(content)) return false;
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/caller.prc b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/caller.prc
new file mode 100644
index 000000000..59756d761
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/caller.prc
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PROCEDURE caller IS
+BEGIN
+  core.info;
+  -- a comment naming app and a literal stay as they are
+  DBMS_OUTPUT.PUT_LINE('app');
+END caller;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pkb b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pkb
new file mode 100644
index 000000000..247691435
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pkb
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PACKAGE BODY core AS
+  PROCEDURE info IS
+  BEGIN
+    NULL;
+  END info;
+END core;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pks b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pks
new file mode 100644
index 000000000..9cbba47b9
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/after/pkg_app.pks
@@ -0,0 +1,4 @@
+CREATE OR REPLACE PACKAGE core AS
+  PROCEDURE info;
+END core;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/caller.prc b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/caller.prc
new file mode 100644
index 000000000..1910b5406
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/caller.prc
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PROCEDURE caller IS
+BEGIN
+  app.info;
+  -- a comment naming app and a literal stay as they are
+  DBMS_OUTPUT.PUT_LINE('app');
+END caller;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pkb b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pkb
new file mode 100644
index 000000000..60ebf3139
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pkb
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PACKAGE BODY app AS
+  PROCEDURE info IS
+  BEGIN
+    NULL;
+  END info;
+END app;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pks b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pks
new file mode 100644
index 000000000..0e51de125
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/before/pkg_app.pks
@@ -0,0 +1,4 @@
+CREATE OR REPLACE PACKAGE app AS
+  PROCEDURE info;
+END app;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/package-rename/case.json b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/case.json
new file mode 100644
index 000000000..f2b315a35
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/package-rename/case.json
@@ -0,0 +1,16 @@
+{
+  "language": "plsql",
+  "description": "Rename a package: spec and body headers, both END labels and a cross-file package-qualified call change together; a same-spelled comment and string literal do not.",
+  "categories": ["package-scope", "cross-file"],
+  "target": {
+    "name": "APP",
+    "kind": "Module",
+    "file": "pkg_app.pks"
+  },
+  "newName": "core",
+  "expectedTargetName": "CORE",
+  "expect": {
+    "status": "success",
+    "edits": 5
+  }
+}
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/caller.prc b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/caller.prc
new file mode 100644
index 000000000..974fc9a09
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/caller.prc
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PROCEDURE caller IS
+BEGIN
+  app.info;
+  -- `n` is no member of package APP: here `app` can only be a schema.
+  app.n;
+END caller;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/n.prc b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/n.prc
new file mode 100644
index 000000000..d8a7251ca
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/n.prc
@@ -0,0 +1,5 @@
+CREATE OR REPLACE PROCEDURE n IS
+BEGIN
+  NULL;
+END n;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pkb b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pkb
new file mode 100644
index 000000000..60ebf3139
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pkb
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PACKAGE BODY app AS
+  PROCEDURE info IS
+  BEGIN
+    NULL;
+  END info;
+END app;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pks b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pks
new file mode 100644
index 000000000..0e51de125
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/after/pkg_app.pks
@@ -0,0 +1,4 @@
+CREATE OR REPLACE PACKAGE app AS
+  PROCEDURE info;
+END app;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/caller.prc b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/caller.prc
new file mode 100644
index 000000000..974fc9a09
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/caller.prc
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PROCEDURE caller IS
+BEGIN
+  app.info;
+  -- `n` is no member of package APP: here `app` can only be a schema.
+  app.n;
+END caller;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/n.prc b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/n.prc
new file mode 100644
index 000000000..d8a7251ca
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/n.prc
@@ -0,0 +1,5 @@
+CREATE OR REPLACE PROCEDURE n IS
+BEGIN
+  NULL;
+END n;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pkb b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pkb
new file mode 100644
index 000000000..60ebf3139
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pkb
@@ -0,0 +1,7 @@
+CREATE OR REPLACE PACKAGE BODY app AS
+  PROCEDURE info IS
+  BEGIN
+    NULL;
+  END info;
+END app;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pks b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pks
new file mode 100644
index 000000000..0e51de125
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/before/pkg_app.pks
@@ -0,0 +1,4 @@
+CREATE OR REPLACE PACKAGE app AS
+  PROCEDURE info;
+END app;
+/
diff --git a/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/case.json b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/case.json
new file mode 100644
index 000000000..d4014389b
--- /dev/null
+++ b/gitnexus/test/fixtures/rename-integration/plsql/refuse-schema-qualifier/case.json
@@ -0,0 +1,16 @@
+{
+  "language": "plsql",
+  "description": "Refuse to rename package APP when a call `app.n` resolves to a standalone procedure: there `app` is a schema qualifier, not the package, so it must not be rewritten and every source byte must stay unchanged.",
+  "categories": ["package-scope", "negative", "unchanged-on-error"],
+  "target": {
+    "name": "APP",
+    "kind": "Module",
+    "file": "pkg_app.pks"
+  },
+  "newName": "core",
+  "expect": {
+    "status": "error",
+    "code": "ambiguous_reference",
+    "planningStatus": "blocked"
+  }
+}
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index bfbcb18f1..9c7316348 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -274,6 +274,23 @@ describe('file classification', () => {
         'CREATE PROCEDURE p()\nBEGIN\n  -- nvl( is not MySQL\n  SELECT 1;\nEND\n/\n',
       ),
     ).toBe(false);
+    // Dialect evidence comes from code, never from comments or string literals.
+    expect(looksLikeOraclePlSql('CREATE PROCEDURE p AS BEGIN SELECT 1; -- :=\nEND;')).toBe(false);
+    expect(
+      looksLikeOraclePlSql("CREATE PROCEDURE p AS\nBEGIN\n  SELECT 'END IF; x := 1';\nEND;"),
+    ).toBe(false);
+    expect(
+      looksLikeOraclePlSql(
+        '/* CREATE PROCEDURE p IS */\nCREATE PROCEDURE p AS\nBEGIN\n  SELECT 1;\nEND;',
+      ),
+    ).toBe(false);
+    expect(
+      looksLikeOraclePlSql("CREATE PROCEDURE p AS\nBEGIN\n  SELECT q'[it's -- not]';\nEND;"),
+    ).toBe(false);
+    // …while code next to a comment or literal still counts.
+    expect(
+      looksLikeOraclePlSql("CREATE PROCEDURE p AS -- note\nBEGIN\n  x := 'a';\nEND;\n/\n"),
+    ).toBe(true);
     // A package header is Oracle-only even with `AS` and no other marker.
     expect(looksLikeOraclePlSql('CREATE PACKAGE p AS PROCEDURE q(x NUMBER); END p;')).toBe(true);
     expect(
diff --git a/gitnexus/test/unit/scenario-map/fixture-similarity.test.ts b/gitnexus/test/unit/scenario-map/fixture-similarity.test.ts
index 550142873..bb7ecba99 100644
--- a/gitnexus/test/unit/scenario-map/fixture-similarity.test.ts
+++ b/gitnexus/test/unit/scenario-map/fixture-similarity.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { beforeAll, describe, expect, it } from 'vitest';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
@@ -25,6 +25,11 @@ import type {
 import { SupportedLanguages } from 'gitnexus-shared';
 import { layer1Files } from '../../../tools/scenario-map/path-coverage/prefilter.js';
 import { isLanguageAvailable } from '../../../src/core/tree-sitter/parser-loader.js';
+import { loadPlSqlParser } from '../../../src/core/ingestion/plsql/facts-store.js';
+
+// The PL/SQL parser loads lazily (its pipeline phase awaits it); vitest cannot
+// take the synchronous require fallback for TypeScript sources, so preload it.
+beforeAll(loadPlSqlParser);
 
 const ROOT = 'gitnexus/test/fixtures';
 const FILE = 'gitnexus/test/integration/example.test.ts';
@@ -54,7 +59,7 @@ const FIXTURES = {
     'export function twice(value: number) { while (value > 0) { value--; } return value; }',
 };
 
-// Exercise the real native providers, including standalone COBOL and embedded Vue scripts.
+// Exercise the real native providers, including standalone COBOL and PL/SQL and embedded Vue scripts.
 const LANGUAGE_FIXTURES: Record<SupportedLanguages, [string, string]> = {
   typescript: ['ts', 'function twice(x: number) { return x + x; }'],
   javascript: ['js', 'function twice(x) { return x + x; }'],
@@ -83,6 +88,10 @@ const LANGUAGE_FIXTURES: Record<SupportedLanguages, [string, string]> = {
     'cbl',
     '       IDENTIFICATION DIVISION.\n       PROGRAM-ID. SAMPLE.\n       PROCEDURE DIVISION.\n       MAIN-PARA.\n           DISPLAY "HI".\n           STOP RUN.\n',
   ],
+  plsql: [
+    'prc',
+    'CREATE OR REPLACE FUNCTION twice(x NUMBER) RETURN NUMBER IS\nBEGIN\n  RETURN x + x;\nEND twice;\n/\n',
+  ],
 };
 
 it.each(Object.entries(LANGUAGE_FIXTURES))(
@@ -93,6 +102,7 @@ it.each(Object.entries(LANGUAGE_FIXTURES))(
     const result = await profiler.profile([root]);
     if (
       language !== SupportedLanguages.Cobol &&
+      language !== SupportedLanguages.PlSql &&
       !isLanguageAvailable(language as SupportedLanguages, `main.${extension}`)
     ) {
       expect(result.contentKey).not.toBeNull();

From d401f818884f821a980910a298d0391862bfef34 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:02:40 +0800
Subject: [PATCH 15/17] fix(plsql): claim OR REPLACE routines with plain-SQL
 bodies; bound the bench
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- `CREATE OR REPLACE PROCEDURE|FUNCTION … IS|AS` is Oracle even when the
  body holds only SQL: T-SQL writes CREATE OR ALTER, and the other dialects
  that write OR REPLACE declare LANGUAGE/RETURNS, write `AS (expr)` or go
  straight to BEGIN, which stay excluded.
- bench/plsql-parse uses the production size-scaled segment deadline, so a
  stalled parse ends as a timed-out segment that --check rejects instead of
  hanging the job; timeouts are now checked explicitly.
---
 gitnexus/bench/plsql-parse/measure.mjs        | 12 ++++++--
 .../src/core/ingestion/plsql/file-types.ts    | 18 ++++++++++--
 gitnexus/test/unit/plsql-extract.test.ts      | 29 +++++++++++++++++++
 3 files changed, 55 insertions(+), 4 deletions(-)

diff --git a/gitnexus/bench/plsql-parse/measure.mjs b/gitnexus/bench/plsql-parse/measure.mjs
index cf9cd6586..b5e8c7793 100644
--- a/gitnexus/bench/plsql-parse/measure.mjs
+++ b/gitnexus/bench/plsql-parse/measure.mjs
@@ -30,8 +30,11 @@ const FIXTURE_ROOT = path.resolve(__dirname, '..', '..', 'test', 'fixtures', 'la
 const BASELINE_PATH = path.resolve(__dirname, 'baselines.json');
 const PLSQL_EXTENSIONS = ['.sql', '.pks', '.pkb', '.pck', '.pls', '.plb', '.prc', '.fnc', '.trg'];
 
-/** No deadline: the bench measures the parse, not the fallback. */
-const OPTIONS = { segmentDeadlineMs: Number.POSITIVE_INFINITY };
+/**
+ * The production, size-scaled segment deadline: a parse that stalls ends as a
+ * timed-out segment, which `--check` rejects, instead of hanging the job.
+ */
+const OPTIONS = {};
 
 const SMALL = 60;
 const LARGE = 240;
@@ -136,6 +139,7 @@ function measure() {
     },
     scaling_ratio: +(l.ms / s.ms / (largeLines / smallLines)).toFixed(3),
     synthetic_errors: s.facts.segmentsWithErrors + l.facts.segmentsWithErrors,
+    synthetic_timeouts: s.facts.segmentsTimedOut + l.facts.segmentsTimedOut,
     synthetic_calls: l.facts.calls.length,
     synthetic_accesses: l.facts.accesses.length,
   };
@@ -151,6 +155,10 @@ if (process.argv.includes('--check')) {
     failures.push(
       `fingerprint drift: ${result.fingerprint} != baseline ${baseline.fingerprint} (re-baseline only for an intended facts change)`,
     );
+  if (result.synthetic_timeouts !== 0)
+    failures.push(
+      `synthetic bodies hit the parse deadline in ${result.synthetic_timeouts} segments`,
+    );
   if (result.synthetic_errors !== 0)
     failures.push(`synthetic bodies parsed with ${result.synthetic_errors} erroneous segments`);
   if (result.scaling_ratio >= baseline.scaling_budget)
diff --git a/gitnexus/src/core/ingestion/plsql/file-types.ts b/gitnexus/src/core/ingestion/plsql/file-types.ts
index 8f3ec394c..1be24d316 100644
--- a/gitnexus/src/core/ingestion/plsql/file-types.ts
+++ b/gitnexus/src/core/ingestion/plsql/file-types.ts
@@ -55,6 +55,18 @@ const ORACLE_IS_HEADER =
  */
 const ORACLE_PACKAGE_HEADER =
   /^[ \t]*create\s+(?:or\s+replace\s+)?(?:(?:non)?editionable\s+)?package(?:\s+body)?\s+[\w$#."]+(?:(?!\bbegin\b)[\s\S]){0,4000}?\b(?:is|as)\b/im;
+/**
+ * `CREATE OR REPLACE PROCEDURE|FUNCTION <name> … IS|AS`. T-SQL writes
+ * `CREATE OR ALTER`; MySQL/MariaDB, DB2 and BigQuery procedures go straight to
+ * `BEGIN`; PostgreSQL, Redshift and Snowflake declare a `LANGUAGE` or
+ * `RETURNS` and quote the body; a BigQuery SQL function writes `AS (expr)`.
+ * Without those, an `OR REPLACE` routine with `IS|AS` is Oracle even when its
+ * body is plain SQL. The header must not cross a `;`.
+ */
+const OR_REPLACE_ROUTINE_HEADER =
+  /^[ \t]*create\s+or\s+replace\s+(?:(?:non)?editionable\s+)?(?:procedure|function)\s+[\w$#."]+(?:(?!\bbegin\b)[^;]){0,4000}?\b(?:is|as)\b(?!\s*\()/im;
+/** `LANGUAGE <x>` other than an Oracle Java/C call spec, or `RETURNS`. */
+const NON_ORACLE_ROUTINE = /\breturns\b|\blanguage\s+(?!java\b|c\b)\w+/i;
 /**
  * A trigger whose body is a PL/SQL block. The header is shared with
  * PostgreSQL and MySQL/MariaDB, so the dialects are told apart by what they
@@ -123,11 +135,13 @@ export function looksLikeOraclePlSql(source: string): boolean {
   if (POSTGRES_DOLLAR_BODY.test(content) || TSQL_MARKERS.test(content)) return false;
   // `IS` after a unit header is Oracle-only syntax (T-SQL, PostgreSQL and
   // MySQL write `AS` or `BEGIN`), so a plain `CREATE PROCEDURE p IS …` needs
-  // no further marker, nor does any package header; a procedure or function
-  // `AS` header (shared with T-SQL) needs PL/SQL syntax from ORACLE_MARKERS.
+  // no further marker, nor does any package header or `OR REPLACE` routine;
+  // a plain `CREATE PROCEDURE|FUNCTION … AS` header (shared with T-SQL) needs
+  // PL/SQL syntax from ORACLE_MARKERS.
   return (
     ORACLE_IS_HEADER.test(content) ||
     ORACLE_PACKAGE_HEADER.test(content) ||
+    (OR_REPLACE_ROUTINE_HEADER.test(content) && !NON_ORACLE_ROUTINE.test(content)) ||
     looksLikeOracleTrigger(content) ||
     ORACLE_MARKERS.test(content)
   );
diff --git a/gitnexus/test/unit/plsql-extract.test.ts b/gitnexus/test/unit/plsql-extract.test.ts
index 9c7316348..d7e138e69 100644
--- a/gitnexus/test/unit/plsql-extract.test.ts
+++ b/gitnexus/test/unit/plsql-extract.test.ts
@@ -274,6 +274,35 @@ describe('file classification', () => {
         'CREATE PROCEDURE p()\nBEGIN\n  -- nvl( is not MySQL\n  SELECT 1;\nEND\n/\n',
       ),
     ).toBe(false);
+    // `CREATE OR REPLACE … AS` is Oracle even with a plain-SQL body; other
+    // dialects that write OR REPLACE declare LANGUAGE/RETURNS or skip IS/AS.
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR REPLACE PROCEDURE p AS BEGIN INSERT INTO audit_log VALUES (1); END;',
+      ),
+    ).toBe(true);
+    expect(
+      looksLikeOraclePlSql(
+        "CREATE OR REPLACE PROCEDURE p() AS 'INSERT INTO t VALUES (1)' LANGUAGE sql;",
+      ),
+    ).toBe(false);
+    expect(looksLikeOraclePlSql("CREATE OR REPLACE FUNCTION f() RETURNS FLOAT AS '3.14';")).toBe(
+      false,
+    );
+    expect(looksLikeOraclePlSql('CREATE OR REPLACE FUNCTION ds.f(x INT64) AS (x + 1);')).toBe(
+      false,
+    );
+    expect(
+      looksLikeOraclePlSql(
+        'CREATE OR REPLACE FUNCTION ds.f(x INT64) AS (x + 1);\nSELECT a AS b FROM t;',
+      ),
+    ).toBe(false);
+    expect(
+      looksLikeOraclePlSql('CREATE OR REPLACE PROCEDURE p() BEGIN INSERT INTO t VALUES (1); END;'),
+    ).toBe(false);
+    expect(
+      looksLikeOraclePlSql('CREATE OR ALTER PROCEDURE p AS BEGIN INSERT INTO t VALUES (1); END;'),
+    ).toBe(false);
     // Dialect evidence comes from code, never from comments or string literals.
     expect(looksLikeOraclePlSql('CREATE PROCEDURE p AS BEGIN SELECT 1; -- :=\nEND;')).toBe(false);
     expect(

From 3f891033f0e83c4fe413ad0c716ed7e15324c6dc Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:20:03 +0800
Subject: [PATCH 16/17] test(plsql): guard against eager dynamic loads of the
 parser

The lazy-loading guard only scanned import statements, so a top-level
`void import('./extract.js')` in a light module would load the parser at
evaluation unnoticed. It now also scans import(), require() and
createRequire()() calls (not type-only `typeof import()`): light modules
may not load the parser or extractor at all, and facts-store may load the
extractor only through its two known paths.
---
 gitnexus/test/unit/plsql-lazy-parser.test.ts | 47 +++++++++++++++++++-
 1 file changed, 46 insertions(+), 1 deletion(-)

diff --git a/gitnexus/test/unit/plsql-lazy-parser.test.ts b/gitnexus/test/unit/plsql-lazy-parser.test.ts
index 186f0ca6d..0490ee7de 100644
--- a/gitnexus/test/unit/plsql-lazy-parser.test.ts
+++ b/gitnexus/test/unit/plsql-lazy-parser.test.ts
@@ -53,12 +53,51 @@ function valueImports(source: string): string[] {
   return out;
 }
 
+/**
+ * Every module specifier this file loads at run time: `import('…')` and
+ * `require('…')`, including a `createRequire(…)('…')` call, but not a
+ * type-only `typeof import('…')`. A top-level
+ * `void import('./extract.js')` would load the parser at evaluation even
+ * though no import statement names it.
+ */
+function dynamicLoads(source: string): string[] {
+  return [
+    ...source.matchAll(
+      /(?<!\btypeof\s+)\b(?:import|require|createRequire\([^)]*\))\s*\(\s*(['"`])([^'"`]+)\1/g,
+    ),
+  ].map((m) => m[2]!);
+}
+
+const FACTS_STORE = 'plsql/facts-store.ts';
+
 describe('PL/SQL parser loads lazily', () => {
   it.each(LIGHT_MODULES)('%s imports the parser and extractor by type only', (file) => {
     const source = readFileSync(path.join(INGESTION, file), 'utf8');
     expect(valueImports(source).filter((spec) => HEAVY.test(spec))).toEqual([]);
   });
 
+  it.each(LIGHT_MODULES.filter((file) => file !== FACTS_STORE))(
+    '%s never loads the parser or extractor dynamically either',
+    (file) => {
+      const source = readFileSync(path.join(INGESTION, file), 'utf8');
+      expect(dynamicLoads(source).filter((spec) => HEAVY.test(spec))).toEqual([]);
+    },
+  );
+
+  it('the dynamic-load scanner sees import(), require() and createRequire()()', () => {
+    expect(
+      dynamicLoads(
+        [
+          "void import('./extract.js');",
+          'const p = await import("./generated/PlSqlParser.js");',
+          "require('antlr4ng');",
+          "createRequire(import.meta.url)('./extract.js');",
+          "const t: typeof import('./extract.js') = x;",
+        ].join('\n'),
+      ),
+    ).toEqual(['./extract.js', './generated/PlSqlParser.js', 'antlr4ng', './extract.js']);
+  });
+
   it('the scanner sees side-effect imports and re-exports', () => {
     expect(
       valueImports(
@@ -85,8 +124,14 @@ describe('PL/SQL parser loads lazily', () => {
   });
 
   it('facts-store is the one place the extractor is loaded: dynamically, or by its require fallback', () => {
-    const source = readFileSync(path.join(INGESTION, 'plsql/facts-store.ts'), 'utf8');
+    const source = readFileSync(path.join(INGESTION, FACTS_STORE), 'utf8');
     expect(source).toMatch(/await import\('\.\/extract\.js'\)/);
     expect(source).toMatch(/createRequire\(import\.meta\.url\)\('\.\/extract\.js'\)/);
+    // Exactly those two (inside loadPlSqlParser and the fallback): any other
+    // load, such as an eager top-level `void import(…)`, changes this list.
+    expect(dynamicLoads(source).filter((spec) => HEAVY.test(spec))).toEqual([
+      './extract.js',
+      './extract.js',
+    ]);
   });
 });

From f1c522208af38326ad38f2d46786f8691db60d11 Mon Sep 17 00:00:00 2001
From: Asyncronize <56194330+Asyncronize@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:56:04 +0800
Subject: [PATCH 17/17] test(plsql): scan the shared registries in the
 lazy-loading guard

The guard now also scans the four shared modules that register PL/SQL
(languages/index.ts, the scope-resolver registry, the phase index and
pipeline.ts). Specifiers are resolved against the importing file before
being judged, so the general `./parse.js` phase no longer reads as the
PL/SQL parser; only plsql/extract, plsql/parse, plsql/generated/ and
antlr4ng count as heavy.
---
 gitnexus/test/unit/plsql-lazy-parser.test.ts | 32 +++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/gitnexus/test/unit/plsql-lazy-parser.test.ts b/gitnexus/test/unit/plsql-lazy-parser.test.ts
index 0490ee7de..18b141ac6 100644
--- a/gitnexus/test/unit/plsql-lazy-parser.test.ts
+++ b/gitnexus/test/unit/plsql-lazy-parser.test.ts
@@ -12,8 +12,15 @@ import { describe, expect, it } from 'vitest';
 
 const INGESTION = path.resolve(__dirname, '../../src/core/ingestion');
 
-/** Modules reachable from the provider registry, the scope resolver and the pipeline phase. */
+/**
+ * The shared registries that register PL/SQL (provider list, scope-resolver
+ * table, phase index and phase list) plus every module they reach through it.
+ */
 const LIGHT_MODULES = [
+  'languages/index.ts',
+  'scope-resolution/pipeline/registry.ts',
+  'pipeline-phases/index.ts',
+  'pipeline.ts',
   'languages/plsql.ts',
   'languages/plsql/index.ts',
   'languages/plsql/captures.ts',
@@ -31,7 +38,13 @@ const LIGHT_MODULES = [
   'plsql/script-include.ts',
 ];
 
-const HEAVY = /(?:^|\/)(?:extract|parse)\.js$|\/generated\/|^antlr4ng$/;
+/** The ANTLR runtime, or (resolved from `file`) the PL/SQL extractor, parse module or generated parser. */
+function isHeavy(file: string, spec: string): boolean {
+  if (spec === 'antlr4ng') return true;
+  if (!spec.startsWith('.')) return false;
+  const target = path.posix.join(path.posix.dirname(file), spec);
+  return /^plsql\/(?:extract|parse)\.js$|^plsql\/generated\//.test(target);
+}
 
 /**
  * Every module specifier this file evaluates at load: `import … from '…'`
@@ -73,17 +86,26 @@ const FACTS_STORE = 'plsql/facts-store.ts';
 describe('PL/SQL parser loads lazily', () => {
   it.each(LIGHT_MODULES)('%s imports the parser and extractor by type only', (file) => {
     const source = readFileSync(path.join(INGESTION, file), 'utf8');
-    expect(valueImports(source).filter((spec) => HEAVY.test(spec))).toEqual([]);
+    expect(valueImports(source).filter((spec) => isHeavy(file, spec))).toEqual([]);
   });
 
   it.each(LIGHT_MODULES.filter((file) => file !== FACTS_STORE))(
     '%s never loads the parser or extractor dynamically either',
     (file) => {
       const source = readFileSync(path.join(INGESTION, file), 'utf8');
-      expect(dynamicLoads(source).filter((spec) => HEAVY.test(spec))).toEqual([]);
+      expect(dynamicLoads(source).filter((spec) => isHeavy(file, spec))).toEqual([]);
     },
   );
 
+  it('resolves specifiers before judging them: only the PL/SQL parser modules are heavy', () => {
+    expect(isHeavy('pipeline-phases/index.ts', './parse.js')).toBe(false);
+    expect(isHeavy('pipeline-phases/index.ts', '../plsql/parse.js')).toBe(true);
+    expect(isHeavy('languages/index.ts', '../plsql/extract.js')).toBe(true);
+    expect(isHeavy('plsql/facts-store.ts', './generated/PlSqlParser.js')).toBe(true);
+    expect(isHeavy('plsql/resolve.ts', './names.js')).toBe(false);
+    expect(isHeavy('pipeline.ts', 'antlr4ng')).toBe(true);
+  });
+
   it('the dynamic-load scanner sees import(), require() and createRequire()()', () => {
     expect(
       dynamicLoads(
@@ -129,7 +151,7 @@ describe('PL/SQL parser loads lazily', () => {
     expect(source).toMatch(/createRequire\(import\.meta\.url\)\('\.\/extract\.js'\)/);
     // Exactly those two (inside loadPlSqlParser and the fallback): any other
     // load, such as an eager top-level `void import(…)`, changes this list.
-    expect(dynamicLoads(source).filter((spec) => HEAVY.test(spec))).toEqual([
+    expect(dynamicLoads(source).filter((spec) => isHeavy(FACTS_STORE, spec))).toEqual([
       './extract.js',
       './extract.js',
     ]);